Imported Upstream version 6.10.0.49

Former-commit-id: 1d6753294b2993e1fbf92de9366bb9544db4189b

external/llvm-project/compiler-rt/test/msan/Linux/cmsghdr.cc

@@ -0,0 +1,101 @@
+// RUN: %clangxx_msan %s -std=c++11 -DSENDMSG -DPOISONFD -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=SENDMSG
+// RUN: %clangxx_msan %s -std=c++11 -DSENDMSG -DPOISONCRED -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=SENDMSG
+// RUN: %clangxx_msan %s -std=c++11 -DSENDMSG -DPOISONLEN -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=SENDMSG
+// RUN: %clangxx_msan %s -std=c++11 -DSENDMSG -DPOISONLEVEL -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=SENDMSG
+// RUN: %clangxx_msan %s -std=c++11 -DSENDMSG -DPOISONTYPE -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=SENDMSG
+// RUN: %clangxx_msan %s -std=c++11 -DSENDMSG -DPOISONLEN2 -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=SENDMSG
+// RUN: %clangxx_msan %s -std=c++11 -DSENDMSG -DPOISONLEVEL2 -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=SENDMSG
+// RUN: %clangxx_msan %s -std=c++11 -DSENDMSG -DPOISONTYPE2 -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=SENDMSG
+// RUN: %clangxx_msan %s -std=c++11 -DSENDMSG -o %t && %run %t 2>&1 | FileCheck %s --check-prefix=NEGATIVE
+
+// UNSUPPORTED: android
+
+#include <assert.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <netdb.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <sanitizer/msan_interface.h>
+
+const int kBufSize = 10;
+
+int main() {
+  int ret;
+  char buf[kBufSize] = {0};
+  pthread_t client_thread;
+  struct sockaddr_un serveraddr;
+
+  int sock[2];
+  ret = socketpair(AF_UNIX, SOCK_STREAM, 0, sock);
+  assert(ret == 0);
+
+  int sockfd = sock[0];
+
+  struct iovec iov[] = {{buf, 10}};
+  struct msghdr msg = {0};
+  msg.msg_iov = iov;
+  msg.msg_iovlen = 1;
+  msg.msg_flags = 0;
+
+  static const int kNumFds = 3;
+  char controlbuf[CMSG_SPACE(kNumFds * sizeof(int)) +
+                  CMSG_SPACE(sizeof(struct ucred))];
+  msg.msg_control = &controlbuf;
+  msg.msg_controllen = sizeof(controlbuf);
+
+  struct cmsghdr *cmsg = (struct cmsghdr *)&controlbuf;
+  assert(cmsg);
+  int myfds[kNumFds];
+  for (int &fd : myfds)
+    fd = sockfd;
+#ifdef POISONFD
+  __msan_poison(&myfds[1], sizeof(int));
+#endif
+  cmsg->cmsg_level = SOL_SOCKET;
+  cmsg->cmsg_type = SCM_RIGHTS;
+  cmsg->cmsg_len = CMSG_LEN(kNumFds * sizeof(int));
+  memcpy(CMSG_DATA(cmsg), myfds, kNumFds * sizeof(int));
+#ifdef POISONLEVEL
+  __msan_poison(&cmsg->cmsg_level, sizeof(cmsg->cmsg_level));
+#endif
+#ifdef POISONTYPE
+  __msan_poison(&cmsg->cmsg_type, sizeof(cmsg->cmsg_type));
+#endif
+#ifdef POISONLEN
+  __msan_poison(&cmsg->cmsg_len, sizeof(cmsg->cmsg_len));
+#endif
+
+  cmsg = (struct cmsghdr *)(&controlbuf[CMSG_SPACE(kNumFds * sizeof(int))]);
+  assert(cmsg);
+  struct ucred cred = {getpid(), getuid(), getgid()};
+#ifdef POISONCRED
+  __msan_poison(&cred.uid, sizeof(cred.uid));
+#endif
+  cmsg->cmsg_level = SOL_SOCKET;
+  cmsg->cmsg_type = SCM_CREDENTIALS;
+  cmsg->cmsg_len = CMSG_LEN(sizeof(struct ucred));
+  memcpy(CMSG_DATA(cmsg), &cred, sizeof(struct ucred));
+#ifdef POISONLEVEL2
+  __msan_poison(&cmsg->cmsg_level, sizeof(cmsg->cmsg_level));
+#endif
+#ifdef POISONTYPE2
+  __msan_poison(&cmsg->cmsg_type, sizeof(cmsg->cmsg_type));
+#endif
+#ifdef POISONLEN2
+  __msan_poison(&cmsg->cmsg_len, sizeof(cmsg->cmsg_len));
+#endif
+
+  ret = sendmsg(sockfd, &msg, 0);
+  // SENDMSG: MemorySanitizer: use-of-uninitialized-value
+  if (ret == -1) printf("%d: %s\n", errno, strerror(errno));
+  assert(ret > 0);
+
+  fprintf(stderr, "== done\n");
+  // NEGATIVE: == done
+  return 0;
+}

