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