test/CodeGenCXX/strict-vtable-pointers.cpp

   1 // RUN: %clang_cc1 %s -I%S -triple=x86_64-apple-darwin10 -fstrict-vtable-pointers -std=c++11 -disable-llvm-passes -O2 -emit-llvm -o %t.ll
   2 // RUN: FileCheck --check-prefix=CHECK-CTORS %s < %t.ll
   3 // RUN: FileCheck --check-prefix=CHECK-NEW %s < %t.ll
   4 // RUN: FileCheck --check-prefix=CHECK-DTORS %s < %t.ll
   5 // RUN: FileCheck --check-prefix=CHECK-LINK-REQ %s < %t.ll
   6
   7 typedef __typeof__(sizeof(0)) size_t;
   8 void *operator new(size_t, void*) throw();
   9
  10 struct NotTrivialDtor {
  11   ~NotTrivialDtor();
  12 };
  13
  14 struct DynamicBase1 {
  15   NotTrivialDtor obj;
  16   virtual void foo();
  17 };
  18
  19 struct DynamicDerived : DynamicBase1 {
  20   void foo();
  21 };
  22
  23 struct DynamicBase2 {
  24   virtual void bar();
  25   ~DynamicBase2() {
  26     bar();
  27   }
  28 };
  29
  30 struct DynamicDerivedMultiple : DynamicBase1, DynamicBase2 {
  31   virtual void foo();
  32   virtual void bar();
  33 };
  34
  35 struct StaticBase {
  36   NotTrivialDtor obj;
  37   void bar();
  38 };
  39
  40 struct DynamicFromStatic : StaticBase {
  41   virtual void bar();
  42 };
  43
  44 struct DynamicFromVirtualStatic1 : virtual StaticBase {
  45 };
  46
  47 struct DynamicFromVirtualStatic2 : virtual StaticBase {
  48 };
  49
  50 struct DynamicFrom2Virtuals :
  51             DynamicFromVirtualStatic1,
  52             DynamicFromVirtualStatic2 {
  53 };
  54
  55 // CHECK-NEW-LABEL: define void @_Z12LocalObjectsv()
  56 // CHECK-NEW-NOT: @llvm.invariant.group.barrier(
  57 // CHECK-NEW-LABEL: {{^}}}
  58 void LocalObjects() {
  59   DynamicBase1 DB;
  60   DB.foo();
  61   DynamicDerived DD;
  62   DD.foo();
  63
  64   DynamicBase2 DB2;
  65   DB2.bar();
  66
  67   StaticBase SB;
  68   SB.bar();
  69
  70   DynamicDerivedMultiple DDM;
  71   DDM.foo();
  72   DDM.bar();
  73
  74   DynamicFromStatic DFS;
  75   DFS.bar();
  76   DynamicFromVirtualStatic1 DFVS1;
  77   DFVS1.bar();
  78   DynamicFrom2Virtuals DF2V;
  79   DF2V.bar();
  80 }
  81
  82 struct DynamicFromVirtualStatic1;
  83 // CHECK-CTORS-LABEL: define linkonce_odr void @_ZN25DynamicFromVirtualStatic1C1Ev
  84 // CHECK-CTORS-NOT: @llvm.invariant.group.barrier(
  85 // CHECK-CTORS-LABEL: {{^}}}
  86
  87 struct DynamicFrom2Virtuals;
  88 // CHECK-CTORS-LABEL: define linkonce_odr void @_ZN20DynamicFrom2VirtualsC1Ev
  89 // CHECK-CTORS: call i8* @llvm.invariant.group.barrier(
  90 // CHECK-CTORS-LABEL: {{^}}}
  91
  92
  93 // CHECK-NEW-LABEL: define void @_Z9Pointers1v()
  94 // CHECK-NEW-NOT: @llvm.invariant.group.barrier(
  95 // CHECK-NEW-LABEL: call void @_ZN12DynamicBase1C1Ev(
  96
  97 // CHECK-NEW: %[[THIS3:.*]] = call i8* @llvm.invariant.group.barrier(i8* %[[THIS2:.*]])
  98 // CHECK-NEW: %[[THIS4:.*]] = bitcast i8* %[[THIS3]] to %[[DynamicDerived:.*]]*
  99 // CHECK-NEW: call void @_ZN14DynamicDerivedC1Ev(%[[DynamicDerived:.*]]* %[[THIS4]])
 100 // CHECK-NEW-LABEL: {{^}}}
 101 void Pointers1() {
 102   DynamicBase1 *DB = new DynamicBase1;
 103   DB->foo();
 104
 105   DynamicDerived *DD = new (DB) DynamicDerived;
 106   DD->foo();
 107   DD->~DynamicDerived();
 108 }
 109
 110 // CHECK-NEW-LABEL: define void @_Z14HackingObjectsv()
 111 // CHECK-NEW:  call void @_ZN12DynamicBase1C1Ev
 112 // CHECK-NEW:  call i8* @llvm.invariant.group.barrier(
 113 // CHECK-NEW:  call void @_ZN14DynamicDerivedC1Ev(
 114 // CHECK-NEW:  call i8* @llvm.invariant.group.barrier(
 115 // CHECK-NEW: call void @_ZN12DynamicBase1C1Ev(
 116 // CHECK-NEW-LABEL: {{^}}}
 117 void HackingObjects() {
 118   DynamicBase1 DB;
 119   DB.foo();
 120
 121   DynamicDerived *DB2 = new (&DB) DynamicDerived;
 122   // Using DB now is prohibited.
 123   DB2->foo();
 124   DB2->~DynamicDerived();
 125
 126   // We have to get back to the previous type to avoid calling wrong destructor
 127   new (&DB) DynamicBase1;
 128   DB.foo();
 129 }
 130
 131 /*** Testing Constructors ***/
 132 struct DynamicBase1;
 133 // CHECK-CTORS-LABEL: define linkonce_odr void @_ZN12DynamicBase1C2Ev(
 134 // CHECK-CTORS-NOT: call i8* @llvm.invariant.group.barrier(
 135 // CHECK-CTORS-LABEL: {{^}}}
 136
 137
 138 struct DynamicDerived;
 139
 140 // CHECK-CTORS-LABEL: define linkonce_odr void @_ZN14DynamicDerivedC2Ev(
 141 // CHECK-CTORS: %[[THIS0:.*]] = load %[[DynamicDerived:.*]]*, %[[DynamicDerived]]** {{.*}}
 142 // CHECK-CTORS: %[[THIS1:.*]] = bitcast %[[DynamicDerived:.*]]* %[[THIS0]] to i8*
 143 // CHECK-CTORS: %[[THIS2:.*]] = call i8* @llvm.invariant.group.barrier(i8* %[[THIS1:.*]])
 144 // CHECK-CTORS: %[[THIS3:.*]] = bitcast i8* %[[THIS2]] to %[[DynamicDerived]]*
 145 // CHECK-CTORS: %[[THIS4:.*]] = bitcast %[[DynamicDerived]]* %[[THIS3]] to %[[DynamicBase:.*]]*
 146 // CHECK-CTORS: call void @_ZN12DynamicBase1C2Ev(%[[DynamicBase]]* %[[THIS4]])
 147
 148 // CHECK-CTORS: %[[THIS5:.*]] = bitcast %struct.DynamicDerived* %[[THIS0]] to i32 (...)***
 149 // CHECK-CTORS: store {{.*}} %[[THIS5]]
 150 // CHECK-CTORS-LABEL: {{^}}}
 151
 152 struct DynamicDerivedMultiple;
 153 // CHECK-CTORS-LABEL: define linkonce_odr void @_ZN22DynamicDerivedMultipleC2Ev(
 154
 155 // CHECK-CTORS: %[[THIS0:.*]] = load %[[CLASS:.*]]*, %[[CLASS]]** {{.*}}
 156 // CHECK-CTORS: %[[THIS1:.*]] = bitcast %[[CLASS:.*]]* %[[THIS0]] to i8*
 157 // CHECK-CTORS: %[[THIS2:.*]] = call i8* @llvm.invariant.group.barrier(i8* %[[THIS1]])
 158 // CHECK-CTORS: %[[THIS3:.*]] = bitcast i8* %[[THIS2]] to %[[CLASS]]*
 159 // CHECK-CTORS: %[[THIS4:.*]] = bitcast %[[CLASS]]* %[[THIS3]] to %[[BASE_CLASS:.*]]*
 160 // CHECK-CTORS: call void @_ZN12DynamicBase1C2Ev(%[[BASE_CLASS]]* %[[THIS4]])
 161
 162 // CHECK-CTORS: call i8* @llvm.invariant.group.barrier(
 163
 164 // CHECK-CTORS: call void @_ZN12DynamicBase2C2Ev(
 165 // CHECK-CTORS-NOT: @llvm.invariant.group.barrier
 166
 167
 168 // CHECK-CTORS: %[[THIS10:.*]] = bitcast %struct.DynamicDerivedMultiple* %[[THIS0]] to i32 (...)***
 169 // CHECK-CTORS: store {{.*}} @_ZTV22DynamicDerivedMultiple, i32 0, inrange i32 0, i32 2) {{.*}} %[[THIS10]]
 170 // CHECK-CTORS: %[[THIS11:.*]] = bitcast %struct.DynamicDerivedMultiple* %[[THIS0]] to i8*
 171 // CHECK-CTORS: %[[THIS_ADD:.*]] = getelementptr inbounds i8, i8* %[[THIS11]], i64 16
 172 // CHECK-CTORS: %[[THIS12:.*]]  = bitcast i8* %[[THIS_ADD]] to i32 (...)***
 173
 174
 175 // CHECK-CTORS: store {{.*}} @_ZTV22DynamicDerivedMultiple, i32 0, inrange i32 1, i32 2) {{.*}} %[[THIS12]]
 176 // CHECK-CTORS-LABEL: {{^}}}
 177
 178 struct DynamicFromStatic;
 179 // CHECK-CTORS-LABEL: define linkonce_odr void @_ZN17DynamicFromStaticC2Ev(
 180 // CHECK-CTORS-NOT: @llvm.invariant.group.barrier(
 181 // CHECK-CTORS-LABEL: {{^}}}
 182
 183 struct A {
 184   virtual void foo();
 185 };
 186 struct B : A {
 187   virtual void foo();
 188 };
 189
 190 union U {
 191   A a;
 192   B b;
 193 };
 194
 195 void changeToB(U *u);
 196 void changeToA(U *u);
 197
 198 void g2(A *a) {
 199   a->foo();
 200 }
 201 // We have to guard access to union fields with invariant.group, because
 202 // it is very easy to skip the barrier with unions. In this example the inlined
 203 // g2 will produce loads with the same !invariant.group metadata, and
 204 // u->a and u->b would use the same pointer.
 205 // CHECK-NEW-LABEL: define void @_Z14UnionsBarriersP1U
 206 void UnionsBarriers(U *u) {
 207   // CHECK-NEW: call void @_Z9changeToBP1U(
 208   changeToB(u);
 209   // CHECK-NEW: call i8* @llvm.invariant.group.barrier(i8*
 210   // CHECK-NEW: call void @_Z2g2P1A(%struct.A*
 211   g2(&u->b);
 212   // CHECK-NEW: call void @_Z9changeToAP1U(%union.U*
 213   changeToA(u);
 214   // CHECK-NEW: call i8* @llvm.invariant.group.barrier(i8*
 215   // call void @_Z2g2P1A(%struct.A* %a)
 216   g2(&u->a);
 217   // CHECK-NEW-NOT: call i8* @llvm.invariant.group.barrier(i8*
 218 }
 219
 220 struct HoldingVirtuals {
 221   A a;
 222 };
 223
 224 struct Empty {};
 225 struct AnotherEmpty {
 226   Empty e;
 227 };
 228 union NoVptrs {
 229   int a;
 230   AnotherEmpty empty;
 231 };
 232 void take(AnotherEmpty &);
 233
 234 // CHECK-NEW-LABEL: noBarriers
 235 void noBarriers(NoVptrs &noVptrs) {
 236   // CHECK-NEW-NOT: call i8* @llvm.invariant.group.barrier(i8*
 237   // CHECK-NEW: 42
 238   noVptrs.a += 42;
 239   // CHECK-NEW-NOT: call i8* @llvm.invariant.group.barrier(i8*
 240   // CHECK-NEW: call void @_Z4takeR12AnotherEmpty(
 241   take(noVptrs.empty);
 242 }
 243
 244 union U2 {
 245   HoldingVirtuals h;
 246   int z;
 247 };
 248 void take(HoldingVirtuals &);
 249
 250 // CHECK-NEW-LABEL: define void @_Z15UnionsBarriers2R2U2
 251 void UnionsBarriers2(U2 &u) {
 252   // CHECK-NEW-NOT: call i8* @llvm.invariant.group.barrier(i8*
 253   // CHECK-NEW: 42
 254   u.z += 42;
 255   // CHECK-NEW: call i8* @llvm.invariant.group.barrier(i8*
 256   // CHECK-NEW: call void @_Z4takeR15HoldingVirtuals(
 257   take(u.h);
 258 }
 259
 260 struct VirtualInBase : HoldingVirtuals, Empty {
 261 };
 262
 263 struct VirtualInVBase : virtual Empty, virtual HoldingVirtuals {
 264 };
 265
 266 // It has vtable by virtual inheritance.
 267 struct VirtualInheritance : virtual Empty {
 268 };
 269
 270 union U3 {
 271   VirtualInBase v1;
 272   VirtualInBase v2;
 273   VirtualInheritance v3;
 274   int z;
 275 };
 276
 277 void take(VirtualInBase &);
 278 void take(VirtualInVBase &);
 279 void take(VirtualInheritance &);
 280
 281 void UnionsBarrier3(U3 &u) {
 282   // CHECK-NEW-NOT: call i8* @llvm.invariant.group.barrier(i8*
 283   // CHECK-NEW: 42
 284   u.z += 42;
 285   // CHECK-NEW: call i8* @llvm.invariant.group.barrier(i8*
 286   // CHECK-NEW: call void @_Z4takeR13VirtualInBase(
 287   take(u.v1);
 288   // CHECK-NEW: call i8* @llvm.invariant.group.barrier(i8*
 289   // CHECK-NEW: call void @_Z4takeR13VirtualInBase(
 290   take(u.v2);
 291
 292   // CHECK-NEW: call i8* @llvm.invariant.group.barrier(i8*
 293   // CHECK-NEW: call void @_Z4takeR18VirtualInheritance(
 294   take(u.v3);
 295 }
 296
 297 /** DTORS **/
 298 // CHECK-DTORS-LABEL: define linkonce_odr void @_ZN10StaticBaseD2Ev(
 299 // CHECK-DTORS-NOT: call i8* @llvm.invariant.group.barrier(
 300 // CHECK-DTORS-LABEL: {{^}}}
 301
 302
 303 // CHECK-DTORS-LABEL: define linkonce_odr void @_ZN25DynamicFromVirtualStatic2D2Ev(
 304 // CHECK-DTORS-NOT: invariant.barrier
 305 // CHECK-DTORS-LABEL: {{^}}}
 306
 307 // CHECK-DTORS-LABEL: define linkonce_odr void @_ZN17DynamicFromStaticD2Ev
 308 // CHECK-DTORS-NOT: call i8* @llvm.invariant.group.barrier(
 309 // CHECK-DTORS-LABEL: {{^}}}
 310
 311
 312 // CHECK-DTORS-LABEL: define linkonce_odr void @_ZN22DynamicDerivedMultipleD2Ev(
 313
 314 // CHECK-DTORS-LABEL: define linkonce_odr void @_ZN12DynamicBase2D2Ev(
 315 // CHECK-DTORS: call i8* @llvm.invariant.group.barrier(
 316 // CHECK-DTORS-LABEL: {{^}}}
 317
 318 // CHECK-DTORS-LABEL: define linkonce_odr void @_ZN12DynamicBase1D2Ev
 319 // CHECK-DTORS: call i8* @llvm.invariant.group.barrier(
 320 // CHECK-DTORS-LABEL: {{^}}}
 321
 322 // CHECK-DTORS-LABEL: define linkonce_odr void @_ZN14DynamicDerivedD2Ev
 323 // CHECK-DTORS-NOT: call i8* @llvm.invariant.group.barrier(
 324 // CHECK-DTORS-LABEL: {{^}}}
 325
 326
 327 // CHECK-LINK-REQ: !llvm.module.flags = !{![[FIRST:[0-9]+]], ![[SEC:[0-9]+]]{{.*}}}
 328
 329 // CHECK-LINK-REQ: ![[FIRST]] = !{i32 1, !"StrictVTablePointers", i32 1}
 330 // CHECK-LINK-REQ: ![[SEC]] = !{i32 3, !"StrictVTablePointersRequirement", ![[META:.*]]}
 331 // CHECK-LINK-REQ: ![[META]] = !{!"StrictVTablePointers", i32 1}
 332