external/llvm-project/compiler-rt/test/msan/Linux/eventfd.cc

@@ -0,0 +1,18 @@
+// RUN: %clangxx_msan -O0 %s -o %t && %run %t 2>&1
+
+#include <assert.h>
+#include <sys/eventfd.h>
+
+#include <sanitizer/msan_interface.h>
+
+int main(int argc, char *argv[]) {
+  int efd = eventfd(42, 0);
+  assert(efd >= 0);
+
+  eventfd_t v;
+  int ret = eventfd_read(efd, &v);
+  assert(ret == 0);
+  __msan_check_mem_is_initialized(&v, sizeof(v));
+
+  assert(v == 42);
+}

external/llvm-project/compiler-rt/test/msan/Linux/fopencookie.cc

@@ -0,0 +1,65 @@
+// Test fopencookie interceptor.
+// RUN: %clangxx_msan -std=c++11 -O0 %s -o %t && %run %t
+// RUN: %clangxx_msan -std=c++11 -fsanitize-memory-track-origins -O0 %s -o %t && %run %t
+
+#include <assert.h>
+#include <pthread.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <sanitizer/msan_interface.h>
+
+constexpr uintptr_t kMagicCookie = 0x12345678;
+
+static ssize_t cookie_read(void *cookie, char *buf, size_t size) {
+  assert((uintptr_t)cookie == kMagicCookie);
+  memset(buf, 0, size);
+  return 0;
+}
+
+static ssize_t cookie_write(void *cookie, const char *buf, size_t size) {
+  assert((uintptr_t)cookie == kMagicCookie);
+  __msan_check_mem_is_initialized(buf, size);
+  return 0;
+}
+
+static int cookie_seek(void *cookie, off64_t *offset, int whence) {
+  assert((uintptr_t)cookie == kMagicCookie);
+  __msan_check_mem_is_initialized(offset, sizeof(*offset));
+  return 0;
+}
+
+static int cookie_close(void *cookie) {
+  assert((uintptr_t)cookie == kMagicCookie);
+  return 0;
+}
+
+void PoisonStack() { char a[8192]; }
+
+void TestPoisonStack() {
+  // Verify that PoisonStack has poisoned the stack - otherwise this test is not
+  // testing anything.
+  char a;
+  assert(__msan_test_shadow(&a - 1000, 1) == 0);
+}
+
+int main() {
+  void *cookie = (void *)kMagicCookie;
+  FILE *f = fopencookie(cookie, "rw",
+                        {cookie_read, cookie_write, cookie_seek, cookie_close});
+  PoisonStack();
+  TestPoisonStack();
+  fseek(f, 100, SEEK_SET);
+  char buf[50];
+  fread(buf, 50, 1, f);
+  fwrite(buf, 50, 1, f);
+  fclose(f);
+
+  f = fopencookie(cookie, "rw", {nullptr, nullptr, nullptr, nullptr});
+  fseek(f, 100, SEEK_SET);
+  fread(buf, 50, 1, f);
+  fwrite(buf, 50, 1, f);
+  fclose(f);
+}

external/llvm-project/compiler-rt/test/msan/Linux/forkpty.cc

@@ -0,0 +1,25 @@
+// RUN: %clangxx_msan -O0 -g %s -lutil -o %t && %run %t
+
+#include <assert.h>
+#include <pty.h>
+#include <unistd.h>
+#include <cstring>
+
+#include <sanitizer/msan_interface.h>
+
+int
+main (int argc, char** argv)
+{
+  int master, slave;
+  openpty(&master, &slave, NULL, NULL, NULL);
+  assert(__msan_test_shadow(&master, sizeof(master)) == -1);
+  assert(__msan_test_shadow(&slave, sizeof(slave)) == -1);
+
+  char ttyname[255];
+  ttyname_r(master, ttyname, sizeof(ttyname));
+  assert(__msan_test_shadow(ttyname, strlen(ttyname) + 1) == -1);
+
+  int master2;
+  forkpty(&master2, NULL, NULL, NULL);
+  assert(__msan_test_shadow(&master2, sizeof(master2)) == -1);
+}

