test/CodeGenCXX/microsoft-abi-virtual-inheritance.cpp

   1 // RUN: %clang_cc1 %s -fno-rtti -triple=i386-pc-win32 -emit-llvm -o %t
   2 // RUN: FileCheck %s < %t
   3 // RUN: FileCheck --check-prefix=CHECK2 %s < %t
   4
   5 // For now, just make sure x86_64 doesn't crash.
   6 // RUN: %clang_cc1 %s -fno-rtti -triple=x86_64-pc-win32 -emit-llvm -o %t
   7
   8 struct VBase {
   9   virtual ~VBase();
  10   virtual void foo();
  11   virtual void bar();
  12   int field;
  13 };
  14
  15 struct B : virtual VBase {
  16   B();
  17   virtual ~B();
  18   virtual void foo();
  19   virtual void bar();
  20 };
  21
  22 B::B() {
  23   // CHECK-LABEL: define x86_thiscallcc %struct.B* @"\01??0B@@QAE@XZ"
  24   // CHECK:   %[[THIS:.*]] = load %struct.B*, %struct.B**
  25   // CHECK:   br i1 %{{.*}}, label %[[INIT_VBASES:.*]], label %[[SKIP_VBASES:.*]]
  26
  27   // Don't check the INIT_VBASES case as it's covered by the ctor tests.
  28
  29   // CHECK: %[[SKIP_VBASES]]
  30   // CHECK:   %[[THIS_i8:.*]] = bitcast %struct.B* %[[THIS]] to i8*
  31   // CHECK:   %[[VBPTR:.*]] = getelementptr inbounds i8, i8* %[[THIS_i8]], i32 0
  32   // ...
  33   // CHECK:   %[[THIS_i8:.*]] = bitcast %struct.B* %[[THIS]] to i8*
  34   // CHECK:   %[[VFPTR_i8:.*]] = getelementptr inbounds i8, i8* %[[THIS_i8]], i32 %{{.*}}
  35   // CHECK:   %[[VFPTR:.*]] = bitcast i8* %[[VFPTR_i8]] to i32 (...)***
  36   // CHECK:   store i32 (...)** bitcast ({ [3 x i8*] }* @"\01??_7B@@6B@" to i32 (...)**), i32 (...)*** %[[VFPTR]]
  37
  38   // Initialize vtorDisp:
  39   // CHECK:   %[[THIS_i8:.*]] = bitcast %struct.B* %[[THIS]] to i8*
  40   // CHECK:   %[[VBPTR:.*]] = getelementptr inbounds i8, i8* %[[THIS_i8]], i32 0
  41   // ...
  42   // CHECK:   %[[VBASE_OFFSET:.*]] = add nsw i32 0, %{{.*}}
  43   // CHECK:   %[[VTORDISP_VAL:.*]] = sub i32 %[[VBASE_OFFSET]], 8
  44   // CHECK:   %[[THIS_i8:.*]] = bitcast %struct.B* %[[THIS]] to i8*
  45   // CHECK:   %[[VBASE_i8:.*]] = getelementptr inbounds i8, i8* %[[THIS_i8]], i32 %[[VBASE_OFFSET]]
  46   // CHECK:   %[[VTORDISP_i8:.*]] = getelementptr i8, i8* %[[VBASE_i8]], i32 -4
  47   // CHECK:   %[[VTORDISP_PTR:.*]] = bitcast i8* %[[VTORDISP_i8]] to i32*
  48   // CHECK:   store i32 %[[VTORDISP_VAL]], i32* %[[VTORDISP_PTR]]
  49
  50   // CHECK: ret
  51 }
  52
  53 B::~B() {
  54   // CHECK-LABEL: define x86_thiscallcc void @"\01??1B@@UAE@XZ"
  55   // Adjust the this parameter:
  56   // CHECK:   %[[THIS_PARAM_i8:.*]] = bitcast %struct.B* {{.*}} to i8*
  57   // CHECK:   %[[THIS_i8:.*]] = getelementptr inbounds i8, i8* %[[THIS_PARAM_i8]], i32 -8
  58   // CHECK:   %[[THIS:.*]] = bitcast i8* %[[THIS_i8]] to %struct.B*
  59   // CHECK:   store %struct.B* %[[THIS]], %struct.B** %[[THIS_ADDR:.*]], align 4
  60   // CHECK:   %[[THIS:.*]] = load %struct.B*, %struct.B** %[[THIS_ADDR]]
  61
  62   // Restore the vfptr that could have been changed by a subclass.
  63   // CHECK:   %[[THIS_i8:.*]] = bitcast %struct.B* %[[THIS]] to i8*
  64   // CHECK:   %[[VBPTR:.*]] = getelementptr inbounds i8, i8* %[[THIS_i8]], i32 0
  65   // ...
  66   // CHECK:   %[[THIS_i8:.*]] = bitcast %struct.B* %[[THIS]] to i8*
  67   // CHECK:   %[[VFPTR_i8:.*]] = getelementptr inbounds i8, i8* %[[THIS_i8]], i32 %{{.*}}
  68   // CHECK:   %[[VFPTR:.*]] = bitcast i8* %[[VFPTR_i8]] to i32 (...)***
  69   // CHECK:   store i32 (...)** bitcast ({ [3 x i8*] }* @"\01??_7B@@6B@" to i32 (...)**), i32 (...)*** %[[VFPTR]]
  70
  71   // Initialize vtorDisp:
  72   // CHECK:   %[[THIS_i8:.*]] = bitcast %struct.B* %[[THIS]] to i8*
  73   // CHECK:   %[[VBPTR:.*]] = getelementptr inbounds i8, i8* %[[THIS_i8]], i32 0
  74   // ...
  75   // CHECK:   %[[VBASE_OFFSET:.*]] = add nsw i32 0, %{{.*}}
  76   // CHECK:   %[[VTORDISP_VAL:.*]] = sub i32 %[[VBASE_OFFSET]], 8
  77   // CHECK:   %[[THIS_i8:.*]] = bitcast %struct.B* %[[THIS]] to i8*
  78   // CHECK:   %[[VBASE_i8:.*]] = getelementptr inbounds i8, i8* %[[THIS_i8]], i32 %[[VBASE_OFFSET]]
  79   // CHECK:   %[[VTORDISP_i8:.*]] = getelementptr i8, i8* %[[VBASE_i8]], i32 -4
  80   // CHECK:   %[[VTORDISP_PTR:.*]] = bitcast i8* %[[VTORDISP_i8]] to i32*
  81   // CHECK:   store i32 %[[VTORDISP_VAL]], i32* %[[VTORDISP_PTR]]
  82
  83   foo();  // Avoid the "trivial destructor" optimization.
  84
  85   // CHECK: ret
  86
  87   // CHECK2-LABEL: define linkonce_odr x86_thiscallcc void @"\01??_DB@@QAEXXZ"(%struct.B*
  88   // CHECK2: %[[THIS:.*]] = load %struct.B*, %struct.B** {{.*}}
  89   // CHECK2: %[[THIS_i8:.*]] = bitcast %struct.B* %[[THIS]] to i8*
  90   // CHECK2: %[[B_i8:.*]] = getelementptr i8, i8* %[[THIS_i8]], i32 8
  91   // CHECK2: %[[B:.*]] = bitcast i8* %[[B_i8]] to %struct.B*
  92   // CHECK2: call x86_thiscallcc void @"\01??1B@@UAE@XZ"(%struct.B* %[[B]])
  93   // CHECK2: %[[THIS_i8:.*]] = bitcast %struct.B* %[[THIS]] to i8*
  94   // CHECK2: %[[VBASE_i8:.*]] = getelementptr inbounds i8, i8* %[[THIS_i8]], i32 8
  95   // CHECK2: %[[VBASE:.*]] = bitcast i8* %[[VBASE_i8]] to %struct.VBase*
  96   // CHECK2: call x86_thiscallcc void @"\01??1VBase@@UAE@XZ"(%struct.VBase* %[[VBASE]])
  97   // CHECK2: ret
  98
  99   // CHECK2-LABEL: define linkonce_odr x86_thiscallcc i8* @"\01??_GB@@UAEPAXI@Z"
 100   // CHECK2:   %[[THIS_PARAM_i8:.*]] = bitcast %struct.B* {{.*}} to i8*
 101   // CHECK2:   %[[THIS_i8:.*]] = getelementptr inbounds i8, i8* %[[THIS_PARAM_i8:.*]], i32 -8
 102   // CHECK2:   %[[THIS:.*]] = bitcast i8* %[[THIS_i8]] to %struct.B*
 103   // CHECK2:   store %struct.B* %[[THIS]], %struct.B** %[[THIS_ADDR:.*]], align 4
 104   // CHECK2:   %[[THIS:.*]] = load %struct.B*, %struct.B** %[[THIS_ADDR]]
 105   // CHECK2:   call x86_thiscallcc void @"\01??_DB@@QAEXXZ"(%struct.B* %[[THIS]])
 106   // ...
 107   // CHECK2: ret
 108 }
 109
 110 void B::foo() {
 111 // CHECK-LABEL: define x86_thiscallcc void @"\01?foo@B@@UAEXXZ"(i8*
 112 //
 113 // B::foo gets 'this' cast to VBase* in ECX (i.e. this+8) so we
 114 // need to adjust 'this' before use.
 115 //
 116 // CHECK: %[[THIS_ADDR:.*]] = alloca %struct.B*, align 4
 117 // CHECK: %[[THIS_i8:.*]] = getelementptr inbounds i8, i8* %[[ECX:.*]], i32 -8
 118 // CHECK: %[[THIS:.*]] = bitcast i8* %[[THIS_i8]] to %struct.B*
 119 // CHECK: store %struct.B* %[[THIS]], %struct.B** %[[THIS_ADDR]], align 4
 120
 121   field = 42;
 122 // CHECK: %[[THIS:.*]] = load %struct.B*, %struct.B** %[[THIS_ADDR]]
 123 // CHECK: %[[THIS8:.*]] = bitcast %struct.B* %[[THIS]] to i8*
 124 // CHECK: %[[VBPTR:.*]] = getelementptr inbounds i8, i8* %[[THIS8]], i32 0
 125 // CHECK: %[[VBPTR8:.*]] = bitcast i8* %[[VBPTR]] to i32**
 126 // CHECK: %[[VBTABLE:.*]] = load i32*, i32** %[[VBPTR8]]
 127 // CHECK: %[[VBENTRY:.*]] = getelementptr inbounds i32, i32* %[[VBTABLE]], i32 1
 128 // CHECK: %[[VBOFFSET32:.*]] = load i32, i32* %[[VBENTRY]]
 129 // CHECK: %[[VBOFFSET:.*]] = add nsw i32 0, %[[VBOFFSET32]]
 130 // CHECK: %[[THIS8:.*]] = bitcast %struct.B* %[[THIS]] to i8*
 131 // CHECK: %[[VBASE_i8:.*]] = getelementptr inbounds i8, i8* %[[THIS8]], i32 %[[VBOFFSET]]
 132 // CHECK: %[[VBASE:.*]] = bitcast i8* %[[VBASE_i8]] to %struct.VBase*
 133 // CHECK: %[[FIELD:.*]] = getelementptr inbounds %struct.VBase, %struct.VBase* %[[VBASE]], i32 0, i32 1
 134 // CHECK: store i32 42, i32* %[[FIELD]], align 4
 135 //
 136 // CHECK: ret void
 137 }
 138
 139 void call_vbase_bar(B *obj) {
 140 // CHECK-LABEL: define void @"\01?call_vbase_bar@@YAXPAUB@@@Z"(%struct.B* %obj)
 141 // CHECK: %[[OBJ:.*]] = load %struct.B
 142
 143   obj->bar();
 144 // When calling a vbase's virtual method, one needs to adjust 'this'
 145 // at the caller site.
 146 //
 147 // CHECK: %[[OBJ_i8:.*]] = bitcast %struct.B* %[[OBJ]] to i8*
 148 // CHECK: %[[VBPTR:.*]] = getelementptr inbounds i8, i8* %[[OBJ_i8]], i32 0
 149 // CHECK: %[[VBPTR8:.*]] = bitcast i8* %[[VBPTR]] to i32**
 150 // CHECK: %[[VBTABLE:.*]] = load i32*, i32** %[[VBPTR8]]
 151 // CHECK: %[[VBENTRY:.*]] = getelementptr inbounds i32, i32* %[[VBTABLE]], i32 1
 152 // CHECK: %[[VBOFFSET32:.*]] = load i32, i32* %[[VBENTRY]]
 153 // CHECK: %[[VBOFFSET:.*]] = add nsw i32 0, %[[VBOFFSET32]]
 154 // CHECK: %[[VBASE_i8:.*]] = getelementptr inbounds i8, i8* %[[OBJ_i8]], i32 %[[VBOFFSET]]
 155 // CHECK: %[[VFPTR:.*]] = bitcast i8* %[[VBASE_i8]] to void (i8*)***
 156 // CHECK: %[[VFTABLE:.*]] = load void (i8*)**, void (i8*)*** %[[VFPTR]]
 157 // CHECK: %[[VFUN:.*]] = getelementptr inbounds void (i8*)*, void (i8*)** %[[VFTABLE]], i64 2
 158 // CHECK: %[[VFUN_VALUE:.*]] = load void (i8*)*, void (i8*)** %[[VFUN]]
 159 //
 160 // CHECK: %[[OBJ_i8:.*]] = bitcast %struct.B* %[[OBJ]] to i8*
 161 // CHECK: %[[VBPTR:.*]] = getelementptr inbounds i8, i8* %[[OBJ_i8]], i32 0
 162 // CHECK: %[[VBPTR8:.*]] = bitcast i8* %[[VBPTR]] to i32**
 163 // CHECK: %[[VBTABLE:.*]] = load i32*, i32** %[[VBPTR8]]
 164 // CHECK: %[[VBENTRY:.*]] = getelementptr inbounds i32, i32* %[[VBTABLE]], i32 1
 165 // CHECK: %[[VBOFFSET32:.*]] = load i32, i32* %[[VBENTRY]]
 166 // CHECK: %[[VBOFFSET:.*]] = add nsw i32 0, %[[VBOFFSET32]]
 167 // CHECK: %[[VBASE:.*]] = getelementptr inbounds i8, i8* %[[OBJ_i8]], i32 %[[VBOFFSET]]
 168 //
 169 // CHECK: call x86_thiscallcc void %[[VFUN_VALUE]](i8* %[[VBASE]])
 170 //
 171 // CHECK: ret void
 172 }
 173
 174 void delete_B(B *obj) {
 175 // CHECK-LABEL: define void @"\01?delete_B@@YAXPAUB@@@Z"(%struct.B* %obj)
 176 // CHECK: %[[OBJ:.*]] = load %struct.B
 177
 178   delete obj;
 179 // CHECK: %[[OBJ_i8:.*]] = bitcast %struct.B* %[[OBJ]] to i8*
 180 // CHECK: %[[VBPTR:.*]] = getelementptr inbounds i8, i8* %[[OBJ_i8]], i32 0
 181 // CHECK: %[[VBPTR8:.*]] = bitcast i8* %[[VBPTR]] to i32**
 182 // CHECK: %[[VBTABLE:.*]] = load i32*, i32** %[[VBPTR8]]
 183 // CHECK: %[[VBENTRY:.*]] = getelementptr inbounds i32, i32* %[[VBTABLE]], i32 1
 184 // CHECK: %[[VBOFFSET32:.*]] = load i32, i32* %[[VBENTRY]]
 185 // CHECK: %[[VBOFFSET:.*]] = add nsw i32 0, %[[VBOFFSET32]]
 186 // CHECK: %[[VBASE_i8:.*]] = getelementptr inbounds i8, i8* %[[OBJ_i8]], i32 %[[VBOFFSET]]
 187 // CHECK: %[[VFPTR:.*]] = bitcast i8* %[[VBASE_i8]] to i8* (%struct.B*, i32)***
 188 // CHECK: %[[VFTABLE:.*]] = load i8* (%struct.B*, i32)**, i8* (%struct.B*, i32)*** %[[VFPTR]]
 189 // CHECK: %[[VFUN:.*]] = getelementptr inbounds i8* (%struct.B*, i32)*, i8* (%struct.B*, i32)** %[[VFTABLE]], i64 0
 190 // CHECK: %[[VFUN_VALUE:.*]] = load i8* (%struct.B*, i32)*, i8* (%struct.B*, i32)** %[[VFUN]]
 191 //
 192 // CHECK: %[[OBJ_i8:.*]] = bitcast %struct.B* %[[OBJ]] to i8*
 193 // CHECK: %[[VBPTR:.*]] = getelementptr inbounds i8, i8* %[[OBJ_i8]], i32 0
 194 // CHECK: %[[VBPTR8:.*]] = bitcast i8* %[[VBPTR]] to i32**
 195 // CHECK: %[[VBTABLE:.*]] = load i32*, i32** %[[VBPTR8]]
 196 // CHECK: %[[VBENTRY:.*]] = getelementptr inbounds i32, i32* %[[VBTABLE]], i32 1
 197 // CHECK: %[[VBOFFSET32:.*]] = load i32, i32* %[[VBENTRY]]
 198 // CHECK: %[[VBOFFSET:.*]] = add nsw i32 0, %[[VBOFFSET32]]
 199 // CHECK: %[[VBASE_i8:.*]] = getelementptr inbounds i8, i8* %[[OBJ_i8]], i32 %[[VBOFFSET]]
 200 // CHECK: %[[VBASE:.*]] = bitcast i8* %[[VBASE_i8]] to %struct.B*
 201 //
 202 // CHECK: call x86_thiscallcc i8* %[[VFUN_VALUE]](%struct.B* %[[VBASE]], i32 1)
 203 // CHECK: ret void
 204 }
 205
 206 void call_complete_dtor() {
 207   // CHECK-LABEL: define void @"\01?call_complete_dtor@@YAXXZ"
 208   B b;
 209   // CHECK: call x86_thiscallcc %struct.B* @"\01??0B@@QAE@XZ"(%struct.B* %[[B:.*]], i32 1)
 210   // CHECK-NOT: getelementptr
 211   // CHECK: call x86_thiscallcc void @"\01??_DB@@QAEXXZ"(%struct.B* %[[B]])
 212   // CHECK: ret
 213 }
 214
 215 struct C : B {
 216   C();
 217   // has an implicit vdtor.
 218 };
 219
 220 // Used to crash on an assertion.
 221 C::C() {
 222 // CHECK-LABEL: define x86_thiscallcc %struct.C* @"\01??0C@@QAE@XZ"
 223 }
 224
 225 namespace multiple_vbases {
 226 struct A {
 227   virtual void a();
 228 };
 229
 230 struct B {
 231   virtual void b();
 232 };
 233
 234 struct C {
 235   virtual void c();
 236 };
 237
 238 struct D : virtual A, virtual B, virtual C {
 239   virtual void a();
 240   virtual void b();
 241   virtual void c();
 242   D();
 243 };
 244
 245 D::D() {
 246   // CHECK-LABEL: define x86_thiscallcc %"struct.multiple_vbases::D"* @"\01??0D@multiple_vbases@@QAE@XZ"
 247   // Just make sure we emit 3 vtordisps after initializing vfptrs.
 248   // CHECK: store i32 (...)** bitcast ({ [1 x i8*] }* @"\01??_7D@multiple_vbases@@6BA@1@@" to i32 (...)**), i32 (...)*** %{{.*}}
 249   // CHECK: store i32 (...)** bitcast ({ [1 x i8*] }* @"\01??_7D@multiple_vbases@@6BB@1@@" to i32 (...)**), i32 (...)*** %{{.*}}
 250   // CHECK: store i32 (...)** bitcast ({ [1 x i8*] }* @"\01??_7D@multiple_vbases@@6BC@1@@" to i32 (...)**), i32 (...)*** %{{.*}}
 251   // ...
 252   // CHECK: store i32 %{{.*}}, i32* %{{.*}}
 253   // CHECK: store i32 %{{.*}}, i32* %{{.*}}
 254   // CHECK: store i32 %{{.*}}, i32* %{{.*}}
 255   // CHECK: ret
 256 }
 257 }
 258
 259 namespace diamond {
 260 struct A {
 261   A();
 262   virtual ~A();
 263 };
 264
 265 struct B : virtual A {
 266   B();
 267   ~B();
 268 };
 269
 270 struct C : virtual A {
 271   C();
 272   ~C();
 273   int c1, c2, c3;
 274 };
 275
 276 struct Z {
 277   int z;
 278 };
 279
 280 struct D : virtual Z, B, C {
 281   D();
 282   ~D();
 283 } d;
 284
 285 D::~D() {
 286   // CHECK-LABEL: define x86_thiscallcc void @"\01??1D@diamond@@UAE@XZ"(%"struct.diamond::D"*{{.*}})
 287   // CHECK: %[[ARG_i8:.*]] = bitcast %"struct.diamond::D"* %{{.*}} to i8*
 288   // CHECK: %[[THIS_i8:.*]] = getelementptr inbounds i8, i8* %[[ARG_i8]], i32 -24
 289   // CHECK: %[[THIS:.*]] = bitcast i8* %[[THIS_i8]] to %"struct.diamond::D"*
 290   // CHECK: store %"struct.diamond::D"* %[[THIS]], %"struct.diamond::D"** %[[THIS_VAL:.*]], align 4
 291   // CHECK: %[[THIS:.*]] = load %"struct.diamond::D"*, %"struct.diamond::D"** %[[THIS_VAL]]
 292   // CHECK: %[[D_i8:.*]] = bitcast %"struct.diamond::D"* %[[THIS]] to i8*
 293   // CHECK: %[[C_i8:.*]] = getelementptr inbounds i8, i8* %[[D_i8]], i32 4
 294   // CHECK: %[[C:.*]] = bitcast i8* %[[C_i8]] to %"struct.diamond::C"*
 295   // CHECK: %[[C_i8:.*]] = bitcast %"struct.diamond::C"* %[[C]] to i8*
 296   // CHECK: %[[ARG_i8:.*]] = getelementptr i8, i8* %{{.*}}, i32 16
 297   // FIXME: We might consider changing the dtor this parameter type to i8*.
 298   // CHECK: %[[ARG:.*]] = bitcast i8* %[[ARG_i8]] to %"struct.diamond::C"*
 299   // CHECK: call x86_thiscallcc void @"\01??1C@diamond@@UAE@XZ"(%"struct.diamond::C"* %[[ARG]])
 300
 301   // CHECK: %[[B:.*]] = bitcast %"struct.diamond::D"* %[[THIS]] to %"struct.diamond::B"*
 302   // CHECK: %[[B_i8:.*]] = bitcast %"struct.diamond::B"* %[[B]] to i8*
 303   // CHECK: %[[ARG_i8:.*]] = getelementptr i8, i8* %[[B_i8]], i32 4
 304   // CHECK: %[[ARG:.*]] = bitcast i8* %[[ARG_i8]] to %"struct.diamond::B"*
 305   // CHECK: call x86_thiscallcc void @"\01??1B@diamond@@UAE@XZ"(%"struct.diamond::B"* %[[ARG]])
 306   // CHECK: ret void
 307 }
 308
 309 }
 310
 311 namespace test2 {
 312 struct A { A(); };
 313 struct B : virtual A { B() {} };
 314 struct C : B, A { C() {} };
 315
 316 // PR18435: Order mattered here.  We were generating code for the delegating
 317 // call to B() from C().
 318 void callC() { C x; }
 319
 320 // CHECK-LABEL: define linkonce_odr x86_thiscallcc %"struct.test2::C"* @"\01??0C@test2@@QAE@XZ"
 321 // CHECK:           (%"struct.test2::C"* returned %this, i32 %is_most_derived)
 322 // CHECK: br i1
 323 //   Virtual bases
 324 // CHECK: call x86_thiscallcc %"struct.test2::A"* @"\01??0A@test2@@QAE@XZ"(%"struct.test2::A"* %{{.*}})
 325 // CHECK: br label
 326 //   Non-virtual bases
 327 // CHECK: call x86_thiscallcc %"struct.test2::B"* @"\01??0B@test2@@QAE@XZ"(%"struct.test2::B"* %{{.*}}, i32 0)
 328 // CHECK: call x86_thiscallcc %"struct.test2::A"* @"\01??0A@test2@@QAE@XZ"(%"struct.test2::A"* %{{.*}})
 329 // CHECK: ret
 330
 331 // CHECK2-LABEL: define linkonce_odr x86_thiscallcc %"struct.test2::B"* @"\01??0B@test2@@QAE@XZ"
 332 // CHECK2:           (%"struct.test2::B"* returned %this, i32 %is_most_derived)
 333 // CHECK2: call x86_thiscallcc %"struct.test2::A"* @"\01??0A@test2@@QAE@XZ"(%"struct.test2::A"* %{{.*}})
 334 // CHECK2: ret
 335
 336 }
 337
 338 namespace test3 {
 339 // PR19104: A non-virtual call of a virtual method doesn't use vftable thunks,
 340 // so requires only static adjustment which is different to the one used
 341 // for virtual calls.
 342 struct A {
 343   virtual void foo();
 344 };
 345
 346 struct B : virtual A {
 347   virtual void bar();
 348 };
 349
 350 struct C : virtual A {
 351   virtual void foo();
 352 };
 353
 354 struct D : B, C {
 355   virtual void bar();
 356   int field;  // Laid out between C and A subobjects in D.
 357 };
 358
 359 void D::bar() {
 360   // CHECK-LABEL: define x86_thiscallcc void @"\01?bar@D@test3@@UAEXXZ"(%"struct.test3::D"* %this)
 361
 362   C::foo();
 363   // Shouldn't need any vbtable lookups.  All we have to do is adjust to C*,
 364   // then compensate for the adjustment performed in the C::foo() prologue.
 365   // CHECK-NOT: load i8*, i8**
 366   // CHECK: %[[OBJ_i8:.*]] = bitcast %"struct.test3::D"* %{{.*}} to i8*
 367   // CHECK: %[[C_i8:.*]] = getelementptr inbounds i8, i8* %[[OBJ_i8]], i32 8
 368   // CHECK: %[[C:.*]] = bitcast i8* %[[C_i8]] to %"struct.test3::C"*
 369   // CHECK: %[[C_i8:.*]] = bitcast %"struct.test3::C"* %[[C]] to i8*
 370   // CHECK: %[[ARG:.*]] = getelementptr i8, i8* %[[C_i8]], i32 4
 371   // CHECK: call x86_thiscallcc void @"\01?foo@C@test3@@UAEXXZ"(i8* %[[ARG]])
 372   // CHECK: ret
 373 }
 374 }
 375
 376 namespace test4{
 377 // PR19172: We used to merge method vftable locations wrong.
 378
 379 struct A {
 380   virtual ~A() {}
 381 };
 382
 383 struct B {
 384   virtual ~B() {}
 385 };
 386
 387 struct C : virtual A, B {
 388   virtual ~C();
 389 };
 390
 391 void foo(void*);
 392
 393 C::~C() {
 394   // CHECK-LABEL: define x86_thiscallcc void @"\01??1C@test4@@UAE@XZ"(%"struct.test4::C"* %this)
 395
 396   // In this case "this" points to the most derived class, so no GEPs needed.
 397   // CHECK-NOT: getelementptr
 398   // CHECK-NOT: bitcast
 399   // CHECK: %[[VFPTR_i8:.*]] = bitcast %"struct.test4::C"* %{{.*}} to i32 (...)***
 400   // CHECK: store i32 (...)** bitcast ({ [1 x i8*] }* @"\01??_7C@test4@@6BB@1@@" to i32 (...)**), i32 (...)*** %[[VFPTR_i8]]
 401
 402   foo(this);
 403   // CHECK: ret
 404 }
 405
 406 void destroy(C *obj) {
 407   // CHECK-LABEL: define void @"\01?destroy@test4@@YAXPAUC@1@@Z"(%"struct.test4::C"* %obj)
 408
 409   delete obj;
 410   // CHECK: %[[VPTR:.*]] = bitcast %"struct.test4::C"* %[[OBJ:.*]] to i8* (%"struct.test4::C"*, i32)***
 411   // CHECK: %[[VFTABLE:.*]] = load i8* (%"struct.test4::C"*, i32)**, i8* (%"struct.test4::C"*, i32)*** %[[VPTR]]
 412   // CHECK: %[[VFTENTRY:.*]] = getelementptr inbounds i8* (%"struct.test4::C"*, i32)*, i8* (%"struct.test4::C"*, i32)** %[[VFTABLE]], i64 0
 413   // CHECK: %[[VFUN:.*]] = load i8* (%"struct.test4::C"*, i32)*, i8* (%"struct.test4::C"*, i32)** %[[VFTENTRY]]
 414   // CHECK: call x86_thiscallcc i8* %[[VFUN]](%"struct.test4::C"* %[[OBJ]], i32 1)
 415   // CHECK: ret
 416 }
 417
 418 struct D {
 419   virtual void d();
 420 };
 421
 422 // The first non-virtual base doesn't have a vdtor,
 423 // but "this adjustment" is not needed.
 424 struct E : D, B, virtual A {
 425   virtual ~E();
 426 };
 427
 428 E::~E() {
 429   // CHECK-LABEL: define x86_thiscallcc void @"\01??1E@test4@@UAE@XZ"(%"struct.test4::E"* %this)
 430
 431   // In this case "this" points to the most derived class, so no GEPs needed.
 432   // CHECK-NOT: getelementptr
 433   // CHECK-NOT: bitcast
 434   // CHECK: %[[VFPTR_i8:.*]] = bitcast %"struct.test4::E"* %{{.*}} to i32 (...)***
 435   // CHECK: store i32 (...)** bitcast ({ [1 x i8*] }* @"\01??_7E@test4@@6BD@1@@" to i32 (...)**), i32 (...)*** %[[VFPTR_i8]]
 436   foo(this);
 437 }
 438
 439 void destroy(E *obj) {
 440   // CHECK-LABEL: define void @"\01?destroy@test4@@YAXPAUE@1@@Z"(%"struct.test4::E"* %obj)
 441
 442   // CHECK-NOT: getelementptr
 443   // CHECK: %[[OBJ_i8:.*]] = bitcast %"struct.test4::E"* %[[OBJ:.*]] to i8*
 444   // CHECK: %[[B_i8:.*]] = getelementptr inbounds i8, i8* %[[OBJ_i8]], i32 4
 445   // CHECK: %[[VPTR:.*]] = bitcast i8* %[[B_i8]] to i8* (%"struct.test4::E"*, i32)***
 446   // CHECK: %[[VFTABLE:.*]] = load i8* (%"struct.test4::E"*, i32)**, i8* (%"struct.test4::E"*, i32)*** %[[VPTR]]
 447   // CHECK: %[[VFTENTRY:.*]] = getelementptr inbounds i8* (%"struct.test4::E"*, i32)*, i8* (%"struct.test4::E"*, i32)** %[[VFTABLE]], i64 0
 448   // CHECK: %[[VFUN:.*]] = load i8* (%"struct.test4::E"*, i32)*, i8* (%"struct.test4::E"*, i32)** %[[VFTENTRY]]
 449   // CHECK: %[[OBJ_i8:.*]] = bitcast %"struct.test4::E"* %[[OBJ]] to i8*
 450   // CHECK: %[[B_i8:.*]] = getelementptr inbounds i8, i8* %[[OBJ_i8]], i32 4
 451   // FIXME: in fact, the call should take i8* and the bitcast is redundant.
 452   // CHECK: %[[B_as_E:.*]] = bitcast i8* %[[B_i8]] to %"struct.test4::E"*
 453   // CHECK: call x86_thiscallcc i8* %[[VFUN]](%"struct.test4::E"* %[[B_as_E]], i32 1)
 454   delete obj;
 455 }
 456
 457 }
 458
 459 namespace test5 {
 460 // PR25370: Don't zero-initialize vbptrs in virtual bases.
 461 struct A {
 462   virtual void f();
 463 };
 464
 465 struct B : virtual A {
 466   int Field;
 467 };
 468
 469 struct C : B {
 470   C();
 471 };
 472
 473 C::C() : B() {}
 474 // CHECK-LABEL: define x86_thiscallcc %"struct.test5::C"* @"\01??0C@test5@@QAE@XZ"(
 475 // CHECK:   %[[THIS:.*]] = load %"struct.test5::C"*, %"struct.test5::C"**
 476 // CHECK:   br i1 %{{.*}}, label %[[INIT_VBASES:.*]], label %[[SKIP_VBASES:.*]]
 477
 478 // CHECK: %[[SKIP_VBASES]]
 479 // CHECK:   %[[B:.*]] = bitcast %"struct.test5::C"* %[[THIS]] to %"struct.test5::B"*
 480 // CHECK:   %[[B_i8:.*]] = bitcast %"struct.test5::B"* %[[B]] to i8*
 481 // CHECK:   %[[FIELD:.*]] = getelementptr inbounds i8, i8* %[[B_i8]], i32 4
 482 // CHECK:   call void @llvm.memset.p0i8.i32(i8* %[[FIELD]], i8 0, i32 4, i32 4, i1 false)
 483 }
 484
 485 namespace pr27621 {
 486 // Devirtualization through a static_cast used to make us compute the 'this'
 487 // adjustment for B::g instead of C::g. When we directly call C::g, 'this' is a
 488 // B*, and the prologue of C::g will adjust it to a C*.
 489 struct A { virtual void f(); };
 490 struct B { virtual void g(); };
 491 struct C final : A, B {
 492   virtual void h();
 493   void g() override;
 494 };
 495 void callit(C *p) {
 496   static_cast<B*>(p)->g();
 497 }
 498 // CHECK-LABEL: define void @"\01?callit@pr27621@@YAXPAUC@1@@Z"(%"struct.pr27621::C"* %{{.*}})
 499 // CHECK: %[[B_i8:.*]] = getelementptr i8, i8* %{{.*}}, i32 4
 500 // CHECK: call x86_thiscallcc void @"\01?g@C@pr27621@@UAEXXZ"(i8* %[[B_i8]])
 501 }
 502
 503 namespace test6 {
 504 class A {};
 505 class B : virtual A {};
 506 class C : virtual B {
 507   virtual void m_fn1();
 508   float field;
 509 };
 510 class D : C {
 511   D();
 512 };
 513 D::D() : C() {}
 514 // CHECK-LABEL: define x86_thiscallcc %"class.test6::D"* @"\01??0D@test6@@AAE@XZ"(
 515 // CHECK:   %[[THIS:.*]] = load %"class.test6::D"*, %"class.test6::D"**
 516 // CHECK:   br i1 %{{.*}}, label %[[INIT_VBASES:.*]], label %[[SKIP_VBASES:.*]]
 517
 518 // CHECK: %[[SKIP_VBASES]]
 519 // CHECK:   %[[C:.*]] = bitcast %"class.test6::D"* %[[THIS]] to %"class.test6::C"*
 520 // CHECK:   %[[C_i8:.*]] = bitcast %"class.test6::C"* %[[C]] to i8*
 521 // CHECK:   %[[FIELD:.*]] = getelementptr inbounds i8, i8* %[[C_i8]], i32 8
 522 // CHECK:   call void @llvm.memset.p0i8.i32(i8* %[[FIELD]], i8 0, i32 4, i32 4, i1 false)
 523 }