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