external/llvm-project/compiler-rt/test/msan/Linux/getresid.cc

@@ -0,0 +1,25 @@
+// RUN: %clangxx_msan -O0 %s -o %t && %run %t %p 2>&1
+// RUN: %clangxx_msan -O0 -D_FILE_OFFSET_BITS=64 %s -o %t && %run %t %p 2>&1
+// RUN: %clangxx_msan -O3 %s -o %t && %run %t %p 2>&1
+
+#include <assert.h>
+#include <unistd.h>
+
+#include <sanitizer/msan_interface.h>
+
+int main(int argc, char *argv[]) {
+  uid_t uids[6];
+  assert(0 == __msan_test_shadow(uids, 6 * sizeof(uid_t)));
+  assert(0 == getresuid(&uids[0], &uids[2], &uids[4]));
+  for (int i = 0; i < 3; i++)
+    assert(sizeof(uid_t) ==
+           __msan_test_shadow(uids + 2 * i, 2 * sizeof(uid_t)));
+
+  gid_t gids[6];
+  assert(0 == __msan_test_shadow(gids, 6 * sizeof(gid_t)));
+  assert(0 == getresgid(&gids[0], &gids[2], &gids[4]));
+  for (int i = 0; i < 3; i++)
+    assert(sizeof(gid_t) ==
+           __msan_test_shadow(gids + 2 * i, 2 * sizeof(gid_t)));
+  return 0;
+}

external/llvm-project/compiler-rt/test/msan/Linux/glob.cc

@@ -0,0 +1,27 @@
+// RUN: %clangxx_msan -O0 %s -o %t && %run %t %p 2>&1 | FileCheck %s
+// RUN: %clangxx_msan -O0 -D_FILE_OFFSET_BITS=64 %s -o %t && %run %t %p 2>&1 | FileCheck %s
+// RUN: %clangxx_msan -O3 %s -o %t && %run %t %p 2>&1 | FileCheck %s
+
+#include <assert.h>
+#include <glob.h>
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+
+int main(int argc, char *argv[]) {
+  assert(argc == 2);
+  char buf[1024];
+  snprintf(buf, sizeof(buf), "%s/%s", argv[1], "glob_test_root/*a");
+
+  glob_t globbuf;
+  int res = glob(buf, 0, 0, &globbuf);
+
+  printf("%d %s\n", errno, strerror(errno));
+  assert(res == 0);
+  assert(globbuf.gl_pathc == 2);
+  printf("%zu\n", strlen(globbuf.gl_pathv[0]));
+  printf("%zu\n", strlen(globbuf.gl_pathv[1]));
+  printf("PASS\n");
+  // CHECK: PASS
+  return 0;
+}

external/llvm-project/compiler-rt/test/msan/Linux/glob_altdirfunc.cc

