test/CodeGenCXX/microsoft-abi-vtables-multiple-nonvirtual-inheritance-no-thunks.cpp

   1 // RUN: %clang_cc1 %s -fno-rtti -triple=i386-pc-win32 -emit-llvm -o %t.ll -fdump-vtable-layouts >%t
   2 // RUN: FileCheck %s < %t
   3 // RUN: FileCheck --check-prefix=MANGLING %s < %t.ll
   4
   5 namespace test1 {
   6 struct A {
   7   virtual void f();
   8 };
   9
  10 struct B {
  11   virtual void g();
  12   // Add an extra virtual method so it's easier to check for the absence of thunks.
  13   virtual void h();
  14 };
  15
  16 struct X : A, B {
  17   // CHECK-LABEL: VFTable for 'test1::A' in 'test1::X' (1 entry)
  18   // CHECK-NEXT:   0 | void test1::X::f()
  19
  20   // CHECK-LABEL: VFTable for 'test1::B' in 'test1::X' (2 entries)
  21   // CHECK-NEXT:   0 | void test1::B::g()
  22   // CHECK-NEXT:   1 | void test1::B::h()
  23
  24   // CHECK-LABEL: VFTable indices for 'test1::X' (1 entry)
  25   // CHECK-NEXT:   0 | void test1::X::f()
  26
  27   // MANGLING-DAG: @"\01??_7X@test1@@6BA@1@@"
  28   // MANGLING-DAG: @"\01??_7X@test1@@6BB@1@@"
  29
  30   // Overrides only the left child's method (A::f), needs no thunks.
  31   virtual void f();
  32 } x;
  33
  34 void build_vftable(X *obj) { obj->f(); }
  35 }
  36
  37 namespace test2 {
  38 struct A {
  39   virtual void f();
  40 };
  41
  42 struct B {
  43   virtual void g();
  44   virtual void h();
  45 };
  46
  47 struct X : A, B {
  48   // CHECK-LABEL: VFTable for 'test2::A' in 'test2::X' (1 entry)
  49   // CHECK-NEXT:   0 | void test2::A::f()
  50
  51   // CHECK-LABEL: VFTable for 'test2::B' in 'test2::X' (2 entries)
  52   // CHECK-NEXT:   0 | void test2::X::g()
  53   // CHECK-NEXT:   1 | void test2::B::h()
  54
  55   // CHECK-LABEL: VFTable indices for 'test2::X' (1 entry).
  56   // CHECK-NEXT:   via vfptr at offset 4
  57   // CHECK-NEXT:   0 | void test2::X::g()
  58
  59   // Overrides only the right child's method (B::g), needs this adjustment but
  60   // not thunks.
  61   virtual void g();
  62 };
  63
  64 void build_vftable(X *obj) { obj->g(); }
  65 }
  66
  67 namespace test3 {
  68 struct A {
  69   virtual void f();
  70 };
  71
  72 struct B {
  73   virtual void g();
  74   virtual void h();
  75 };
  76
  77 struct X : A, B {
  78   // CHECK-LABEL: VFTable for 'test3::A' in 'test3::X' (2 entries)
  79   // CHECK-NEXT:   0 | void test3::A::f()
  80   // CHECK-NEXT:   1 | void test3::X::i()
  81
  82   // CHECK-LABEL: VFTable for 'test3::B' in 'test3::X' (2 entries)
  83   // CHECK-NEXT:   0 | void test3::B::g()
  84   // CHECK-NEXT:   1 | void test3::B::h()
  85
  86   // CHECK-LABEL: VFTable indices for 'test3::X' (1 entry).
  87   // CHECK-NEXT:   1 | void test3::X::i()
  88
  89   // Only adds a new method.
  90   virtual void i();
  91 };
  92
  93 void build_vftable(X *obj) { obj->i(); }
  94 }
  95
  96 namespace test4 {
  97 struct A {
  98   virtual void f();
  99 };
 100
 101 struct Empty { };  // Doesn't have a vftable!
 102
 103 // Only the right base has a vftable, so it's laid out before the left one!
 104 struct X : Empty, A {
 105   // CHECK-LABEL: VFTable for 'test4::A' in 'test4::X' (1 entry)
 106   // CHECK-NEXT:   0 | void test4::X::f()
 107
 108   // CHECK-LABEL: VFTable indices for 'test4::X' (1 entry).
 109   // CHECK-NEXT:   0 | void test4::X::f()
 110
 111   // MANGLING-DAG: @"\01??_7X@test4@@6B@"
 112
 113   virtual void f();
 114 } x;
 115
 116 void build_vftable(X *obj) { obj->f(); }
 117 }
 118
 119 namespace test5 {
 120 struct A {
 121   virtual void f();
 122 };
 123
 124 struct B {
 125   virtual void g();
 126   virtual void h();
 127 };
 128
 129 struct C : A, B {
 130   virtual void f();
 131 };
 132
 133 struct X : C {
 134   // CHECK-LABEL: VFTable for 'test5::A' in 'test5::C' in 'test5::X' (1 entry).
 135   // CHECK-NEXT:   0 | void test5::X::f()
 136
 137   // CHECK-LABEL: VFTable for 'test5::B' in 'test5::C' in 'test5::X' (2 entries).
 138   // CHECK-NEXT:   0 | void test5::B::g()
 139   // CHECK-NEXT:   1 | void test5::B::h()
 140
 141   // CHECK-LABEL: VFTable indices for 'test5::X' (1 entry).
 142   // CHECK-NEXT:   0 | void test5::X::f()
 143
 144   // MANGLING-DAG: @"\01??_7X@test5@@6BA@1@@"
 145   // MANGLING-DAG: @"\01??_7X@test5@@6BB@1@@"
 146
 147   // Overrides both C::f and A::f.
 148   virtual void f();
 149 } x;
 150
 151 void build_vftable(X *obj) { obj->f(); }
 152 }
 153
 154 namespace test6 {
 155 struct A {
 156   virtual void f();
 157 };
 158
 159 struct B {
 160   virtual void g();
 161   virtual void h();
 162 };
 163
 164 struct C : A, B {
 165   virtual void g();
 166 };
 167
 168 struct X : C {
 169   // CHECK-LABEL: VFTable for 'test6::A' in 'test6::C' in 'test6::X' (1 entry).
 170   // CHECK-NEXT:   0 | void test6::A::f()
 171
 172   // CHECK-LABEL: VFTable for 'test6::B' in 'test6::C' in 'test6::X' (2 entries).
 173   // CHECK-NEXT:   0 | void test6::X::g()
 174   // CHECK-NEXT:   1 | void test6::B::h()
 175
 176   // CHECK-LABEL: VFTable indices for 'test6::X' (1 entry).
 177   // CHECK-NEXT:   via vfptr at offset 4
 178   // CHECK-NEXT:   0 | void test6::X::g()
 179
 180   // Overrides both C::g and B::g.
 181   virtual void g();
 182 };
 183
 184 void build_vftable(X *obj) { obj->g(); }
 185 }
 186
 187 namespace test7 {
 188 struct A {
 189   virtual void f();
 190 };
 191
 192 struct B {
 193   virtual void g();
 194   virtual void h();
 195 };
 196
 197 struct C : A, B {
 198   // Only adds a new method.
 199   virtual void i();
 200 };
 201
 202 struct X : C {
 203   // CHECK-LABEL: VFTable for 'test7::A' in 'test7::C' in 'test7::X' (2 entries).
 204   // CHECK-NEXT:   0 | void test7::A::f()
 205   // CHECK-NEXT:   1 | void test7::C::i()
 206
 207   // CHECK-LABEL: VFTable for 'test7::B' in 'test7::C' in 'test7::X' (2 entries).
 208   // CHECK-NEXT:   0 | void test7::X::g()
 209   // CHECK-NEXT:   1 | void test7::B::h()
 210
 211   // CHECK-LABEL: VFTable indices for 'test7::X' (1 entry).
 212   // CHECK-NEXT:   via vfptr at offset 4
 213   // CHECK-NEXT:   0 | void test7::X::g()
 214
 215   // Overrides grandparent's B::g.
 216   virtual void g();
 217 };
 218
 219 void build_vftable(X *obj) { obj->g(); }
 220 }
 221
 222 namespace test8 {
 223 struct A {
 224   virtual void f();
 225 };
 226
 227 struct B : A {
 228   virtual void g();
 229 };
 230
 231 // There are two 'A' subobjects in this class.
 232 struct X : A, B {
 233   // CHECK-LABEL: VFTable for 'test8::A' in 'test8::X' (2 entries).
 234   // CHECK-NEXT:   0 | void test8::A::f()
 235   // CHECK-NEXT:   1 | void test8::X::h()
 236
 237   // CHECK-LABEL: VFTable for 'test8::A' in 'test8::B' in 'test8::X' (2 entries).
 238   // CHECK-NEXT:   0 | void test8::A::f()
 239   // CHECK-NEXT:   1 | void test8::B::g()
 240
 241   // CHECK-LABEL: VFTable indices for 'test8::X' (1 entry).
 242   // CHECK-NEXT:   1 | void test8::X::h()
 243
 244   // MANGLING-DAG: @"\01??_7X@test8@@6BA@1@@"
 245   // MANGLING-DAG: @"\01??_7X@test8@@6BB@1@@"
 246
 247   virtual void h();
 248 } x;
 249
 250 void build_vftable(X *obj) { obj->h(); }
 251 }
 252
 253 namespace test9 {
 254 struct A {
 255   virtual void f();
 256 };
 257
 258 struct B {
 259   virtual void g();
 260   virtual void h();
 261 };
 262
 263 struct C : A, B {
 264   // Overrides only the left child's method (A::f).
 265   virtual void f();
 266 };
 267
 268 struct D : A, B {
 269   // Overrides only the right child's method (B::g).
 270   virtual void g();
 271 };
 272
 273 // 2-level structure with repeating subobject types, but no thunks needed.
 274 struct X : C, D {
 275   // CHECK-LABEL: VFTable for 'test9::A' in 'test9::C' in 'test9::X' (2 entries)
 276   // CHECK-NEXT:   0 | void test9::C::f()
 277   // CHECK-NEXT:   1 | void test9::X::z()
 278
 279   // CHECK-LABEL: VFTable for 'test9::B' in 'test9::C' in 'test9::X' (2 entries)
 280   // CHECK-NEXT:   0 | void test9::B::g()
 281   // CHECK-NEXT:   1 | void test9::B::h()
 282
 283   // CHECK-LABEL: VFTable for 'test9::A' in 'test9::D' in 'test9::X' (1 entry)
 284   // CHECK-NEXT:   0 | void test9::A::f()
 285
 286   // CHECK-LABEL: VFTable for 'test9::B' in 'test9::D' in 'test9::X' (2 entries)
 287   // CHECK-NEXT:   0 | void test9::D::g()
 288   // CHECK-NEXT:   1 | void test9::B::h()
 289
 290   // CHECK-LABEL: VFTable indices for 'test9::X' (1 entry).
 291   // CHECK-NEXT:   1 | void test9::X::z()
 292
 293   // MANGLING-DAG: @"\01??_7X@test9@@6BA@1@C@1@@"
 294   // MANGLING-DAG: @"\01??_7X@test9@@6BA@1@D@1@@"
 295   // MANGLING-DAG: @"\01??_7X@test9@@6BB@1@C@1@@"
 296   // MANGLING-DAG: @"\01??_7X@test9@@6BB@1@D@1@@"
 297
 298   virtual void z();
 299 } x;
 300
 301 void build_vftable(test9::X *obj) { obj->z(); }
 302 }