1 // RUN: %clang_cc1 -std=c++11 -Wno-uninitialized -fno-rtti -emit-llvm %s -o - -triple=i386-pc-win32 -fms-extensions | FileCheck -allow-deprecated-dag-overlap %s 2 // RUN: %clang_cc1 -std=c++11 -Wno-uninitialized -fno-rtti -emit-llvm %s -o - -triple=x86_64-pc-win32 -fms-extensions | FileCheck %s -check-prefix=X64 3 // RUN: %clang_cc1 -std=c++11 -Wno-uninitialized -fno-rtti -emit-llvm %s -o - -triple=i386-pc-win32 -DINCOMPLETE_VIRTUAL -fms-extensions -verify 4 // RUN: %clang_cc1 -std=c++11 -Wno-uninitialized -fno-rtti -emit-llvm %s -o - -triple=i386-pc-win32 -DINCOMPLETE_VIRTUAL -DMEMFUN -fms-extensions -verify 5 6 namespace pr37399 { 7 template <typename T> 8 struct Functor { 9 void (T::*PtrToMemberFunction)(); 10 }; 11 // CHECK-DAG: %"struct.pr37399::Functor" = type { i8* } 12 13 template <typename SomeType> 14 class SimpleDerivedFunctor; 15 template <typename SomeType> 16 class SimpleDerivedFunctor : public Functor<SimpleDerivedFunctor<SomeType>> {}; 17 // CHECK-DAG: %"class.pr37399::SimpleDerivedFunctor" = type { %"struct.pr37399::Functor" } 18 19 SimpleDerivedFunctor<void> SimpleFunctor; 20 // CHECK-DAG: @"?SimpleFunctor@pr37399@@3V?$SimpleDerivedFunctor@X@1@A" = dso_local global %"class.pr37399::SimpleDerivedFunctor" zeroinitializer, align 4 21 22 short Global = 0; 23 template <typename SomeType> 24 class DerivedFunctor; 25 template <typename SomeType> 26 class DerivedFunctor 27 : public Functor<DerivedFunctor<void>> { 28 public: 29 void Foo() { 30 Global = 42; 31 } 32 }; 33 34 class MultipleBase { 35 public: 36 MultipleBase() : Value() {} 37 short Value; 38 }; 39 // CHECK-DAG: %"class.pr37399::MultipleBase" = type { i16 } 40 41 template <typename SomeType> 42 class MultiplyDerivedFunctor; 43 template <typename SomeType> 44 class MultiplyDerivedFunctor 45 : public Functor<MultiplyDerivedFunctor<void>>, 46 public MultipleBase { 47 public: 48 void Foo() { 49 MultipleBase::Value = 42*2; 50 } 51 }; 52 53 class VirtualBase { 54 public: 55 VirtualBase() : Value() {} 56 short Value; 57 }; 58 // CHECK-DAG: %"class.pr37399::VirtualBase" = type { i16 } 59 60 template <typename SomeType> 61 class VirtBaseFunctor 62 : public Functor<SomeType>, 63 public virtual VirtualBase{}; 64 template <typename SomeType> 65 class VirtuallyDerivedFunctor; 66 template <typename SomeType> 67 class VirtuallyDerivedFunctor 68 : public VirtBaseFunctor<VirtuallyDerivedFunctor<void>>, 69 public virtual VirtualBase { 70 public: 71 void Foo() { 72 VirtualBase::Value = 42*3; 73 } 74 }; 75 } // namespace pr37399 76 77 pr37399::DerivedFunctor<int> BFunctor; 78 // CHECK-DAG: @"?BFunctor@@3V?$DerivedFunctor@H@pr37399@@A" = dso_local global %"[[BFUNCTOR:class.pr37399::DerivedFunctor(\.[0-9]+)?]]" zeroinitializer, align 8 79 // CHECK-DAG: %"[[BFUNCTOR]]" = type { %"[[BFUNCTORBASE:struct.pr37399::Functor(\.[0-9]+)?]]" } 80 // CHECK-DAG: %"[[BFUNCTORBASE]]" = type { { i8*, i32, i32, i32 } } 81 pr37399::DerivedFunctor<void> AFunctor; 82 // CHECK-DAG: @"?AFunctor@@3V?$DerivedFunctor@X@pr37399@@A" = dso_local global %"[[AFUNCTOR:class.pr37399::DerivedFunctor(\.[0-9]+)?]]" zeroinitializer, align 8 83 // CHECK-DAG: %"[[AFUNCTOR]]" = type { %"[[AFUNCTORBASE:struct.pr37399::Functor(\.[0-9]+)?]]" } 84 // CHECK-DAG: %"[[AFUNCTORBASE]]" = type { { i8*, i32, i32, i32 } } 85 86 pr37399::MultiplyDerivedFunctor<int> DFunctor; 87 // CHECK-DAG: @"?DFunctor@@3V?$MultiplyDerivedFunctor@H@pr37399@@A" = dso_local global %"[[DFUNCTOR:class.pr37399::MultiplyDerivedFunctor(\.[0-9]+)?]]" zeroinitializer, align 8 88 // CHECK-DAG: %"[[DFUNCTOR]]" = type { %"[[DFUNCTORBASE:struct.pr37399::Functor(\.[0-9]+)?]]", %"class.pr37399::MultipleBase", [6 x i8] } 89 // CHECK-DAG: %"[[DFUNCTORBASE]]" = type { { i8*, i32, i32, i32 } } 90 pr37399::MultiplyDerivedFunctor<void> CFunctor; 91 // CHECK-DAG: @"?CFunctor@@3V?$MultiplyDerivedFunctor@X@pr37399@@A" = dso_local global %"[[CFUNCTOR:class.pr37399::MultiplyDerivedFunctor(\.[0-9]+)?]]" zeroinitializer, align 8 92 // CHECK-DAG: %"[[CFUNCTOR]]" = type { %"[[CFUNCTORBASE:struct.pr37399::Functor(\.[0-9]+)?]]", %"class.pr37399::MultipleBase", [6 x i8] } 93 // CHECK-DAG: %"[[CFUNCTORBASE]]" = type { { i8*, i32, i32, i32 } } 94 95 pr37399::VirtuallyDerivedFunctor<int> FFunctor; 96 // CHECK-DAG: @"?FFunctor@@3V?$VirtuallyDerivedFunctor@H@pr37399@@A" = dso_local global %"[[FFUNCTOR:class.pr37399::VirtuallyDerivedFunctor(\.[0-9]+)?]]" zeroinitializer, align 8 97 // CHECK-DAG: %"[[FFUNCTOR]]" = type { %"class.pr37399::VirtBaseFunctor.base", %"class.pr37399::VirtualBase" } 98 pr37399::VirtuallyDerivedFunctor<void> EFunctor; 99 // CHECK-DAG: @"?EFunctor@@3V?$VirtuallyDerivedFunctor@X@pr37399@@A" = dso_local global %"[[EFUNCTOR:class.pr37399::VirtuallyDerivedFunctor(\.[0-9]+)?]]" zeroinitializer, align 8 100 // CHECK-DAG: %"[[EFUNCTOR]]" = type { %"class.pr37399::VirtBaseFunctor.base", %"class.pr37399::VirtualBase" } 101 102 // CHECK-DAG: %"class.pr37399::VirtBaseFunctor.base" = type <{ %"[[VFUNCTORBASE:struct.pr37399::Functor(\.[0-9]+)?]]", i32*, [4 x i8] }> 103 // CHECK-DAG: %"[[VFUNCTORBASE]]" = type { { i8*, i32, i32, i32 } } 104 105 namespace pr37399 { 106 void SingleInheritanceFnPtrCall() { 107 BFunctor.PtrToMemberFunction = &DerivedFunctor<void>::Foo; 108 (AFunctor.*(BFunctor.PtrToMemberFunction))(); 109 } 110 void MultipleInheritanceFnPtrCall() { 111 DFunctor.PtrToMemberFunction = &MultiplyDerivedFunctor<void>::Foo; 112 Global = CFunctor.MultipleBase::Value; 113 (CFunctor.*(DFunctor.PtrToMemberFunction))(); 114 Global = CFunctor.MultipleBase::Value; 115 } 116 void VirtualInheritanceFnPtrCall() { 117 FFunctor.PtrToMemberFunction = &VirtuallyDerivedFunctor<void>::Foo; 118 Global = EFunctor.VirtualBase::Value; 119 (EFunctor.*(FFunctor.PtrToMemberFunction))(); 120 Global = EFunctor.VirtualBase::Value; 121 } 122 } // namespace pr37399 123 124 namespace pr43803 { 125 // This case is interesting because it exercises conversion between member 126 // pointer types when emitting constants. 127 128 struct B; 129 struct C { int B::*option; }; 130 extern const C table[3]; 131 struct A { 132 int x, y; 133 // Test the indirect case. 134 struct { 135 int z; 136 }; 137 }; 138 struct B : A {}; 139 const C table[] = { 140 {&B::x}, 141 {&B::y}, 142 {&B::z}, 143 }; 144 145 // CHECK: @"?table@pr43803@@3QBUC@1@B" = dso_local constant [3 x %"struct.pr43803::C"] 146 // CHECK-SAME: [%"struct.pr43803::C" { { i32, i32, i32 } zeroinitializer, [4 x i8] undef }, 147 // CHECK-SAME: %"struct.pr43803::C" { { i32, i32, i32 } { i32 4, i32 0, i32 0 }, [4 x i8] undef }, 148 // CHECK-SAME: %"struct.pr43803::C" { { i32, i32, i32 } { i32 8, i32 0, i32 0 }, [4 x i8] undef }] 149 } 150 151 namespace pr48687 { 152 template <typename T> struct A { 153 T value; 154 static constexpr auto address = &A<T>::value; 155 }; 156 extern template class A<float>; 157 template class A<float>; 158 // CHECK: @"?address@?$A@M@pr48687@@2QQ12@MQ12@" = weak_odr dso_local constant i32 0, comdat, align 4 159 } 160 161 struct PR26313_Y; 162 typedef void (PR26313_Y::*PR26313_FUNC)(); 163 struct PR26313_X { 164 PR26313_FUNC *ptr; 165 PR26313_X(); 166 }; 167 PR26313_X::PR26313_X() {} 168 void PR26313_f(PR26313_FUNC *p) { delete p; } 169 170 struct PR26313_Z; 171 int PR26313_Z::**a = nullptr; 172 int PR26313_Z::*b = *a; 173 // CHECK-DAG: @"?a@@3PAPQPR26313_Z@@HA" = dso_local global %0* null, align 4 174 // CHECK-DAG: @"?b@@3PQPR26313_Z@@HQ1@" = dso_local global { i32, i32, i32 } { i32 0, i32 0, i32 -1 }, align 4 175 176 namespace PR20947 { 177 struct A; 178 int A::**a = nullptr; 179 // CHECK-DAG: @"?a@PR20947@@3PAPQA@1@HA" = dso_local global %{{.*}}* null, align 4 180 181 struct B; 182 int B::*&b = b; 183 // CHECK-DAG: @"?b@PR20947@@3AAPQB@1@HA" = dso_local global %{{.*}}* null, align 4 184 } 185 186 namespace PR20017 { 187 template <typename T> 188 struct A { 189 int T::*m_fn1() { return nullptr; } 190 }; 191 struct B; 192 auto a = &A<B>::m_fn1; 193 // CHECK-DAG: @"?a@PR20017@@3P8?$A@UB@PR20017@@@1@AEPQB@1@HXZQ21@" = dso_local global i8* bitcast ({ i32, i32, i32 } ({{.*}}*)* @"?m_fn1@?$A@UB@PR20017@@@PR20017@@QAEPQB@2@HXZ" to i8*), align 4 194 } 195 196 #ifndef INCOMPLETE_VIRTUAL 197 struct B1 { 198 void foo(); 199 int b; 200 }; 201 struct B2 { 202 int b2; 203 void foo(); 204 }; 205 struct Single : B1 { 206 void foo(); 207 }; 208 struct Multiple : B1, B2 { 209 int m; 210 void foo(); 211 }; 212 struct Virtual : virtual B1 { 213 int v; 214 void foo(); 215 }; 216 217 struct POD { 218 int a; 219 int b; 220 }; 221 222 struct Polymorphic { 223 virtual void myVirtual(); 224 int a; 225 int b; 226 }; 227 228 // This class uses the virtual inheritance model, yet its vbptr offset is not 0. 229 // We still use zero for the null field offset, despite it being a valid field 230 // offset. 231 struct NonZeroVBPtr : POD, Virtual { 232 int n; 233 void foo(); 234 }; 235 236 struct Unspecified; 237 struct UnspecSingle; 238 239 // Check that we can lower the LLVM types and get the null initializers right. 240 int Single ::*s_d_memptr; 241 int Polymorphic::*p_d_memptr; 242 int Multiple ::*m_d_memptr; 243 int Virtual ::*v_d_memptr; 244 int NonZeroVBPtr::*n_d_memptr; 245 int Unspecified::*u_d_memptr; 246 int UnspecSingle::*us_d_memptr; 247 // CHECK: @"?s_d_memptr@@3PQSingle@@HQ1@" = dso_local global i32 -1, align 4 248 // CHECK: @"?p_d_memptr@@3PQPolymorphic@@HQ1@" = dso_local global i32 0, align 4 249 // CHECK: @"?m_d_memptr@@3PQMultiple@@HQ1@" = dso_local global i32 -1, align 4 250 // CHECK: @"?v_d_memptr@@3PQVirtual@@HQ1@" = dso_local global { i32, i32 } 251 // CHECK: { i32 0, i32 -1 }, align 4 252 // CHECK: @"?n_d_memptr@@3PQNonZeroVBPtr@@HQ1@" = dso_local global { i32, i32 } 253 // CHECK: { i32 0, i32 -1 }, align 4 254 // CHECK: @"?u_d_memptr@@3PQUnspecified@@HQ1@" = dso_local global { i32, i32, i32 } 255 // CHECK: { i32 0, i32 0, i32 -1 }, align 4 256 // CHECK: @"?us_d_memptr@@3PQUnspecSingle@@HQ1@" = dso_local global { i32, i32, i32 } 257 // CHECK: { i32 0, i32 0, i32 -1 }, align 4 258 259 void (Single ::*s_f_memptr)(); 260 void (Multiple::*m_f_memptr)(); 261 void (Virtual ::*v_f_memptr)(); 262 // CHECK: @"?s_f_memptr@@3P8Single@@AEXXZQ1@" = dso_local global i8* null, align 4 263 // CHECK: @"?m_f_memptr@@3P8Multiple@@AEXXZQ1@" = dso_local global { i8*, i32 } zeroinitializer, align 4 264 // CHECK: @"?v_f_memptr@@3P8Virtual@@AEXXZQ1@" = dso_local global { i8*, i32, i32 } zeroinitializer, align 4 265 266 // We can define Unspecified after locking in the inheritance model. 267 struct Unspecified : Multiple, Virtual { 268 void foo(); 269 int u; 270 }; 271 272 struct UnspecSingle { 273 void foo(); 274 }; 275 276 // Test memptr emission in a constant expression. 277 namespace Const { 278 void (Single ::*s_f_mp)() = &Single::foo; 279 void (Multiple ::*m_f_mp)() = &B2::foo; 280 void (Virtual ::*v_f_mp)() = &Virtual::foo; 281 void (Unspecified::*u_f_mp)() = &Unspecified::foo; 282 void (UnspecSingle::*us_f_mp)() = &UnspecSingle::foo; 283 // CHECK: @"?s_f_mp@Const@@3P8Single@@AEXXZQ2@" = 284 // CHECK: global i8* bitcast ({{.*}} @"?foo@Single@@QAEXXZ" to i8*), align 4 285 // CHECK: @"?m_f_mp@Const@@3P8Multiple@@AEXXZQ2@" = 286 // CHECK: global { i8*, i32 } { i8* bitcast ({{.*}} @"?foo@B2@@QAEXXZ" to i8*), i32 4 }, align 4 287 // CHECK: @"?v_f_mp@Const@@3P8Virtual@@AEXXZQ2@" = 288 // CHECK: global { i8*, i32, i32 } { i8* bitcast ({{.*}} @"?foo@Virtual@@QAEXXZ" to i8*), i32 0, i32 0 }, align 4 289 // CHECK: @"?u_f_mp@Const@@3P8Unspecified@@AEXXZQ2@" = 290 // CHECK: global { i8*, i32, i32, i32 } { i8* bitcast ({{.*}} @"?foo@Unspecified@@QAEXXZ" to i8*), i32 0, i32 0, i32 0 }, align 4 291 // CHECK: @"?us_f_mp@Const@@3P8UnspecSingle@@AEXXZQ2@" = 292 // CHECK: global { i8*, i32, i32, i32 } { i8* bitcast ({{.*}} @"?foo@UnspecSingle@@QAEXXZ" to i8*), i32 0, i32 0, i32 0 }, align 4 293 } 294 295 namespace CastParam { 296 // This exercises ConstExprEmitter instead of ValueDecl::evaluateValue. The 297 // extra reinterpret_cast for the parameter type requires more careful folding. 298 // FIXME: Or does it? If reinterpret_casts are no-ops, we should be able to 299 // strip them in evaluateValue() and just proceed as normal with an APValue. 300 struct A { 301 int a; 302 void foo(A *p); 303 }; 304 struct B { int b; }; 305 struct C : B, A { int c; }; 306 307 void (A::*ptr1)(void *) = (void (A::*)(void *)) &A::foo; 308 // CHECK: @"?ptr1@CastParam@@3P8A@1@AEXPAX@ZQ21@" = 309 // CHECK: global i8* bitcast (void ({{.*}})* @"?foo@A@CastParam@@QAEXPAU12@@Z" to i8*), align 4 310 311 // Try a reinterpret_cast followed by a memptr conversion. 312 void (C::*ptr2)(void *) = (void (C::*)(void *)) (void (A::*)(void *)) &A::foo; 313 // CHECK: @"?ptr2@CastParam@@3P8C@1@AEXPAX@ZQ21@" = 314 // CHECK: global { i8*, i32 } { i8* bitcast (void ({{.*}})* @"?foo@A@CastParam@@QAEXPAU12@@Z" to i8*), i32 4 }, align 4 315 316 void (C::*ptr3)(void *) = (void (C::*)(void *)) (void (A::*)(void *)) (void (A::*)(A *)) 0; 317 // CHECK: @"?ptr3@CastParam@@3P8C@1@AEXPAX@ZQ21@" = 318 // CHECK: global { i8*, i32 } zeroinitializer, align 4 319 320 struct D : C { 321 virtual void isPolymorphic(); 322 int d; 323 }; 324 325 // Try a cast that changes the inheritance model. Null for D is 0, but null for 326 // C is -1. We need the cast to long in order to hit the non-APValue path. 327 int C::*ptr4 = (int C::*) (int D::*) (long D::*) 0; 328 // CHECK: @"?ptr4@CastParam@@3PQC@1@HQ21@" = dso_local global i32 -1, align 4 329 330 // MSVC rejects this but we accept it. 331 int C::*ptr5 = (int C::*) (long D::*) 0; 332 // CHECK: @"?ptr5@CastParam@@3PQC@1@HQ21@" = dso_local global i32 -1, align 4 333 } 334 335 struct UnspecWithVBPtr; 336 int UnspecWithVBPtr::*forceUnspecWithVBPtr; 337 struct UnspecWithVBPtr : B1, virtual B2 { 338 int u; 339 void foo(); 340 }; 341 342 // Test emitting non-virtual member pointers in a non-constexpr setting. 343 void EmitNonVirtualMemberPointers() { 344 void (Single ::*s_f_memptr)() = &Single::foo; 345 void (Multiple ::*m_f_memptr)() = &Multiple::foo; 346 void (Virtual ::*v_f_memptr)() = &Virtual::foo; 347 void (Unspecified::*u_f_memptr)() = &Unspecified::foo; 348 void (UnspecWithVBPtr::*u2_f_memptr)() = &UnspecWithVBPtr::foo; 349 // CHECK: define dso_local void @"?EmitNonVirtualMemberPointers@@YAXXZ"() {{.*}} { 350 // CHECK: alloca i8*, align 4 351 // CHECK: alloca { i8*, i32 }, align 4 352 // CHECK: alloca { i8*, i32, i32 }, align 4 353 // CHECK: alloca { i8*, i32, i32, i32 }, align 4 354 // CHECK: store i8* bitcast (void (%{{.*}}*)* @"?foo@Single@@QAEXXZ" to i8*), i8** %{{.*}}, align 4 355 // CHECK: store { i8*, i32 } 356 // CHECK: { i8* bitcast (void (%{{.*}}*)* @"?foo@Multiple@@QAEXXZ" to i8*), i32 0 }, 357 // CHECK: { i8*, i32 }* %{{.*}}, align 4 358 // CHECK: store { i8*, i32, i32 } 359 // CHECK: { i8* bitcast (void (%{{.*}}*)* @"?foo@Virtual@@QAEXXZ" to i8*), i32 0, i32 0 }, 360 // CHECK: { i8*, i32, i32 }* %{{.*}}, align 4 361 // CHECK: store { i8*, i32, i32, i32 } 362 // CHECK: { i8* bitcast (void (%{{.*}}*)* @"?foo@Unspecified@@QAEXXZ" to i8*), i32 0, i32 0, i32 0 }, 363 // CHECK: { i8*, i32, i32, i32 }* %{{.*}}, align 4 364 // CHECK: store { i8*, i32, i32, i32 } 365 // CHECK: { i8* bitcast (void (%{{.*}}*)* @"?foo@UnspecWithVBPtr@@QAEXXZ" to i8*), 366 // CHECK: i32 0, i32 0, i32 0 }, 367 // CHECK: { i8*, i32, i32, i32 }* %{{.*}}, align 4 368 // CHECK: ret void 369 // CHECK: } 370 } 371 372 void podMemPtrs() { 373 int POD::*memptr; 374 memptr = &POD::a; 375 memptr = &POD::b; 376 if (memptr) 377 memptr = 0; 378 // Check that member pointers use the right offsets and that null is -1. 379 // CHECK: define dso_local void @"?podMemPtrs@@YAXXZ"() {{.*}} { 380 // CHECK: %[[memptr:.*]] = alloca i32, align 4 381 // CHECK-NEXT: store i32 0, i32* %[[memptr]], align 4 382 // CHECK-NEXT: store i32 4, i32* %[[memptr]], align 4 383 // CHECK-NEXT: %[[memptr_val:.*]] = load i32, i32* %[[memptr]], align 4 384 // CHECK-NEXT: %{{.*}} = icmp ne i32 %[[memptr_val]], -1 385 // CHECK-NEXT: br i1 %{{.*}}, label %{{.*}}, label %{{.*}} 386 // CHECK: store i32 -1, i32* %[[memptr]], align 4 387 // CHECK: ret void 388 // CHECK: } 389 } 390 391 void polymorphicMemPtrs() { 392 int Polymorphic::*memptr; 393 memptr = &Polymorphic::a; 394 memptr = &Polymorphic::b; 395 if (memptr) 396 memptr = 0; 397 // Member pointers for polymorphic classes include the vtable slot in their 398 // offset and use 0 to represent null. 399 // CHECK: define dso_local void @"?polymorphicMemPtrs@@YAXXZ"() {{.*}} { 400 // CHECK: %[[memptr:.*]] = alloca i32, align 4 401 // CHECK-NEXT: store i32 4, i32* %[[memptr]], align 4 402 // CHECK-NEXT: store i32 8, i32* %[[memptr]], align 4 403 // CHECK-NEXT: %[[memptr_val:.*]] = load i32, i32* %[[memptr]], align 4 404 // CHECK-NEXT: %{{.*}} = icmp ne i32 %[[memptr_val]], 0 405 // CHECK-NEXT: br i1 %{{.*}}, label %{{.*}}, label %{{.*}} 406 // CHECK: store i32 0, i32* %[[memptr]], align 4 407 // CHECK: ret void 408 // CHECK: } 409 } 410 411 bool nullTestDataUnspecified(int Unspecified::*mp) { 412 return mp; 413 // CHECK: define dso_local zeroext i1 @"?nullTestDataUnspecified@@YA_NPQUnspecified@@H@Z"{{.*}} { 414 // CHECK: %{{.*}} = load { i32, i32, i32 }, { i32, i32, i32 }* %{{.*}}, align 4 415 // CHECK: store { i32, i32, i32 } {{.*}} align 4 416 // CHECK: %[[mp:.*]] = load { i32, i32, i32 }, { i32, i32, i32 }* %{{.*}}, align 4 417 // CHECK: %[[mp0:.*]] = extractvalue { i32, i32, i32 } %[[mp]], 0 418 // CHECK: %[[cmp0:.*]] = icmp ne i32 %[[mp0]], 0 419 // CHECK: %[[mp1:.*]] = extractvalue { i32, i32, i32 } %[[mp]], 1 420 // CHECK: %[[cmp1:.*]] = icmp ne i32 %[[mp1]], 0 421 // CHECK: %[[and0:.*]] = or i1 %[[cmp0]], %[[cmp1]] 422 // CHECK: %[[mp2:.*]] = extractvalue { i32, i32, i32 } %[[mp]], 2 423 // CHECK: %[[cmp2:.*]] = icmp ne i32 %[[mp2]], -1 424 // CHECK: %[[and1:.*]] = or i1 %[[and0]], %[[cmp2]] 425 // CHECK: ret i1 %[[and1]] 426 // CHECK: } 427 428 // Pass this large type indirectly. 429 // X64-LABEL: define dso_local zeroext i1 @"?nullTestDataUnspecified@@ 430 // X64: ({ i32, i32, i32 }* %0) 431 } 432 433 bool nullTestFunctionUnspecified(void (Unspecified::*mp)()) { 434 return mp; 435 // CHECK: define dso_local zeroext i1 @"?nullTestFunctionUnspecified@@YA_NP8Unspecified@@AEXXZ@Z"{{.*}} { 436 // CHECK: %{{.*}} = load { i8*, i32, i32, i32 }, { i8*, i32, i32, i32 }* %{{.*}}, align 4 437 // CHECK: store { i8*, i32, i32, i32 } {{.*}} align 4 438 // CHECK: %[[mp:.*]] = load { i8*, i32, i32, i32 }, { i8*, i32, i32, i32 }* %{{.*}}, align 4 439 // CHECK: %[[mp0:.*]] = extractvalue { i8*, i32, i32, i32 } %[[mp]], 0 440 // CHECK: %[[cmp0:.*]] = icmp ne i8* %[[mp0]], null 441 // CHECK: ret i1 %[[cmp0]] 442 // CHECK: } 443 } 444 445 int loadDataMemberPointerVirtual(Virtual *o, int Virtual::*memptr) { 446 return o->*memptr; 447 // Test that we can unpack this aggregate member pointer and load the member 448 // data pointer. 449 // CHECK: define dso_local i32 @"?loadDataMemberPointerVirtual@@YAHPAUVirtual@@PQ1@H@Z"{{.*}} { 450 // CHECK: %[[o:.*]] = load %{{.*}}*, %{{.*}}** %{{.*}}, align 4 451 // CHECK: %[[memptr:.*]] = load { i32, i32 }, { i32, i32 }* %{{.*}}, align 4 452 // CHECK: %[[memptr0:.*]] = extractvalue { i32, i32 } %[[memptr:.*]], 0 453 // CHECK: %[[memptr1:.*]] = extractvalue { i32, i32 } %[[memptr:.*]], 1 454 // CHECK: %[[v6:.*]] = bitcast %{{.*}}* %[[o]] to i8* 455 // CHECK: %[[vbptr:.*]] = getelementptr inbounds i8, i8* %[[v6]], i32 0 456 // CHECK: %[[vbptr_a:.*]] = bitcast i8* %[[vbptr]] to i32** 457 // CHECK: %[[vbtable:.*]] = load i32*, i32** %[[vbptr_a:.*]] 458 // CHECK: %[[memptr1_shr:.*]] = ashr exact i32 %[[memptr1]], 2 459 // CHECK: %[[v7:.*]] = getelementptr inbounds i32, i32* %[[vbtable]], i32 %[[memptr1_shr]] 460 // CHECK: %[[vbase_offs:.*]] = load i32, i32* %[[v7]] 461 // CHECK: %[[v10:.*]] = getelementptr inbounds i8, i8* %[[vbptr]], i32 %[[vbase_offs]] 462 // CHECK: %[[offset:.*]] = getelementptr inbounds i8, i8* %[[v10]], i32 %[[memptr0]] 463 // CHECK: %[[v11:.*]] = bitcast i8* %[[offset]] to i32* 464 // CHECK: %[[v12:.*]] = load i32, i32* %[[v11]] 465 // CHECK: ret i32 %[[v12]] 466 // CHECK: } 467 468 // A two-field data memptr on x64 gets coerced to i64 and is passed in a 469 // register or memory. 470 // X64-LABEL: define dso_local i32 @"?loadDataMemberPointerVirtual@@YAHPEAUVirtual@@PEQ1@H@Z" 471 // X64: (%struct.Virtual* %o, i64 %memptr.coerce) 472 } 473 474 int loadDataMemberPointerUnspecified(Unspecified *o, int Unspecified::*memptr) { 475 return o->*memptr; 476 // Test that we can unpack this aggregate member pointer and load the member 477 // data pointer. 478 // CHECK: define dso_local i32 @"?loadDataMemberPointerUnspecified@@YAHPAUUnspecified@@PQ1@H@Z"{{.*}} { 479 // CHECK: %[[o:.*]] = load %{{.*}}*, %{{.*}}** %{{.*}}, align 4 480 // CHECK: %[[memptr:.*]] = load { i32, i32, i32 }, { i32, i32, i32 }* %{{.*}}, align 4 481 // CHECK: %[[memptr0:.*]] = extractvalue { i32, i32, i32 } %[[memptr:.*]], 0 482 // CHECK: %[[memptr1:.*]] = extractvalue { i32, i32, i32 } %[[memptr:.*]], 1 483 // CHECK: %[[memptr2:.*]] = extractvalue { i32, i32, i32 } %[[memptr:.*]], 2 484 // CHECK: %[[base:.*]] = bitcast %{{.*}}* %[[o]] to i8* 485 // CHECK: %[[is_vbase:.*]] = icmp ne i32 %[[memptr2]], 0 486 // CHECK: br i1 %[[is_vbase]], label %[[vadjust:.*]], label %[[skip:.*]] 487 // 488 // CHECK: [[vadjust]] 489 // CHECK: %[[vbptr:.*]] = getelementptr inbounds i8, i8* %[[base]], i32 %[[memptr1]] 490 // CHECK: %[[vbptr_a:.*]] = bitcast i8* %[[vbptr]] to i32** 491 // CHECK: %[[vbtable:.*]] = load i32*, i32** %[[vbptr_a:.*]] 492 // CHECK: %[[memptr2_shr:.*]] = ashr exact i32 %[[memptr2]], 2 493 // CHECK: %[[v7:.*]] = getelementptr inbounds i32, i32* %[[vbtable]], i32 %[[memptr2_shr]] 494 // CHECK: %[[vbase_offs:.*]] = load i32, i32* %[[v7]] 495 // CHECK: %[[base_adj:.*]] = getelementptr inbounds i8, i8* %[[vbptr]], i32 %[[vbase_offs]] 496 // 497 // CHECK: [[skip]] 498 // CHECK: %[[new_base:.*]] = phi i8* [ %[[base]], %{{.*}} ], [ %[[base_adj]], %[[vadjust]] ] 499 // CHECK: %[[offset:.*]] = getelementptr inbounds i8, i8* %[[new_base]], i32 %[[memptr0]] 500 // CHECK: %[[v11:.*]] = bitcast i8* %[[offset]] to i32* 501 // CHECK: %[[v12:.*]] = load i32, i32* %[[v11]] 502 // CHECK: ret i32 %[[v12]] 503 // CHECK: } 504 } 505 506 void callMemberPointerSingle(Single *o, void (Single::*memptr)()) { 507 (o->*memptr)(); 508 // Just look for an indirect thiscall. 509 // CHECK: define dso_local void @"?callMemberPointerSingle@@{{.*}} {{.*}} { 510 // CHECK: call x86_thiscallcc void %{{.*}}(%{{.*}} %{{.*}}) 511 // CHECK: ret void 512 // CHECK: } 513 514 // X64-LABEL: define dso_local void @"?callMemberPointerSingle@@ 515 // X64: (%struct.Single* %o, i8* %memptr) 516 // X64: bitcast i8* %{{[^ ]*}} to void (%struct.Single*)* 517 // X64: ret void 518 } 519 520 void callMemberPointerMultiple(Multiple *o, void (Multiple::*memptr)()) { 521 (o->*memptr)(); 522 // CHECK: define dso_local void @"?callMemberPointerMultiple@@{{.*}} { 523 // CHECK: %[[memptr0:.*]] = extractvalue { i8*, i32 } %{{.*}}, 0 524 // CHECK: %[[memptr1:.*]] = extractvalue { i8*, i32 } %{{.*}}, 1 525 // CHECK: %[[this_adjusted:.*]] = getelementptr inbounds i8, i8* %{{.*}}, i32 %[[memptr1]] 526 // CHECK: %[[this:.*]] = bitcast i8* %[[this_adjusted]] to {{.*}} 527 // CHECK: %[[fptr:.*]] = bitcast i8* %[[memptr0]] to {{.*}} 528 // CHECK: call x86_thiscallcc void %[[fptr]](%{{.*}} %[[this]]) 529 // CHECK: ret void 530 // CHECK: } 531 } 532 533 void callMemberPointerVirtualBase(Virtual *o, void (Virtual::*memptr)()) { 534 (o->*memptr)(); 535 // This shares a lot with virtual data member pointers. 536 // CHECK: define dso_local void @"?callMemberPointerVirtualBase@@{{.*}} { 537 // CHECK: %[[memptr0:.*]] = extractvalue { i8*, i32, i32 } %{{.*}}, 0 538 // CHECK: %[[memptr1:.*]] = extractvalue { i8*, i32, i32 } %{{.*}}, 1 539 // CHECK: %[[memptr2:.*]] = extractvalue { i8*, i32, i32 } %{{.*}}, 2 540 // CHECK: %[[vbptr:.*]] = getelementptr inbounds i8, i8* %{{.*}}, i32 0 541 // CHECK: %[[vbptr_a:.*]] = bitcast i8* %[[vbptr]] to i32** 542 // CHECK: %[[vbtable:.*]] = load i32*, i32** %[[vbptr_a:.*]] 543 // CHECK: %[[memptr2_shr:.*]] = ashr exact i32 %[[memptr2]], 2 544 // CHECK: %[[v7:.*]] = getelementptr inbounds i32, i32* %[[vbtable]], i32 %[[memptr2_shr]] 545 // CHECK: %[[vbase_offs:.*]] = load i32, i32* %[[v7]] 546 // CHECK: %[[v10:.*]] = getelementptr inbounds i8, i8* %[[vbptr]], i32 %[[vbase_offs]] 547 // CHECK: %[[this_adjusted:.*]] = getelementptr inbounds i8, i8* %[[v10]], i32 %[[memptr1]] 548 // CHECK: %[[fptr:.*]] = bitcast i8* %[[memptr0]] to void ({{.*}}) 549 // CHECK: %[[this:.*]] = bitcast i8* %[[this_adjusted]] to {{.*}} 550 // CHECK: call x86_thiscallcc void %[[fptr]](%{{.*}} %[[this]]) 551 // CHECK: ret void 552 // CHECK: } 553 } 554 555 bool compareSingleFunctionMemptr(void (Single::*l)(), void (Single::*r)()) { 556 return l == r; 557 // Should only be one comparison here. 558 // CHECK: define dso_local zeroext i1 @"?compareSingleFunctionMemptr@@YA_NP8Single@@AEXXZ0@Z"{{.*}} { 559 // CHECK-NOT: icmp 560 // CHECK: %[[r:.*]] = icmp eq 561 // CHECK-NOT: icmp 562 // CHECK: ret i1 %[[r]] 563 // CHECK: } 564 565 // X64-LABEL: define dso_local zeroext i1 @"?compareSingleFunctionMemptr@@ 566 // X64: (i8* %{{[^,]*}}, i8* %{{[^)]*}}) 567 } 568 569 bool compareNeqSingleFunctionMemptr(void (Single::*l)(), void (Single::*r)()) { 570 return l != r; 571 // Should only be one comparison here. 572 // CHECK: define dso_local zeroext i1 @"?compareNeqSingleFunctionMemptr@@YA_NP8Single@@AEXXZ0@Z"{{.*}} { 573 // CHECK-NOT: icmp 574 // CHECK: %[[r:.*]] = icmp ne 575 // CHECK-NOT: icmp 576 // CHECK: ret i1 %[[r]] 577 // CHECK: } 578 } 579 580 bool unspecFuncMemptrEq(void (Unspecified::*l)(), void (Unspecified::*r)()) { 581 return l == r; 582 // CHECK: define dso_local zeroext i1 @"?unspecFuncMemptrEq@@YA_NP8Unspecified@@AEXXZ0@Z"{{.*}} { 583 // CHECK: %[[lhs0:.*]] = extractvalue { i8*, i32, i32, i32 } %[[l:.*]], 0 584 // CHECK: %{{.*}} = extractvalue { i8*, i32, i32, i32 } %[[r:.*]], 0 585 // CHECK: %[[cmp0:.*]] = icmp eq i8* %[[lhs0]], %{{.*}} 586 // CHECK: %{{.*}} = extractvalue { i8*, i32, i32, i32 } %[[l]], 1 587 // CHECK: %{{.*}} = extractvalue { i8*, i32, i32, i32 } %[[r]], 1 588 // CHECK: %[[cmp1:.*]] = icmp eq i32 589 // CHECK: %{{.*}} = extractvalue { i8*, i32, i32, i32 } %[[l]], 2 590 // CHECK: %{{.*}} = extractvalue { i8*, i32, i32, i32 } %[[r]], 2 591 // CHECK: %[[cmp2:.*]] = icmp eq i32 592 // CHECK: %[[res12:.*]] = and i1 %[[cmp1]], %[[cmp2]] 593 // CHECK: %{{.*}} = extractvalue { i8*, i32, i32, i32 } %[[l]], 3 594 // CHECK: %{{.*}} = extractvalue { i8*, i32, i32, i32 } %[[r]], 3 595 // CHECK: %[[cmp3:.*]] = icmp eq i32 596 // CHECK: %[[res123:.*]] = and i1 %[[res12]], %[[cmp3]] 597 // CHECK: %[[iszero:.*]] = icmp eq i8* %[[lhs0]], null 598 // CHECK: %[[bits_or_null:.*]] = or i1 %[[res123]], %[[iszero]] 599 // CHECK: %{{.*}} = and i1 %[[bits_or_null]], %[[cmp0]] 600 // CHECK: ret i1 %{{.*}} 601 // CHECK: } 602 603 // X64-LABEL: define dso_local zeroext i1 @"?unspecFuncMemptrEq@@ 604 // X64: ({ i8*, i32, i32, i32 }* %0, { i8*, i32, i32, i32 }* %1) 605 } 606 607 bool unspecFuncMemptrNeq(void (Unspecified::*l)(), void (Unspecified::*r)()) { 608 return l != r; 609 // CHECK: define dso_local zeroext i1 @"?unspecFuncMemptrNeq@@YA_NP8Unspecified@@AEXXZ0@Z"{{.*}} { 610 // CHECK: %[[lhs0:.*]] = extractvalue { i8*, i32, i32, i32 } %[[l:.*]], 0 611 // CHECK: %{{.*}} = extractvalue { i8*, i32, i32, i32 } %[[r:.*]], 0 612 // CHECK: %[[cmp0:.*]] = icmp ne i8* %[[lhs0]], %{{.*}} 613 // CHECK: %{{.*}} = extractvalue { i8*, i32, i32, i32 } %[[l]], 1 614 // CHECK: %{{.*}} = extractvalue { i8*, i32, i32, i32 } %[[r]], 1 615 // CHECK: %[[cmp1:.*]] = icmp ne i32 616 // CHECK: %{{.*}} = extractvalue { i8*, i32, i32, i32 } %[[l]], 2 617 // CHECK: %{{.*}} = extractvalue { i8*, i32, i32, i32 } %[[r]], 2 618 // CHECK: %[[cmp2:.*]] = icmp ne i32 619 // CHECK: %[[res12:.*]] = or i1 %[[cmp1]], %[[cmp2]] 620 // CHECK: %{{.*}} = extractvalue { i8*, i32, i32, i32 } %[[l]], 3 621 // CHECK: %{{.*}} = extractvalue { i8*, i32, i32, i32 } %[[r]], 3 622 // CHECK: %[[cmp3:.*]] = icmp ne i32 623 // CHECK: %[[res123:.*]] = or i1 %[[res12]], %[[cmp3]] 624 // CHECK: %[[iszero:.*]] = icmp ne i8* %[[lhs0]], null 625 // CHECK: %[[bits_or_null:.*]] = and i1 %[[res123]], %[[iszero]] 626 // CHECK: %{{.*}} = or i1 %[[bits_or_null]], %[[cmp0]] 627 // CHECK: ret i1 %{{.*}} 628 // CHECK: } 629 } 630 631 bool unspecDataMemptrEq(int Unspecified::*l, int Unspecified::*r) { 632 return l == r; 633 // CHECK: define dso_local zeroext i1 @"?unspecDataMemptrEq@@YA_NPQUnspecified@@H0@Z"{{.*}} { 634 // CHECK: extractvalue { i32, i32, i32 } %{{.*}}, 0 635 // CHECK: extractvalue { i32, i32, i32 } %{{.*}}, 0 636 // CHECK: icmp eq i32 637 // CHECK: extractvalue { i32, i32, i32 } %{{.*}}, 1 638 // CHECK: extractvalue { i32, i32, i32 } %{{.*}}, 1 639 // CHECK: icmp eq i32 640 // CHECK: extractvalue { i32, i32, i32 } %{{.*}}, 2 641 // CHECK: extractvalue { i32, i32, i32 } %{{.*}}, 2 642 // CHECK: icmp eq i32 643 // CHECK: and i1 644 // CHECK: and i1 645 // CHECK: ret i1 646 // CHECK: } 647 648 // X64-LABEL: define dso_local zeroext i1 @"?unspecDataMemptrEq@@ 649 // X64: ({ i32, i32, i32 }* %0, { i32, i32, i32 }* %1) 650 } 651 652 void (Multiple::*convertB2FuncToMultiple(void (B2::*mp)()))() { 653 return mp; 654 // CHECK: define dso_local i64 @"?convertB2FuncToMultiple@@YAP8Multiple@@AEXXZP8B2@@AEXXZ@Z"{{.*}} { 655 // CHECK: store 656 // CHECK: %[[mp:.*]] = load i8*, i8** %{{.*}}, align 4 657 // CHECK: icmp ne i8* %[[mp]], null 658 // CHECK: br i1 %{{.*}} label %{{.*}}, label %{{.*}} 659 // 660 // memptr.convert: ; preds = %entry 661 // CHECK: insertvalue { i8*, i32 } undef, i8* %[[mp]], 0 662 // CHECK: insertvalue { i8*, i32 } %{{.*}}, i32 4, 1 663 // CHECK: br label 664 // 665 // memptr.converted: ; preds = %memptr.convert, %entry 666 // CHECK: phi { i8*, i32 } [ zeroinitializer, %{{.*}} ], [ {{.*}} ] 667 // CHECK: } 668 } 669 670 void (B2::*convertMultipleFuncToB2(void (Multiple::*mp)()))() { 671 // FIXME: cl emits warning C4407 on this code because of the representation 672 // change. We might want to do the same. 673 return static_cast<void (B2::*)()>(mp); 674 // FIXME: We should return i8* instead of i32 here. The ptrtoint cast prevents 675 // LLVM from optimizing away the branch. This is likely a bug in 676 // lib/CodeGen/TargetInfo.cpp with how we classify memptr types for returns. 677 // 678 // CHECK: define dso_local i32 @"?convertMultipleFuncToB2@@YAP8B2@@AEXXZP8Multiple@@AEXXZ@Z"{{.*}} { 679 // CHECK: store 680 // CHECK: %[[src:.*]] = load { i8*, i32 }, { i8*, i32 }* %{{.*}}, align 4 681 // CHECK: extractvalue { i8*, i32 } %[[src]], 0 682 // CHECK: icmp ne i8* %{{.*}}, null 683 // CHECK: br i1 %{{.*}}, label %{{.*}}, label %{{.*}} 684 // 685 // memptr.convert: ; preds = %entry 686 // CHECK: %[[fp:.*]] = extractvalue { i8*, i32 } %[[src]], 0 687 // CHECK: br label 688 // 689 // memptr.converted: ; preds = %memptr.convert, %entry 690 // CHECK: phi i8* [ null, %{{.*}} ], [ %[[fp]], %{{.*}} ] 691 // CHECK: } 692 } 693 694 namespace Test1 { 695 696 struct A { int a; }; 697 struct B { int b; }; 698 struct C : virtual A { int c; }; 699 struct D : B, C { int d; }; 700 701 void (D::*convertCToD(void (C::*mp)()))() { 702 return mp; 703 // CHECK: define dso_local void @"?convertCToD@Test1@@YAP8D@1@AEXXZP8C@1@AEXXZ@Z"{{.*}} { 704 // CHECK: store 705 // CHECK: load { i8*, i32, i32 }, { i8*, i32, i32 }* %{{.*}}, align 4 706 // CHECK: extractvalue { i8*, i32, i32 } %{{.*}}, 0 707 // CHECK: icmp ne i8* %{{.*}}, null 708 // CHECK: br i1 %{{.*}}, label %{{.*}}, label %{{.*}} 709 // 710 // memptr.convert: ; preds = %entry 711 // CHECK: extractvalue { i8*, i32, i32 } %{{.*}}, 0 712 // CHECK: %[[nvoff:.*]] = extractvalue { i8*, i32, i32 } %{{.*}}, 1 713 // CHECK: %[[vbidx:.*]] = extractvalue { i8*, i32, i32 } %{{.*}}, 2 714 // CHECK: %[[is_nvbase:.*]] = icmp eq i32 %[[vbidx]], 0 715 // CHECK: %[[nv_disp:.*]] = add nsw i32 %[[nvoff]], 4 716 // CHECK: %[[nv_adj:.*]] = select i1 %[[is_nvbase]], i32 %[[nv_disp]], i32 0 717 // CHECK: %[[dst_adj:.*]] = select i1 %[[is_nvbase]], i32 4, i32 0 718 // CHECK: %[[adj:.*]] = sub nsw i32 %[[nv_adj]], %[[dst_adj]] 719 // CHECK: insertvalue { i8*, i32, i32 } undef, i8* {{.*}}, 0 720 // CHECK: insertvalue { i8*, i32, i32 } {{.*}}, i32 %[[adj]], 1 721 // CHECK: insertvalue { i8*, i32, i32 } {{.*}}, i32 {{.*}}, 2 722 // CHECK: br label 723 // 724 // memptr.converted: ; preds = %memptr.convert, %entry 725 // CHECK: phi { i8*, i32, i32 } [ { i8* null, i32 0, i32 -1 }, {{.*}} ], [ {{.*}} ] 726 // CHECK: } 727 } 728 729 } 730 731 namespace Test2 { 732 // Test that we dynamically convert between different null reps. 733 734 struct A { int a; }; 735 struct B : A { int b; }; 736 struct C : A { 737 int c; 738 virtual void hasVfPtr(); 739 }; 740 741 int A::*reinterpret(int B::*mp) { 742 return reinterpret_cast<int A::*>(mp); 743 // CHECK: define dso_local i32 @"?reinterpret@Test2@@YAPQA@1@HPQB@1@H@Z"{{.*}} { 744 // CHECK-NOT: select 745 // CHECK: ret i32 746 // CHECK: } 747 } 748 749 int A::*reinterpret(int C::*mp) { 750 return reinterpret_cast<int A::*>(mp); 751 // CHECK: define dso_local i32 @"?reinterpret@Test2@@YAPQA@1@HPQC@1@H@Z"{{.*}} { 752 // CHECK: %[[mp:.*]] = load i32, i32* 753 // CHECK: %[[cmp:.*]] = icmp ne i32 %[[mp]], 0 754 // CHECK: select i1 %[[cmp]], i32 %[[mp]], i32 -1 755 // CHECK: } 756 } 757 758 } 759 760 namespace Test3 { 761 // Make sure we cast 'this' to i8* before using GEP. 762 763 struct A { 764 int a; 765 int b; 766 }; 767 768 int *load_data(A *a, int A::*mp) { 769 return &(a->*mp); 770 // CHECK-LABEL: define dso_local i32* @"?load_data@Test3@@YAPAHPAUA@1@PQ21@H@Z"{{.*}} { 771 // CHECK: %[[a:.*]] = load %"struct.Test3::A"*, %"struct.Test3::A"** %{{.*}}, align 4 772 // CHECK: %[[mp:.*]] = load i32, i32* %{{.*}}, align 4 773 // CHECK: %[[a_i8:.*]] = bitcast %"struct.Test3::A"* %[[a]] to i8* 774 // CHECK: getelementptr inbounds i8, i8* %[[a_i8]], i32 %[[mp]] 775 // CHECK: } 776 } 777 778 } 779 780 namespace Test4 { 781 782 struct A { virtual void f(); }; 783 struct B { virtual void g(); }; 784 struct C : A, B { virtual void g(); }; 785 786 void (C::*getmp())() { 787 return &C::g; 788 } 789 // CHECK-LABEL: define dso_local i64 @"?getmp@Test4@@YAP8C@1@AEXXZXZ"() 790 // CHECK: store { i8*, i32 } { i8* bitcast (void (%"struct.Test4::C"*, ...)* @"??_9C@Test4@@$BA@AE" to i8*), i32 4 }, { i8*, i32 }* %{{.*}} 791 // 792 793 // CHECK-LABEL: define linkonce_odr x86_thiscallcc void @"??_9C@Test4@@$BA@AE"(%"struct.Test4::C"* %this, ...) {{.*}} comdat 794 // CHECK-NOT: getelementptr 795 // CHECK: load void (%"struct.Test4::C"*, ...)**, void (%"struct.Test4::C"*, ...)*** %{{.*}} 796 // CHECK: getelementptr inbounds void (%"struct.Test4::C"*, ...)*, void (%"struct.Test4::C"*, ...)** %{{.*}}, i64 0 797 // CHECK-NOT: getelementptr 798 // CHECK: musttail call x86_thiscallcc void (%"struct.Test4::C"*, ...) % 799 800 } 801 802 namespace pr20007 { 803 struct A { 804 void f(); 805 void f(int); 806 }; 807 struct B : public A {}; 808 void test() { void (B::*a)() = &B::f; } 809 // CHECK-LABEL: define dso_local void @"?test@pr20007@@YAXXZ" 810 // CHECK: store i8* bitcast (void (%"struct.pr20007::A"*)* @"?f@A@pr20007@@QAEXXZ" to i8*) 811 } 812 813 namespace pr20007_kw { 814 struct A { 815 void f(); 816 void f(int); 817 }; 818 struct __single_inheritance B; 819 struct B : public A {}; 820 void test() { void (B::*a)() = &B::f; } 821 // CHECK-LABEL: define dso_local void @"?test@pr20007_kw@@YAXXZ" 822 // CHECK: store i8* bitcast (void (%"struct.pr20007_kw::A"*)* @"?f@A@pr20007_kw@@QAEXXZ" to i8*) 823 } 824 825 namespace pr20007_pragma { 826 struct A { 827 void f(); 828 void f(int); 829 }; 830 struct B : public A {}; 831 void test() { (void)(void (B::*)()) &B::f; } 832 #pragma pointers_to_members(full_generality, virtual_inheritance) 833 static_assert(sizeof(int B::*) == 4, ""); 834 static_assert(sizeof(int A::*) == 4, ""); 835 #pragma pointers_to_members(best_case) 836 // CHECK-LABEL: define dso_local void @"?test@pr20007_pragma@@YAXXZ" 837 } 838 839 namespace pr20007_pragma2 { 840 struct A { 841 }; 842 struct B : public A { 843 void f(); 844 }; 845 void test() { (void)&B::f; } 846 #pragma pointers_to_members(full_generality, virtual_inheritance) 847 static_assert(sizeof(int B::*) == 4, ""); 848 static_assert(sizeof(int A::*) == 12, ""); 849 #pragma pointers_to_members(best_case) 850 // CHECK-LABEL: define dso_local void @"?test@pr20007_pragma2@@YAXXZ" 851 } 852 853 namespace pr23823 { 854 struct Base { void Method(); }; 855 struct Child : Base {}; 856 void use(void (Child::*const &)()); 857 void f() { use(&Child::Method); } 858 #pragma pointers_to_members(full_generality, virtual_inheritance) 859 static_assert(sizeof(int Base::*) == 4, ""); 860 static_assert(sizeof(int Child::*) == 4, ""); 861 #pragma pointers_to_members(best_case) 862 } 863 864 namespace pr19987 { 865 template <typename T> 866 struct S { 867 int T::*x; 868 }; 869 870 struct U : S<U> {}; 871 872 static_assert(sizeof(S<U>::x) == 12, ""); 873 } 874 875 #else 876 struct __virtual_inheritance A; 877 #ifdef MEMFUN 878 int foo(A *a, int (A::*mp)()) { 879 return (a->*mp)(); // expected-error{{requires a complete class type}} 880 } 881 #else 882 int foo(A *a, int A::*mp) { 883 return a->*mp; // expected-error{{requires a complete class type}} 884 } 885 #endif 886 #endif 887 888 namespace pr23878 { 889 struct A { virtual void g(); }; 890 struct B { virtual void f(); }; 891 struct C : virtual B { void f(); }; 892 struct D : A, C {}; 893 894 typedef void (D::*DMemPtrTy)(); 895 896 // CHECK-LABEL: define dso_local void @"?get_memptr@pr23878@@YAP8D@1@AEXXZXZ" 897 // CHECK: @"??_9C@pr23878@@$BA@AE" to i8*), i32 0, i32 4 898 DMemPtrTy get_memptr() { return &D::f; } 899 } 900 901 class C {}; 902 903 typedef void (C::*f)(); 904 905 class CA : public C { 906 public: 907 void OnHelp(void); 908 int OnHelp(int); 909 }; 910 911 // CHECK-LABEL: foo_fun 912 void foo_fun() { 913 // CHECK: store i8* bitcast (void (%class.CA*)* @"?OnHelp@CA@@QAEXXZ" to i8*), i8** 914 f func = (f)&CA::OnHelp; 915 } 916 namespace PR24703 { 917 struct S; 918 919 void f(int S::*&p) {} 920 // CHECK-LABEL: define dso_local void @"?f@PR24703@@YAXAAPQS@1@H@Z"( 921 } 922 923 namespace ReferenceToMPTWithIncompleteClass { 924 struct S; 925 struct J; 926 struct K; 927 extern K *k; 928 929 // CHECK-LABEL: @"?f@ReferenceToMPTWithIncompleteClass@@YAIAAPQS@1@H@Z"( 930 // CHECK: ret i32 12 931 unsigned f(int S::*&p) { return sizeof p; } 932 933 // CHECK-LABEL: @"?g@ReferenceToMPTWithIncompleteClass@@YA_NAAPQJ@1@H0@Z"( 934 bool g(int J::*&p, int J::*&q) { return p == q; } 935 936 // CHECK-LABEL: @"?h@ReferenceToMPTWithIncompleteClass@@YAHAAPQK@1@H@Z"( 937 int h(int K::*&p) { return k->*p; } 938 } 939 940 namespace PMFInTemplateArgument { 941 template <class C, int (C::*M)(int)> 942 void JSMethod(); 943 class A { 944 int printd(int); 945 void printd(); 946 }; 947 void A::printd() { JSMethod<A, &A::printd>(); } 948 // CHECK-LABEL: @"??$JSMethod@VA@PMFInTemplateArgument@@$1?printd@12@AAEHH@Z@PMFInTemplateArgument@@YAXXZ"( 949 } 950