1 // RUN: %clang_cc1 -fno-rtti -emit-llvm %s -o - -cxx-abi microsoft -triple=i386-pc-win32 | FileCheck %s 2 3 struct B1 { 4 int b; 5 }; 6 struct B2 { }; 7 struct Single : B1 { }; 8 struct Multiple : B1, B2 { }; 9 struct Virtual : virtual B1 { 10 int v; 11 }; 12 13 struct POD { 14 int a; 15 int b; 16 }; 17 18 struct Polymorphic { 19 virtual void myVirtual(); 20 int a; 21 int b; 22 }; 23 24 // This class uses the virtual inheritance model, yet its vbptr offset is not 0. 25 // We still use zero for the null field offset, despite it being a valid field 26 // offset. 27 struct NonZeroVBPtr : POD, Virtual { 28 int n; 29 }; 30 31 struct Unspecified; 32 33 // Check that we can lower the LLVM types and get the initializers right. 34 int Single ::*s_d_memptr; 35 int Polymorphic::*p_d_memptr; 36 int Multiple ::*m_d_memptr; 37 int Virtual ::*v_d_memptr; 38 int NonZeroVBPtr::*n_d_memptr; 39 int Unspecified::*u_d_memptr; 40 // CHECK: @"\01?s_d_memptr@@3PQSingle@@HA" = global i32 -1, align 4 41 // CHECK: @"\01?p_d_memptr@@3PQPolymorphic@@HA" = global i32 0, align 4 42 // CHECK: @"\01?m_d_memptr@@3PQMultiple@@HA" = global i32 -1, align 4 43 // CHECK: @"\01?v_d_memptr@@3PQVirtual@@HA" = global { i32, i32 } 44 // CHECK: { i32 0, i32 -1 }, align 4 45 // CHECK: @"\01?n_d_memptr@@3PQNonZeroVBPtr@@HA" = global { i32, i32 } 46 // CHECK: { i32 0, i32 -1 }, align 4 47 // CHECK: @"\01?u_d_memptr@@3PQUnspecified@@HA" = global { i32, i32, i32 } 48 // CHECK: { i32 0, i32 0, i32 -1 }, align 4 49 50 void (Single ::*s_f_memptr)(); 51 void (Multiple::*m_f_memptr)(); 52 void (Virtual ::*v_f_memptr)(); 53 // CHECK: @"\01?s_f_memptr@@3P8Single@@AEXXZA" = global i8* null, align 4 54 // CHECK: @"\01?m_f_memptr@@3P8Multiple@@AEXXZA" = global { i8*, i32 } zeroinitializer, align 4 55 // CHECK: @"\01?v_f_memptr@@3P8Virtual@@AEXXZA" = global { i8*, i32, i32 } zeroinitializer, align 4 56 57 void podMemPtrs() { 58 int POD::*memptr; 59 memptr = &POD::a; 60 memptr = &POD::b; 61 if (memptr) 62 memptr = 0; 63 // Check that member pointers use the right offsets and that null is -1. 64 // CHECK: define void @"\01?podMemPtrs@@YAXXZ"() #0 { 65 // CHECK: %[[memptr:.*]] = alloca i32, align 4 66 // CHECK-NEXT: store i32 0, i32* %[[memptr]], align 4 67 // CHECK-NEXT: store i32 4, i32* %[[memptr]], align 4 68 // CHECK-NEXT: %[[memptr_val:.*]] = load i32* %[[memptr]], align 4 69 // CHECK-NEXT: %{{.*}} = icmp ne i32 %[[memptr_val]], -1 70 // CHECK-NEXT: br i1 %{{.*}}, label %{{.*}}, label %{{.*}} 71 // CHECK: store i32 -1, i32* %[[memptr]], align 4 72 // CHECK: ret void 73 // CHECK: } 74 } 75 76 void polymorphicMemPtrs() { 77 int Polymorphic::*memptr; 78 memptr = &Polymorphic::a; 79 memptr = &Polymorphic::b; 80 if (memptr) 81 memptr = 0; 82 // Member pointers for polymorphic classes include the vtable slot in their 83 // offset and use 0 to represent null. 84 // CHECK: define void @"\01?polymorphicMemPtrs@@YAXXZ"() #0 { 85 // CHECK: %[[memptr:.*]] = alloca i32, align 4 86 // CHECK-NEXT: store i32 4, i32* %[[memptr]], align 4 87 // CHECK-NEXT: store i32 8, i32* %[[memptr]], align 4 88 // CHECK-NEXT: %[[memptr_val:.*]] = load i32* %[[memptr]], align 4 89 // CHECK-NEXT: %{{.*}} = icmp ne i32 %[[memptr_val]], 0 90 // CHECK-NEXT: br i1 %{{.*}}, label %{{.*}}, label %{{.*}} 91 // CHECK: store i32 0, i32* %[[memptr]], align 4 92 // CHECK: ret void 93 // CHECK: } 94 } 95 96 bool nullTestDataUnspecified(int Unspecified::*mp) { 97 return mp; 98 // CHECK: define zeroext i1 @"\01?nullTestDataUnspecified@@YA_NPQUnspecified@@H@Z"{{.*}} { 99 // CHECK: %{{.*}} = load { i32, i32, i32 }* %{{.*}}, align 4 100 // CHECK: store { i32, i32, i32 } {{.*}} align 4 101 // CHECK: %[[mp:.*]] = load { i32, i32, i32 }* %{{.*}}, align 4 102 // CHECK: %[[mp0:.*]] = extractvalue { i32, i32, i32 } %[[mp]], 0 103 // CHECK: %[[cmp0:.*]] = icmp ne i32 %[[mp0]], 0 104 // CHECK: %[[mp1:.*]] = extractvalue { i32, i32, i32 } %[[mp]], 1 105 // CHECK: %[[cmp1:.*]] = icmp ne i32 %[[mp1]], 0 106 // CHECK: %[[and0:.*]] = and i1 %[[cmp0]], %[[cmp1]] 107 // CHECK: %[[mp2:.*]] = extractvalue { i32, i32, i32 } %[[mp]], 2 108 // CHECK: %[[cmp2:.*]] = icmp ne i32 %[[mp2]], -1 109 // CHECK: %[[and1:.*]] = and i1 %[[and0]], %[[cmp2]] 110 // CHECK: ret i1 %[[and1]] 111 // CHECK: } 112 } 113 114 bool nullTestFunctionUnspecified(void (Unspecified::*mp)()) { 115 return mp; 116 // CHECK: define zeroext i1 @"\01?nullTestFunctionUnspecified@@YA_NP8Unspecified@@AEXXZ@Z"{{.*}} { 117 // CHECK: %{{.*}} = load { i8*, i32, i32, i32 }* %{{.*}}, align 4 118 // CHECK: store { i8*, i32, i32, i32 } {{.*}} align 4 119 // CHECK: %[[mp:.*]] = load { i8*, i32, i32, i32 }* %{{.*}}, align 4 120 // CHECK: %[[mp0:.*]] = extractvalue { i8*, i32, i32, i32 } %[[mp]], 0 121 // CHECK: %[[cmp0:.*]] = icmp ne i8* %[[mp0]], null 122 // CHECK: ret i1 %[[cmp0]] 123 // CHECK: } 124 } 125 126 int loadDataMemberPointerVirtual(Virtual *o, int Virtual::*memptr) { 127 return o->*memptr; 128 // Test that we can unpack this aggregate member pointer and load the member 129 // data pointer. 130 // CHECK: define i32 @"\01?loadDataMemberPointerVirtual@@YAHPAUVirtual@@PQ1@H@Z"{{.*}} { 131 // CHECK: %[[o:.*]] = load %{{.*}}** %{{.*}}, align 4 132 // CHECK: %[[memptr:.*]] = load { i32, i32 }* %{{.*}}, align 4 133 // CHECK: %[[memptr0:.*]] = extractvalue { i32, i32 } %[[memptr:.*]], 0 134 // CHECK: %[[memptr1:.*]] = extractvalue { i32, i32 } %[[memptr:.*]], 1 135 // CHECK: %[[v6:.*]] = bitcast %{{.*}}* %[[o]] to i8* 136 // CHECK: %[[vbptr:.*]] = getelementptr inbounds i8* %[[v6]], i32 0 137 // CHECK: %[[vbptr_a:.*]] = bitcast i8* %[[vbptr]] to i8** 138 // CHECK: %[[vbtable:.*]] = load i8** %[[vbptr_a:.*]] 139 // CHECK: %[[v7:.*]] = getelementptr inbounds i8* %[[vbtable]], i32 %[[memptr1]] 140 // CHECK: %[[v8:.*]] = bitcast i8* %[[v7]] to i32* 141 // CHECK: %[[vbase_offs:.*]] = load i32* %[[v8]] 142 // CHECK: %[[v10:.*]] = getelementptr inbounds i8* %[[vbptr]], i32 %[[vbase_offs]] 143 // CHECK: %[[offset:.*]] = getelementptr inbounds i8* %[[v10]], i32 %[[memptr0]] 144 // CHECK: %[[v11:.*]] = bitcast i8* %[[offset]] to i32* 145 // CHECK: %[[v12:.*]] = load i32* %[[v11]] 146 // CHECK: ret i32 %[[v12]] 147 // CHECK: } 148 } 149 150 int loadDataMemberPointerUnspecified(Unspecified *o, int Unspecified::*memptr) { 151 return o->*memptr; 152 // Test that we can unpack this aggregate member pointer and load the member 153 // data pointer. 154 // CHECK: define i32 @"\01?loadDataMemberPointerUnspecified@@YAHPAUUnspecified@@PQ1@H@Z"{{.*}} { 155 // CHECK: %[[o:.*]] = load %{{.*}}** %{{.*}}, align 4 156 // CHECK: %[[memptr:.*]] = load { i32, i32, i32 }* %{{.*}}, align 4 157 // CHECK: %[[memptr0:.*]] = extractvalue { i32, i32, i32 } %[[memptr:.*]], 0 158 // CHECK: %[[memptr1:.*]] = extractvalue { i32, i32, i32 } %[[memptr:.*]], 1 159 // CHECK: %[[memptr2:.*]] = extractvalue { i32, i32, i32 } %[[memptr:.*]], 2 160 // CHECK: %[[base:.*]] = bitcast %{{.*}}* %[[o]] to i8* 161 // CHECK: %[[is_vbase:.*]] = icmp ne i32 %[[memptr2]], 0 162 // CHECK: br i1 %[[is_vbase]], label %[[vadjust:.*]], label %[[skip:.*]] 163 // 164 // CHECK: [[vadjust]] 165 // CHECK: %[[vbptr:.*]] = getelementptr inbounds i8* %[[base]], i32 %[[memptr1]] 166 // CHECK: %[[vbptr_a:.*]] = bitcast i8* %[[vbptr]] to i8** 167 // CHECK: %[[vbtable:.*]] = load i8** %[[vbptr_a:.*]] 168 // CHECK: %[[v7:.*]] = getelementptr inbounds i8* %[[vbtable]], i32 %[[memptr2]] 169 // CHECK: %[[v8:.*]] = bitcast i8* %[[v7]] to i32* 170 // CHECK: %[[vbase_offs:.*]] = load i32* %[[v8]] 171 // CHECK: %[[base_adj:.*]] = getelementptr inbounds i8* %[[vbptr]], i32 %[[vbase_offs]] 172 // 173 // CHECK: [[skip]] 174 // CHECK: %[[new_base:.*]] = phi i8* [ %[[base]], %{{.*}} ], [ %[[base_adj]], %[[vadjust]] ] 175 // CHECK: %[[offset:.*]] = getelementptr inbounds i8* %[[new_base]], i32 %[[memptr0]] 176 // CHECK: %[[v11:.*]] = bitcast i8* %[[offset]] to i32* 177 // CHECK: %[[v12:.*]] = load i32* %[[v11]] 178 // CHECK: ret i32 %[[v12]] 179 // CHECK: } 180 } 181 182 void callMemberPointerSingle(Single *o, void (Single::*memptr)()) { 183 (o->*memptr)(); 184 // Just look for an indirect thiscall. 185 // CHECK: define void @"\01?callMemberPointerSingle@@{{.*}} #0 { 186 // CHECK: call x86_thiscallcc void %{{.*}}(%{{.*}} %{{.*}}) 187 // CHECK: ret void 188 // CHECK: } 189 } 190 191 void callMemberPointerMultiple(Multiple *o, void (Multiple::*memptr)()) { 192 (o->*memptr)(); 193 // CHECK: define void @"\01?callMemberPointerMultiple@@{{.*}} #0 { 194 // CHECK: %[[memptr0:.*]] = extractvalue { i8*, i32 } %{{.*}}, 0 195 // CHECK: %[[memptr1:.*]] = extractvalue { i8*, i32 } %{{.*}}, 1 196 // CHECK: %[[this_adjusted:.*]] = getelementptr inbounds i8* %{{.*}}, i32 %[[memptr1]] 197 // CHECK: %[[this:.*]] = bitcast i8* %[[this_adjusted]] to {{.*}} 198 // CHECK: %[[fptr:.*]] = bitcast i8* %[[memptr0]] to {{.*}} 199 // CHECK: call x86_thiscallcc void %[[fptr]](%{{.*}} %[[this]]) 200 // CHECK: ret void 201 // CHECK: } 202 } 203 204 void callMemberPointerVirtualBase(Virtual *o, void (Virtual::*memptr)()) { 205 (o->*memptr)(); 206 // This shares a lot with virtual data member pointers. 207 // CHECK: define void @"\01?callMemberPointerVirtualBase@@{{.*}} #0 { 208 // CHECK: %[[memptr0:.*]] = extractvalue { i8*, i32, i32 } %{{.*}}, 0 209 // CHECK: %[[memptr1:.*]] = extractvalue { i8*, i32, i32 } %{{.*}}, 1 210 // CHECK: %[[memptr2:.*]] = extractvalue { i8*, i32, i32 } %{{.*}}, 2 211 // CHECK: %[[vbptr:.*]] = getelementptr inbounds i8* %{{.*}}, i32 0 212 // CHECK: %[[vbptr_a:.*]] = bitcast i8* %[[vbptr]] to i8** 213 // CHECK: %[[vbtable:.*]] = load i8** %[[vbptr_a:.*]] 214 // CHECK: %[[v7:.*]] = getelementptr inbounds i8* %[[vbtable]], i32 %[[memptr2]] 215 // CHECK: %[[v8:.*]] = bitcast i8* %[[v7]] to i32* 216 // CHECK: %[[vbase_offs:.*]] = load i32* %[[v8]] 217 // CHECK: %[[v10:.*]] = getelementptr inbounds i8* %[[vbptr]], i32 %[[vbase_offs]] 218 // CHECK: %[[this_adjusted:.*]] = getelementptr inbounds i8* %[[v10]], i32 %[[memptr1]] 219 // CHECK: %[[fptr:.*]] = bitcast i8* %[[memptr0]] to void ({{.*}}) 220 // CHECK: %[[this:.*]] = bitcast i8* %[[this_adjusted]] to {{.*}} 221 // CHECK: call x86_thiscallcc void %[[fptr]](%{{.*}} %[[this]]) 222 // CHECK: ret void 223 // CHECK: } 224 } 225