Add dynamic_cast regression tests from PR33425, PR33439, and PR33487

[rprichard]

See https://reviews.llvm.org/D36446 and https://reviews.llvm.org/D36447 for the fixes themselves.

[• Quuxplusone]

test/dynamic_cast.pass.cpp

24

I wonder whether these types could reasonably be char[11], char[23], char[35], char[47], char[59], char[71] etc., instead of being many tens of kilobytes. They don't *have* to be big in order for the unpatched library to fail the test, right? In fact the unpatched library ought to fail the test even when they're all char[1]?

[rprichard]

@Quuxplusone Yes, the tests fail regardless of whether the padding fields exist or how large they are. I copied them from the other libcxxabi dynamic_cast* tests. I'm not really sure what they do. Considering their sizes, I'm guessing the intent was something like, "ensure that every combination of padding fields (plus internal vptrs / alignment) yields a unique sum". Adding padding fields also seems to make pointers of different types have different values. (Maybe the "nearly empty class" stuff in the Itanium C++ ABI document is relevant.)

Maybe the padding could be smaller.

At one point, the large padding caused a stack overflow on embedded targets -- it was fixed here: https://github.com/llvm-mirror/libcxxabi/commit/eca353d4849b2b1f7bca76edb40b3534433a5a26.

[• Quuxplusone]

test/dynamic_cast.pass.cpp

24

@Quuxplusone Yes, the tests fail regardless of whether the padding fields exist or how large they are. I copied them from the other libcxxabi dynamic_cast* tests. I'm not really sure what they do. Considering their sizes, I'm guessing the intent was something like, "ensure that every combination of padding fields (plus internal vptrs / alignment) yields a unique sum". Adding padding fields also seems to make pointers of different types have different values.

Hm. Well, if it's just copied from elsewhere, then sure, whatever. :) I withdraw the comment.

[EricWF]

Can these tests be checked in with their respective fixes, so both the test and the fix can be committed atomically?

[rprichard]

The tests are now included with the two bugfix revisions.

test/dynamic_cast.pass.cpp

+//===------------------------- dynamic_cast.pass.cpp ----------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is dual licensed under the MIT and the University of Illinois Open
+// Source Licenses. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include <cassert>
+
+// This test explicitly tests dynamic cast with types that have inaccessible
+// bases.
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Winaccessible-base"
+#endif
+
+typedef char Pad1[43981];
+typedef char Pad2[34981];
+typedef char Pad3[93481];
+typedef char Pad4[13489];
+typedef char Pad5[81349];
+typedef char Pad6[34819];
+typedef char Pad7[3489];
+
+namespace t1
+{
+
+// PR33425
+struct C3 { virtual ~C3() {} Pad1 _; };
+struct C5 : protected virtual C3 { Pad2 _; };
+struct C6 : virtual C5 { Pad3 _; };
+struct C7 : virtual C3 { Pad4 _; };
+struct C9 : C6, C7 { Pad5 _; };
+
+C9 c9;
+C3 *c3 = &c9;
+
+void test()
+{
+    assert(dynamic_cast<C3*>(c3) == static_cast<C3*>(&c9));
+    assert(dynamic_cast<C5*>(c3) == static_cast<C5*>(&c9));
+    assert(dynamic_cast<C6*>(c3) == static_cast<C6*>(&c9));
+    assert(dynamic_cast<C7*>(c3) == static_cast<C7*>(&c9));
+    assert(dynamic_cast<C9*>(c3) == static_cast<C9*>(&c9));
+}
+
+}  // t1
+
+namespace t2
+{
+
+// PR33425
+struct Src { virtual ~Src() {} Pad1 _; };
+struct Mask : protected virtual Src { Pad2 _; };
+struct Dest : Mask { Pad3 _; };
+struct Root : Dest, virtual Src { Pad4 _; };
+
+Root root;
+Src *src = &root;
+
+void test()
+{
+    assert(dynamic_cast<Src*>(src) == static_cast<Src*>(&root));
+    assert(dynamic_cast<Mask*>(src) == static_cast<Mask*>(&root));
+    assert(dynamic_cast<Dest*>(src) == static_cast<Dest*>(&root));
+    assert(dynamic_cast<Root*>(src) == static_cast<Root*>(&root));
+}
+
+}  // t2
+
+namespace t3
+{
+
+// PR33439
+struct C2 { virtual ~C2() {} Pad1 _; };
+struct C3 { virtual ~C3() {} Pad2 _; };
+struct C4 : C3 { Pad3 _; };
+struct C8 : C2, virtual C4 { Pad4 _; };
+struct C9 : C4, C8 { Pad5 _; };
+
+C9 c9;
+C2 *c2 = &c9;
+
+void test()
+{
+    assert(dynamic_cast<C2*>(c2) == static_cast<C2*>(&c9));
+    assert(dynamic_cast<C3*>(c2) == 0);
+    assert(dynamic_cast<C4*>(c2) == 0);
+    assert(dynamic_cast<C8*>(c2) == static_cast<C8*>(&c9));
+    assert(dynamic_cast<C9*>(c2) == static_cast<C9*>(&c9));
+}
+
+}  // t3
+
+namespace t4
+{
+
+// PR33439
+struct Dummy { virtual ~Dummy() {} Pad1 _; };
+struct Src { virtual ~Src() {} Pad2 _; };
+struct Dest : Dummy { Pad3 _; };
+struct A1 : Dest { Pad4 _; };
+struct A2 : Dest { Pad5 _; };
+struct Root : Src, A1, A2 { Pad6 _; };
+
+Root root;
+Src *src = &root;
+
+void test()
+{
+    assert(dynamic_cast<Dummy*>(src) == 0);
+    assert(dynamic_cast<Src*>(src) == static_cast<Src*>(&root));
+    assert(dynamic_cast<Dest*>(src) == 0);
+    assert(dynamic_cast<A1*>(src) == static_cast<A1*>(&root));
+    assert(dynamic_cast<A2*>(src) == static_cast<A2*>(&root));
+}
+
+}  // t4
+
+namespace t5
+{
+
+// PR33487
+struct Class1 { virtual ~Class1() {} Pad1 _; };
+struct Shared : virtual Class1 { Pad2 _; };
+struct Class6 : virtual Shared { Pad3 _; };
+struct Left : Class6 { Pad4 _; };
+struct Right : Class6 { Pad5 _; };
+struct Main : Left, Right { Pad6 _; };
+
+Main m;
+Class1 *c1 = &m;
+
+void test()
+{
+    assert(dynamic_cast<Class1*>(c1) == static_cast<Class1*>(&m));
+    assert(dynamic_cast<Shared*>(c1) == static_cast<Shared*>(&m));
+    assert(dynamic_cast<Class6*>(c1) == 0);
+    assert(dynamic_cast<Left*>(c1) == static_cast<Left*>(&m));
+    assert(dynamic_cast<Right*>(c1) == static_cast<Right*>(&m));
+    assert(dynamic_cast<Main*>(c1) == static_cast<Main*>(&m));
+}
+
+}  // t5
+
+int main()
+{
+    t1::test();
+    t2::test();
+    t3::test();
+    t4::test();
+    t5::test();
+}