aboutsummaryrefslogtreecommitdiff
path: root/test/scudo/memalign.c
diff options
context:
space:
mode:
Diffstat (limited to 'test/scudo/memalign.c')
-rw-r--r--test/scudo/memalign.c81
1 files changed, 81 insertions, 0 deletions
diff --git a/test/scudo/memalign.c b/test/scudo/memalign.c
new file mode 100644
index 000000000000..1fe6e3ec7eed
--- /dev/null
+++ b/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;
+}