1  //===------------------------- dynamic_cast.pass.cpp ----------------------===//
  2  //
  3  // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  4  // See https://llvm.org/LICENSE.txt for license information.
  5  // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  6  //
  7  //===----------------------------------------------------------------------===//
  8  
  9  // XFAIL: gcc-7, gcc-8, gcc-9
 10  
 11  // PR33425 and PR33487 are not fixed until the dylib shipped with macOS 10.15
 12  // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.14
 13  
 14  // PR33439 isn't fixed until the dylib shipped with macOS 10.14
 15  // XFAIL: use_system_cxx_lib && target={{.+}}-apple-macosx10.{{9|10|11|12|13}}
 16  
 17  #include <cassert>
 18  
 19  // This test explicitly tests dynamic cast with types that have inaccessible
 20  // bases.
 21  #if defined(__clang__)
 22  #   pragma clang diagnostic ignored "-Winaccessible-base"
 23  #elif defined(__GNUC__) && (__GNUC__ >= 10)
 24  #   pragma GCC diagnostic ignored "-Winaccessible-base"
 25  #endif
 26  
 27  typedef char Pad1[43981];
 28  typedef char Pad2[34981];
 29  typedef char Pad3[93481];
 30  typedef char Pad4[13489];
 31  typedef char Pad5[81349];
 32  typedef char Pad6[34819];
 33  typedef char Pad7[3489];
 34  
 35  namespace t1
 36  {
 37  
 38  // PR33425
 39  struct C3 { virtual ~C3() {} Pad1 _; };
 40  struct C5 : protected virtual C3 { Pad2 _; };
 41  struct C6 : virtual C5 { Pad3 _; };
 42  struct C7 : virtual C3 { Pad4 _; };
 43  struct C9 : C6, C7 { Pad5 _; };
 44  
 45  C9 c9;
 46  C3 *c3 = &c9;
 47  
 48  void test()
 49  {
 50      assert(dynamic_cast<C3*>(c3) == static_cast<C3*>(&c9));
 51      assert(dynamic_cast<C5*>(c3) == static_cast<C5*>(&c9));
 52      assert(dynamic_cast<C6*>(c3) == static_cast<C6*>(&c9));
 53      assert(dynamic_cast<C7*>(c3) == static_cast<C7*>(&c9));
 54      assert(dynamic_cast<C9*>(c3) == static_cast<C9*>(&c9));
 55  }
 56  
 57  }  // t1
 58  
 59  namespace t2
 60  {
 61  
 62  // PR33425
 63  struct Src { virtual ~Src() {} Pad1 _; };
 64  struct Mask : protected virtual Src { Pad2 _; };
 65  struct Dest : Mask { Pad3 _; };
 66  struct Root : Dest, virtual Src { Pad4 _; };
 67  
 68  Root root;
 69  Src *src = &root;
 70  
 71  void test()
 72  {
 73      assert(dynamic_cast<Src*>(src) == static_cast<Src*>(&root));
 74      assert(dynamic_cast<Mask*>(src) == static_cast<Mask*>(&root));
 75      assert(dynamic_cast<Dest*>(src) == static_cast<Dest*>(&root));
 76      assert(dynamic_cast<Root*>(src) == static_cast<Root*>(&root));
 77  }
 78  
 79  }  // t2
 80  
 81  namespace t3
 82  {
 83  
 84  // PR33487
 85  struct Class1 { virtual ~Class1() {} Pad1 _; };
 86  struct Shared : virtual Class1 { Pad2 _; };
 87  struct Class6 : virtual Shared { Pad3 _; };
 88  struct Left : Class6 { Pad4 _; };
 89  struct Right : Class6 { Pad5 _; };
 90  struct Main : Left, Right { Pad6 _; };
 91  
 92  Main m;
 93  Class1 *c1 = &m;
 94  
 95  void test()
 96  {
 97      assert(dynamic_cast<Class1*>(c1) == static_cast<Class1*>(&m));
 98      assert(dynamic_cast<Shared*>(c1) == static_cast<Shared*>(&m));
 99      assert(dynamic_cast<Class6*>(c1) == 0);
100      assert(dynamic_cast<Left*>(c1) == static_cast<Left*>(&m));
101      assert(dynamic_cast<Right*>(c1) == static_cast<Right*>(&m));
102      assert(dynamic_cast<Main*>(c1) == static_cast<Main*>(&m));
103  }
104  
105  }  // t3
106  
107  namespace t4
108  {
109  
110  // PR33439
111  struct C2 { virtual ~C2() {} Pad1 _; };
112  struct C3 { virtual ~C3() {} Pad2 _; };
113  struct C4 : C3 { Pad3 _; };
114  struct C8 : C2, virtual C4 { Pad4 _; };
115  struct C9 : C4, C8 { Pad5 _; };
116  
117  C9 c9;
118  C2 *c2 = &c9;
119  
120  void test()
121  {
122      assert(dynamic_cast<C2*>(c2) == static_cast<C2*>(&c9));
123      assert(dynamic_cast<C3*>(c2) == 0);
124      assert(dynamic_cast<C4*>(c2) == 0);
125      assert(dynamic_cast<C8*>(c2) == static_cast<C8*>(&c9));
126      assert(dynamic_cast<C9*>(c2) == static_cast<C9*>(&c9));
127  }
128  
129  }  // t4
130  
131  namespace t5
132  {
133  
134  // PR33439
135  struct Dummy { virtual ~Dummy() {} Pad1 _; };
136  struct Src { virtual ~Src() {} Pad2 _; };
137  struct Dest : Dummy { Pad3 _; };
138  struct A1 : Dest { Pad4 _; };
139  struct A2 : Dest { Pad5 _; };
140  struct Root : Src, A1, A2 { Pad6 _; };
141  
142  Root root;
143  Src *src = &root;
144  
145  void test()
146  {
147      assert(dynamic_cast<Dummy*>(src) == 0);
148      assert(dynamic_cast<Src*>(src) == static_cast<Src*>(&root));
149      assert(dynamic_cast<Dest*>(src) == 0);
150      assert(dynamic_cast<A1*>(src) == static_cast<A1*>(&root));
151      assert(dynamic_cast<A2*>(src) == static_cast<A2*>(&root));
152  }
153  
154  }  // t5
155  
156  int main(int, char**)
157  {
158      t1::test();
159      t2::test();
160      t3::test();
161      t4::test();
162      t5::test();
163  
164      return 0;
165  }