Ulrich Weigand | 9230997 | 2012-10-24 12:22:56 +0000 | [diff] [blame] | 1 | // RUN: %clang_cc1 -triple i386-unknown-unknown -std=c++11 %s -emit-llvm -o - | FileCheck %s |
Anders Carlsson | f89e042 | 2011-01-23 21:07:30 +0000 | [diff] [blame] | 2 | |
| 3 | namespace Test1 { |
| 4 | struct A { |
| 5 | virtual int f() final; |
| 6 | }; |
| 7 | |
Stephen Lin | 93ab6bf | 2013-08-15 06:47:53 +0000 | [diff] [blame] | 8 | // CHECK-LABEL: define i32 @_ZN5Test11fEPNS_1AE |
Anders Carlsson | f89e042 | 2011-01-23 21:07:30 +0000 | [diff] [blame] | 9 | int f(A *a) { |
| 10 | // CHECK: call i32 @_ZN5Test11A1fEv |
| 11 | return a->f(); |
| 12 | } |
| 13 | } |
| 14 | |
| 15 | namespace Test2 { |
| 16 | struct A final { |
| 17 | virtual int f(); |
| 18 | }; |
| 19 | |
Stephen Lin | 93ab6bf | 2013-08-15 06:47:53 +0000 | [diff] [blame] | 20 | // CHECK-LABEL: define i32 @_ZN5Test21fEPNS_1AE |
Anders Carlsson | f89e042 | 2011-01-23 21:07:30 +0000 | [diff] [blame] | 21 | int f(A *a) { |
| 22 | // CHECK: call i32 @_ZN5Test21A1fEv |
| 23 | return a->f(); |
| 24 | } |
| 25 | } |
Anders Carlsson | 1679f5a | 2011-01-29 03:52:01 +0000 | [diff] [blame] | 26 | |
| 27 | namespace Test3 { |
| 28 | struct A { |
| 29 | virtual int f(); |
| 30 | }; |
| 31 | |
| 32 | struct B final : A { }; |
| 33 | |
Stephen Lin | 93ab6bf | 2013-08-15 06:47:53 +0000 | [diff] [blame] | 34 | // CHECK-LABEL: define i32 @_ZN5Test31fEPNS_1BE |
Anders Carlsson | 1679f5a | 2011-01-29 03:52:01 +0000 | [diff] [blame] | 35 | int f(B *b) { |
| 36 | // CHECK: call i32 @_ZN5Test31A1fEv |
| 37 | return b->f(); |
| 38 | } |
Anders Carlsson | 268ab8c | 2011-01-29 05:04:11 +0000 | [diff] [blame] | 39 | |
Stephen Lin | 93ab6bf | 2013-08-15 06:47:53 +0000 | [diff] [blame] | 40 | // CHECK-LABEL: define i32 @_ZN5Test31fERNS_1BE |
Anders Carlsson | 268ab8c | 2011-01-29 05:04:11 +0000 | [diff] [blame] | 41 | int f(B &b) { |
| 42 | // CHECK: call i32 @_ZN5Test31A1fEv |
| 43 | return b.f(); |
| 44 | } |
| 45 | |
Stephen Lin | 93ab6bf | 2013-08-15 06:47:53 +0000 | [diff] [blame] | 46 | // CHECK-LABEL: define i32 @_ZN5Test31fEPv |
Anders Carlsson | 268ab8c | 2011-01-29 05:04:11 +0000 | [diff] [blame] | 47 | int f(void *v) { |
| 48 | // CHECK: call i32 @_ZN5Test31A1fEv |
| 49 | return static_cast<B*>(v)->f(); |
| 50 | } |
Anders Carlsson | 1679f5a | 2011-01-29 03:52:01 +0000 | [diff] [blame] | 51 | } |
Rafael Espindola | 0b4fe50 | 2012-06-26 17:45:31 +0000 | [diff] [blame] | 52 | |
| 53 | namespace Test4 { |
| 54 | struct A { |
| 55 | virtual void f(); |
Stephen Hines | 0e2c34f | 2015-03-23 12:09:02 -0700 | [diff] [blame] | 56 | virtual int operator-(); |
Rafael Espindola | 0b4fe50 | 2012-06-26 17:45:31 +0000 | [diff] [blame] | 57 | }; |
| 58 | |
| 59 | struct B final : A { |
| 60 | virtual void f(); |
Stephen Hines | 0e2c34f | 2015-03-23 12:09:02 -0700 | [diff] [blame] | 61 | virtual int operator-(); |
Rafael Espindola | 0b4fe50 | 2012-06-26 17:45:31 +0000 | [diff] [blame] | 62 | }; |
| 63 | |
Stephen Lin | 93ab6bf | 2013-08-15 06:47:53 +0000 | [diff] [blame] | 64 | // CHECK-LABEL: define void @_ZN5Test41fEPNS_1BE |
Rafael Espindola | 0b4fe50 | 2012-06-26 17:45:31 +0000 | [diff] [blame] | 65 | void f(B* d) { |
| 66 | // CHECK: call void @_ZN5Test41B1fEv |
| 67 | static_cast<A*>(d)->f(); |
Stephen Hines | 0e2c34f | 2015-03-23 12:09:02 -0700 | [diff] [blame] | 68 | // CHECK: call i32 @_ZN5Test41BngEv |
| 69 | -static_cast<A&>(*d); |
Rafael Espindola | 0b4fe50 | 2012-06-26 17:45:31 +0000 | [diff] [blame] | 70 | } |
| 71 | } |
| 72 | |
| 73 | namespace Test5 { |
| 74 | struct A { |
| 75 | virtual void f(); |
Stephen Hines | 0e2c34f | 2015-03-23 12:09:02 -0700 | [diff] [blame] | 76 | virtual int operator-(); |
Rafael Espindola | 0b4fe50 | 2012-06-26 17:45:31 +0000 | [diff] [blame] | 77 | }; |
| 78 | |
| 79 | struct B : A { |
| 80 | virtual void f(); |
Stephen Hines | 0e2c34f | 2015-03-23 12:09:02 -0700 | [diff] [blame] | 81 | virtual int operator-(); |
Rafael Espindola | 0b4fe50 | 2012-06-26 17:45:31 +0000 | [diff] [blame] | 82 | }; |
| 83 | |
| 84 | struct C final : B { |
| 85 | }; |
| 86 | |
Stephen Lin | 93ab6bf | 2013-08-15 06:47:53 +0000 | [diff] [blame] | 87 | // CHECK-LABEL: define void @_ZN5Test51fEPNS_1CE |
Rafael Espindola | 0b4fe50 | 2012-06-26 17:45:31 +0000 | [diff] [blame] | 88 | void f(C* d) { |
Rafael Espindola | ea01d76 | 2012-06-28 14:28:57 +0000 | [diff] [blame] | 89 | // FIXME: It should be possible to devirtualize this case, but that is |
| 90 | // not implemented yet. |
| 91 | // CHECK: getelementptr |
| 92 | // CHECK-NEXT: %[[FUNC:.*]] = load |
| 93 | // CHECK-NEXT: call void %[[FUNC]] |
Rafael Espindola | 0b4fe50 | 2012-06-26 17:45:31 +0000 | [diff] [blame] | 94 | static_cast<A*>(d)->f(); |
| 95 | } |
Stephen Hines | 0e2c34f | 2015-03-23 12:09:02 -0700 | [diff] [blame] | 96 | // CHECK-LABEL: define void @_ZN5Test53fopEPNS_1CE |
| 97 | void fop(C* d) { |
| 98 | // FIXME: It should be possible to devirtualize this case, but that is |
| 99 | // not implemented yet. |
| 100 | // CHECK: getelementptr |
| 101 | // CHECK-NEXT: %[[FUNC:.*]] = load |
| 102 | // CHECK-NEXT: call i32 %[[FUNC]] |
| 103 | -static_cast<A&>(*d); |
| 104 | } |
Rafael Espindola | 0b4fe50 | 2012-06-26 17:45:31 +0000 | [diff] [blame] | 105 | } |
| 106 | |
| 107 | namespace Test6 { |
| 108 | struct A { |
| 109 | virtual ~A(); |
| 110 | }; |
| 111 | |
| 112 | struct B : public A { |
| 113 | virtual ~B(); |
| 114 | }; |
| 115 | |
| 116 | struct C { |
| 117 | virtual ~C(); |
| 118 | }; |
| 119 | |
| 120 | struct D final : public C, public B { |
| 121 | }; |
| 122 | |
Stephen Lin | 93ab6bf | 2013-08-15 06:47:53 +0000 | [diff] [blame] | 123 | // CHECK-LABEL: define void @_ZN5Test61fEPNS_1DE |
Rafael Espindola | 0b4fe50 | 2012-06-26 17:45:31 +0000 | [diff] [blame] | 124 | void f(D* d) { |
| 125 | // CHECK: call void @_ZN5Test61DD1Ev |
| 126 | static_cast<A*>(d)->~A(); |
| 127 | } |
| 128 | } |
Rafael Espindola | 632fbaa | 2012-06-28 01:56:38 +0000 | [diff] [blame] | 129 | |
| 130 | namespace Test7 { |
| 131 | struct foo { |
| 132 | virtual void g() {} |
| 133 | }; |
| 134 | |
| 135 | struct bar { |
| 136 | virtual int f() { return 0; } |
| 137 | }; |
| 138 | |
| 139 | struct zed final : public foo, public bar { |
| 140 | int z; |
| 141 | virtual int f() {return z;} |
| 142 | }; |
| 143 | |
Stephen Lin | 93ab6bf | 2013-08-15 06:47:53 +0000 | [diff] [blame] | 144 | // CHECK-LABEL: define i32 @_ZN5Test71fEPNS_3zedE |
Rafael Espindola | 632fbaa | 2012-06-28 01:56:38 +0000 | [diff] [blame] | 145 | int f(zed *z) { |
| 146 | // CHECK: alloca |
| 147 | // CHECK-NEXT: store |
| 148 | // CHECK-NEXT: load |
Eli Friedman | 465e89e | 2012-10-25 00:12:49 +0000 | [diff] [blame] | 149 | // CHECK-NEXT: call i32 @_ZN5Test73zed1fEv |
Rafael Espindola | 632fbaa | 2012-06-28 01:56:38 +0000 | [diff] [blame] | 150 | // CHECK-NEXT: ret |
| 151 | return static_cast<bar*>(z)->f(); |
| 152 | } |
| 153 | } |
Rafael Espindola | ea01d76 | 2012-06-28 14:28:57 +0000 | [diff] [blame] | 154 | |
| 155 | namespace Test8 { |
| 156 | struct A { virtual ~A() {} }; |
| 157 | struct B { |
| 158 | int b; |
| 159 | virtual int foo() { return b; } |
| 160 | }; |
| 161 | struct C final : A, B { }; |
Stephen Lin | 93ab6bf | 2013-08-15 06:47:53 +0000 | [diff] [blame] | 162 | // CHECK-LABEL: define i32 @_ZN5Test84testEPNS_1CE |
Rafael Espindola | ea01d76 | 2012-06-28 14:28:57 +0000 | [diff] [blame] | 163 | int test(C *c) { |
| 164 | // CHECK: %[[THIS:.*]] = phi |
| 165 | // CHECK-NEXT: call i32 @_ZN5Test81B3fooEv(%"struct.Test8::B"* %[[THIS]]) |
| 166 | return static_cast<B*>(c)->foo(); |
| 167 | } |
| 168 | } |
Rafael Espindola | 4a889e4 | 2012-06-28 15:11:39 +0000 | [diff] [blame] | 169 | |
| 170 | namespace Test9 { |
| 171 | struct A { |
| 172 | int a; |
| 173 | }; |
| 174 | struct B { |
| 175 | int b; |
| 176 | }; |
| 177 | struct C : public B, public A { |
| 178 | }; |
| 179 | struct RA { |
| 180 | virtual A *f() { |
| 181 | return 0; |
| 182 | } |
Stephen Hines | 0e2c34f | 2015-03-23 12:09:02 -0700 | [diff] [blame] | 183 | virtual A *operator-() { |
| 184 | return 0; |
| 185 | } |
Rafael Espindola | 4a889e4 | 2012-06-28 15:11:39 +0000 | [diff] [blame] | 186 | }; |
| 187 | struct RC final : public RA { |
| 188 | virtual C *f() { |
| 189 | C *x = new C(); |
| 190 | x->a = 1; |
| 191 | x->b = 2; |
| 192 | return x; |
| 193 | } |
Stephen Hines | 0e2c34f | 2015-03-23 12:09:02 -0700 | [diff] [blame] | 194 | virtual C *operator-() { |
| 195 | C *x = new C(); |
| 196 | x->a = 1; |
| 197 | x->b = 2; |
| 198 | return x; |
| 199 | } |
Rafael Espindola | 4a889e4 | 2012-06-28 15:11:39 +0000 | [diff] [blame] | 200 | }; |
| 201 | // CHECK: define {{.*}} @_ZN5Test91fEPNS_2RCE |
| 202 | A *f(RC *x) { |
| 203 | // FIXME: It should be possible to devirtualize this case, but that is |
| 204 | // not implemented yet. |
Stephen Hines | 176edba | 2014-12-01 14:53:08 -0800 | [diff] [blame] | 205 | // CHECK: load |
| 206 | // CHECK: bitcast |
| 207 | // CHECK: [[F_PTR_RA:%.+]] = bitcast |
| 208 | // CHECK: [[VTABLE:%.+]] = load {{.+}} [[F_PTR_RA]] |
| 209 | // CHECK: [[VFN:%.+]] = getelementptr inbounds {{.+}} [[VTABLE]], i{{[0-9]+}} 0 |
| 210 | // CHECK-NEXT: %[[FUNC:.*]] = load {{.+}} [[VFN]] |
Rafael Espindola | 4a889e4 | 2012-06-28 15:11:39 +0000 | [diff] [blame] | 211 | // CHECK-NEXT: = call {{.*}} %[[FUNC]] |
| 212 | return static_cast<RA*>(x)->f(); |
| 213 | } |
Stephen Hines | 0e2c34f | 2015-03-23 12:09:02 -0700 | [diff] [blame] | 214 | // CHECK: define {{.*}} @_ZN5Test93fopEPNS_2RCE |
| 215 | A *fop(RC *x) { |
| 216 | // FIXME: It should be possible to devirtualize this case, but that is |
| 217 | // not implemented yet. |
| 218 | // CHECK: load |
| 219 | // CHECK: bitcast |
| 220 | // CHECK: [[F_PTR_RA:%.+]] = bitcast |
| 221 | // CHECK: [[VTABLE:%.+]] = load {{.+}} [[F_PTR_RA]] |
| 222 | // CHECK: [[VFN:%.+]] = getelementptr inbounds {{.+}} [[VTABLE]], i{{[0-9]+}} 1 |
| 223 | // CHECK-NEXT: %[[FUNC:.*]] = load {{.+}} [[VFN]] |
| 224 | // CHECK-NEXT: = call {{.*}} %[[FUNC]] |
| 225 | return -static_cast<RA&>(*x); |
| 226 | } |
Rafael Espindola | 4a889e4 | 2012-06-28 15:11:39 +0000 | [diff] [blame] | 227 | } |