@@ -0,0 +1,78 @@
+// RUN: %clangxx_msan -O0 %s -o %t && %run %t %p 2>&1 | FileCheck %s
+// RUN: %clangxx_msan -O0 -D_FILE_OFFSET_BITS=64 %s -o %t && %run %t %p 2>&1 | FileCheck %s
+// RUN: %clangxx_msan -O3 %s -o %t && %run %t %p 2>&1 | FileCheck %s
+
+#include <assert.h>
+#include <glob.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <dirent.h>
+#include <unistd.h>
+
+#include <sanitizer/msan_interface.h>
+
+static void my_gl_closedir(void *dir) {
+  if (!dir)
+    exit(1);
+  closedir((DIR *)dir);
+}
+
+static struct dirent *my_gl_readdir(void *dir) {
+  if (!dir)
+    exit(1);
+  struct dirent *d = readdir((DIR *)dir);
+  if (d) __msan_poison(d, d->d_reclen); // hehe
+  return d;
+}
+
+static void *my_gl_opendir(const char *s) {
+  assert(__msan_test_shadow(s, strlen(s) + 1) == (size_t)-1);
+  return opendir(s);
+}
+
+static int my_gl_lstat(const char *s, struct stat *st) {
+  assert(__msan_test_shadow(s, strlen(s) + 1) == (size_t)-1);
+  if (!st)
+    exit(1);
+  return lstat(s, st);
+}
+
+static int my_gl_stat(const char *s, struct stat *st) {
+  assert(__msan_test_shadow(s, strlen(s) + 1) == (size_t)-1);
+  if (!st)
+    exit(1);
+  return lstat(s, st);
+}
+
+int main(int argc, char *argv[]) {
+  assert(argc == 2);
+  char buf[1024];
+  snprintf(buf, sizeof(buf), "%s/%s", argv[1], "glob_test_root/*a");
+
+  glob_t globbuf;
+  globbuf.gl_closedir = my_gl_closedir;
+  globbuf.gl_readdir = my_gl_readdir;
+  globbuf.gl_opendir = my_gl_opendir;
+  globbuf.gl_lstat = my_gl_lstat;
+  globbuf.gl_stat = my_gl_stat;
+  for (int i = 0; i < 10000; ++i) {
+    int res = glob(buf, GLOB_ALTDIRFUNC | GLOB_MARK, 0, &globbuf);
+    assert(res == 0);
+    printf("%d %s\n", errno, strerror(errno));
+    assert(globbuf.gl_pathc == 2);
+    printf("%zu\n", strlen(globbuf.gl_pathv[0]));
+    printf("%zu\n", strlen(globbuf.gl_pathv[1]));
+    __msan_poison(globbuf.gl_pathv[0], strlen(globbuf.gl_pathv[0]) + 1);
+    __msan_poison(globbuf.gl_pathv[1], strlen(globbuf.gl_pathv[1]) + 1);
+    globfree(&globbuf);
+  }
+
+  printf("PASS\n");
+  // CHECK: PASS
+  return 0;
+}

external/llvm-project/compiler-rt/test/msan/Linux/glob_nomatch.cc

@@ -0,0 +1,21 @@
+// RUN: %clangxx_msan -O0 %s -o %t && %run %t %p
+// RUN: %clangxx_msan -O3 %s -o %t && %run %t %p
+
+#include <assert.h>
+#include <glob.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(int argc, char *argv[]) {
+  assert(argc == 2);
+  char buf[1024];
+  snprintf(buf, sizeof(buf), "%s/%s", argv[1], "glob_test_root/*c");
+
+  glob_t globbuf;
+  int res = glob(buf, 0, 0, &globbuf);
+  assert(res == GLOB_NOMATCH);
+  assert(globbuf.gl_pathc == 0);
+  if (globbuf.gl_pathv == 0)
+    exit(0);
+  return 0;
+}

external/llvm-project/compiler-rt/test/msan/Linux/ioctl_sound.cc

@@ -0,0 +1,29 @@
+// RUN: %clangxx_msan -O0 -g %s -o %t && %run %t
+// RUN: %clangxx_msan -O3 -g %s -o %t && %run %t
+
+#include <assert.h>
+#include <fcntl.h>
+#include <sound/asound.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <unistd.h>
+
+#include <sanitizer/msan_interface.h>
+
+int main(int argc, char **argv) {
+  int fd = open("/dev/snd/controlC0", O_RDONLY);
+  if (fd < 0) {
+    printf("Unable to open sound device.");
+    return 0;
+  }
+  const unsigned sz = sizeof(snd_ctl_card_info);
+  void *info = malloc(sz + 1);
+  assert(__msan_test_shadow(info, sz) == 0);
+  assert(ioctl(fd, SNDRV_CTL_IOCTL_CARD_INFO, info) >= 0);
+  assert(__msan_test_shadow(info, sz + 1) == sz);
+  close(fd);
+  free(info);
+  return 0;
+}

external/llvm-project/compiler-rt/test/msan/Linux/lit.local.cfg

@@ -0,0 +1,9 @@
+def getRoot(config):
+  if not config.parent:
+    return config
+  return getRoot(config.parent)
+
+root = getRoot(config)
+
+if root.host_os not in ['Linux']:
+  config.unsupported = True

external/llvm-project/compiler-rt/test/msan/Linux/mallinfo.cc

@@ -0,0 +1,13 @@
+// RUN: %clangxx_msan -O0 -g %s -o %t && %run %t
+// UNSUPPORTED: aarch64-target-arch
+
+#include <assert.h>
+#include <malloc.h>
+
+#include <sanitizer/msan_interface.h>
+
+int main(void) {
+  struct mallinfo mi = mallinfo();
+  assert(__msan_test_shadow(&mi, sizeof(mi)) == -1);
+  return 0;
+}

