1 // RUN: %clang_cc1 -fno-rtti -emit-llvm %s -o - -triple=i386-pc-win32 | FileCheck %s 2 // RUN: %clang_cc1 -fno-rtti -emit-llvm %s -o - -triple=i386-pc-win32 -DINCOMPLETE_VIRTUAL -fms-extensions -verify 3 // RUN: %clang_cc1 -fno-rtti -emit-llvm %s -o - -triple=i386-pc-win32 -DINCOMPLETE_VIRTUAL -DMEMFUN -fms-extensions -verify 4 // FIXME: Test x86_64 member pointers when codegen no longer asserts on records 5 // with virtual bases. 6 7 #ifndef INCOMPLETE_VIRTUAL 8 struct B1 { 9 void foo(); 10 int b; 11 }; 12 struct B2 { 13 int b2; 14 void foo(); 15 }; 16 struct Single : B1 { 17 void foo(); 18 }; 19 struct Multiple : B1, B2 { 20 int m; 21 void foo(); 22 }; 23 struct Virtual : virtual B1 { 24 int v; 25 void foo(); 26 }; 27 28 struct POD { 29 int a; 30 int b; 31 }; 32 33 struct Polymorphic { 34 virtual void myVirtual(); 35 int a; 36 int b; 37 }; 38 39 // This class uses the virtual inheritance model, yet its vbptr offset is not 0. 40 // We still use zero for the null field offset, despite it being a valid field 41 // offset. 42 struct NonZeroVBPtr : POD, Virtual { 43 int n; 44 void foo(); 45 }; 46 47 struct Unspecified; 48 struct UnspecSingle; 49 50 // Check that we can lower the LLVM types and get the null initializers right. 51 int Single ::*s_d_memptr; 52 int Polymorphic::*p_d_memptr; 53 int Multiple ::*m_d_memptr; 54 int Virtual ::*v_d_memptr; 55 int NonZeroVBPtr::*n_d_memptr; 56 int Unspecified::*u_d_memptr; 57 int UnspecSingle::*us_d_memptr; 58 // CHECK: @"\01?s_d_memptr@@3PQSingle@@HQ1@" = global i32 -1, align 4 59 // CHECK: @"\01?p_d_memptr@@3PQPolymorphic@@HQ1@" = global i32 0, align 4 60 // CHECK: @"\01?m_d_memptr@@3PQMultiple@@HQ1@" = global i32 -1, align 4 61 // CHECK: @"\01?v_d_memptr@@3PQVirtual@@HQ1@" = global { i32, i32 } 62 // CHECK: { i32 0, i32 -1 }, align 8 63 // CHECK: @"\01?n_d_memptr@@3PQNonZeroVBPtr@@HQ1@" = global { i32, i32 } 64 // CHECK: { i32 0, i32 -1 }, align 8 65 // CHECK: @"\01?u_d_memptr@@3PQUnspecified@@HQ1@" = global { i32, i32, i32 } 66 // CHECK: { i32 0, i32 0, i32 -1 }, align 8 67 // CHECK: @"\01?us_d_memptr@@3PQUnspecSingle@@HQ1@" = global { i32, i32, i32 } 68 // CHECK: { i32 0, i32 0, i32 -1 }, align 8 69 70 void (Single ::*s_f_memptr)(); 71 void (Multiple::*m_f_memptr)(); 72 void (Virtual ::*v_f_memptr)(); 73 // CHECK: @"\01?s_f_memptr@@3P8Single@@AEXXZQ1@" = global i8* null, align 4 74 // CHECK: @"\01?m_f_memptr@@3P8Multiple@@AEXXZQ1@" = global { i8*, i32 } zeroinitializer, align 8 75 // CHECK: @"\01?v_f_memptr@@3P8Virtual@@AEXXZQ1@" = global { i8*, i32, i32 } zeroinitializer, align 8 76 77 // We can define Unspecified after locking in the inheritance model. 78 struct Unspecified : Multiple, Virtual { 79 void foo(); 80 int u; 81 }; 82 83 struct UnspecSingle { 84 void foo(); 85 }; 86 87 // Test memptr emission in a constant expression. 88 namespace Const { 89 void (Single ::*s_f_mp)() = &Single::foo; 90 void (Multiple ::*m_f_mp)() = &B2::foo; 91 void (Virtual ::*v_f_mp)() = &Virtual::foo; 92 void (Unspecified::*u_f_mp)() = &Unspecified::foo; 93 void (UnspecSingle::*us_f_mp)() = &UnspecSingle::foo; 94 // CHECK: @"\01?s_f_mp@Const@@3P8Single@@AEXXZQ2@" = 95 // CHECK: global i8* bitcast ({{.*}} @"\01?foo@Single@@QAEXXZ" to i8*), align 4 96 // CHECK: @"\01?m_f_mp@Const@@3P8Multiple@@AEXXZQ2@" = 97 // CHECK: global { i8*, i32 } { i8* bitcast ({{.*}} @"\01?foo@B2@@QAEXXZ" to i8*), i32 4 }, align 8 98 // CHECK: @"\01?v_f_mp@Const@@3P8Virtual@@AEXXZQ2@" = 99 // CHECK: global { i8*, i32, i32 } { i8* bitcast ({{.*}} @"\01?foo@Virtual@@QAEXXZ" to i8*), i32 0, i32 0 }, align 8 100 // CHECK: @"\01?u_f_mp@Const@@3P8Unspecified@@AEXXZQ2@" = 101 // CHECK: global { i8*, i32, i32, i32 } { i8* bitcast ({{.*}} @"\01?foo@Unspecified@@QAEXXZ" to i8*), i32 0, i32 12, i32 0 }, align 8 102 // CHECK: @"\01?us_f_mp@Const@@3P8UnspecSingle@@AEXXZQ2@" = 103 // CHECK: global { i8*, i32, i32, i32 } { i8* bitcast ({{.*}} @"\01?foo@UnspecSingle@@QAEXXZ" to i8*), i32 0, i32 0, i32 0 }, align 8 104 } 105 106 namespace CastParam { 107 // This exercises ConstExprEmitter instead of ValueDecl::evaluateValue. The 108 // extra reinterpret_cast for the parameter type requires more careful folding. 109 // FIXME: Or does it? If reinterpret_casts are no-ops, we should be able to 110 // strip them in evaluateValue() and just proceed as normal with an APValue. 111 struct A { 112 int a; 113 void foo(A *p); 114 }; 115 struct B { int b; }; 116 struct C : B, A { int c; }; 117 118 void (A::*ptr1)(void *) = (void (A::*)(void *)) &A::foo; 119 // CHECK: @"\01?ptr1@CastParam@@3P8A@1@AEXPAX@ZQ21@" = 120 // CHECK: global i8* bitcast (void ({{.*}})* @"\01?foo@A@CastParam@@QAEXPAU12@@Z" to i8*), align 4 121 122 // Try a reinterpret_cast followed by a memptr conversion. 123 void (C::*ptr2)(void *) = (void (C::*)(void *)) (void (A::*)(void *)) &A::foo; 124 // CHECK: @"\01?ptr2@CastParam@@3P8C@1@AEXPAX@ZQ21@" = 125 // CHECK: global { i8*, i32 } { i8* bitcast (void ({{.*}})* @"\01?foo@A@CastParam@@QAEXPAU12@@Z" to i8*), i32 4 }, align 8 126 127 void (C::*ptr3)(void *) = (void (C::*)(void *)) (void (A::*)(void *)) (void (A::*)(A *)) 0; 128 // CHECK: @"\01?ptr3@CastParam@@3P8C@1@AEXPAX@ZQ21@" = 129 // CHECK: global { i8*, i32 } zeroinitializer, align 8 130 131 struct D : C { 132 virtual void isPolymorphic(); 133 int d; 134 }; 135 136 // Try a cast that changes the inheritance model. Null for D is 0, but null for 137 // C is -1. We need the cast to long in order to hit the non-APValue path. 138 int C::*ptr4 = (int C::*) (int D::*) (long D::*) 0; 139 // CHECK: @"\01?ptr4@CastParam@@3PQC@1@HQ21@" = global i32 -1, align 4 140 141 // MSVC rejects this but we accept it. 142 int C::*ptr5 = (int C::*) (long D::*) 0; 143 // CHECK: @"\01?ptr5@CastParam@@3PQC@1@HQ21@" = global i32 -1, align 4 144 } 145 146 struct UnspecWithVBPtr; 147 int UnspecWithVBPtr::*forceUnspecWithVBPtr; 148 struct UnspecWithVBPtr : B1, virtual B2 { 149 int u; 150 void foo(); 151 }; 152 153 // Test emitting non-virtual member pointers in a non-constexpr setting. 154 void EmitNonVirtualMemberPointers() { 155 void (Single ::*s_f_memptr)() = &Single::foo; 156 void (Multiple ::*m_f_memptr)() = &Multiple::foo; 157 void (Virtual ::*v_f_memptr)() = &Virtual::foo; 158 void (Unspecified::*u_f_memptr)() = &Unspecified::foo; 159 void (UnspecWithVBPtr::*u2_f_memptr)() = &UnspecWithVBPtr::foo; 160 // CHECK: define void @"\01?EmitNonVirtualMemberPointers@@YAXXZ"() {{.*}} { 161 // CHECK: alloca i8*, align 4 162 // CHECK: alloca { i8*, i32 }, align 8 163 // CHECK: alloca { i8*, i32, i32 }, align 8 164 // CHECK: alloca { i8*, i32, i32, i32 }, align 8 165 // CHECK: store i8* bitcast (void (%{{.*}}*)* @"\01?foo@Single@@QAEXXZ" to i8*), i8** %{{.*}}, align 4 166 // CHECK: store { i8*, i32 } 167 // CHECK: { i8* bitcast (void (%{{.*}}*)* @"\01?foo@Multiple@@QAEXXZ" to i8*), i32 0 }, 168 // CHECK: { i8*, i32 }* %{{.*}}, align 8 169 // CHECK: store { i8*, i32, i32 } 170 // CHECK: { i8* bitcast (void (%{{.*}}*)* @"\01?foo@Virtual@@QAEXXZ" to i8*), i32 0, i32 0 }, 171 // CHECK: { i8*, i32, i32 }* %{{.*}}, align 8 172 // CHECK: store { i8*, i32, i32, i32 } 173 // CHECK: { i8* bitcast (void (%{{.*}}*)* @"\01?foo@Unspecified@@QAEXXZ" to i8*), i32 0, i32 12, i32 0 }, 174 // CHECK: { i8*, i32, i32, i32 }* %{{.*}}, align 8 175 // CHECK: store { i8*, i32, i32, i32 } 176 // CHECK: { i8* bitcast (void (%{{.*}}*)* @"\01?foo@UnspecWithVBPtr@@QAEXXZ" to i8*), 177 // CHECK: i32 0, i32 4, i32 0 }, 178 // CHECK: { i8*, i32, i32, i32 }* %{{.*}}, align 8 179 // CHECK: ret void 180 // CHECK: } 181 } 182 183 void podMemPtrs() { 184 int POD::*memptr; 185 memptr = &POD::a; 186 memptr = &POD::b; 187 if (memptr) 188 memptr = 0; 189 // Check that member pointers use the right offsets and that null is -1. 190 // CHECK: define void @"\01?podMemPtrs@@YAXXZ"() {{.*}} { 191 // CHECK: %[[memptr:.*]] = alloca i32, align 4 192 // CHECK-NEXT: store i32 0, i32* %[[memptr]], align 4 193 // CHECK-NEXT: store i32 4, i32* %[[memptr]], align 4 194 // CHECK-NEXT: %[[memptr_val:.*]] = load i32* %[[memptr]], align 4 195 // CHECK-NEXT: %{{.*}} = icmp ne i32 %[[memptr_val]], -1 196 // CHECK-NEXT: br i1 %{{.*}}, label %{{.*}}, label %{{.*}} 197 // CHECK: store i32 -1, i32* %[[memptr]], align 4 198 // CHECK: ret void 199 // CHECK: } 200 } 201 202 void polymorphicMemPtrs() { 203 int Polymorphic::*memptr; 204 memptr = &Polymorphic::a; 205 memptr = &Polymorphic::b; 206 if (memptr) 207 memptr = 0; 208 // Member pointers for polymorphic classes include the vtable slot in their 209 // offset and use 0 to represent null. 210 // CHECK: define void @"\01?polymorphicMemPtrs@@YAXXZ"() {{.*}} { 211 // CHECK: %[[memptr:.*]] = alloca i32, align 4 212 // CHECK-NEXT: store i32 4, i32* %[[memptr]], align 4 213 // CHECK-NEXT: store i32 8, i32* %[[memptr]], align 4 214 // CHECK-NEXT: %[[memptr_val:.*]] = load i32* %[[memptr]], align 4 215 // CHECK-NEXT: %{{.*}} = icmp ne i32 %[[memptr_val]], 0 216 // CHECK-NEXT: br i1 %{{.*}}, label %{{.*}}, label %{{.*}} 217 // CHECK: store i32 0, i32* %[[memptr]], align 4 218 // CHECK: ret void 219 // CHECK: } 220 } 221 222 bool nullTestDataUnspecified(int Unspecified::*mp) { 223 return mp; 224 // CHECK: define zeroext i1 @"\01?nullTestDataUnspecified@@YA_NPQUnspecified@@H@Z"{{.*}} { 225 // CHECK: %{{.*}} = load { i32, i32, i32 }* %{{.*}}, align 8 226 // CHECK: store { i32, i32, i32 } {{.*}} align 8 227 // CHECK: %[[mp:.*]] = load { i32, i32, i32 }* %{{.*}}, align 8 228 // CHECK: %[[mp0:.*]] = extractvalue { i32, i32, i32 } %[[mp]], 0 229 // CHECK: %[[cmp0:.*]] = icmp ne i32 %[[mp0]], 0 230 // CHECK: %[[mp1:.*]] = extractvalue { i32, i32, i32 } %[[mp]], 1 231 // CHECK: %[[cmp1:.*]] = icmp ne i32 %[[mp1]], 0 232 // CHECK: %[[and0:.*]] = and i1 %[[cmp0]], %[[cmp1]] 233 // CHECK: %[[mp2:.*]] = extractvalue { i32, i32, i32 } %[[mp]], 2 234 // CHECK: %[[cmp2:.*]] = icmp ne i32 %[[mp2]], -1 235 // CHECK: %[[and1:.*]] = and i1 %[[and0]], %[[cmp2]] 236 // CHECK: ret i1 %[[and1]] 237 // CHECK: } 238 } 239 240 bool nullTestFunctionUnspecified(void (Unspecified::*mp)()) { 241 return mp; 242 // CHECK: define zeroext i1 @"\01?nullTestFunctionUnspecified@@YA_NP8Unspecified@@AEXXZ@Z"{{.*}} { 243 // CHECK: %{{.*}} = load { i8*, i32, i32, i32 }* %{{.*}}, align 8 244 // CHECK: store { i8*, i32, i32, i32 } {{.*}} align 8 245 // CHECK: %[[mp:.*]] = load { i8*, i32, i32, i32 }* %{{.*}}, align 8 246 // CHECK: %[[mp0:.*]] = extractvalue { i8*, i32, i32, i32 } %[[mp]], 0 247 // CHECK: %[[cmp0:.*]] = icmp ne i8* %[[mp0]], null 248 // CHECK: ret i1 %[[cmp0]] 249 // CHECK: } 250 } 251 252 int loadDataMemberPointerVirtual(Virtual *o, int Virtual::*memptr) { 253 return o->*memptr; 254 // Test that we can unpack this aggregate member pointer and load the member 255 // data pointer. 256 // CHECK: define i32 @"\01?loadDataMemberPointerVirtual@@YAHPAUVirtual@@PQ1@H@Z"{{.*}} { 257 // CHECK: %[[o:.*]] = load %{{.*}}** %{{.*}}, align 4 258 // CHECK: %[[memptr:.*]] = load { i32, i32 }* %{{.*}}, align 8 259 // CHECK: %[[memptr0:.*]] = extractvalue { i32, i32 } %[[memptr:.*]], 0 260 // CHECK: %[[memptr1:.*]] = extractvalue { i32, i32 } %[[memptr:.*]], 1 261 // CHECK: %[[v6:.*]] = bitcast %{{.*}}* %[[o]] to i8* 262 // CHECK: %[[vbptr:.*]] = getelementptr inbounds i8* %[[v6]], i32 0 263 // CHECK: %[[vbptr_a:.*]] = bitcast i8* %[[vbptr]] to i8** 264 // CHECK: %[[vbtable:.*]] = load i8** %[[vbptr_a:.*]] 265 // CHECK: %[[v7:.*]] = getelementptr inbounds i8* %[[vbtable]], i32 %[[memptr1]] 266 // CHECK: %[[v8:.*]] = bitcast i8* %[[v7]] to i32* 267 // CHECK: %[[vbase_offs:.*]] = load i32* %[[v8]] 268 // CHECK: %[[v10:.*]] = getelementptr inbounds i8* %[[vbptr]], i32 %[[vbase_offs]] 269 // CHECK: %[[offset:.*]] = getelementptr inbounds i8* %[[v10]], i32 %[[memptr0]] 270 // CHECK: %[[v11:.*]] = bitcast i8* %[[offset]] to i32* 271 // CHECK: %[[v12:.*]] = load i32* %[[v11]] 272 // CHECK: ret i32 %[[v12]] 273 // CHECK: } 274 } 275 276 int loadDataMemberPointerUnspecified(Unspecified *o, int Unspecified::*memptr) { 277 return o->*memptr; 278 // Test that we can unpack this aggregate member pointer and load the member 279 // data pointer. 280 // CHECK: define i32 @"\01?loadDataMemberPointerUnspecified@@YAHPAUUnspecified@@PQ1@H@Z"{{.*}} { 281 // CHECK: %[[o:.*]] = load %{{.*}}** %{{.*}}, align 4 282 // CHECK: %[[memptr:.*]] = load { i32, i32, i32 }* %{{.*}}, align 8 283 // CHECK: %[[memptr0:.*]] = extractvalue { i32, i32, i32 } %[[memptr:.*]], 0 284 // CHECK: %[[memptr1:.*]] = extractvalue { i32, i32, i32 } %[[memptr:.*]], 1 285 // CHECK: %[[memptr2:.*]] = extractvalue { i32, i32, i32 } %[[memptr:.*]], 2 286 // CHECK: %[[base:.*]] = bitcast %{{.*}}* %[[o]] to i8* 287 // CHECK: %[[is_vbase:.*]] = icmp ne i32 %[[memptr2]], 0 288 // CHECK: br i1 %[[is_vbase]], label %[[vadjust:.*]], label %[[skip:.*]] 289 // 290 // CHECK: [[vadjust]] 291 // CHECK: %[[vbptr:.*]] = getelementptr inbounds i8* %[[base]], i32 %[[memptr1]] 292 // CHECK: %[[vbptr_a:.*]] = bitcast i8* %[[vbptr]] to i8** 293 // CHECK: %[[vbtable:.*]] = load i8** %[[vbptr_a:.*]] 294 // CHECK: %[[v7:.*]] = getelementptr inbounds i8* %[[vbtable]], i32 %[[memptr2]] 295 // CHECK: %[[v8:.*]] = bitcast i8* %[[v7]] to i32* 296 // CHECK: %[[vbase_offs:.*]] = load i32* %[[v8]] 297 // CHECK: %[[base_adj:.*]] = getelementptr inbounds i8* %[[vbptr]], i32 %[[vbase_offs]] 298 // 299 // CHECK: [[skip]] 300 // CHECK: %[[new_base:.*]] = phi i8* [ %[[base]], %{{.*}} ], [ %[[base_adj]], %[[vadjust]] ] 301 // CHECK: %[[offset:.*]] = getelementptr inbounds i8* %[[new_base]], i32 %[[memptr0]] 302 // CHECK: %[[v11:.*]] = bitcast i8* %[[offset]] to i32* 303 // CHECK: %[[v12:.*]] = load i32* %[[v11]] 304 // CHECK: ret i32 %[[v12]] 305 // CHECK: } 306 } 307 308 void callMemberPointerSingle(Single *o, void (Single::*memptr)()) { 309 (o->*memptr)(); 310 // Just look for an indirect thiscall. 311 // CHECK: define void @"\01?callMemberPointerSingle@@{{.*}} {{.*}} { 312 // CHECK: call x86_thiscallcc void %{{.*}}(%{{.*}} %{{.*}}) 313 // CHECK: ret void 314 // CHECK: } 315 } 316 317 void callMemberPointerMultiple(Multiple *o, void (Multiple::*memptr)()) { 318 (o->*memptr)(); 319 // CHECK: define void @"\01?callMemberPointerMultiple@@{{.*}} { 320 // CHECK: %[[memptr0:.*]] = extractvalue { i8*, i32 } %{{.*}}, 0 321 // CHECK: %[[memptr1:.*]] = extractvalue { i8*, i32 } %{{.*}}, 1 322 // CHECK: %[[this_adjusted:.*]] = getelementptr inbounds i8* %{{.*}}, i32 %[[memptr1]] 323 // CHECK: %[[this:.*]] = bitcast i8* %[[this_adjusted]] to {{.*}} 324 // CHECK: %[[fptr:.*]] = bitcast i8* %[[memptr0]] to {{.*}} 325 // CHECK: call x86_thiscallcc void %[[fptr]](%{{.*}} %[[this]]) 326 // CHECK: ret void 327 // CHECK: } 328 } 329 330 void callMemberPointerVirtualBase(Virtual *o, void (Virtual::*memptr)()) { 331 (o->*memptr)(); 332 // This shares a lot with virtual data member pointers. 333 // CHECK: define void @"\01?callMemberPointerVirtualBase@@{{.*}} { 334 // CHECK: %[[memptr0:.*]] = extractvalue { i8*, i32, i32 } %{{.*}}, 0 335 // CHECK: %[[memptr1:.*]] = extractvalue { i8*, i32, i32 } %{{.*}}, 1 336 // CHECK: %[[memptr2:.*]] = extractvalue { i8*, i32, i32 } %{{.*}}, 2 337 // CHECK: %[[vbptr:.*]] = getelementptr inbounds i8* %{{.*}}, i32 0 338 // CHECK: %[[vbptr_a:.*]] = bitcast i8* %[[vbptr]] to i8** 339 // CHECK: %[[vbtable:.*]] = load i8** %[[vbptr_a:.*]] 340 // CHECK: %[[v7:.*]] = getelementptr inbounds i8* %[[vbtable]], i32 %[[memptr2]] 341 // CHECK: %[[v8:.*]] = bitcast i8* %[[v7]] to i32* 342 // CHECK: %[[vbase_offs:.*]] = load i32* %[[v8]] 343 // CHECK: %[[v10:.*]] = getelementptr inbounds i8* %[[vbptr]], i32 %[[vbase_offs]] 344 // CHECK: %[[this_adjusted:.*]] = getelementptr inbounds i8* %[[v10]], i32 %[[memptr1]] 345 // CHECK: %[[fptr:.*]] = bitcast i8* %[[memptr0]] to void ({{.*}}) 346 // CHECK: %[[this:.*]] = bitcast i8* %[[this_adjusted]] to {{.*}} 347 // CHECK: call x86_thiscallcc void %[[fptr]](%{{.*}} %[[this]]) 348 // CHECK: ret void 349 // CHECK: } 350 } 351 352 bool compareSingleFunctionMemptr(void (Single::*l)(), void (Single::*r)()) { 353 return l == r; 354 // Should only be one comparison here. 355 // CHECK: define zeroext i1 @"\01?compareSingleFunctionMemptr@@YA_NP8Single@@AEXXZ0@Z"{{.*}} { 356 // CHECK-NOT: icmp 357 // CHECK: %[[r:.*]] = icmp eq 358 // CHECK-NOT: icmp 359 // CHECK: ret i1 %[[r]] 360 // CHECK: } 361 } 362 363 bool compareNeqSingleFunctionMemptr(void (Single::*l)(), void (Single::*r)()) { 364 return l != r; 365 // Should only be one comparison here. 366 // CHECK: define zeroext i1 @"\01?compareNeqSingleFunctionMemptr@@YA_NP8Single@@AEXXZ0@Z"{{.*}} { 367 // CHECK-NOT: icmp 368 // CHECK: %[[r:.*]] = icmp ne 369 // CHECK-NOT: icmp 370 // CHECK: ret i1 %[[r]] 371 // CHECK: } 372 } 373 374 bool unspecFuncMemptrEq(void (Unspecified::*l)(), void (Unspecified::*r)()) { 375 return l == r; 376 // CHECK: define zeroext i1 @"\01?unspecFuncMemptrEq@@YA_NP8Unspecified@@AEXXZ0@Z"{{.*}} { 377 // CHECK: %[[lhs0:.*]] = extractvalue { i8*, i32, i32, i32 } %[[l:.*]], 0 378 // CHECK: %{{.*}} = extractvalue { i8*, i32, i32, i32 } %[[r:.*]], 0 379 // CHECK: %[[cmp0:.*]] = icmp eq i8* %[[lhs0]], %{{.*}} 380 // CHECK: %{{.*}} = extractvalue { i8*, i32, i32, i32 } %[[l]], 1 381 // CHECK: %{{.*}} = extractvalue { i8*, i32, i32, i32 } %[[r]], 1 382 // CHECK: %[[cmp1:.*]] = icmp eq i32 383 // CHECK: %{{.*}} = extractvalue { i8*, i32, i32, i32 } %[[l]], 2 384 // CHECK: %{{.*}} = extractvalue { i8*, i32, i32, i32 } %[[r]], 2 385 // CHECK: %[[cmp2:.*]] = icmp eq i32 386 // CHECK: %[[res12:.*]] = and i1 %[[cmp1]], %[[cmp2]] 387 // CHECK: %{{.*}} = extractvalue { i8*, i32, i32, i32 } %[[l]], 3 388 // CHECK: %{{.*}} = extractvalue { i8*, i32, i32, i32 } %[[r]], 3 389 // CHECK: %[[cmp3:.*]] = icmp eq i32 390 // CHECK: %[[res123:.*]] = and i1 %[[res12]], %[[cmp3]] 391 // CHECK: %[[iszero:.*]] = icmp eq i8* %[[lhs0]], null 392 // CHECK: %[[bits_or_null:.*]] = or i1 %[[res123]], %[[iszero]] 393 // CHECK: %{{.*}} = and i1 %[[bits_or_null]], %[[cmp0]] 394 // CHECK: ret i1 %{{.*}} 395 // CHECK: } 396 } 397 398 bool unspecFuncMemptrNeq(void (Unspecified::*l)(), void (Unspecified::*r)()) { 399 return l != r; 400 // CHECK: define zeroext i1 @"\01?unspecFuncMemptrNeq@@YA_NP8Unspecified@@AEXXZ0@Z"{{.*}} { 401 // CHECK: %[[lhs0:.*]] = extractvalue { i8*, i32, i32, i32 } %[[l:.*]], 0 402 // CHECK: %{{.*}} = extractvalue { i8*, i32, i32, i32 } %[[r:.*]], 0 403 // CHECK: %[[cmp0:.*]] = icmp ne i8* %[[lhs0]], %{{.*}} 404 // CHECK: %{{.*}} = extractvalue { i8*, i32, i32, i32 } %[[l]], 1 405 // CHECK: %{{.*}} = extractvalue { i8*, i32, i32, i32 } %[[r]], 1 406 // CHECK: %[[cmp1:.*]] = icmp ne i32 407 // CHECK: %{{.*}} = extractvalue { i8*, i32, i32, i32 } %[[l]], 2 408 // CHECK: %{{.*}} = extractvalue { i8*, i32, i32, i32 } %[[r]], 2 409 // CHECK: %[[cmp2:.*]] = icmp ne i32 410 // CHECK: %[[res12:.*]] = or i1 %[[cmp1]], %[[cmp2]] 411 // CHECK: %{{.*}} = extractvalue { i8*, i32, i32, i32 } %[[l]], 3 412 // CHECK: %{{.*}} = extractvalue { i8*, i32, i32, i32 } %[[r]], 3 413 // CHECK: %[[cmp3:.*]] = icmp ne i32 414 // CHECK: %[[res123:.*]] = or i1 %[[res12]], %[[cmp3]] 415 // CHECK: %[[iszero:.*]] = icmp ne i8* %[[lhs0]], null 416 // CHECK: %[[bits_or_null:.*]] = and i1 %[[res123]], %[[iszero]] 417 // CHECK: %{{.*}} = or i1 %[[bits_or_null]], %[[cmp0]] 418 // CHECK: ret i1 %{{.*}} 419 // CHECK: } 420 } 421 422 bool unspecDataMemptrEq(int Unspecified::*l, int Unspecified::*r) { 423 return l == r; 424 // CHECK: define zeroext i1 @"\01?unspecDataMemptrEq@@YA_NPQUnspecified@@H0@Z"{{.*}} { 425 // CHECK: extractvalue { i32, i32, i32 } %{{.*}}, 0 426 // CHECK: extractvalue { i32, i32, i32 } %{{.*}}, 0 427 // CHECK: icmp eq i32 428 // CHECK: extractvalue { i32, i32, i32 } %{{.*}}, 1 429 // CHECK: extractvalue { i32, i32, i32 } %{{.*}}, 1 430 // CHECK: icmp eq i32 431 // CHECK: extractvalue { i32, i32, i32 } %{{.*}}, 2 432 // CHECK: extractvalue { i32, i32, i32 } %{{.*}}, 2 433 // CHECK: icmp eq i32 434 // CHECK: and i1 435 // CHECK: and i1 436 // CHECK: ret i1 437 // CHECK: } 438 } 439 440 void (Multiple::*convertB2FuncToMultiple(void (B2::*mp)()))() { 441 return mp; 442 // CHECK: define i64 @"\01?convertB2FuncToMultiple@@YAP8Multiple@@AEXXZP8B2@@AEXXZ@Z"{{.*}} { 443 // CHECK: store 444 // CHECK: %[[mp:.*]] = load i8** %{{.*}}, align 4 445 // CHECK: icmp ne i8* %[[mp]], null 446 // CHECK: br i1 %{{.*}} label %{{.*}}, label %{{.*}} 447 // 448 // memptr.convert: ; preds = %entry 449 // CHECK: insertvalue { i8*, i32 } undef, i8* %[[mp]], 0 450 // CHECK: insertvalue { i8*, i32 } %{{.*}}, i32 4, 1 451 // CHECK: br label 452 // 453 // memptr.converted: ; preds = %memptr.convert, %entry 454 // CHECK: phi { i8*, i32 } [ zeroinitializer, %{{.*}} ], [ {{.*}} ] 455 // CHECK: } 456 } 457 458 void (B2::*convertMultipleFuncToB2(void (Multiple::*mp)()))() { 459 // FIXME: cl emits warning C4407 on this code because of the representation 460 // change. We might want to do the same. 461 return static_cast<void (B2::*)()>(mp); 462 // FIXME: We should return i8* instead of i32 here. The ptrtoint cast prevents 463 // LLVM from optimizing away the branch. This is likely a bug in 464 // lib/CodeGen/TargetInfo.cpp with how we classify memptr types for returns. 465 // 466 // CHECK: define i32 @"\01?convertMultipleFuncToB2@@YAP8B2@@AEXXZP8Multiple@@AEXXZ@Z"{{.*}} { 467 // CHECK: store 468 // CHECK: %[[src:.*]] = load { i8*, i32 }* %{{.*}}, align 8 469 // CHECK: extractvalue { i8*, i32 } %[[src]], 0 470 // CHECK: icmp ne i8* %{{.*}}, null 471 // CHECK: br i1 %{{.*}}, label %{{.*}}, label %{{.*}} 472 // 473 // memptr.convert: ; preds = %entry 474 // CHECK: %[[fp:.*]] = extractvalue { i8*, i32 } %[[src]], 0 475 // CHECK: br label 476 // 477 // memptr.converted: ; preds = %memptr.convert, %entry 478 // CHECK: phi i8* [ null, %{{.*}} ], [ %[[fp]], %{{.*}} ] 479 // CHECK: } 480 } 481 482 namespace Test1 { 483 484 struct A { int a; }; 485 struct B { int b; }; 486 struct C : virtual A { int c; }; 487 struct D : B, C { int d; }; 488 489 void (D::*convertCToD(void (C::*mp)()))() { 490 return mp; 491 // CHECK: define void @"\01?convertCToD@Test1@@YAP8D@1@AEXXZP8C@1@AEXXZ@Z"{{.*}} { 492 // CHECK: store 493 // CHECK: load { i8*, i32, i32 }* %{{.*}}, align 8 494 // CHECK: extractvalue { i8*, i32, i32 } %{{.*}}, 0 495 // CHECK: icmp ne i8* %{{.*}}, null 496 // CHECK: br i1 %{{.*}}, label %{{.*}}, label %{{.*}} 497 // 498 // memptr.convert: ; preds = %entry 499 // CHECK: extractvalue { i8*, i32, i32 } %{{.*}}, 0 500 // CHECK: extractvalue { i8*, i32, i32 } %{{.*}}, 1 501 // CHECK: extractvalue { i8*, i32, i32 } %{{.*}}, 2 502 // CHECK: %[[adj:.*]] = add nsw i32 %{{.*}}, 4 503 // CHECK: insertvalue { i8*, i32, i32 } undef, i8* {{.*}}, 0 504 // CHECK: insertvalue { i8*, i32, i32 } {{.*}}, i32 %[[adj]], 1 505 // CHECK: insertvalue { i8*, i32, i32 } {{.*}}, i32 {{.*}}, 2 506 // CHECK: br label 507 // 508 // memptr.converted: ; preds = %memptr.convert, %entry 509 // CHECK: phi { i8*, i32, i32 } [ { i8* null, i32 0, i32 -1 }, {{.*}} ], [ {{.*}} ] 510 // CHECK: } 511 } 512 513 } 514 515 namespace Test2 { 516 // Test that we dynamically convert between different null reps. 517 518 struct A { int a; }; 519 struct B : A { int b; }; 520 struct C : A { 521 int c; 522 virtual void hasVfPtr(); 523 }; 524 525 int A::*reinterpret(int B::*mp) { 526 return reinterpret_cast<int A::*>(mp); 527 // CHECK: define i32 @"\01?reinterpret@Test2@@YAPQA@1@HPQB@1@H@Z"{{.*}} { 528 // CHECK-NOT: select 529 // CHECK: ret i32 530 // CHECK: } 531 } 532 533 int A::*reinterpret(int C::*mp) { 534 return reinterpret_cast<int A::*>(mp); 535 // CHECK: define i32 @"\01?reinterpret@Test2@@YAPQA@1@HPQC@1@H@Z"{{.*}} { 536 // CHECK: %[[mp:.*]] = load i32* 537 // CHECK: %[[cmp:.*]] = icmp ne i32 %[[mp]], 0 538 // CHECK: select i1 %[[cmp]], i32 %[[mp]], i32 -1 539 // CHECK: } 540 } 541 542 } 543 544 namespace Test3 { 545 // Make sure we cast 'this' to i8* before using GEP. 546 547 struct A { 548 int a; 549 int b; 550 }; 551 552 int *load_data(A *a, int A::*mp) { 553 return &(a->*mp); 554 // CHECK-LABEL: define i32* @"\01?load_data@Test3@@YAPAHPAUA@1@PQ21@H@Z"{{.*}} { 555 // CHECK: %[[a:.*]] = load %"struct.Test3::A"** %{{.*}}, align 4 556 // CHECK: %[[mp:.*]] = load i32* %{{.*}}, align 4 557 // CHECK: %[[a_i8:.*]] = bitcast %"struct.Test3::A"* %[[a]] to i8* 558 // CHECK: getelementptr inbounds i8* %[[a_i8]], i32 %[[mp]] 559 // CHECK: } 560 } 561 562 } 563 564 namespace Test4 { 565 566 struct A { virtual void f(); }; 567 struct B { virtual void g(); }; 568 struct C : A, B { virtual void g(); }; 569 570 void (C::*getmp())() { 571 return &C::g; 572 } 573 // CHECK-LABEL: define i64 @"\01?getmp@Test4@@YAP8C@1@AEXXZXZ"() 574 // CHECK: store { i8*, i32 } { i8* bitcast (void (i8*)* @"\01??_9C@Test4@@$BA@AE" to i8*), i32 4 }, { i8*, i32 }* %{{.*}} 575 // 576 577 // CHECK-LABEL: define linkonce_odr x86_thiscallcc void @"\01??_9C@Test4@@$BA@AE"(i8*) 578 // CHECK-NOT: getelementptr 579 // CHECK: load void (i8*)*** %{{.*}} 580 // CHECK: getelementptr inbounds void (i8*)** %{{.*}}, i64 0 581 // CHECK-NOT: getelementptr 582 // CHECK: call x86_thiscallcc void % 583 584 } 585 586 #else 587 struct __virtual_inheritance A; 588 #ifdef MEMFUN 589 int foo(A *a, int (A::*mp)()) { 590 return (a->*mp)(); // expected-error{{requires a complete class type}} 591 } 592 #else 593 int foo(A *a, int A::*mp) { 594 return a->*mp; // expected-error{{requires a complete class type}} 595 } 596 #endif 597 #endif 598