[compiler-rt] r233876 - Add tests for non-virtual call checking.

[Peter Collingbourne]

Author: pcc
Date: Wed Apr  1 19:33:36 2015
New Revision: 233876

URL: http://llvm.org/viewvc/llvm-project?rev=233876&view=rev
Log:
Add tests for non-virtual call checking.

Differential Revision: http://reviews.llvm.org/D8792

Added:
    compiler-rt/trunk/test/cfi/README.txt
    compiler-rt/trunk/test/cfi/nvcall.cpp
Modified:
    compiler-rt/trunk/test/cfi/simple-pass.cpp

Added: compiler-rt/trunk/test/cfi/README.txt
URL: http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/test/cfi/README.txt?rev=233876&view=auto
==============================================================================
--- compiler-rt/trunk/test/cfi/README.txt (added)
+++ compiler-rt/trunk/test/cfi/README.txt Wed Apr  1 19:33:36 2015
@@ -0,0 +1,8 @@
+The tests in this directory use a common convention for exercising the
+functionality associated with bit sets of different sizes. When certain
+macros are defined the tests instantiate classes that force the bit sets
+to be of certain sizes.
+
+- B32 forces 32-bit bit sets.
+- B64 forces 64-bit bit sets.
+- BM forces memory bit sets.

Added: compiler-rt/trunk/test/cfi/nvcall.cpp
URL: http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/test/cfi/nvcall.cpp?rev=233876&view=auto
==============================================================================
--- compiler-rt/trunk/test/cfi/nvcall.cpp (added)
+++ compiler-rt/trunk/test/cfi/nvcall.cpp Wed Apr  1 19:33:36 2015
@@ -0,0 +1,65 @@
+// RUN: %clangxx_cfi -o %t %s
+// RUN: not --crash %t 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -DB32 -o %t %s
+// RUN: not --crash %t 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -DB64 -o %t %s
+// RUN: not --crash %t 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx_cfi -DBM -o %t %s
+// RUN: not --crash %t 2>&1 | FileCheck --check-prefix=CFI %s
+
+// RUN: %clangxx -o %t %s
+// RUN: %t 2>&1 | FileCheck --check-prefix=NCFI %s
+
+// Tests that the CFI mechanism crashes the program when making a non-virtual
+// call to an object of the wrong class, by casting a pointer to such an object
+// and attempting to make a call through it.
+
+#include <stdio.h>
+#include "utils.h"
+
+struct A {
+  virtual void f();
+};
+
+void A::f() {}
+
+struct B {
+  void f();
+  virtual void g();
+};
+
+void B::f() {}
+void B::g() {}
+
+int main() {
+#ifdef B32
+  break_optimization(new Deriver<B, 0>);
+#endif
+
+#ifdef B64
+  break_optimization(new Deriver<B, 0>);
+  break_optimization(new Deriver<B, 1>);
+#endif
+
+#ifdef BM
+  break_optimization(new Deriver<B, 0>);
+  break_optimization(new Deriver<B, 1>);
+  break_optimization(new Deriver<B, 2>);
+#endif
+
+  A *a = new A;
+  break_optimization(a);
+
+  // CFI: 1
+  // NCFI: 1
+  fprintf(stderr, "1\n");
+
+  ((B *)a)->f(); // UB here
+
+  // CFI-NOT: 2
+  // NCFI: 2
+  fprintf(stderr, "2\n");
+}

Modified: compiler-rt/trunk/test/cfi/simple-pass.cpp
URL: http://llvm.org/viewvc/llvm-project/compiler-rt/trunk/test/cfi/simple-pass.cpp?rev=233876&r1=233875&r2=233876&view=diff
==============================================================================
--- compiler-rt/trunk/test/cfi/simple-pass.cpp (original)
+++ compiler-rt/trunk/test/cfi/simple-pass.cpp Wed Apr  1 19:33:36 2015
@@ -3,95 +3,119 @@
 
 // Tests that the CFI mechanism does not crash the program when making various
 // kinds of valid calls involving classes with various different linkages and
-// types of inheritance.
+// types of inheritance, and both virtual and non-virtual member functions.
 
 #include "utils.h"
 
 struct A {
   virtual void f();
+  void g();
 };
 
 void A::f() {}
+void A::g() {}
 
 struct A2 : A {
   virtual void f();
+  void g();
 };
 
 void A2::f() {}
+void A2::g() {}
 
 struct B {
   virtual void f() {}
+  void g() {}
 };
 
 struct B2 : B {
   virtual void f() {}
+  void g() {}
 };
 
 namespace {
 
 struct C {
   virtual void f();
+  void g();
 };
 
 void C::f() {}
+void C::g() {}
 
 struct C2 : C {
   virtual void f();
+  void g();
 };
 
 void C2::f() {}
+void C2::g() {}
 
 struct D {
   virtual void f() {}
+  void g() {}
 };
 
 struct D2 : D {
   virtual void f() {}
+  void g() {}
 };
 
 }
 
 struct E {
   virtual void f() {}
+  void g() {}
 };
 
 struct E2 : virtual E {
   virtual void f() {}
+  void g() {}
 };
 
 int main() {
   A *a = new A;
   break_optimization(a);
   a->f();
+  a->g();
   a = new A2;
   break_optimization(a);
   a->f();
+  a->g();
 
   B *b = new B;
   break_optimization(b);
   b->f();
+  b->g();
   b = new B2;
   break_optimization(b);
   b->f();
+  b->g();
 
   C *c = new C;
   break_optimization(c);
   c->f();
+  c->g();
   c = new C2;
   break_optimization(c);
   c->f();
+  c->g();
 
   D *d = new D;
   break_optimization(d);
   d->f();
+  d->g();
   d = new D2;
   break_optimization(d);
   d->f();
+  d->g();
 
   E *e = new E;
   break_optimization(e);
   e->f();
+  e->g();
   e = new E2;
   break_optimization(e);
   e->f();
+  e->g();
 }