Port msan_test.cc to NetBSD

[krytarowski]

Summary

The changes allows building this file on NetBSD, mostly by
disabling the unsupported functions and adding OS-specific
system includes.

Sponsored by <The NetBSD Foundation>

[vitalybuka]

lib/msan/tests/msan_test.cc

3081–3082

Could please make it:

#if defined(__FreeBSD__) 
// entire function
#elif defined(__NetBSD__)
// entire function
#elif defined(__GLIBC__)
// entire function
#else
# error "TODO: port this"
#endif

[krytarowski]

lib/msan/tests/msan_test.cc

3081–3082

There is an informal tradition to reuse the same code in FreeBSD and NetBSD, ifdefing only the MIB part.

[krytarowski]

lib/msan/tests/msan_test.cc

3081–3082

For example here:

lib/sanitizer_common/sanitizer_linux.cc-#if SANITIZER_FREEBSD || SANITIZER_NETBSD
lib/sanitizer_common/sanitizer_linux.cc-#if SANITIZER_FREEBSD
lib/sanitizer_common/sanitizer_linux.cc:  const int Mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1};
lib/sanitizer_common/sanitizer_linux.cc-#else
lib/sanitizer_common/sanitizer_linux.cc:  const int Mib[4] = {CTL_KERN, KERN_PROC_ARGS, -1, KERN_PROC_PATHNAME};
lib/sanitizer_common/sanitizer_linux.cc-#endif

I will commit it as is, and on request change it to separated functions.

lib/msan/tests/msan_test.cc

 #include <dirent.h>
 #include <pwd.h>
 #include <sys/socket.h>
 #include <netdb.h>
 #include <wordexp.h>
 #include <sys/ipc.h>
 #include <sys/shm.h>
 
-#if !defined(__FreeBSD__)
-# include <malloc.h>
-# include <sys/sysinfo.h>
-# include <sys/vfs.h>
-# include <mntent.h>
-# include <netinet/ether.h>
-# if defined(__linux__)
-#  include <sys/uio.h>
-# endif
-#else
+#if defined(__NetBSD__)
+# include <signal.h>
+# include <netinet/in.h>
+# include <sys/uio.h>
+# include <sys/mount.h>
+# include <sys/sysctl.h>
+# include <net/if.h>
+# include <net/if_ether.h>
+#elif defined(__FreeBSD__)
 # include <signal.h>
 # include <netinet/in.h>
 # include <pthread_np.h>
 # include <sys/uio.h>
 # include <sys/mount.h>
 # include <sys/sysctl.h>
 # include <net/ethernet.h>
 # define f_namelen f_namemax  // FreeBSD names this statfs field so.
 # define cpu_set_t cpuset_t
 extern "C" {
 // FreeBSD's <ssp/string.h> defines mempcpy() to be a macro expanding into
 // a __builtin___mempcpy_chk() call, but since Msan RTL defines it as an
 // ordinary function, we can declare it here to complete the tests.
 void *mempcpy(void *dest, const void *src, size_t n);
 }
+#else
+# include <malloc.h>
+# include <sys/sysinfo.h>
+# include <sys/vfs.h>
+# include <mntent.h>
+# include <netinet/ether.h>
+# if defined(__linux__)
+#  include <sys/uio.h>
+# endif
 #endif
 
 #if defined(__i386__) || defined(__x86_64__)
 # include <emmintrin.h>
 # define MSAN_HAS_M128 1
 #else
 # define MSAN_HAS_M128 0
 #endif
 
 #ifdef __AVX2__
 # include <immintrin.h>
 #endif
 
-// On FreeBSD procfs is not enabled by default.
-#if defined(__FreeBSD__)
+#if defined(__FreeBSD__) || defined(__NetBSD__)
 # define FILE_TO_READ "/bin/cat"
 # define DIR_TO_READ "/bin"
 # define SUBFILE_TO_READ "cat"
 # define SYMLINK_TO_READ "/usr/bin/tar"
 # define SUPERUSER_GROUP "wheel"
 #else
 # define FILE_TO_READ "/proc/self/stat"
 # define DIR_TO_READ "/proc/self"
