[scudo] Implement stricter separation of C vs C++

Summary:
Initially, Scudo had a monolithic design where both C and C++ functions were
living in the same library. This was not necessarily ideal, and with the work
on -fsanitize=scudo, it became more apparent that this needed to change.

We are splitting the new/delete interceptor in their own C++ library. This
allows more flexibility, notably with regard to std::bad_alloc when the work is
done. This also allows us to not link new & delete when using pure C.

Additionally, we add the UBSan runtimes with Scudo, in order to be able to have
a -fsanitize=scudo,undefined in Clang (see work in D39334).

The changes in this patch:
- split the cxx specific code in the scudo cmake file into a new library;
  (remove the spurious foreach loop, that was not necessary)
- add the UBSan runtimes (both C and C++);
- change the test cmake file to allow for specific C & C++ tests;
- make C tests pure C, rename their extension accordingly.

Reviewers: alekseyshl

Reviewed By: alekseyshl

Subscribers: srhines, mgorny, llvm-commits

Differential Revision: https://reviews.llvm.org/D39461

llvm-svn: 317097

1 files changed, 81 insertions, 0 deletions

diff --git a/compiler-rt/test/scudo/memalign.c b/compiler-rt/test/scudo/memalign.c
new file mode 100644
index 00000000000..1fe6e3ec7ee
--- /dev/null
+++ b/compiler-rt/test/scudo/memalign.c
@@ -0,0 +1,81 @@
+// RUN: %clang_scudo %s -o %t
+// RUN:                                                 %run %t valid   2>&1
+// RUN:                                             not %run %t invalid 2>&1
+// RUN: %env_scudo_opts=allocator_may_return_null=1     %run %t invalid 2>&1
+
+// Tests that the various aligned allocation functions work as intended. Also
+// tests for the condition where the alignment is not a power of 2.
+
+#include <assert.h>
+#include <errno.h>
+#include <malloc.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+// Sometimes the headers may not have this...
+void *aligned_alloc(size_t alignment, size_t size);
+
+int main(int argc, char **argv)
+{
+  void *p = NULL;
+  size_t alignment = 1U << 12;
+  size_t size = 1U << 12;
+  int err;
+
+  assert(argc == 2);
+
+  if (!strcmp(argv[1], "valid")) {
+    posix_memalign(&p, alignment, size);
+    assert(p);
+    assert(((uintptr_t)p & (alignment - 1)) == 0);
+    free(p);
+    p = aligned_alloc(alignment, size);
+    assert(p);
+    assert(((uintptr_t)p & (alignment - 1)) == 0);
+    free(p);
+    // Tests various combinations of alignment and sizes
+    for (int i = (sizeof(void *) == 4) ? 3 : 4; i < 19; i++) {
+      alignment = 1U << i;
+      for (int j = 1; j < 33; j++) {
+        size = 0x800 * j;
+        for (int k = 0; k < 3; k++) {
+          p = memalign(alignment, size - (2 * sizeof(void *) * k));
+          assert(p);
+          assert(((uintptr_t)p & (alignment - 1)) == 0);
+          free(p);
+        }
+      }
+    }
+    // For larger alignment, reduce the number of allocations to avoid running
+    // out of potential addresses (on 32-bit).
+    for (int i = 19; i <= 24; i++) {
+      for (int k = 0; k < 3; k++) {
+        p = memalign(alignment, 0x1000 - (2 * sizeof(void *) * k));
+        assert(p);
+        assert(((uintptr_t)p & (alignment - 1)) == 0);
+        free(p);
+      }
+    }
+  }
+  if (!strcmp(argv[1], "invalid")) {
+    // Alignment is not a power of 2.
+    p = memalign(alignment - 1, size);
+    assert(!p);
+    // Size is not a multiple of alignment.
+    p = aligned_alloc(alignment, size >> 1);
+    assert(!p);
+    void *p_unchanged = (void *)0x42UL;
+    p = p_unchanged;
+    // Alignment is not a power of 2.
+    err = posix_memalign(&p, 3, size);
+    assert(p == p_unchanged);
+    assert(err == EINVAL);
+    // Alignment is a power of 2, but not a multiple of size(void *).
+    err = posix_memalign(&p, 2, size);
+    assert(p == p_unchanged);
+    assert(err == EINVAL);
+  }
+  return 0;
+}