aboutsummaryrefslogtreecommitdiff
path: root/test/dfsan
diff options
context:
space:
mode:
authorDimitry Andric <dim@FreeBSD.org>2015-01-07 19:55:37 +0000
committerDimitry Andric <dim@FreeBSD.org>2015-01-07 19:55:37 +0000
commitca9211ecdede9bdedb812b2243a4abdb8dacd1b9 (patch)
tree9b19e801150082c33e9152275829a6ce90614b55 /test/dfsan
parent8ef50bf3d1c287b5013c3168de77a462dfce3495 (diff)
downloadsrc-ca9211ecdede9bdedb812b2243a4abdb8dacd1b9.tar.gz
src-ca9211ecdede9bdedb812b2243a4abdb8dacd1b9.zip
Import compiler-rt trunk r224034.vendor/compiler-rt/compiler-rt-r224034
Notes
Notes: svn path=/vendor/compiler-rt/dist/; revision=276789 svn path=/vendor/compiler-rt/compiler-rt-r224034/; revision=276790; tag=vendor/compiler-rt/compiler-rt-r224034
Diffstat (limited to 'test/dfsan')
-rw-r--r--test/dfsan/CMakeLists.txt15
-rw-r--r--test/dfsan/Inputs/flags_abilist.txt10
-rw-r--r--test/dfsan/basic.c28
-rw-r--r--test/dfsan/custom.cc958
-rw-r--r--test/dfsan/dump_labels.c69
-rw-r--r--test/dfsan/flags.c24
-rw-r--r--test/dfsan/fncall.c26
-rw-r--r--test/dfsan/label_count.c75
-rw-r--r--test/dfsan/lit.cfg26
-rw-r--r--test/dfsan/lit.site.cfg.in5
-rw-r--r--test/dfsan/propagate.c47
-rw-r--r--test/dfsan/vararg.c24
-rw-r--r--test/dfsan/write_callback.c110
13 files changed, 1417 insertions, 0 deletions
diff --git a/test/dfsan/CMakeLists.txt b/test/dfsan/CMakeLists.txt
new file mode 100644
index 000000000000..3fa1af24be51
--- /dev/null
+++ b/test/dfsan/CMakeLists.txt
@@ -0,0 +1,15 @@
+set(DFSAN_LIT_TESTS_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+
+configure_lit_site_cfg(
+ ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.in
+ ${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg)
+
+set(DFSAN_TEST_DEPS ${SANITIZER_COMMON_LIT_TEST_DEPS})
+if(NOT COMPILER_RT_STANDALONE_BUILD)
+ list(APPEND DFSAN_TEST_DEPS dfsan)
+endif()
+
+add_lit_testsuite(check-dfsan "Running the DataFlowSanitizer tests"
+ ${CMAKE_CURRENT_BINARY_DIR}
+ DEPENDS ${DFSAN_TEST_DEPS})
+set_target_properties(check-dfsan PROPERTIES FOLDER "DFSan tests")
diff --git a/test/dfsan/Inputs/flags_abilist.txt b/test/dfsan/Inputs/flags_abilist.txt
new file mode 100644
index 000000000000..94b1fa298259
--- /dev/null
+++ b/test/dfsan/Inputs/flags_abilist.txt
@@ -0,0 +1,10 @@
+fun:f=uninstrumented
+
+fun:main=uninstrumented
+fun:main=discard
+
+fun:dfsan_create_label=uninstrumented
+fun:dfsan_create_label=discard
+
+fun:dfsan_set_label=uninstrumented
+fun:dfsan_set_label=discard
diff --git a/test/dfsan/basic.c b/test/dfsan/basic.c
new file mode 100644
index 000000000000..6582727e5e61
--- /dev/null
+++ b/test/dfsan/basic.c
@@ -0,0 +1,28 @@
+// RUN: %clang_dfsan -m64 %s -o %t && %run %t
+// RUN: %clang_dfsan -mllvm -dfsan-args-abi -m64 %s -o %t && %run %t
+
+// Tests that labels are propagated through loads and stores.
+
+#include <sanitizer/dfsan_interface.h>
+#include <assert.h>
+
+int main(void) {
+ int i = 1;
+ dfsan_label i_label = dfsan_create_label("i", 0);
+ dfsan_set_label(i_label, &i, sizeof(i));
+
+ dfsan_label new_label = dfsan_get_label(i);
+ assert(i_label == new_label);
+
+ dfsan_label read_label = dfsan_read_label(&i, sizeof(i));
+ assert(i_label == read_label);
+
+ dfsan_label j_label = dfsan_create_label("j", 0);
+ dfsan_add_label(j_label, &i, sizeof(i));
+
+ read_label = dfsan_read_label(&i, sizeof(i));
+ assert(dfsan_has_label(read_label, i_label));
+ assert(dfsan_has_label(read_label, j_label));
+
+ return 0;
+}
diff --git a/test/dfsan/custom.cc b/test/dfsan/custom.cc
new file mode 100644
index 000000000000..d7bb3e3073fb
--- /dev/null
+++ b/test/dfsan/custom.cc
@@ -0,0 +1,958 @@
+// RUN: %clang_dfsan -m64 %s -o %t && DFSAN_OPTIONS="strict_data_dependencies=0" %run %t
+// RUN: %clang_dfsan -mllvm -dfsan-args-abi -m64 %s -o %t && DFSAN_OPTIONS="strict_data_dependencies=0" %run %t
+// RUN: %clang_dfsan -DSTRICT_DATA_DEPENDENCIES -m64 %s -o %t && %run %t
+// RUN: %clang_dfsan -DSTRICT_DATA_DEPENDENCIES -mllvm -dfsan-args-abi -m64 %s -o %t && %run %t
+
+// Tests custom implementations of various glibc functions.
+
+#include <sanitizer/dfsan_interface.h>
+
+#include <arpa/inet.h>
+#include <assert.h>
+#include <fcntl.h>
+#include <link.h>
+#include <poll.h>
+#include <pthread.h>
+#include <pwd.h>
+#include <sched.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/select.h>
+#include <sys/resource.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <time.h>
+#include <unistd.h>
+
+dfsan_label i_label = 0;
+dfsan_label j_label = 0;
+dfsan_label k_label = 0;
+dfsan_label i_j_label = 0;
+
+#define ASSERT_ZERO_LABEL(data) \
+ assert(0 == dfsan_get_label((long) (data)))
+
+#define ASSERT_READ_ZERO_LABEL(ptr, size) \
+ assert(0 == dfsan_read_label(ptr, size))
+
+#define ASSERT_LABEL(data, label) \
+ assert(label == dfsan_get_label((long) (data)))
+
+#define ASSERT_READ_LABEL(ptr, size, label) \
+ assert(label == dfsan_read_label(ptr, size))
+
+void test_stat() {
+ int i = 1;
+ dfsan_set_label(i_label, &i, sizeof(i));
+
+ struct stat s;
+ s.st_dev = i;
+ assert(0 == stat("/", &s));
+ ASSERT_ZERO_LABEL(s.st_dev);
+
+ s.st_dev = i;
+ assert(-1 == stat("/nonexistent", &s));
+ ASSERT_LABEL(s.st_dev, i_label);
+}
+
+void test_fstat() {
+ int i = 1;
+ dfsan_set_label(i_label, &i, sizeof(i));
+
+ struct stat s;
+ int fd = open("/dev/zero", O_RDONLY);
+ s.st_dev = i;
+ int rv = fstat(fd, &s);
+ assert(0 == rv);
+ ASSERT_ZERO_LABEL(s.st_dev);
+}
+
+void test_memcmp() {
+ char str1[] = "str1", str2[] = "str2";
+ dfsan_set_label(i_label, &str1[3], 1);
+ dfsan_set_label(j_label, &str2[3], 1);
+
+ int rv = memcmp(str1, str2, sizeof(str1));
+ assert(rv < 0);
+#ifdef STRICT_DATA_DEPENDENCIES
+ ASSERT_ZERO_LABEL(rv);
+#else
+ ASSERT_LABEL(rv, i_j_label);
+#endif
+}
+
+void test_memcpy() {
+ char str1[] = "str1";
+ char str2[sizeof(str1)];
+ dfsan_set_label(i_label, &str1[3], 1);
+
+ ASSERT_ZERO_LABEL(memcpy(str2, str1, sizeof(str1)));
+ assert(0 == memcmp(str2, str1, sizeof(str1)));
+ ASSERT_ZERO_LABEL(str2[0]);
+ ASSERT_LABEL(str2[3], i_label);
+}
+
+void test_memset() {
+ char buf[8];
+ int j = 'a';
+ dfsan_set_label(j_label, &j, sizeof(j));
+
+ ASSERT_ZERO_LABEL(memset(&buf, j, sizeof(buf)));
+ for (int i = 0; i < 8; ++i) {
+ ASSERT_LABEL(buf[i], j_label);
+ assert(buf[i] == 'a');
+ }
+}
+
+void test_strcmp() {
+ char str1[] = "str1", str2[] = "str2";
+ dfsan_set_label(i_label, &str1[3], 1);
+ dfsan_set_label(j_label, &str2[3], 1);
+
+ int rv = strcmp(str1, str2);
+ assert(rv < 0);
+#ifdef STRICT_DATA_DEPENDENCIES
+ ASSERT_ZERO_LABEL(rv);
+#else
+ ASSERT_LABEL(rv, i_j_label);
+#endif
+}
+
+void test_strlen() {
+ char str1[] = "str1";
+ dfsan_set_label(i_label, &str1[3], 1);
+
+ int rv = strlen(str1);
+ assert(rv == 4);
+#ifdef STRICT_DATA_DEPENDENCIES
+ ASSERT_ZERO_LABEL(rv);
+#else
+ ASSERT_LABEL(rv, i_label);
+#endif
+}
+
+void test_strdup() {
+ char str1[] = "str1";
+ dfsan_set_label(i_label, &str1[3], 1);
+
+ char *strd = strdup(str1);
+ ASSERT_ZERO_LABEL(strd[0]);
+ ASSERT_LABEL(strd[3], i_label);
+ free(strd);
+}
+
+void test_strncpy() {
+ char str1[] = "str1";
+ char str2[sizeof(str1)];
+ dfsan_set_label(i_label, &str1[3], 1);
+
+ char *strd = strncpy(str2, str1, 5);
+ assert(strd == str2);
+ assert(strcmp(str1, str2) == 0);
+ ASSERT_ZERO_LABEL(strd);
+ ASSERT_ZERO_LABEL(strd[0]);
+ ASSERT_ZERO_LABEL(strd[1]);
+ ASSERT_ZERO_LABEL(strd[2]);
+ ASSERT_LABEL(strd[3], i_label);
+
+ strd = strncpy(str2, str1, 3);
+ assert(strd == str2);
+ assert(strncmp(str1, str2, 3) == 0);
+ ASSERT_ZERO_LABEL(strd);
+ ASSERT_ZERO_LABEL(strd[0]);
+ ASSERT_ZERO_LABEL(strd[1]);
+ ASSERT_ZERO_LABEL(strd[2]);
+}
+
+void test_strncmp() {
+ char str1[] = "str1", str2[] = "str2";
+ dfsan_set_label(i_label, &str1[3], 1);
+ dfsan_set_label(j_label, &str2[3], 1);
+
+ int rv = strncmp(str1, str2, sizeof(str1));
+ assert(rv < 0);
+#ifdef STRICT_DATA_DEPENDENCIES
+ ASSERT_ZERO_LABEL(rv);
+#else
+ ASSERT_LABEL(rv, dfsan_union(i_label, j_label));
+#endif
+
+ rv = strncmp(str1, str2, 3);
+ assert(rv == 0);
+ ASSERT_ZERO_LABEL(rv);
+}
+
+void test_strcasecmp() {
+ char str1[] = "str1", str2[] = "str2", str3[] = "Str1";
+ dfsan_set_label(i_label, &str1[3], 1);
+ dfsan_set_label(j_label, &str2[3], 1);
+ dfsan_set_label(j_label, &str3[2], 1);
+
+ int rv = strcasecmp(str1, str2);
+ assert(rv < 0);
+#ifdef STRICT_DATA_DEPENDENCIES
+ ASSERT_ZERO_LABEL(rv);
+#else
+ ASSERT_LABEL(rv, dfsan_union(i_label, j_label));
+#endif
+
+ rv = strcasecmp(str1, str3);
+ assert(rv == 0);
+#ifdef STRICT_DATA_DEPENDENCIES
+ ASSERT_ZERO_LABEL(rv);
+#else
+ ASSERT_LABEL(rv, dfsan_union(i_label, j_label));
+#endif
+}
+
+void test_strncasecmp() {
+ char str1[] = "Str1", str2[] = "str2";
+ dfsan_set_label(i_label, &str1[3], 1);
+ dfsan_set_label(j_label, &str2[3], 1);
+
+ int rv = strncasecmp(str1, str2, sizeof(str1));
+ assert(rv < 0);
+#ifdef STRICT_DATA_DEPENDENCIES
+ ASSERT_ZERO_LABEL(rv);
+#else
+ ASSERT_LABEL(rv, dfsan_union(i_label, j_label));
+#endif
+
+ rv = strncasecmp(str1, str2, 3);
+ assert(rv == 0);
+ ASSERT_ZERO_LABEL(rv);
+}
+
+void test_strchr() {
+ char str1[] = "str1";
+ dfsan_set_label(i_label, &str1[3], 1);
+
+ char *crv = strchr(str1, 'r');
+ assert(crv == &str1[2]);
+ ASSERT_ZERO_LABEL(crv);
+
+ crv = strchr(str1, '1');
+ assert(crv == &str1[3]);
+#ifdef STRICT_DATA_DEPENDENCIES
+ ASSERT_ZERO_LABEL(crv);
+#else
+ ASSERT_LABEL(crv, i_label);
+#endif
+
+ crv = strchr(str1, 'x');
+ assert(!crv);
+#ifdef STRICT_DATA_DEPENDENCIES
+ ASSERT_ZERO_LABEL(crv);
+#else
+ ASSERT_LABEL(crv, i_label);
+#endif
+}
+
+void test_calloc() {
+ // With any luck this sequence of calls will cause calloc to return the same
+ // pointer both times. This is probably the best we can do to test this
+ // function.
+ char *crv = (char *) calloc(4096, 1);
+ ASSERT_ZERO_LABEL(crv[0]);
+ dfsan_set_label(i_label, crv, 100);
+ free(crv);
+
+ crv = (char *) calloc(4096, 1);
+ ASSERT_ZERO_LABEL(crv[0]);
+ free(crv);
+}
+
+void test_read() {
+ char buf[16];
+ dfsan_set_label(i_label, buf, 1);
+ dfsan_set_label(j_label, buf + 15, 1);
+
+ ASSERT_LABEL(buf[0], i_label);
+ ASSERT_LABEL(buf[15], j_label);
+
+ int fd = open("/dev/zero", O_RDONLY);
+ int rv = read(fd, buf, sizeof(buf));
+ assert(rv == sizeof(buf));
+ ASSERT_ZERO_LABEL(rv);
+ ASSERT_ZERO_LABEL(buf[0]);
+ ASSERT_ZERO_LABEL(buf[15]);
+ close(fd);
+}
+
+void test_pread() {
+ char buf[16];
+ dfsan_set_label(i_label, buf, 1);
+ dfsan_set_label(j_label, buf + 15, 1);
+
+ ASSERT_LABEL(buf[0], i_label);
+ ASSERT_LABEL(buf[15], j_label);
+
+ int fd = open("/bin/sh", O_RDONLY);
+ int rv = pread(fd, buf, sizeof(buf), 0);
+ assert(rv == sizeof(buf));
+ ASSERT_ZERO_LABEL(rv);
+ ASSERT_ZERO_LABEL(buf[0]);
+ ASSERT_ZERO_LABEL(buf[15]);
+ close(fd);
+}
+
+void test_dlopen() {
+ void *map = dlopen(NULL, RTLD_NOW);
+ assert(map);
+ ASSERT_ZERO_LABEL(map);
+ dlclose(map);
+ map = dlopen("/nonexistent", RTLD_NOW);
+ assert(!map);
+ ASSERT_ZERO_LABEL(map);
+}
+
+void test_clock_gettime() {
+ struct timespec tp;
+ dfsan_set_label(j_label, ((char *)&tp) + 3, 1);
+ int t = clock_gettime(CLOCK_REALTIME, &tp);
+ assert(t == 0);
+ ASSERT_ZERO_LABEL(t);
+ ASSERT_ZERO_LABEL(((char *)&tp)[3]);
+}
+
+void test_ctime_r() {
+ char *buf = (char*) malloc(64);
+ time_t t = 0;
+
+ char *ret = ctime_r(&t, buf);
+ ASSERT_ZERO_LABEL(ret);
+ assert(buf == ret);
+ ASSERT_READ_ZERO_LABEL(buf, strlen(buf) + 1);
+
+ dfsan_set_label(i_label, &t, sizeof(t));
+ ret = ctime_r(&t, buf);
+ ASSERT_ZERO_LABEL(ret);
+ ASSERT_READ_LABEL(buf, strlen(buf) + 1, i_label);
+
+ t = 0;
+ dfsan_set_label(j_label, &buf, sizeof(&buf));
+ ret = ctime_r(&t, buf);
+ ASSERT_LABEL(ret, j_label);
+ ASSERT_READ_ZERO_LABEL(buf, strlen(buf) + 1);
+}
+
+static int write_callback_count = 0;
+static int last_fd;
+static const unsigned char *last_buf;
+static size_t last_count;
+
+void write_callback(int fd, const void *buf, size_t count) {
+ write_callback_count++;
+
+ last_fd = fd;
+ last_buf = (const unsigned char*) buf;
+ last_count = count;
+}
+
+void test_dfsan_set_write_callback() {
+ char buf[] = "Sample chars";
+ int buf_len = strlen(buf);
+
+ int fd = open("/dev/null", O_WRONLY);
+
+ dfsan_set_write_callback(write_callback);
+
+ write_callback_count = 0;
+
+ // Callback should be invoked on every call to write().
+ int res = write(fd, buf, buf_len);
+ assert(write_callback_count == 1);
+ ASSERT_READ_ZERO_LABEL(&res, sizeof(res));
+ ASSERT_READ_ZERO_LABEL(&last_fd, sizeof(last_fd));
+ ASSERT_READ_ZERO_LABEL(last_buf, sizeof(last_buf));
+ ASSERT_READ_ZERO_LABEL(&last_count, sizeof(last_count));
+
+ // Add a label to write() arguments. Check that the labels are readable from
+ // the values passed to the callback.
+ dfsan_set_label(i_label, &fd, sizeof(fd));
+ dfsan_set_label(j_label, &(buf[3]), 1);
+ dfsan_set_label(k_label, &buf_len, sizeof(buf_len));
+
+ res = write(fd, buf, buf_len);
+ assert(write_callback_count == 2);
+ ASSERT_READ_ZERO_LABEL(&res, sizeof(res));
+ ASSERT_READ_LABEL(&last_fd, sizeof(last_fd), i_label);
+ ASSERT_READ_LABEL(&last_buf[3], sizeof(last_buf[3]), j_label);
+ ASSERT_READ_LABEL(last_buf, sizeof(last_buf), j_label);
+ ASSERT_READ_LABEL(&last_count, sizeof(last_count), k_label);
+
+ dfsan_set_write_callback(NULL);
+}
+
+void test_fgets() {
+ char *buf = (char*) malloc(128);
+ FILE *f = fopen("/etc/passwd", "r");
+ dfsan_set_label(j_label, buf, 1);
+ char *ret = fgets(buf, sizeof(buf), f);
+ assert(ret == buf);
+ ASSERT_ZERO_LABEL(ret);
+ ASSERT_READ_ZERO_LABEL(buf, 128);
+ dfsan_set_label(j_label, &buf, sizeof(&buf));
+ ret = fgets(buf, sizeof(buf), f);
+ ASSERT_LABEL(ret, j_label);
+ fclose(f);
+}
+
+void test_getcwd() {
+ char buf[1024];
+ char *ptr = buf;
+ dfsan_set_label(i_label, buf + 2, 2);
+ char* ret = getcwd(buf, sizeof(buf));
+ assert(ret == buf);
+ assert(ret[0] == '/');
+ ASSERT_READ_ZERO_LABEL(buf + 2, 2);
+ dfsan_set_label(i_label, &ptr, sizeof(ptr));
+ ret = getcwd(ptr, sizeof(buf));
+ ASSERT_LABEL(ret, i_label);
+}
+
+void test_get_current_dir_name() {
+ char* ret = get_current_dir_name();
+ assert(ret);
+ assert(ret[0] == '/');
+ ASSERT_READ_ZERO_LABEL(ret, strlen(ret) + 1);
+}
+
+void test_gethostname() {
+ char buf[1024];
+ dfsan_set_label(i_label, buf + 2, 2);
+ assert(gethostname(buf, sizeof(buf)) == 0);
+ ASSERT_READ_ZERO_LABEL(buf + 2, 2);
+}
+
+void test_getrlimit() {
+ struct rlimit rlim;
+ dfsan_set_label(i_label, &rlim, sizeof(rlim));
+ assert(getrlimit(RLIMIT_CPU, &rlim) == 0);
+ ASSERT_READ_ZERO_LABEL(&rlim, sizeof(rlim));
+}
+
+void test_getrusage() {
+ struct rusage usage;
+ dfsan_set_label(i_label, &usage, sizeof(usage));
+ assert(getrusage(RUSAGE_SELF, &usage) == 0);
+ ASSERT_READ_ZERO_LABEL(&usage, sizeof(usage));
+}
+
+void test_strcpy() {
+ char src[] = "hello world";
+ char dst[sizeof(src) + 2];
+ dfsan_set_label(0, src, sizeof(src));
+ dfsan_set_label(0, dst, sizeof(dst));
+ dfsan_set_label(i_label, src + 2, 1);
+ dfsan_set_label(j_label, src + 3, 1);
+ dfsan_set_label(j_label, dst + 4, 1);
+ dfsan_set_label(i_label, dst + 12, 1);
+ char *ret = strcpy(dst, src);
+ assert(ret == dst);
+ assert(strcmp(src, dst) == 0);
+ for (int i = 0; i < strlen(src) + 1; ++i) {
+ assert(dfsan_get_label(dst[i]) == dfsan_get_label(src[i]));
+ }
+ // Note: if strlen(src) + 1 were used instead to compute the first untouched
+ // byte of dest, the label would be I|J. This is because strlen() might
+ // return a non-zero label, and because by default pointer labels are not
+ // ignored on loads.
+ ASSERT_LABEL(dst[12], i_label);
+}
+
+void test_strtol() {
+ char buf[] = "1234578910";
+ char *endptr = NULL;
+ dfsan_set_label(i_label, buf + 1, 1);
+ dfsan_set_label(j_label, buf + 10, 1);
+ long int ret = strtol(buf, &endptr, 10);
+ assert(ret == 1234578910);
+ assert(endptr == buf + 10);
+ ASSERT_LABEL(ret, i_j_label);
+}
+
+void test_strtoll() {
+ char buf[] = "1234578910 ";
+ char *endptr = NULL;
+ dfsan_set_label(i_label, buf + 1, 1);
+ dfsan_set_label(j_label, buf + 2, 1);
+ long long int ret = strtoll(buf, &endptr, 10);
+ assert(ret == 1234578910);
+ assert(endptr == buf + 10);
+ ASSERT_LABEL(ret, i_j_label);
+}
+
+void test_strtoul() {
+ char buf[] = "0xffffffffffffaa";
+ char *endptr = NULL;
+ dfsan_set_label(i_label, buf + 1, 1);
+ dfsan_set_label(j_label, buf + 2, 1);
+ long unsigned int ret = strtol(buf, &endptr, 16);
+ assert(ret == 72057594037927850);
+ assert(endptr == buf + 16);
+ ASSERT_LABEL(ret, i_j_label);
+}
+
+void test_strtoull() {
+ char buf[] = "0xffffffffffffffaa";
+ char *endptr = NULL;
+ dfsan_set_label(i_label, buf + 1, 1);
+ dfsan_set_label(j_label, buf + 2, 1);
+ long long unsigned int ret = strtoull(buf, &endptr, 16);
+ assert(ret == 0xffffffffffffffaa);
+ assert(endptr == buf + 18);
+ ASSERT_LABEL(ret, i_j_label);
+}
+
+void test_strtod() {
+ char buf[] = "12345.76 foo";
+ char *endptr = NULL;
+ dfsan_set_label(i_label, buf + 1, 1);
+ dfsan_set_label(j_label, buf + 6, 1);
+ double ret = strtod(buf, &endptr);
+ assert(ret == 12345.76);
+ assert(endptr == buf + 8);
+ ASSERT_LABEL(ret, i_j_label);
+}
+
+void test_time() {
+ time_t t = 0;
+ dfsan_set_label(i_label, &t, 1);
+ time_t ret = time(&t);
+ assert(ret == t);
+ assert(ret > 0);
+ ASSERT_ZERO_LABEL(t);
+}
+
+void test_inet_pton() {
+ char addr4[] = "127.0.0.1";
+ dfsan_set_label(i_label, addr4 + 3, 1);
+ struct in_addr in4;
+ int ret4 = inet_pton(AF_INET, addr4, &in4);
+ assert(ret4 == 1);
+ ASSERT_READ_LABEL(&in4, sizeof(in4), i_label);
+ assert(in4.s_addr == 0x0100007f);
+
+ char addr6[] = "::1";
+ dfsan_set_label(j_label, addr6 + 3, 1);
+ struct in6_addr in6;
+ int ret6 = inet_pton(AF_INET6, addr6, &in6);
+ assert(ret6 == 1);
+ ASSERT_READ_LABEL(((char *) &in6) + sizeof(in6) - 1, 1, j_label);
+}
+
+void test_localtime_r() {
+ time_t t0 = 1384800998;
+ struct tm t1;
+ dfsan_set_label(i_label, &t0, sizeof(t0));
+ struct tm* ret = localtime_r(&t0, &t1);
+ assert(ret == &t1);
+ assert(t1.tm_min == 56);
+ ASSERT_LABEL(t1.tm_mon, i_label);
+}
+
+void test_getpwuid_r() {
+ struct passwd pwd;
+ char buf[1024];
+ struct passwd *result;
+
+ dfsan_set_label(i_label, &pwd, 4);
+ int ret = getpwuid_r(0, &pwd, buf, sizeof(buf), &result);
+ assert(ret == 0);
+ assert(strcmp(pwd.pw_name, "root") == 0);
+ assert(result == &pwd);
+ ASSERT_READ_ZERO_LABEL(&pwd, 4);
+}
+
+void test_poll() {
+ struct pollfd fd;
+ fd.fd = 0;
+ fd.events = POLLIN;
+ dfsan_set_label(i_label, &fd.revents, sizeof(fd.revents));
+ int ret = poll(&fd, 1, 1);
+ ASSERT_ZERO_LABEL(fd.revents);
+ assert(ret >= 0);
+}
+
+void test_select() {
+ struct timeval t;
+ fd_set fds;
+ t.tv_sec = 2;
+ FD_SET(0, &fds);
+ dfsan_set_label(i_label, &fds, sizeof(fds));
+ dfsan_set_label(j_label, &t, sizeof(t));
+ int ret = select(1, &fds, NULL, NULL, &t);
+ assert(ret >= 0);
+ ASSERT_ZERO_LABEL(t.tv_sec);
+ ASSERT_READ_ZERO_LABEL(&fds, sizeof(fds));
+}
+
+void test_sched_getaffinity() {
+ cpu_set_t mask;
+ dfsan_set_label(j_label, &mask, 1);
+ int ret = sched_getaffinity(0, sizeof(mask), &mask);
+ assert(ret == 0);
+ ASSERT_READ_ZERO_LABEL(&mask, sizeof(mask));
+}
+
+void test_sigemptyset() {
+ sigset_t set;
+ dfsan_set_label(j_label, &set, 1);
+ int ret = sigemptyset(&set);
+ assert(ret == 0);
+ ASSERT_READ_ZERO_LABEL(&set, sizeof(set));
+}
+
+void test_sigaction() {
+ struct sigaction oldact;
+ dfsan_set_label(j_label, &oldact, 1);
+ int ret = sigaction(SIGUSR1, NULL, &oldact);
+ assert(ret == 0);
+ ASSERT_READ_ZERO_LABEL(&oldact, sizeof(oldact));
+}
+
+void test_gettimeofday() {
+ struct timeval tv;
+ struct timezone tz;
+ dfsan_set_label(i_label, &tv, sizeof(tv));
+ dfsan_set_label(j_label, &tz, sizeof(tz));
+ int ret = gettimeofday(&tv, &tz);
+ assert(ret == 0);
+ ASSERT_READ_ZERO_LABEL(&tv, sizeof(tv));
+ ASSERT_READ_ZERO_LABEL(&tz, sizeof(tz));
+}
+
+void *pthread_create_test_cb(void *p) {
+ assert(p == (void *)1);
+ ASSERT_ZERO_LABEL(p);
+ return (void *)2;
+}
+
+void test_pthread_create() {
+ pthread_t pt;
+ pthread_create(&pt, 0, pthread_create_test_cb, (void *)1);
+ void *cbrv;
+ pthread_join(pt, &cbrv);
+ assert(cbrv == (void *)2);
+}
+
+int dl_iterate_phdr_test_cb(struct dl_phdr_info *info, size_t size,
+ void *data) {
+ assert(data == (void *)3);
+ ASSERT_ZERO_LABEL(info);
+ ASSERT_ZERO_LABEL(size);
+ ASSERT_ZERO_LABEL(data);
+ return 0;
+}
+
+void test_dl_iterate_phdr() {
+ dl_iterate_phdr(dl_iterate_phdr_test_cb, (void *)3);
+}
+
+void test_strrchr() {
+ char str1[] = "str1str1";
+ dfsan_set_label(i_label, &str1[7], 1);
+
+ char *rv = strrchr(str1, 'r');
+ assert(rv == &str1[6]);
+#ifdef STRICT_DATA_DEPENDENCIES
+ ASSERT_ZERO_LABEL(rv);
+#else
+ ASSERT_LABEL(rv, i_label);
+#endif
+}
+
+void test_strstr() {
+ char str1[] = "str1str1";
+ dfsan_set_label(i_label, &str1[3], 1);
+ dfsan_set_label(j_label, &str1[5], 1);
+
+ char *rv = strstr(str1, "1s");
+ assert(rv == &str1[3]);
+#ifdef STRICT_DATA_DEPENDENCIES
+ ASSERT_ZERO_LABEL(rv);
+#else
+ ASSERT_LABEL(rv, i_label);
+#endif
+
+ rv = strstr(str1, "2s");
+ assert(rv == NULL);
+#ifdef STRICT_DATA_DEPENDENCIES
+ ASSERT_ZERO_LABEL(rv);
+#else
+ ASSERT_LABEL(rv, i_j_label);
+#endif
+}
+
+void test_memchr() {
+ char str1[] = "str1";
+ dfsan_set_label(i_label, &str1[3], 1);
+ dfsan_set_label(j_label, &str1[4], 1);
+
+ char *crv = (char *) memchr(str1, 'r', sizeof(str1));
+ assert(crv == &str1[2]);
+ ASSERT_ZERO_LABEL(crv);
+
+ crv = (char *) memchr(str1, '1', sizeof(str1));
+ assert(crv == &str1[3]);
+#ifdef STRICT_DATA_DEPENDENCIES
+ ASSERT_ZERO_LABEL(crv);
+#else
+ ASSERT_LABEL(crv, i_label);
+#endif
+
+ crv = (char *) memchr(str1, 'x', sizeof(str1));
+ assert(!crv);
+#ifdef STRICT_DATA_DEPENDENCIES
+ ASSERT_ZERO_LABEL(crv);
+#else
+ ASSERT_LABEL(crv, i_j_label);
+#endif
+}
+
+void alarm_handler(int unused) {
+ ;
+}
+
+void test_nanosleep() {
+ struct timespec req, rem;
+ req.tv_sec = 1;
+ req.tv_nsec = 0;
+ dfsan_set_label(i_label, &rem, sizeof(rem));
+
+ // non interrupted
+ int rv = nanosleep(&req, &rem);
+ assert(rv == 0);
+ ASSERT_ZERO_LABEL(rv);
+ ASSERT_READ_LABEL(&rem, 1, i_label);
+
+ // interrupted by an alarm
+ signal(SIGALRM, alarm_handler);
+ req.tv_sec = 3;
+ alarm(1);
+ rv = nanosleep(&req, &rem);
+ assert(rv == -1);
+ ASSERT_ZERO_LABEL(rv);
+ ASSERT_READ_ZERO_LABEL(&rem, sizeof(rem));
+}
+
+void test_socketpair() {
+ int fd[2];
+
+ dfsan_set_label(i_label, fd, sizeof(fd));
+ int rv = socketpair(PF_LOCAL, SOCK_STREAM, 0, fd);
+ assert(rv == 0);
+ ASSERT_ZERO_LABEL(rv);
+ ASSERT_READ_ZERO_LABEL(fd, sizeof(fd));
+}
+
+void test_write() {
+ int fd = open("/dev/null", O_WRONLY);
+
+ char buf[] = "a string";
+ int len = strlen(buf);
+
+ // The result of a write always unlabeled.
+ int res = write(fd, buf, len);
+ assert(res > 0);
+ ASSERT_ZERO_LABEL(res);
+
+ // Label all arguments to write().
+ dfsan_set_label(i_label, &(buf[3]), 1);
+ dfsan_set_label(j_label, &fd, sizeof(fd));
+ dfsan_set_label(i_label, &len, sizeof(len));
+
+ // The value returned by write() should have no label.
+ res = write(fd, buf, len);
+ ASSERT_ZERO_LABEL(res);
+
+ close(fd);
+}
+
+template <class T>
+void test_sprintf_chunk(const char* expected, const char* format, T arg) {
+ char buf[512];
+ memset(buf, 'a', sizeof(buf));
+
+ char padded_expected[512];
+ strcpy(padded_expected, "foo ");
+ strcat(padded_expected, expected);
+ strcat(padded_expected, " bar");
+
+ char padded_format[512];
+ strcpy(padded_format, "foo ");
+ strcat(padded_format, format);
+ strcat(padded_format, " bar");
+
+ // Non labelled arg.
+ assert(sprintf(buf, padded_format, arg) == strlen(padded_expected));
+ assert(strcmp(buf, padded_expected) == 0);
+ ASSERT_READ_LABEL(buf, strlen(padded_expected), 0);
+ memset(buf, 'a', sizeof(buf));
+
+ // Labelled arg.
+ dfsan_set_label(i_label, &arg, sizeof(arg));
+ assert(sprintf(buf, padded_format, arg) == strlen(padded_expected));
+ assert(strcmp(buf, padded_expected) == 0);
+ ASSERT_READ_LABEL(buf, 4, 0);
+ ASSERT_READ_LABEL(buf + 4, strlen(padded_expected) - 8, i_label);
+ ASSERT_READ_LABEL(buf + (strlen(padded_expected) - 4), 4, 0);
+}
+
+void test_sprintf() {
+ char buf[2048];
+ memset(buf, 'a', sizeof(buf));
+
+ // Test formatting (no conversion specifier).
+ assert(sprintf(buf, "Hello world!") == 12);
+ assert(strcmp(buf, "Hello world!") == 0);
+ ASSERT_READ_LABEL(buf, sizeof(buf), 0);
+
+ // Test for extra arguments.
+ assert(sprintf(buf, "Hello world!", 42, "hello") == 12);
+ assert(strcmp(buf, "Hello world!") == 0);
+ ASSERT_READ_LABEL(buf, sizeof(buf), 0);
+
+ // Test formatting & label propagation (multiple conversion specifiers): %s,
+ // %d, %n, %f, and %%.
+ const char* s = "world";
+ int m = 8;
+ int d = 27;
+ dfsan_set_label(k_label, (void *) (s + 1), 2);
+ dfsan_set_label(i_label, &m, sizeof(m));
+ dfsan_set_label(j_label, &d, sizeof(d));
+ int n;
+ int r = sprintf(buf, "hello %s, %-d/%d/%d %f %% %n%d", s, 2014, m, d,
+ 12345.6781234, &n, 1000);
+ assert(r == 42);
+ assert(strcmp(buf, "hello world, 2014/8/27 12345.678123 % 1000") == 0);
+ ASSERT_READ_LABEL(buf, 7, 0);
+ ASSERT_READ_LABEL(buf + 7, 2, k_label);
+ ASSERT_READ_LABEL(buf + 9, 9, 0);
+ ASSERT_READ_LABEL(buf + 18, 1, i_label);
+ ASSERT_READ_LABEL(buf + 19, 1, 0);
+ ASSERT_READ_LABEL(buf + 20, 2, j_label);
+ ASSERT_READ_LABEL(buf + 22, 15, 0);
+ ASSERT_LABEL(r, 0);
+ assert(n == 38);
+
+ // Test formatting & label propagation (single conversion specifier, with
+ // additional length and precision modifiers).
+ test_sprintf_chunk("-559038737", "%d", 0xdeadbeef);
+ test_sprintf_chunk("3735928559", "%u", 0xdeadbeef);
+ test_sprintf_chunk("12345", "%i", 12345);
+ test_sprintf_chunk("751", "%o", 0751);
+ test_sprintf_chunk("babe", "%x", 0xbabe);
+ test_sprintf_chunk("0000BABE", "%.8X", 0xbabe);
+ test_sprintf_chunk("-17", "%hhd", 0xdeadbeef);
+ test_sprintf_chunk("-16657", "%hd", 0xdeadbeef);
+ test_sprintf_chunk("deadbeefdeadbeef", "%lx", 0xdeadbeefdeadbeef);
+ test_sprintf_chunk("0xdeadbeefdeadbeef", "%p",
+ (void *) 0xdeadbeefdeadbeef);
+ test_sprintf_chunk("18446744073709551615", "%ju", (intmax_t) -1);
+ test_sprintf_chunk("18446744073709551615", "%zu", (size_t) -1);
+ test_sprintf_chunk("18446744073709551615", "%tu", (size_t) -1);
+
+ test_sprintf_chunk("0x1.f9acffa7eb6bfp-4", "%a", 0.123456);
+ test_sprintf_chunk("0X1.F9ACFFA7EB6BFP-4", "%A", 0.123456);
+ test_sprintf_chunk("0.12346", "%.5f", 0.123456);
+ test_sprintf_chunk("0.123456", "%g", 0.123456);
+ test_sprintf_chunk("1.234560e-01", "%e", 0.123456);
+ test_sprintf_chunk("1.234560E-01", "%E", 0.123456);
+ test_sprintf_chunk("0.1234567891234560", "%.16Lf",
+ (long double) 0.123456789123456);
+
+ test_sprintf_chunk("z", "%c", 'z');
+
+ // %n, %s, %d, %f, and %% already tested
+}
+
+void test_snprintf() {
+ char buf[2048];
+ memset(buf, 'a', sizeof(buf));
+ dfsan_set_label(0, buf, sizeof(buf));
+ const char* s = "world";
+ int y = 2014;
+ int m = 8;
+ int d = 27;
+ dfsan_set_label(k_label, (void *) (s + 1), 2);
+ dfsan_set_label(i_label, &y, sizeof(y));
+ dfsan_set_label(j_label, &m, sizeof(m));
+ int r = snprintf(buf, 19, "hello %s, %-d/%d/%d %f", s, y, m, d,
+ 12345.6781234);
+ // The return value is the number of bytes that would have been written to
+ // the final string if enough space had been available.
+ assert(r == 35);
+ assert(memcmp(buf, "hello world, 2014/", 19) == 0);
+ ASSERT_READ_LABEL(buf, 7, 0);
+ ASSERT_READ_LABEL(buf + 7, 2, k_label);
+ ASSERT_READ_LABEL(buf + 9, 4, 0);
+ ASSERT_READ_LABEL(buf + 13, 4, i_label);
+ ASSERT_READ_LABEL(buf + 17, 2, 0);
+ ASSERT_LABEL(r, 0);
+}
+
+int main(void) {
+ i_label = dfsan_create_label("i", 0);
+ j_label = dfsan_create_label("j", 0);
+ k_label = dfsan_create_label("k", 0);
+ i_j_label = dfsan_union(i_label, j_label);
+
+ test_calloc();
+ test_clock_gettime();
+ test_ctime_r();
+ test_dfsan_set_write_callback();
+ test_dl_iterate_phdr();
+ test_dlopen();
+ test_fgets();
+ test_fstat();
+ test_get_current_dir_name();
+ test_getcwd();
+ test_gethostname();
+ test_getpwuid_r();
+ test_getrlimit();
+ test_getrusage();
+ test_gettimeofday();
+ test_inet_pton();
+ test_localtime_r();
+ test_memchr();
+ test_memcmp();
+ test_memcpy();
+ test_memset();
+ test_nanosleep();
+ test_poll();
+ test_pread();
+ test_pthread_create();
+ test_read();
+ test_sched_getaffinity();
+ test_select();
+ test_sigaction();
+ test_sigemptyset();
+ test_snprintf();
+ test_socketpair();
+ test_sprintf();
+ test_stat();
+ test_strcasecmp();
+ test_strchr();
+ test_strcmp();
+ test_strcpy();
+ test_strdup();
+ test_strlen();
+ test_strncasecmp();
+ test_strncmp();
+ test_strncpy();
+ test_strrchr();
+ test_strstr();
+ test_strtod();
+ test_strtol();
+ test_strtoll();
+ test_strtoul();
+ test_strtoull();
+ test_time();
+ test_write();
+}
diff --git a/test/dfsan/dump_labels.c b/test/dfsan/dump_labels.c
new file mode 100644
index 000000000000..67801af1838f
--- /dev/null
+++ b/test/dfsan/dump_labels.c
@@ -0,0 +1,69 @@
+// RUN: %clang_dfsan -m64 %s -o %t
+// RUN: DFSAN_OPTIONS=dump_labels_at_exit=/dev/stdout %run %t 2>&1 | FileCheck %s
+// RUN: DFSAN_OPTIONS=dump_labels_at_exit=/dev/stdout not %run %t c 2>&1 | FileCheck %s --check-prefix=CHECK-OOL
+// RUN: DFSAN_OPTIONS=dump_labels_at_exit=/dev/stdout not %run %t u 2>&1 | FileCheck %s --check-prefix=CHECK-OOL
+
+// Tests that labels are properly dumped at program termination.
+
+#include <sanitizer/dfsan_interface.h>
+#include <assert.h>
+#include <stdio.h>
+
+int main(int argc, char** argv) {
+ int i = 1;
+ dfsan_label i_label = dfsan_create_label("i", 0);
+ dfsan_set_label(i_label, &i, sizeof(i));
+
+ int j = 2;
+ dfsan_label j_label = dfsan_create_label("j", 0);
+ dfsan_set_label(j_label, &j, sizeof(j));
+
+ int k = 3;
+ dfsan_label k_label = dfsan_create_label("k", 0);
+ dfsan_set_label(k_label, &k, sizeof(k));
+
+ dfsan_label ij_label = dfsan_get_label(i + j);
+ dfsan_label ijk_label = dfsan_get_label(i + j + k);
+
+ fprintf(stderr, "i %d j %d k %d ij %d ijk %d\n", i_label, j_label, k_label,
+ ij_label, ijk_label);
+
+ // CHECK: 1 0 0 i
+ // CHECK: 2 0 0 j
+ // CHECK: 3 0 0 k
+ // CHECK: 4 1 2
+ // CHECK: 5 3 4
+
+ if (argc > 1) {
+ // Exhaust the labels.
+ unsigned long num_labels = 1 << (sizeof(dfsan_label) * 8);
+ for (unsigned long i = ijk_label + 1; i < num_labels - 2; ++i) {
+ dfsan_label l = dfsan_create_label("l", 0);
+ assert(l == i);
+ }
+
+ // Consume the last available label.
+ dfsan_label l = dfsan_union(5, 6);
+ assert(l == num_labels - 2);
+
+ // Try to allocate another label (either explicitly or by unioning two
+ // existing labels), but expect a crash.
+ if (argv[1][0] == 'c') {
+ l = dfsan_create_label("l", 0);
+ } else {
+ l = dfsan_union(6, 7);
+ }
+
+ // CHECK-OOL: FATAL: DataFlowSanitizer: out of labels
+ // CHECK-OOL: 1 0 0 i
+ // CHECK-OOL: 2 0 0 j
+ // CHECK-OOL: 3 0 0 k
+ // CHECK-OOL: 4 1 2
+ // CHECK-OOL: 5 3 4
+ // CHECK-OOL: 6 0 0
+ // CHECK-OOL: 65534 5 6
+ // CHECK-OOL: 65535 0 0 <init label>
+ }
+
+ return 0;
+}
diff --git a/test/dfsan/flags.c b/test/dfsan/flags.c
new file mode 100644
index 000000000000..79069b96f83a
--- /dev/null
+++ b/test/dfsan/flags.c
@@ -0,0 +1,24 @@
+// RUN: %clang_dfsan -m64 %s -fsanitize-blacklist=%S/Inputs/flags_abilist.txt -mllvm -dfsan-debug-nonzero-labels -o %t && %run %t 2>&1 | FileCheck %s
+// RUN: %clang_dfsan -m64 %s -fsanitize-blacklist=%S/Inputs/flags_abilist.txt -mllvm -dfsan-debug-nonzero-labels -o %t && DFSAN_OPTIONS=warn_unimplemented=0 %run %t 2>&1 | count 0
+// RUN: %clang_dfsan -m64 %s -fsanitize-blacklist=%S/Inputs/flags_abilist.txt -mllvm -dfsan-debug-nonzero-labels -o %t && DFSAN_OPTIONS=warn_nonzero_labels=1 %run %t 2>&1 | FileCheck --check-prefix=CHECK-NONZERO %s
+
+// Tests that flags work correctly.
+
+#include <sanitizer/dfsan_interface.h>
+
+int f(int i) {
+ return i;
+}
+
+int main(void) {
+ int i = 1;
+ dfsan_label i_label = dfsan_create_label("i", 0);
+ dfsan_set_label(i_label, &i, sizeof(i));
+
+ // CHECK: WARNING: DataFlowSanitizer: call to uninstrumented function f
+ // CHECK-NOT: WARNING: DataFlowSanitizer: saw nonzero label
+ // CHECK-NONZERO: WARNING: DataFlowSanitizer: saw nonzero label
+ f(i);
+
+ return 0;
+}
diff --git a/test/dfsan/fncall.c b/test/dfsan/fncall.c
new file mode 100644
index 000000000000..e780f3145e87
--- /dev/null
+++ b/test/dfsan/fncall.c
@@ -0,0 +1,26 @@
+// RUN: %clang_dfsan -m64 %s -o %t && %run %t
+// RUN: %clang_dfsan -mllvm -dfsan-args-abi -m64 %s -o %t && %run %t
+
+// Tests that labels are propagated through function calls.
+
+#include <sanitizer/dfsan_interface.h>
+#include <assert.h>
+
+int f(int x) {
+ int j = 2;
+ dfsan_label j_label = dfsan_create_label("j", 0);
+ dfsan_set_label(j_label, &j, sizeof(j));
+ return x + j;
+}
+
+int main(void) {
+ int i = 1;
+ dfsan_label i_label = dfsan_create_label("i", 0);
+ dfsan_set_label(i_label, &i, sizeof(i));
+
+ dfsan_label ij_label = dfsan_get_label(f(i));
+ assert(dfsan_has_label(ij_label, i_label));
+ assert(dfsan_has_label_with_desc(ij_label, "j"));
+
+ return 0;
+}
diff --git a/test/dfsan/label_count.c b/test/dfsan/label_count.c
new file mode 100644
index 000000000000..a4b608701811
--- /dev/null
+++ b/test/dfsan/label_count.c
@@ -0,0 +1,75 @@
+// RUN: %clang_dfsan -DLIB -m64 -c %s -o %t.lib.o && \
+// RUN: %clang_dfsan -m64 -c %s -o %t.o && \
+// RUN: %clang_dfsan -m64 %t.lib.o %t.o -o %t.bin && \
+// RUN: %run %t.bin
+
+// RUN: %clang_dfsan -mllvm -dfsan-args-abi -m64 -DLIB -c %s -o %t.lib.o && \
+// RUN: %clang_dfsan -mllvm -dfsan-args-abi -m64 -c %s -o %t.o && \
+// RUN: %clang_dfsan -mllvm -dfsan-args-abi -m64 %t.o %t.lib.o -o %t.bin && \
+// RUN: %run %t.bin
+
+#include <sanitizer/dfsan_interface.h>
+#include <assert.h>
+
+#ifdef LIB
+// Compiling this file with and without LIB defined allows this file to be
+// built as two separate translation units. This ensures that the code
+// can not be optimized in a way that removes behavior we wish to test. For
+// example, computing a value should cause labels to be allocated only if
+// the computation is actually done. Putting the computation here prevents
+// the compiler from optimizing away the computation (and labeling) that
+// tests wish to verify.
+
+int add_in_separate_translation_unit(int a, int b) {
+ return a + b;
+}
+
+int multiply_in_separate_translation_unit(int a, int b) {
+ return a * b;
+}
+
+#else
+
+int add_in_separate_translation_unit(int i, int j);
+int multiply_in_separate_translation_unit(int i, int j);
+
+int main(void) {
+ size_t label_count;
+
+ // No labels allocated yet.
+ label_count = dfsan_get_label_count();
+ assert(0 == label_count);
+
+ int i = 1;
+ dfsan_label i_label = dfsan_create_label("i", 0);
+ dfsan_set_label(i_label, &i, sizeof(i));
+
+ // One label allocated for i.
+ label_count = dfsan_get_label_count();
+ assert(1u == label_count);
+
+ int j = 2;
+ dfsan_label j_label = dfsan_create_label("j", 0);
+ dfsan_set_label(j_label, &j, sizeof(j));
+
+ // Check that a new label was allocated for j.
+ label_count = dfsan_get_label_count();
+ assert(2u == label_count);
+
+ // Create a value that combines i and j.
+ int i_plus_j = add_in_separate_translation_unit(i, j);
+
+ // Check that a label was created for the union of i and j.
+ label_count = dfsan_get_label_count();
+ assert(3u == label_count);
+
+ // Combine i and j in a different way. Check that the existing label is
+ // reused, and a new label is not created.
+ int j_times_i = multiply_in_separate_translation_unit(j, i);
+ label_count = dfsan_get_label_count();
+ assert(3u == label_count);
+ assert(dfsan_get_label(i_plus_j) == dfsan_get_label(j_times_i));
+
+ return 0;
+}
+#endif // #ifdef LIB
diff --git a/test/dfsan/lit.cfg b/test/dfsan/lit.cfg
new file mode 100644
index 000000000000..d4adb9a5110a
--- /dev/null
+++ b/test/dfsan/lit.cfg
@@ -0,0 +1,26 @@
+# -*- Python -*-
+
+import os
+
+# Setup config name.
+config.name = 'DataFlowSanitizer'
+
+# Setup source root.
+config.test_source_root = os.path.dirname(__file__)
+
+# Setup default compiler flags used with -fsanitize=dataflow option.
+clang_dfsan_cflags = ["-fsanitize=dataflow"]
+clang_dfsan_cxxflags = config.cxx_mode_flags + clang_dfsan_cflags
+
+def build_invocation(compile_flags):
+ return " " + " ".join([config.clang] + compile_flags) + " "
+
+config.substitutions.append( ("%clang_dfsan ", build_invocation(clang_dfsan_cflags)) )
+config.substitutions.append( ("%clangxx_dfsan ", build_invocation(clang_dfsan_cxxflags)) )
+
+# Default test suffixes.
+config.suffixes = ['.c', '.cc', '.cpp']
+
+# DataFlowSanitizer tests are currently supported on Linux only.
+if config.host_os not in ['Linux']:
+ config.unsupported = True
diff --git a/test/dfsan/lit.site.cfg.in b/test/dfsan/lit.site.cfg.in
new file mode 100644
index 000000000000..859284eca140
--- /dev/null
+++ b/test/dfsan/lit.site.cfg.in
@@ -0,0 +1,5 @@
+# Load common config for all compiler-rt lit tests.
+lit_config.load_config(config, "@COMPILER_RT_BINARY_DIR@/test/lit.common.configured")
+
+# Load tool-specific config that would do the real work.
+lit_config.load_config(config, "@DFSAN_LIT_TESTS_DIR@/lit.cfg")
diff --git a/test/dfsan/propagate.c b/test/dfsan/propagate.c
new file mode 100644
index 000000000000..733538cb109a
--- /dev/null
+++ b/test/dfsan/propagate.c
@@ -0,0 +1,47 @@
+// RUN: %clang_dfsan -m64 %s -o %t && %run %t
+// RUN: %clang_dfsan -mllvm -dfsan-args-abi -m64 %s -o %t && %run %t
+
+// Tests that labels are propagated through computation and that union labels
+// are properly created.
+
+#include <sanitizer/dfsan_interface.h>
+#include <assert.h>
+
+int main(void) {
+ assert(dfsan_union(0, 0) == 0);
+
+ int i = 1;
+ dfsan_label i_label = dfsan_create_label("i", 0);
+ dfsan_set_label(i_label, &i, sizeof(i));
+
+ int j = 2;
+ dfsan_label j_label = dfsan_create_label("j", 0);
+ dfsan_set_label(j_label, &j, sizeof(j));
+
+ int k = 3;
+ dfsan_label k_label = dfsan_create_label("k", 0);
+ dfsan_set_label(k_label, &k, sizeof(k));
+
+ int k2 = 4;
+ dfsan_set_label(k_label, &k2, sizeof(k2));
+
+ dfsan_label ij_label = dfsan_get_label(i + j);
+ assert(dfsan_has_label(ij_label, i_label));
+ assert(dfsan_has_label(ij_label, j_label));
+ assert(!dfsan_has_label(ij_label, k_label));
+ // Test uniquing.
+ assert(dfsan_union(i_label, j_label) == ij_label);
+ assert(dfsan_union(j_label, i_label) == ij_label);
+
+ dfsan_label ijk_label = dfsan_get_label(i + j + k);
+ assert(dfsan_has_label(ijk_label, i_label));
+ assert(dfsan_has_label(ijk_label, j_label));
+ assert(dfsan_has_label(ijk_label, k_label));
+
+ assert(dfsan_get_label(k + k2) == k_label);
+
+ struct { int i, j; } s = { i, j };
+ assert(dfsan_read_label(&s, sizeof(s)) == ij_label);
+
+ return 0;
+}
diff --git a/test/dfsan/vararg.c b/test/dfsan/vararg.c
new file mode 100644
index 000000000000..2227ba715639
--- /dev/null
+++ b/test/dfsan/vararg.c
@@ -0,0 +1,24 @@
+// RUN: %clang_dfsan -m64 %s -o %t
+// RUN: not %run %t 2>&1 | FileCheck %s
+// RUN: %run %t foo
+// RUN: %clang_dfsan -mllvm -dfsan-args-abi -m64 %s -o %t
+// RUN: not %run %t 2>&1 | FileCheck %s
+// RUN: %run %t foo
+
+#include <stdio.h>
+
+int do_nothing(const char *format, ...) {
+ return 0;
+}
+
+int main(int argc, char **argv) {
+ int (*fp)(const char *, ...);
+
+ if (argc > 1)
+ fp = do_nothing;
+ else
+ fp = printf;
+
+ // CHECK: FATAL: DataFlowSanitizer: unsupported indirect call to vararg function printf
+ fp("hello %s\n", "world");
+}
diff --git a/test/dfsan/write_callback.c b/test/dfsan/write_callback.c
new file mode 100644
index 000000000000..bb35f3250740
--- /dev/null
+++ b/test/dfsan/write_callback.c
@@ -0,0 +1,110 @@
+// RUN: %clang_dfsan -m64 %s -o %t && %run %t | FileCheck %s
+// RUN: %clang_dfsan -mllvm -dfsan-args-abi -m64 %s -o %t && %run %t | FileCheck %s
+
+// Tests that the custom implementation of write() does writes with or without
+// a callback set using dfsan_set_write_callback().
+
+#include <sanitizer/dfsan_interface.h>
+
+#include <assert.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+// Check write callback arguments by having the callback store them in
+// the following variables:
+static int last_callback_arg_fd;
+static const void *last_callback_arg_buf;
+static size_t last_callback_arg_count;
+
+// Allow tests to check the number of callbacks made by incrementing
+// this count. When callbacks are verified, the count is reset.
+static int count_unverified_callbacks = 0;
+
+// This callbact will be installed using dfsan_set_write_callback()
+// in tests below.
+static void write_callback(int fd, const void *buf, size_t count) {
+ // Do not do anything in this function that might call write().
+ count_unverified_callbacks++;
+
+ last_callback_arg_fd = fd;
+ last_callback_arg_buf = buf;
+ last_callback_arg_count = count;
+}
+
+static void write_string_to_stdout(char *string) {
+ char *cur = string;
+ int bytes_left = strlen(string);
+ while (bytes_left > 0) {
+ int res = write(fileno(stdout), cur, bytes_left);
+ assert (res >= 0);
+ cur += res;
+ bytes_left -= res;
+ }
+}
+
+static void test_can_write_without_callback() {
+ dfsan_set_write_callback(NULL);
+ count_unverified_callbacks = 0;
+
+ char aString[] = "Test that writes work without callback.\n";
+ // CHECK: Test that writes work without callback.
+ write_string_to_stdout(aString);
+
+ assert(count_unverified_callbacks == 0);
+}
+
+static void test_can_write_with_callback() {
+ dfsan_set_write_callback(write_callback);
+
+ count_unverified_callbacks = 0;
+
+ char stringWithCallback[] = "Test that writes work with callback.\n";
+ // CHECK: Test that writes work with callback.
+ write_string_to_stdout(stringWithCallback);
+
+ // Data was written, so at least one call to write() was made.
+ // Because a write may not process all the bytes it is passed, there
+ // may have been several calls to write().
+ assert(count_unverified_callbacks > 0);
+ count_unverified_callbacks = 0;
+
+ dfsan_set_write_callback(NULL);
+
+ char stringWithoutCallback[] = "Writes work after the callback is removed.\n";
+ // CHECK: Writes work after the callback is removed.
+ write_string_to_stdout(stringWithoutCallback);
+ assert(count_unverified_callbacks == 0);
+}
+
+static void test_failing_write_runs_callback() {
+ // Open /dev/null in read-only mode. Calling write() on fd will fail.
+ int fd = open("/dev/null", O_RDONLY);
+ assert(fd != -1);
+
+ // Install a callback.
+ dfsan_set_write_callback(write_callback);
+
+ // Write to the read-only file handle. The write will fail, but the callback
+ // should still be invoked.
+ char aString[] = "This text will fail to be written.\n";
+ int len = strlen(aString);
+ int write_result = write(fd, aString, len);
+ assert(write_result == -1);
+
+ assert(count_unverified_callbacks == 1);
+ count_unverified_callbacks = 0;
+
+ assert(fd == last_callback_arg_fd);
+ assert(aString == last_callback_arg_buf);
+ assert(len == last_callback_arg_count);
+
+ close(fd);
+}
+
+int main(int argc, char* argv[]) {
+ test_can_write_without_callback();
+ test_can_write_with_callback();
+ test_failing_write_runs_callback();
+}