external/llvm-project/compiler-rt/test/msan/Linux/mincore.cc

@@ -0,0 +1,36 @@
+// RUN: %clangxx_msan -std=c++11 -O0 %s -o %t && %run %t
+
+#include <assert.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <sanitizer/msan_interface.h>
+
+int main(void) {
+  unsigned char vec[20];
+  int res;
+  size_t PS = sysconf(_SC_PAGESIZE);
+  void *addr = mmap(nullptr, 20 * PS, PROT_READ | PROT_WRITE,
+                    MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
+
+  __msan_poison(&vec, sizeof(vec));
+  res = mincore(addr, 10 * PS, vec);
+  assert(res == 0);
+  assert(__msan_test_shadow(vec, sizeof(vec)) == 10);
+
+  __msan_poison(&vec, sizeof(vec));
+  res = mincore(addr, 10 * PS + 42, vec);
+  assert(res == 0);
+  assert(__msan_test_shadow(vec, sizeof(vec)) == 11);
+
+  __msan_poison(&vec, sizeof(vec));
+  res = mincore(addr, 10 * PS - 1, vec);
+  assert(res == 0);
+  assert(__msan_test_shadow(vec, sizeof(vec)) == 10);
+
+  __msan_poison(&vec, sizeof(vec));
+  res = mincore(addr, 1, vec);
+  assert(res == 0);
+  assert(__msan_test_shadow(vec, sizeof(vec)) == 1);
+
+  return 0;
+}

external/llvm-project/compiler-rt/test/msan/Linux/obstack.cc

@@ -0,0 +1,37 @@
+// RUN: %clangxx_msan -O0 -g %s -o %t && %run %t
+// RUN: %clangxx_msan -O0 -g -DPOSITIVE %s -o %t && not %run %t 2>&1 | FileCheck %s
+
+#include <obstack.h>
+#include <sanitizer/msan_interface.h>
+#include <stdlib.h>
+
+static void *obstack_chunk_alloc(size_t sz) {
+  return malloc(sz);
+}
+
+static void obstack_chunk_free(void *p) {
+  free(p);
+}
+
+int main(void) {
+  obstack obs;
+  obstack_init(&obs);
+  for (size_t sz = 16; sz < 0xFFFF; sz *= 2) {
+    void *p = obstack_alloc(&obs, sz);
+    int data[10] = {0};
+    obstack_grow(&obs, &data, sizeof(data));
+    obstack_blank(&obs, sz);
+    obstack_grow(&obs, &data, sizeof(data));
+    obstack_int_grow(&obs, 13);
+    p = obstack_finish(&obs);
+#ifdef POSITIVE
+    if (sz == 4096) {
+      __msan_check_mem_is_initialized(p, sizeof(data));
+      __msan_check_mem_is_initialized(p, sizeof(data) + 1);
+    }
+    // CHECK: WARNING: MemorySanitizer: use-of-uninitialized-value
+    // CHECK: #0 0x{{.*}} in main{{.*}}obstack.cc:[[@LINE-3]]
+#endif
+  }
+  obstack_free(&obs, 0);
+}

external/llvm-project/compiler-rt/test/msan/Linux/poll.cc

@@ -0,0 +1,42 @@
+// RUN: %clangxx_msan -O0 -std=c++11 -g %s -o %t
+// RUN: %run %t _ 2>&1 | FileCheck %s --check-prefix=CLEAN
+// RUN: not %run %t A 2>&1 | FileCheck %s --check-prefix=A
+// RUN: not %run %t B 2>&1 | FileCheck %s --check-prefix=B
+
+#include <assert.h>
+#include <poll.h>
+#include <signal.h>
+#include <stdio.h>
+
+#include <sanitizer/msan_interface.h>
+
+int main(int argc, char **argv) {
+  char T = argv[1][0];
+
+  struct timespec ts;
+  ts.tv_sec = 0;
+  ts.tv_nsec = 1000;
+  int res = ppoll(nullptr, 0, &ts, nullptr);
+  assert(res == 0);
+
+  if (T == 'A') {
+    __msan_poison(&ts.tv_sec, sizeof(ts.tv_sec));
+    ppoll(nullptr, 0, &ts, nullptr);
+    // A: use-of-uninitialized-value
+  }
+
+  // A-NOT: ==1
+  // B: ==1
+  fprintf(stderr, "==1\n");
+
+  sigset_t sig;
+  if (T != 'B')
+    sigemptyset(&sig);
+  ppoll(nullptr, 0, &ts, &sig);
+  // B: use-of-uninitialized-value
+
+  // B-NOT: ==2
+  // CLEAN: ==2
+  fprintf(stderr, "==2\n");
+  return 0;
+}

external/llvm-project/compiler-rt/test/msan/Linux/process_vm_readv.cc

@@ -0,0 +1,75 @@
+// RUN: %clangxx_msan -std=c++11 -O0 %s -o %t && %run %t
+// RUN: %clangxx_msan -std=c++11 -O0 %s -o %t -DPOSITIVE && not %run %t 2>&1 | FileCheck %s
+
+#include <assert.h>
+#include <dlfcn.h>
+#include <sanitizer/msan_interface.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/uio.h>
+#include <unistd.h>
+#include <errno.h>
+
+typedef ssize_t (*process_vm_readwritev_fn)(pid_t, const iovec *, unsigned long,
+                                            const iovec *, unsigned long,
+                                            unsigned long);
+
+// Exit with success, emulating the expected output.
+int exit_dummy()
+{
+#ifdef POSITIVE
+    printf("process_vm_readv not found or not implemented!\n");
+    printf(
+        "WARNING: MemorySanitizer: use-of-uninitialized-value (not really)\n");
+    return 1;
+#else
+    return 0;
+#endif
+}
+
+int main(void) {
+  // This requires glibc 2.15.
+  process_vm_readwritev_fn libc_process_vm_readv =
+      (process_vm_readwritev_fn)dlsym(RTLD_NEXT, "process_vm_readv");
+  if (!libc_process_vm_readv)
+    return exit_dummy();
+
+  process_vm_readwritev_fn process_vm_readv =
+      (process_vm_readwritev_fn)dlsym(RTLD_DEFAULT, "process_vm_readv");
+  process_vm_readwritev_fn process_vm_writev =
+      (process_vm_readwritev_fn)dlsym(RTLD_DEFAULT, "process_vm_writev");
+
+  char a[100];
+  memset(a, 0xab, 100);
+
+  char b[100];
+  iovec iov_a[] = {{(void *)a, 20}, (void *)(a + 50), 10};
+  iovec iov_b[] = {{(void *)(b + 10), 10}, (void *)(b + 30), 20};
+
+  __msan_poison(&b, sizeof(b));
+  ssize_t res = process_vm_readv(getpid(), iov_b, 2, iov_a, 2, 0);
+  if (errno == ENOSYS) // Function not implemented 
+    return exit_dummy();
+
+  assert(res == 30);
+  __msan_check_mem_is_initialized(b + 10, 10);
+  __msan_check_mem_is_initialized(b + 30, 20);
+  assert(__msan_test_shadow(b + 9, 1) == 0);
+  assert(__msan_test_shadow(b + 20, 1) == 0);
+  assert(__msan_test_shadow(b + 29, 1) == 0);
+  assert(__msan_test_shadow(b + 50, 1) == 0);
+
+#ifdef POSITIVE
+  __msan_unpoison(&b, sizeof(b));
+  __msan_poison(b + 32, 1);
+  res = process_vm_writev(getpid(), iov_b, 2, iov_a, 2, 0);
+// CHECK: WARNING: MemorySanitizer: use-of-uninitialized-value
+#else
+  __msan_unpoison(&b, sizeof(b));
+  res = process_vm_writev(getpid(), iov_b, 2, iov_a, 2, 0);
+  assert(res == 30);
+#endif
+
+  return 0;
+}

external/llvm-project/compiler-rt/test/msan/Linux/sendmsg.cc

@@ -0,0 +1,96 @@
+// RUN: %clangxx_msan %s -DSEND -DPOISON -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=SEND
+// RUN: %clangxx_msan %s -DSENDTO -DPOISON -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=SENDTO
+// RUN: %clangxx_msan %s -DSENDMSG -DPOISON -o %t && not %run %t 2>&1 | FileCheck %s --check-prefix=SENDMSG
+
+// RUN: %clangxx_msan %s -DSEND -o %t && %run %t 2>&1 | FileCheck %s --check-prefix=NEGATIVE
+// RUN: %clangxx_msan %s -DSENDTO -o %t && %run %t 2>&1 | FileCheck %s --check-prefix=NEGATIVE
+// RUN: %clangxx_msan %s -DSENDMSG -o %t && %run %t 2>&1 | FileCheck %s --check-prefix=NEGATIVE
+
+// RUN: %clangxx_msan %s -DSEND -DPOISON -o %t && \
+// RUN:   MSAN_OPTIONS=intercept_send=0 %run %t 2>&1 | FileCheck %s --check-prefix=NEGATIVE
+// RUN: %clangxx_msan %s -DSENDTO -DPOISON -o %t && \
+// RUN:   MSAN_OPTIONS=intercept_send=0 %run %t 2>&1 | FileCheck %s --check-prefix=NEGATIVE
+// RUN: %clangxx_msan %s -DSENDMSG -DPOISON -o %t && \
+// RUN:   MSAN_OPTIONS=intercept_send=0 %run %t 2>&1 | FileCheck %s --check-prefix=NEGATIVE
+
+// UNSUPPORTED: android
+
+#include <assert.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <netdb.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sanitizer/msan_interface.h>
+
+const int kBufSize = 10;
+int sockfd;
+
+int main() {
+  int ret;
+  char buf[kBufSize] = {0};
+  pthread_t client_thread;
+  struct sockaddr_in serveraddr;
+  struct sockaddr_in6 serveraddr6;
+
+  memset(&serveraddr, 0, sizeof(serveraddr));
+  serveraddr.sin_family = AF_INET;
+  serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);
+  serveraddr.sin_port = 0;
+  struct sockaddr *addr = (struct sockaddr *)&serveraddr;
+  socklen_t addrlen = sizeof(serveraddr);
+
+  sockfd = socket(addr->sa_family, SOCK_DGRAM, 0);
+  if (sockfd <= 0) {
+    // Try to fall-back to IPv6
+    memset(&serveraddr6, 0, sizeof(serveraddr6));
+    serveraddr6.sin6_family = AF_INET6;
+    serveraddr6.sin6_addr = in6addr_any;
+    serveraddr6.sin6_port = 0;
+    addr = (struct sockaddr *)&serveraddr6;
+    addrlen = sizeof(serveraddr6);
+
+    sockfd = socket(addr->sa_family, SOCK_DGRAM, 0);
+  }
+  assert(sockfd > 0);
+
+  bind(sockfd, addr, addrlen);
+  getsockname(sockfd, addr, &addrlen);
+
+#if defined(POISON)
+  __msan_poison(buf + 7, 1);
+#endif
+
+#if defined(SENDMSG)
+  struct iovec iov[2] = {{buf, 5}, {buf + 5, 5}};
+  struct msghdr msg;
+  msg.msg_name = addr;
+  msg.msg_namelen = addrlen;
+  msg.msg_iov = iov;
+  msg.msg_iovlen = 2;
+  msg.msg_control = 0;
+  msg.msg_controllen = 0;
+  msg.msg_flags = 0;
+#endif
+
+#if defined(SEND)
+  ret = connect(sockfd, addr, addrlen);
+  assert(ret == 0);
+  ret = send(sockfd, buf, kBufSize, 0);
+  // SEND: Uninitialized bytes in __interceptor_send at offset 7 inside [{{.*}}, 10)
+  assert(ret > 0);
+#elif defined(SENDTO)
+  ret = sendto(sockfd, buf, kBufSize, 0, addr, addrlen);
+  // SENDTO: Uninitialized bytes in __interceptor_sendto at offset 7 inside [{{.*}}, 10)
+  assert(ret > 0);
+#elif defined(SENDMSG)
+  ret = sendmsg(sockfd, &msg, 0);
+  // SENDMSG: Uninitialized bytes in {{.*}} at offset 2 inside [{{.*}}, 5)
+  assert(ret > 0);
+#endif
+  fprintf(stderr, "== done\n");
+  // NEGATIVE: == done
+  return 0;
+}

external/llvm-project/compiler-rt/test/msan/Linux/strerror_r.cc

@@ -0,0 +1,18 @@
+// RUN: %clang_msan -O0 -g %s -o %t && %run %t
+
+#include <assert.h>
+#include <errno.h>
+#include <string.h>
+
+int main() {
+  char buf[1000];
+  char *res = strerror_r(EINVAL, buf, sizeof(buf));
+  assert(res);
+  volatile int z = strlen(res);
+
+  res = strerror_r(-1, buf, sizeof(buf));
+  assert(res);
+  z = strlen(res);
+
+  return 0;
+}