TEST(MemorySanitizer, fstatat) {
   int res = fstatat(dirfd, SUBFILE_TO_READ, st, 0);
   ASSERT_EQ(0, res);
   EXPECT_NOT_POISONED(st->st_dev);
   EXPECT_NOT_POISONED(st->st_mode);
   EXPECT_NOT_POISONED(st->st_size);
   close(dirfd);
 }
 
+#if !defined(__NetBSD__)
 TEST(MemorySanitizer, statfs) {
   struct statfs st;
   int res = statfs("/", &st);
   ASSERT_EQ(0, res);
   EXPECT_NOT_POISONED(st.f_type);
   EXPECT_NOT_POISONED(st.f_bfree);
   EXPECT_NOT_POISONED(st.f_namelen);
 }
+#endif
 
 TEST(MemorySanitizer, statvfs) {
   struct statvfs st;
   int res = statvfs("/", &st);
   ASSERT_EQ(0, res);
   EXPECT_NOT_POISONED(st.f_bsize);
   EXPECT_NOT_POISONED(st.f_blocks);
   EXPECT_NOT_POISONED(st.f_bfree);
TEST(MemorySanitizer, poll) {
   ASSERT_EQ(1, res);
   EXPECT_NOT_POISONED(fds[0].revents);
   EXPECT_NOT_POISONED(fds[1].revents);
 
   close(pipefd[0]);
   close(pipefd[1]);
 }
 
-// There is no ppoll() on FreeBSD.
-#if !defined (__FreeBSD__)
+#if !defined (__FreeBSD__) && !defined (__NetBSD__)
 TEST(MemorySanitizer, ppoll) {
   int* pipefd = new int[2];
   int res = pipe(pipefd);
   ASSERT_EQ(0, res);
 
   char data = 42;
   res = write(pipefd[1], &data, 1);
   ASSERT_EQ(1, res);

 TEST(MemorySanitizer, gethostbyaddr) {
   in_addr_t addr = inet_addr("127.0.0.1");
   EXPECT_NOT_POISONED(addr);
   struct hostent *he = gethostbyaddr(&addr, sizeof(addr), AF_INET);
   ASSERT_NE((void *)NULL, he);
   EXPECT_HOSTENT_NOT_POISONED(he);
 }
 
+#if !defined(__NetBSD__)
 TEST(MemorySanitizer, gethostent_r) {
   char buf[2000];
   struct hostent he;
   struct hostent *result;
   int err;
   int res = gethostent_r(&he, buf, sizeof(buf), &result, &err);
   ASSERT_EQ(0, res);
   EXPECT_NOT_POISONED(result);
   ASSERT_NE((void *)NULL, result);
   EXPECT_HOSTENT_NOT_POISONED(result);
   EXPECT_NOT_POISONED(err);
 }
+#endif
 
+#if !defined(__NetBSD__)
 TEST(MemorySanitizer, gethostbyname_r) {
   char buf[2000];
   struct hostent he;
   struct hostent *result;
   int err;
   int res = gethostbyname_r("localhost", &he, buf, sizeof(buf), &result, &err);
   ASSERT_EQ(0, res);
   EXPECT_NOT_POISONED(result);
   ASSERT_NE((void *)NULL, result);
   EXPECT_HOSTENT_NOT_POISONED(result);
   EXPECT_NOT_POISONED(err);
 }
+#endif
 
+#if !defined(__NetBSD__)
 TEST(MemorySanitizer, gethostbyname_r_bad_host_name) {
   char buf[2000];
   struct hostent he;
   struct hostent *result;
   int err;
   int res = gethostbyname_r("bad-host-name", &he, buf, sizeof(buf), &result, &err);
   ASSERT_EQ((struct hostent *)0, result);
   EXPECT_NOT_POISONED(err);
 }
+#endif
 
+#if !defined(__NetBSD__)
 TEST(MemorySanitizer, gethostbyname_r_erange) {
   char buf[5];
   struct hostent he;
   struct hostent *result;
   int err;
   gethostbyname_r("localhost", &he, buf, sizeof(buf), &result, &err);
   ASSERT_EQ(ERANGE, errno);
   EXPECT_NOT_POISONED(err);
 }
+#endif
 
+#if !defined(__NetBSD__)
 TEST(MemorySanitizer, gethostbyname2_r) {
   char buf[2000];
   struct hostent he;
   struct hostent *result;
   int err;
   int res = gethostbyname2_r("localhost", AF_INET, &he, buf, sizeof(buf),
                              &result, &err);
   ASSERT_EQ(0, res);
   EXPECT_NOT_POISONED(result);
   ASSERT_NE((void *)NULL, result);
   EXPECT_HOSTENT_NOT_POISONED(result);
   EXPECT_NOT_POISONED(err);
 }
+#endif
 
+#if !defined(__NetBSD__)
 TEST(MemorySanitizer, gethostbyaddr_r) {
   char buf[2000];
   struct hostent he;
   struct hostent *result;
   int err;
   in_addr_t addr = inet_addr("127.0.0.1");
   EXPECT_NOT_POISONED(addr);
   int res = gethostbyaddr_r(&addr, sizeof(addr), AF_INET, &he, buf, sizeof(buf),
                             &result, &err);
   ASSERT_EQ(0, res);
   EXPECT_NOT_POISONED(result);
   ASSERT_NE((void *)NULL, result);
   EXPECT_HOSTENT_NOT_POISONED(result);
   EXPECT_NOT_POISONED(err);
 }
+#endif
 
 TEST(MemorySanitizer, getsockopt) {
   int sock = socket(AF_UNIX, SOCK_STREAM, 0);
   struct linger l[2];
   socklen_t sz = sizeof(l[0]);
   int res = getsockopt(sock, SOL_SOCKET, SO_LINGER, &l[0], &sz);
   ASSERT_EQ(0, res);
   ASSERT_EQ(sizeof(l[0]), sz);

 
 TEST(MemorySanitizer, getcwd_gnu) {
   char* res = getcwd(NULL, 0);
   ASSERT_TRUE(res != NULL);
   EXPECT_NOT_POISONED(res[0]);
   free(res);
 }
 
-// There's no get_current_dir_name() on FreeBSD.
-#if !defined(__FreeBSD__)
+#if !defined(__FreeBSD__) && !defined(__NetBSD__)
 TEST(MemorySanitizer, get_current_dir_name) {
   char* res = get_current_dir_name();
   ASSERT_TRUE(res != NULL);
   EXPECT_NOT_POISONED(res[0]);
   free(res);
 }
 #endif
 
 TEST(MemorySanitizer, shmctl) {
   int id = shmget(IPC_PRIVATE, 4096, 0644 | IPC_CREAT);
   ASSERT_GT(id, -1);
 
   struct shmid_ds ds;
   int res = shmctl(id, IPC_STAT, &ds);
   ASSERT_GT(res, -1);
   EXPECT_NOT_POISONED(ds);
 
-  // FreeBSD does not support shmctl(IPC_INFO) and shmctl(SHM_INFO).
-#if !defined(__FreeBSD__)
+#if !defined(__FreeBSD__) && !defined(__NetBSD__)
   struct shminfo si;
   res = shmctl(id, IPC_INFO, (struct shmid_ds *)&si);
   ASSERT_GT(res, -1);
   EXPECT_NOT_POISONED(si);
 
   struct shm_info s_i;
   res = shmctl(id, SHM_INFO, (struct shmid_ds *)&s_i);
   ASSERT_GT(res, -1);
TEST(MemorySanitizer, shmat) {
 
   res = shmdt(q);
   ASSERT_EQ(0, res);
 
   res = shmctl(id, IPC_RMID, 0);
   ASSERT_GT(res, -1);
 }
 
-// There's no random_r() on FreeBSD.
-#if !defined(__FreeBSD__)
+#if !defined(__FreeBSD__) && !defined(__NetBSD__)
 TEST(MemorySanitizer, random_r) {
   int32_t x;
   char z[64];
   memset(z, 0, sizeof(z));
 
   struct random_data buf;
   memset(&buf, 0, sizeof(buf));
 
TEST(MemorySanitizer, realpath_null) {
   const char* relpath = ".";
   char* res = realpath(relpath, NULL);
   printf("%d, %s\n", errno, strerror(errno));
   ASSERT_TRUE(res != NULL);
   EXPECT_NOT_POISONED(res[0]);
   free(res);
 }
 
-// There's no canonicalize_file_name() on FreeBSD.
-#if !defined(__FreeBSD__)
+#if !defined(__FreeBSD__) && !defined(__NetBSD__)
 TEST(MemorySanitizer, canonicalize_file_name) {
   const char* relpath = ".";
   char* res = canonicalize_file_name(relpath);
   ASSERT_TRUE(res != NULL);
   EXPECT_NOT_POISONED(res[0]);
   free(res);
 }
 #endif

 }
 
 TEST(MemorySanitizer, modfl) {
   long double x, y;
   x = modfl(2.1, &y);
   EXPECT_NOT_POISONED(y);
 }
 
-// There's no sincos() on FreeBSD.
-#if !defined(__FreeBSD__)
+#if !defined(__FreeBSD__) && !defined(__NetBSD__)
 TEST(MemorySanitizer, sincos) {
   double s, c;
   sincos(0.2, &s, &c);
   EXPECT_NOT_POISONED(s);
   EXPECT_NOT_POISONED(c);
 }
 #endif
 
-// There's no sincosf() on FreeBSD.
-#if !defined(__FreeBSD__)
+#if !defined(__FreeBSD__) && !defined(__NetBSD__)
 TEST(MemorySanitizer, sincosf) {
   float s, c;
   sincosf(0.2, &s, &c);
   EXPECT_NOT_POISONED(s);
   EXPECT_NOT_POISONED(c);
 }
 #endif
 
-// There's no sincosl() on FreeBSD.
-#if !defined(__FreeBSD__)
+#if !defined(__FreeBSD__) && !defined(__NetBSD__)
 TEST(MemorySanitizer, sincosl) {
   long double s, c;
   sincosl(0.2, &s, &c);
   EXPECT_NOT_POISONED(s);
   EXPECT_NOT_POISONED(c);
 }
 #endif
 

 
 TEST(MemorySanitizer, lgammaf_r) {
   int sgn;
   float res = lgammaf_r(1.1, &sgn);
   ASSERT_NE(0.0, res);
   EXPECT_NOT_POISONED(sgn);
 }
 
-// There's no lgammal_r() on FreeBSD.
-#if !defined(__FreeBSD__)
+#if !defined(__FreeBSD__) && !defined(__NetBSD__)
 TEST(MemorySanitizer, lgammal_r) {
   int sgn;
   long double res = lgammal_r(1.1, &sgn);
   ASSERT_NE(0.0, res);
   EXPECT_NOT_POISONED(sgn);
 }
 #endif
 
-// There's no drand48_r() on FreeBSD.
-#if !defined(__FreeBSD__)
+#if !defined(__FreeBSD__) && !defined(__NetBSD__)
 TEST(MemorySanitizer, drand48_r) {
   struct drand48_data buf;
   srand48_r(0, &buf);
   double d;
   drand48_r(&buf, &d);
   EXPECT_NOT_POISONED(d);
 }
 #endif
 
-// There's no lrand48_r() on FreeBSD.
-#if !defined(__FreeBSD__)
+#if !defined(__FreeBSD__) && !defined(__NetBSD__)
 TEST(MemorySanitizer, lrand48_r) {
   struct drand48_data buf;
   srand48_r(0, &buf);
   long d;
   lrand48_r(&buf, &d);
   EXPECT_NOT_POISONED(d);
 }
 #endif
TEST(MemorySanitizer, localtime_r) {
   ASSERT_TRUE(res != NULL);
   EXPECT_NOT_POISONED(time.tm_sec);
   EXPECT_NOT_POISONED(time.tm_hour);
   EXPECT_NOT_POISONED(time.tm_year);
   EXPECT_NOT_POISONED(time.tm_isdst);
   EXPECT_NE(0U, strlen(time.tm_zone));
 }
 
-#if !defined(__FreeBSD__)
+#if !defined(__FreeBSD__) && !defined(__NetBSD__)
 /* Creates a temporary file with contents similar to /etc/fstab to be used
    with getmntent{_r}.  */
 class TempFstabFile {
  public:
    TempFstabFile() : fd (-1) { }
    ~TempFstabFile() {
      if (fd >= 0)
        close (fd);
public:
    }
 
  private:
   char tmpfile[128];
   int fd;
 };
 #endif
 
-// There's no getmntent() on FreeBSD.
-#if !defined(__FreeBSD__)
+#if !defined(__FreeBSD__) && !defined(__NetBSD__)
 TEST(MemorySanitizer, getmntent) {
   TempFstabFile fstabtmp;
   ASSERT_TRUE(fstabtmp.Create());
   FILE *fp = setmntent(fstabtmp.FileName(), "r");
 
   struct mntent *mnt = getmntent(fp);
   ASSERT_TRUE(mnt != NULL);
   ASSERT_NE(0U, strlen(mnt->mnt_fsname));
   ASSERT_NE(0U, strlen(mnt->mnt_dir));
   ASSERT_NE(0U, strlen(mnt->mnt_type));
   ASSERT_NE(0U, strlen(mnt->mnt_opts));
   EXPECT_NOT_POISONED(mnt->mnt_freq);
   EXPECT_NOT_POISONED(mnt->mnt_passno);
   fclose(fp);
 }
 #endif
 
-// There's no getmntent_r() on FreeBSD.
-#if !defined(__FreeBSD__)
+#if !defined(__FreeBSD__) && !defined(__NetBSD__)
 TEST(MemorySanitizer, getmntent_r) {
   TempFstabFile fstabtmp;
   ASSERT_TRUE(fstabtmp.Create());
   FILE *fp = setmntent(fstabtmp.FileName(), "r");
 
   struct mntent mntbuf;
   char buf[1000];
   struct mntent *mnt = getmntent_r(fp, &mntbuf, buf, sizeof(buf));
   ASSERT_TRUE(mnt != NULL);
   ASSERT_NE(0U, strlen(mnt->mnt_fsname));
   ASSERT_NE(0U, strlen(mnt->mnt_dir));
   ASSERT_NE(0U, strlen(mnt->mnt_type));
   ASSERT_NE(0U, strlen(mnt->mnt_opts));
   EXPECT_NOT_POISONED(mnt->mnt_freq);
   EXPECT_NOT_POISONED(mnt->mnt_passno);
   fclose(fp);
 }
 #endif
 
+#if !defined(__NetBSD__)
 TEST(MemorySanitizer, ether) {
   const char *asc = "11:22:33:44:55:66";
   struct ether_addr *paddr = ether_aton(asc);
   EXPECT_NOT_POISONED(*paddr);
 
   struct ether_addr addr;
   paddr = ether_aton_r(asc, &addr);
   ASSERT_EQ(paddr, &addr);
   EXPECT_NOT_POISONED(addr);
 
   char *s = ether_ntoa(&addr);
   ASSERT_NE(0U, strlen(s));
 
   char buf[100];
   s = ether_ntoa_r(&addr, buf);
   ASSERT_EQ(s, buf);
   ASSERT_NE(0U, strlen(buf));
 }
+#endif
 
 TEST(MemorySanitizer, mmap) {
   const int size = 4096;
   void *p1, *p2;
   p1 = mmap(0, size, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANON, -1, 0);
   __msan_poison(p1, size);
   munmap(p1, size);
   for (int i = 0; i < 1000; i++) {
     p2 = mmap(0, size, PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANON, -1, 0);
     if (p2 == p1)
       break;
     else
       munmap(p2, size);
   }
   if (p1 == p2) {
     EXPECT_NOT_POISONED(*(char*)p2);
     munmap(p2, size);
   }
 }
 
-// There's no fcvt() on FreeBSD.
-#if !defined(__FreeBSD__)
+#if !defined(__FreeBSD__) && !defined(__NetBSD__)
 // FIXME: enable and add ecvt.
 // FIXME: check why msandr does nt handle fcvt.
 TEST(MemorySanitizer, fcvt) {
   int a, b;
   break_optimization(&a);
   break_optimization(&b);
   EXPECT_POISONED(a);
   EXPECT_POISONED(b);
   char *str = fcvt(12345.6789, 10, &a, &b);
   EXPECT_NOT_POISONED(a);
   EXPECT_NOT_POISONED(b);
   ASSERT_NE(nullptr, str);
   EXPECT_NOT_POISONED(str[0]);
   ASSERT_NE(0U, strlen(str));
 }
 #endif
 
-// There's no fcvt_long() on FreeBSD.
-#if !defined(__FreeBSD__)
+#if !defined(__FreeBSD__) && !defined(__NetBSD__)
 TEST(MemorySanitizer, fcvt_long) {
   int a, b;
   break_optimization(&a);
   break_optimization(&b);
   EXPECT_POISONED(a);
   EXPECT_POISONED(b);
   char *str = fcvt(111111112345.6789, 10, &a, &b);
   EXPECT_NOT_POISONED(a);

 
 static int cnt;
 
 void SigactionHandler(int signo, siginfo_t* si, void* uc) {
   ASSERT_EQ(signo, SIGPROF);
   ASSERT_TRUE(si != NULL);
   EXPECT_NOT_POISONED(si->si_errno);
   EXPECT_NOT_POISONED(si->si_pid);
-#if __linux__
-# if defined(__x86_64__)
+#ifdef _UC_MACHINE_PC
+  EXPECT_NOT_POISONED(_UC_MACHINE_PC((ucontext_t*)uc));
+#else
+# if __linux__
+#  if defined(__x86_64__)
   EXPECT_NOT_POISONED(((ucontext_t*)uc)->uc_mcontext.gregs[REG_RIP]);
-# elif defined(__i386__)
+#  elif defined(__i386__)
   EXPECT_NOT_POISONED(((ucontext_t*)uc)->uc_mcontext.gregs[REG_EIP]);
-# endif
-#endif
+#  endif
+# endif
+#endif
   ++cnt;
 }
 
 TEST(MemorySanitizer, sigaction) {
   struct sigaction act = {};
   struct sigaction oldact = {};
   struct sigaction origact = {};
 
TEST(MemorySanitizer, LongStruct) {
   EXPECT_NOT_POISONED(s2.b8);
 
   EXPECT_POISONED(s2.a1);
   EXPECT_POISONED(s2.a2);
   EXPECT_POISONED(s2.a4);
   EXPECT_POISONED(s2.a8);
 }
 
-#ifdef __GLIBC__
+#if defined(__NetBSD__)
+#define MSAN_TEST_PRLIMIT 0
+#elif defined(__GLIBC__)
 #define MSAN_TEST_PRLIMIT __GLIBC_PREREQ(2, 13)
 #else
 #define MSAN_TEST_PRLIMIT 1
 #endif
 
 TEST(MemorySanitizer, getrlimit) {
   struct rlimit limit;
   __msan_poison(&limit, sizeof(limit));
TEST(MemorySanitizer, getrusage) {
   EXPECT_NOT_POISONED(usage.ru_minflt);
   EXPECT_NOT_POISONED(usage.ru_majflt);
   EXPECT_NOT_POISONED(usage.ru_inblock);
   EXPECT_NOT_POISONED(usage.ru_oublock);
   EXPECT_NOT_POISONED(usage.ru_nvcsw);
   EXPECT_NOT_POISONED(usage.ru_nivcsw);
 }
 
-#if defined(__FreeBSD__)
+#if defined(__FreeBSD__) || defined(__NetBSD__)
 static void GetProgramPath(char *buf, size_t sz) {
+#if defined(__FreeBSD__)
   int mib[4] = { CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1 };
+#elif defined(__NetBSD__)
+  int mib[4] = { CTL_KERN, KERN_PROC_ARGS, -1, KERN_PROC_PATHNAME};
+#endif
   int res = sysctl(mib, 4, buf, &sz, NULL, 0);
   ASSERT_EQ(0, res);
 }
 #elif defined(__GLIBC__)
 static void GetProgramPath(char *buf, size_t sz) {
   extern char *program_invocation_name;
   int res = snprintf(buf, sz, "%s", program_invocation_name);
   ASSERT_GE(res, 0);

 TEST(MemorySanitizer, dlopenFailed) {
   const char *path = "/libmsan_loadable_does_not_exist.so";
   void *lib = dlopen(path, RTLD_LAZY);
   ASSERT_TRUE(lib == NULL);
 }
 
 #endif // MSAN_TEST_DISABLE_DLOPEN
 
-// There's no sched_getaffinity() on FreeBSD.
-#if !defined(__FreeBSD__)
+#if !defined(__FreeBSD__) && !defined(__NetBSD__)
 TEST(MemorySanitizer, sched_getaffinity) {
   cpu_set_t mask;
   int res = sched_getaffinity(getpid(), sizeof(mask), &mask);
   ASSERT_EQ(0, res);
   EXPECT_NOT_POISONED(mask);
 }
 #endif
 
TEST(MemorySanitizer, pthread_attr_get) {
   {
     void *v;
     size_t w;
     res = pthread_attr_getstack(&attr, &v, &w);
     ASSERT_EQ(0, res);
     EXPECT_NOT_POISONED(v);
     EXPECT_NOT_POISONED(w);
   }
+#if !defined(__NetBSD__)
   {
     cpu_set_t v;
     res = pthread_attr_getaffinity_np(&attr, sizeof(v), &v);
     ASSERT_EQ(0, res);
     EXPECT_NOT_POISONED(v);
   }
+#endif
   res = pthread_attr_destroy(&attr);
   ASSERT_EQ(0, res);
 }
 
 TEST(MemorySanitizer, pthread_getschedparam) {
   int policy;
   struct sched_param param;
   int res = pthread_getschedparam(pthread_self(), &policy, &param);
TEST(MemorySanitizer, posix_memalign) {
   EXPECT_POISONED(p);
   int res = posix_memalign(&p, 4096, 13);
   ASSERT_EQ(0, res);
   EXPECT_NOT_POISONED(p);
   EXPECT_EQ(0U, (uintptr_t)p % 4096);
   free(p);
 }
 
-// There's no memalign() on FreeBSD.
-#if !defined(__FreeBSD__)
+#if !defined(__FreeBSD__) && !defined(__NetBSD__)
 TEST(MemorySanitizer, memalign) {
   void *p = memalign(4096, 13);
   EXPECT_EQ(0U, (uintptr_t)p % 4096);
   free(p);
 }
 #endif
 
 TEST(MemorySanitizer, valloc) {
   void *a = valloc(100);
   uintptr_t PageSize = GetPageSize();
   EXPECT_EQ(0U, (uintptr_t)a % PageSize);
   free(a);
 }
 
-// There's no pvalloc() on FreeBSD.
-#if !defined(__FreeBSD__)
+#if !defined(__FreeBSD__) && !defined(__NetBSD__)
 TEST(MemorySanitizer, pvalloc) {
   uintptr_t PageSize = GetPageSize();
   void *p = pvalloc(PageSize + 100);
   EXPECT_EQ(0U, (uintptr_t)p % PageSize);
   EXPECT_EQ(2 * PageSize, __sanitizer_get_allocated_size(p));
   free(p);
 
   p = pvalloc(0);  // pvalloc(0) should allocate at least one page.

 
 TEST(MemorySanitizer, gethostname) {
   char buf[100];
   int res = gethostname(buf, 100);
   ASSERT_EQ(0, res);
   EXPECT_NOT_POISONED(strlen(buf));
 }
 
-// There's no sysinfo() on FreeBSD.
-#if !defined(__FreeBSD__)
+#if !defined(__FreeBSD__) && !defined(__NetBSD__)
 TEST(MemorySanitizer, sysinfo) {
   struct sysinfo info;
   int res = sysinfo(&info);
   ASSERT_EQ(0, res);
   EXPECT_NOT_POISONED(info);
 }
 #endif
 
TEST(MemorySanitizer, getpwent_r) {
   ASSERT_EQ(0, res);
   EXPECT_NOT_POISONED(pwd.pw_name);
   ASSERT_TRUE(pwd.pw_name != NULL);
   EXPECT_NOT_POISONED(pwd.pw_name[0]);
   EXPECT_NOT_POISONED(pwd.pw_uid);
   EXPECT_NOT_POISONED(pwdres);
 }
 
-// There's no fgetpwent() on FreeBSD.
-#if !defined(__FreeBSD__)
+#if !defined(__FreeBSD__) && !defined(__NetBSD__)
 TEST(MemorySanitizer, fgetpwent) {
   FILE *fp = fopen("/etc/passwd", "r");
   struct passwd *p = fgetpwent(fp);
   ASSERT_TRUE(p != NULL);
   EXPECT_NOT_POISONED(p->pw_name);
   ASSERT_TRUE(p->pw_name != NULL);
   EXPECT_NOT_POISONED(p->pw_name[0]);
   EXPECT_NOT_POISONED(p->pw_uid);
   fclose(fp);
 }
 #endif
 
 TEST(MemorySanitizer, getgrent) {
   setgrent();
   struct group *p = getgrent();
   ASSERT_TRUE(p != NULL);
   EXPECT_NOT_POISONED(p->gr_name);
   ASSERT_TRUE(p->gr_name != NULL);
   EXPECT_NOT_POISONED(p->gr_name[0]);
   EXPECT_NOT_POISONED(p->gr_gid);
 }
 
-// There's no fgetgrent() on FreeBSD.
-#if !defined(__FreeBSD__)
+#if !defined(__FreeBSD__) && !defined(__NetBSD__)
 TEST(MemorySanitizer, fgetgrent) {
   FILE *fp = fopen("/etc/group", "r");
   struct group *grp = fgetgrent(fp);
   ASSERT_TRUE(grp != NULL);
   EXPECT_NOT_POISONED(grp->gr_name);
   ASSERT_TRUE(grp->gr_name != NULL);
   EXPECT_NOT_POISONED(grp->gr_name[0]);
   EXPECT_NOT_POISONED(grp->gr_gid);
TEST(MemorySanitizer, getgrent_r) {
   ASSERT_EQ(0, res);
   EXPECT_NOT_POISONED(grp.gr_name);
   ASSERT_TRUE(grp.gr_name != NULL);
   EXPECT_NOT_POISONED(grp.gr_name[0]);
   EXPECT_NOT_POISONED(grp.gr_gid);
   EXPECT_NOT_POISONED(grpres);
 }
 
-// There's no fgetgrent_r() on FreeBSD and NetBSD.
 #if !defined(__FreeBSD__) && !defined(__NetBSD__)
 TEST(MemorySanitizer, fgetgrent_r) {
   FILE *fp = fopen("/etc/group", "r");
   struct group grp;
   struct group *grpres;
   char buf[10000];
   setgrent();
   int res = fgetgrent_r(fp, &grp, buf, sizeof(buf), &grpres);
void MemCpyTest() {
   __msan_set_origin(y, N * sizeof(T), 777777);
   __msan_set_origin(z, N * sizeof(T), 888888);
   EXPECT_NOT_POISONED(x);
   memcpy(y, x, N * sizeof(T));
   EXPECT_POISONED_O(y[0], ox);
   EXPECT_POISONED_O(y[N/2], ox);
   EXPECT_POISONED_O(y[N-1], ox);
   EXPECT_NOT_POISONED(x);
+#if !defined(__NetBSD__)
   void *res = mempcpy(q, x, N * sizeof(T));
   ASSERT_EQ(q + N, res);
   EXPECT_POISONED_O(q[0], ox);
   EXPECT_POISONED_O(q[N/2], ox);
   EXPECT_POISONED_O(q[N-1], ox);
   EXPECT_NOT_POISONED(x);
+#endif
   memmove(z, x, N * sizeof(T));
   EXPECT_POISONED_O(z[0], ox);
   EXPECT_POISONED_O(z[N/2], ox);
   EXPECT_POISONED_O(z[N-1], ox);
 }
 
 TEST(MemorySanitizerOrigins, LargeMemCpy) {
   if (!TrackingOrigins()) return;