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