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