Add NetBSD support in sanitizer_platform_limits_posix.*

[krytarowski]

Summary

NetBSD is a BSD Operating System, close to FreeBSD, however with distinct interfaces that
were diverged over 20 years ago.

Part of the code inspired by the original work on libsanitizer in GCC 5.4 by Christos Zoulas.

Sponsored by <The NetBSD Foundation>

[joerg]

lib/sanitizer_common/sanitizer_platform_limits_posix.h

33

dlinfo with RTLD_DI_LINKMAP?

232

Why is this duplicating random sets of system headers? Just for using syscall(2) directly? Ugly.

[filcab]

lib/sanitizer_common/sanitizer_platform_limits_posix.h

228

These seem to be roughly the same as the Linux/FreeBSD ones assuming the supported platforms use LP64 (not ILP64). Can't we just share the definition?

If you're planning on enabling the sanitizers on some non LP64 target on NetBSD, may I suggest delaying that architecture, and making sure we work properly on x86/x86-64/arm/arm64/some other platform already supported by Linux, and only then do we add #ifdefs for those "weirder" platforms.

Add something like this if you want a loud error:

#if SANITIZER_NETBSD && !defined(_LP64)
#error Not supported yet!
#endif

You might also be able to merge the __sanitizer_iocb definitions for NetBSD (but not with Linux) is you use fd_t, int, etc. But I'm not 100% sure on that one.

232

They can be used in syscall interceptors.

235

Maybe uptr data[5]? That way you won't need to have two defs.

458

I wonder if doing the same I suggested above (Doing _LP64 platforms first) will be easier to get the patches reviewed+accepted, and then you'd need some smaller changes which will be easier to understand to make it support non LP64 platforms.

472

Why are you changing non NetBSD code? It was already int pw_uid.

695

Seems like it could be shared with FreeBSD, assuming FreeBSD sanitizers only support LP64.
Is the NetBSD definition using u32 on its system headers?

751

Please don't do simple formatting changes in this patch.

973

FreeBSD doesn't seem to need this. Does NetBSD need it?

[krytarowski]

lib/sanitizer_common/sanitizer_platform_limits_posix.h

33

I've followed: reviews.llvm.org/D7233

228

I will try to merge it. Right now we support only regular ABIs.

235

OK.

458

NetBSD always has long long type of time_t regardless of ABI.

472

I will recheck it.

695

typedef struct {
        __uint32_t      __bits[4];
} sigset_t;

• sys/sigtypes.h

Right now I can merge it with FreeBSD.

751

OK

973

FreeBSD has ported it.

ubsan/asan can work without it as of now.

[krytarowski]

Apply changes from review.

[filcab]

lib/sanitizer_common/sanitizer_platform_limits_posix.cc

296

Setting these to -1 looks weird. Can you at least add a small comment? I'm assuming these simply don't exist on NetBSD.

lib/sanitizer_common/sanitizer_platform_limits_posix.h

124

Stray change.

185

Maybe use uptr (Or char*) for aio_buf and long for aio_nbytes and others below?
It seems you can merge these two platforms.

194

There's more than one of these. Right now you're just dealing with x86 and x86_64, so why not just have one #error at the start of the file if you need to, and then not have these cases?

973

If this is set to 0, can't you just use the #else case, which defined __sanitizer_FILE to void?

[krytarowski]

lib/sanitizer_common/sanitizer_platform_limits_posix.cc

296

These interfaces are absent on NetBSD.

lib/sanitizer_common/sanitizer_platform_limits_posix.h

124

I will fix it.

185

I will go for it.

194

It will be gone with the above change.

973

I don't recall right now if I needed to have __sanitizer_FILE != void to make it buildable/functional... but for now I will go for it now.

It will be ported in future.

[krytarowski]

Apply changes from review.

[krytarowski]

@filcab done.

[krytarowski]

ping?

[glider]

A couple of drive-by comments.

lib/sanitizer_common/sanitizer_platform_limits_posix.h

30

Can you please wrap this line into a macro that takes handle and offset and returns the link_map* ?

54

I suggest we always keep SANITIZER_FREEBSD and SANITIZER_NETBSD together in the ifdefs:
!SANITIZER_FREEBSD && !SANITIZER_NETBSD && !SANITIZER_IOS

By the way, do we need a special SANITIZER_BSD for the common BSD-specific cases?
I guess in many cases SANITIZER_FREEBSD || SANITIZER_NETBSD also means "or other BSD system"

79

Please change this to "#if !SANITIZER_ANDROID && !SANITIZER_NETBSD"

609–610

Please fix the comment.

724–733

Please fix the comment.

[krytarowski]

lib/sanitizer_common/sanitizer_platform_limits_posix.h

54

I think that we should keep alphabetical order, both systems diverged over 20 years ago and besides common ancestors decades ago, they are different. Linux adopted BSD interfaces too (like ptrace(2)).

SANITIZER_BSD has no point in my opinion. Pretending that something is BSD-flavor and defining it as a standard is a losing battle, we all are struggling to be compatible with POSIX. Old interfaces over they years were refactored, deprecated, replaced, abandoned, reinvented etc. We will end up with SANITIZER_BSD && !SANITIZER_OPENBSD and similar.

[krytarowski]

Apply changes from review.

[krytarowski]

This is the last patch needed for common-sanitizer on NetBSD.

I've closed existing comments to help to keep track on changes.

[krytarowski]

ASAN, UBSAN and SAFESTACK are already committed.

More to come soon. This diff blocks them all from building.

[krytarowski]

ping

[krytarowski]

Ping x2

[krytarowski]

I plan to go on vacations during September, if there are no more comments I will commit it as it is in the coming week.

[kcc]

This patch has too many #ifdefs.
#ifdefs cause maintenance nightmare.
Instead of #ifdefs, can you move the code to separate *netbsd*.[h,cpp] files?

[krytarowski]

In D35554#853339, @kcc wrote:

This patch has too many #ifdefs.
#ifdefs cause maintenance nightmare.
Instead of #ifdefs, can you move the code to separate *netbsd*.[h,cpp] files?

I've submitted it as a new diff: D37193.

lib/sanitizer_common/sanitizer_platform_limits_posix.h

 //===----------------------------------------------------------------------===//
 
 #ifndef SANITIZER_PLATFORM_LIMITS_POSIX_H
 #define SANITIZER_PLATFORM_LIMITS_POSIX_H
 
 #include "sanitizer_internal_defs.h"
 #include "sanitizer_platform.h"
 
+#define _GET_LINK_MAP_BY_DLOPEN_HANDLE(handle, shift) \
+  ((link_map *)((handle) == nullptr ? nullptr : ((char *)(handle) + (shift))))
+
+// FreeBSD's and NetBSD's dlopen() returns a pointer to an Obj_Entry structure
+// that incorporates the map structure.
 #if SANITIZER_FREEBSD
-// FreeBSD's dlopen() returns a pointer to an Obj_Entry structure that
-// incorporates the map structure.
-# define GET_LINK_MAP_BY_DLOPEN_HANDLE(handle) \
-    ((link_map*)((handle) == nullptr ? nullptr : ((char*)(handle) + 544)))
-// Get sys/_types.h, because that tells us whether 64-bit inodes are
-// used in struct dirent below.
-#include <sys/_types.h>
+#define GET_LINK_MAP_BY_DLOPEN_HANDLE(handle) \
+  _GET_LINK_MAP_BY_DLOPEN_HANDLE(handle, 544)
+#elif SANITIZER_NETBSD
+#if defined(__x86_64__)
+#define GET_LINK_MAP_BY_DLOPEN_HANDLE(handle) \
+  _GET_LINK_MAP_BY_DLOPEN_HANDLE(handle, 608)
+#elif defined(__i386__)
+#define GET_LINK_MAP_BY_DLOPEN_HANDLE(handle) \
+  _GET_LINK_MAP_BY_DLOPEN_HANDLE(handle, 324)
+#endif
 #else
 # define GET_LINK_MAP_BY_DLOPEN_HANDLE(handle) ((link_map*)(handle))
 #endif  // !SANITIZER_FREEBSD
 
+#if SANITIZER_FREEBSD
+// Get sys/_types.h, because that tells us whether 64-bit inodes are
+// used in struct dirent below.
+#include <sys/_types.h>
+#endif
+
 #ifndef __GLIBC_PREREQ
 #define __GLIBC_PREREQ(x, y) 0
 #endif
 
 namespace __sanitizer {
   extern unsigned struct_utsname_sz;
   extern unsigned struct_stat_sz;
-#if !SANITIZER_FREEBSD && !SANITIZER_IOS
+#if !SANITIZER_FREEBSD && !SANITIZER_IOS && !SANITIZER_NETBSD
   extern unsigned struct_stat64_sz;
 #endif
   extern unsigned struct_rusage_sz;
   extern unsigned siginfo_t_sz;
   extern unsigned struct_itimerval_sz;
   extern unsigned pthread_t_sz;
   extern unsigned pthread_cond_t_sz;
   extern unsigned pid_t_sz;
   extern unsigned timeval_sz;
   extern unsigned uid_t_sz;
   extern unsigned gid_t_sz;
   extern unsigned mbstate_t_sz;
   extern unsigned struct_timezone_sz;
   extern unsigned struct_tms_sz;
   extern unsigned struct_itimerspec_sz;
   extern unsigned struct_sigevent_sz;
   extern unsigned struct_sched_param_sz;
+#if !SANITIZER_NETBSD
   extern unsigned struct_statfs64_sz;
+#endif
 
+#if !SANITIZER_ANDROID && !SANITIZER_NETBSD
+  extern unsigned struct_statfs_sz;
+#endif
 #if !SANITIZER_ANDROID
   extern unsigned struct_statfs_sz;
   extern unsigned struct_sockaddr_sz;
   extern unsigned ucontext_t_sz;
 #endif // !SANITIZER_ANDROID
 
 #if SANITIZER_LINUX
 
 #if defined(__x86_64__)
#endif
   extern unsigned struct_new_utsname_sz;
   extern unsigned struct_old_utsname_sz;
   extern unsigned struct_oldold_utsname_sz;
 
   const unsigned struct_kexec_segment_sz = 4 * sizeof(unsigned long);
 #endif  // SANITIZER_LINUX
 
 #if SANITIZER_LINUX || SANITIZER_FREEBSD
 
 #if defined(__powerpc64__) || defined(__s390__)
   const unsigned struct___old_kernel_stat_sz = 0;
 #elif !defined(__sparc__)
   const unsigned struct___old_kernel_stat_sz = 32;
 #endif
+#endif  // SANITIZER_LINUX || SANITIZER_FREEBSD
+
+#if SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD
 
   extern unsigned struct_rlimit_sz;
   extern unsigned struct_utimbuf_sz;
   extern unsigned struct_timespec_sz;
 
   struct __sanitizer_iocb {
+#if SANITIZER_LINUX || SANITIZER_FREEBSD
     u64   aio_data;
     u32   aio_key_or_aio_reserved1; // Simply crazy.
     u32   aio_reserved1_or_aio_key; // Luckily, we don't need these.
     u16   aio_lio_opcode;
     s16   aio_reqprio;
     u32   aio_fildes;
     u64   aio_buf;
     u64   aio_nbytes;
     s64   aio_offset;
     u64   aio_reserved2;
     u64   aio_reserved3;
+#elif SANITIZER_NETBSD
+    u64 aio_offset;
+    uptr aio_buf;
+    long aio_nbytes;
+    u32 aio_fildes;
+    u32 aio_lio_opcode;
+    long aio_reqprio;
+#if _LP64
+    u8 aio_sigevent[32];
+#else
+    u8 aio_sigevent[20];
+#endif
+    u32 _state;
+    u32 _errno;
+    long _retval;
+#endif
   };
+#endif
 
+#if SANITIZER_LINUX || SANITIZER_FREEBSD
   struct __sanitizer_io_event {
     u64 data;
     u64 obj;
     u64 res;
     u64 res2;
   };
+#endif
 
+#if SANITIZER_LINUX || SANITIZER_FREEBSD
   const unsigned iocb_cmd_pread = 0;
   const unsigned iocb_cmd_pwrite = 1;
   const unsigned iocb_cmd_preadv = 7;
   const unsigned iocb_cmd_pwritev = 8;
+#endif
 
   struct __sanitizer___sysctl_args {
     int *name;
     int nlen;
     void *oldval;
     uptr *oldlenp;
     void *newval;
     uptr newlen;
+#if SANITIZER_LINUX || SANITIZER_FREEBSD
     unsigned long ___unused[4];
+#endif
   };
 
+#if SANITIZER_LINUX || SANITIZER_FREEBSD
   const unsigned old_sigset_t_sz = sizeof(unsigned long);
+#endif
 
+#if SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD
   struct __sanitizer_sem_t {
 #if SANITIZER_ANDROID && defined(_LP64)
     int data[4];
 #elif SANITIZER_ANDROID && !defined(_LP64)
     int data;
 #elif SANITIZER_LINUX
     uptr data[4];
 #elif SANITIZER_FREEBSD
     u32 data[4];
+#elif SANITIZER_NETBSD
+    uptr data[5];
 #endif
   };
-#endif // SANITIZER_LINUX || SANITIZER_FREEBSD
+#endif  // SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD
 
 #if SANITIZER_ANDROID
   struct __sanitizer_mallinfo {
     uptr v[10];
   };
 #endif
 
 #if SANITIZER_LINUX && !SANITIZER_ANDROID
struct __sanitizer_shmid_ds {
     unsigned long shm_segsz;
     unsigned int shm_lpid;
     unsigned int shm_cpid;
     int shm_nattch;
     unsigned long shm_atime;
     unsigned long shm_dtime;
     unsigned long shm_ctime;
   };
+
+#elif SANITIZER_NETBSD
+  struct __sanitizer_ipc_perm {
+    u32 uid;
+    u32 gid;
+    u32 cuid;
+    u32 cgid;
+    u32 mode;
+    unsigned short _seq;
+    long _key;
+  };
+
+  struct __sanitizer_shmid_ds {
+    __sanitizer_ipc_perm shm_perm;
+    unsigned long shm_segsz;
+    u32 shm_lpid;
+    u32 shm_cpid;
+    unsigned int shm_nattch;
+    u64 shm_atime;
+    u64 shm_dtime;
+    u64 shm_ctime;
+    void *_shm_internal;
+  };
 #endif
 
-#if (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID
+#if (SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD) && \
+    !SANITIZER_ANDROID
   extern unsigned struct_msqid_ds_sz;
   extern unsigned struct_mq_attr_sz;
   extern unsigned struct_timex_sz;
   extern unsigned struct_statvfs_sz;
-#endif  // (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID
+#endif  // (SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD) &&
+        // !SANITIZER_ANDROID
 
   struct __sanitizer_iovec {
     void *iov_base;
     uptr iov_len;
   };
 
 #if !SANITIZER_ANDROID
   struct __sanitizer_ifaddrs {
     struct __sanitizer_ifaddrs *ifa_next;
     char *ifa_name;
     unsigned int ifa_flags;
     void *ifa_addr;    // (struct sockaddr *)
     void *ifa_netmask; // (struct sockaddr *)
     // This is a union on Linux.
 # ifdef ifa_dstaddr
 # undef ifa_dstaddr
 # endif
     void *ifa_dstaddr; // (struct sockaddr *)
     void *ifa_data;
+#if SANITIZER_NETBSD
+    unsigned int ifa_addrflags;
+#endif
   };
 #endif  // !SANITIZER_ANDROID
 
 #if SANITIZER_MAC
   typedef unsigned long __sanitizer_pthread_key_t;
 #else
   typedef unsigned __sanitizer_pthread_key_t;
 #endif
struct __sanitizer_XDR {
     unsigned x_handy;
   };
 
   const int __sanitizer_XDR_ENCODE = 0;
   const int __sanitizer_XDR_DECODE = 1;
   const int __sanitizer_XDR_FREE = 2;
 #endif
 
+#if SANITIZER_NETBSD || (defined(__x86_64__) && !defined(_LP64))
+  typedef long long __sanitizer_time_t;
+#else
+  typedef long __sanitizer_time_t;
+#endif
+
   struct __sanitizer_passwd {
     char *pw_name;
     char *pw_passwd;
     int pw_uid;
     int pw_gid;
-#if SANITIZER_MAC || SANITIZER_FREEBSD
-    long pw_change;
+#if SANITIZER_MAC || SANITIZER_FREEBSD || SANITIZER_NETBSD
+    __sanitizer_time_t pw_change;
     char *pw_class;
 #endif
 #if !(SANITIZER_ANDROID && (SANITIZER_WORDSIZE == 32))
     char *pw_gecos;
 #endif
     char *pw_dir;
     char *pw_shell;
-#if SANITIZER_MAC || SANITIZER_FREEBSD
-    long pw_expire;
+#if SANITIZER_MAC || SANITIZER_FREEBSD || SANITIZER_NETBSD
+    __sanitizer_time_t pw_expire;
 #endif
 #if SANITIZER_FREEBSD
     int pw_fields;
 #endif
   };
 
   struct __sanitizer_group {
     char *gr_name;
     char *gr_passwd;
     int gr_gid;
     char **gr_mem;
   };
 
-#if defined(__x86_64__) && !defined(_LP64)
-  typedef long long __sanitizer_time_t;
-#else
-  typedef long __sanitizer_time_t;
-#endif
-
   struct __sanitizer_timeb {
     __sanitizer_time_t time;
     unsigned short millitm;
     short timezone;
     short dstflag;
   };
 
   struct __sanitizer_ether_addr {
struct __sanitizer_mntent {
     char *mnt_dir;
     char *mnt_type;
     char *mnt_opts;
     int mnt_freq;
     int mnt_passno;
   };
 #endif
 
-#if SANITIZER_MAC || SANITIZER_FREEBSD
+#if SANITIZER_MAC || SANITIZER_FREEBSD || SANITIZER_NETBSD
   struct __sanitizer_msghdr {
     void *msg_name;
     unsigned msg_namelen;
     struct __sanitizer_iovec *msg_iov;
     unsigned msg_iovlen;
     void *msg_control;
     unsigned msg_controllen;
     int msg_flags;
#if defined(__INO64)
     unsigned long long d_fileno;
     unsigned long long d_off;
 #else
     unsigned int d_fileno;
 #endif
     unsigned short d_reclen;
     // more fields that we don't care about
   };
+#elif SANITIZER_NETBSD
+  struct __sanitizer_dirent {
+    u64 d_fileno;
+    u16 d_reclen;
+    // more fields that we don't care about
+  };
 #elif SANITIZER_ANDROID || defined(__x86_64__)
   struct __sanitizer_dirent {
     unsigned long long d_ino;
     unsigned long long d_off;
     unsigned short d_reclen;
     // more fields that we don't care about
   };
 #else
   struct __sanitizer_dirent {
     uptr d_ino;
     uptr d_off;
     unsigned short d_reclen;
     // more fields that we don't care about
   };
 #endif
 
 #if SANITIZER_LINUX && !SANITIZER_ANDROID
   struct __sanitizer_dirent64 {
     unsigned long long d_ino;
     unsigned long long d_off;
     unsigned short d_reclen;
     // more fields that we don't care about
   };
 #endif
 
-// 'clock_t' is 32 bits wide on x64 FreeBSD
-#if SANITIZER_FREEBSD
+#if SANITIZER_FREEBSD || SANITIZER_NETBSD
   typedef int __sanitizer_clock_t;
 #elif defined(__x86_64__) && !defined(_LP64)
   typedef long long __sanitizer_clock_t;
 #else
   typedef long __sanitizer_clock_t;
 #endif
 
-#if SANITIZER_LINUX
+#if SANITIZER_LINUX || SANITIZER_NETBSD
   typedef int __sanitizer_clockid_t;
 #endif
 
 #if SANITIZER_LINUX || SANITIZER_FREEBSD
 #if defined(_LP64) || defined(__x86_64__) || defined(__powerpc__)\
                    || defined(__mips__)
   typedef unsigned __sanitizer___kernel_uid_t;
   typedef unsigned __sanitizer___kernel_gid_t;
#else
   typedef unsigned short __sanitizer___kernel_old_uid_t;
   typedef unsigned short __sanitizer___kernel_old_gid_t;
 #endif
 
   typedef long long __sanitizer___kernel_loff_t;
   typedef struct {
     unsigned long fds_bits[1024 / (8 * sizeof(long))];
   } __sanitizer___kernel_fd_set;
+#elif SANITIZER_NETBSD
+  typedef u32 __sanitizer___kernel_uid_t;
+  typedef u32 __sanitizer___kernel_gid_t;
+  typedef u64 __sanitizer___kernel_off_t;
+  typedef struct {
+    u32 fds_bits[8];
+  } __sanitizer___kernel_fd_set;
 #endif
 
+#if SANITIZER_NETBSD
+  typedef struct {
+    unsigned int pta_magic;
+    int pta_flags;
+    void *pta_private;
+  } __sanitizer_pthread_attr_t;
+#else
   // This thing depends on the platform. We are only interested in the upper
   // limit. Verified with a compiler assert in .cc.
   const int pthread_attr_t_max_sz = 128;
   union __sanitizer_pthread_attr_t {
     char size[pthread_attr_t_max_sz]; // NOLINT
     void *align;
   };
+#endif
 
 #if SANITIZER_ANDROID
 # if SANITIZER_MIPS
   typedef unsigned long __sanitizer_sigset_t[16/sizeof(unsigned long)];
 # else
   typedef unsigned long __sanitizer_sigset_t;
 # endif
 #elif SANITIZER_MAC
   typedef unsigned __sanitizer_sigset_t;
 #elif SANITIZER_LINUX
   struct __sanitizer_sigset_t {
     // The size is determined by looking at sizeof of real sigset_t on linux.
     uptr val[128 / sizeof(uptr)];
   };
-#elif SANITIZER_FREEBSD
+#elif SANITIZER_FREEBSD || SANITIZER_NETBSD
   struct __sanitizer_sigset_t {
      // uint32_t * 4
      unsigned int __bits[4];
   };
 #endif
 
   // Linux system headers define the 'sa_handler' and 'sa_sigaction' macros.
 #if SANITIZER_ANDROID && (SANITIZER_WORDSIZE == 64)
   struct __sanitizer_sigaction {
     unsigned sa_flags;
     union {
       void (*sigaction)(int sig, void *siginfo, void *uctx);
       void (*handler)(int sig);
     };
     __sanitizer_sigset_t sa_mask;
     void (*sa_restorer)();
struct __sanitizer_sigaction {
     union {
       void (*sigaction)(int sig, void *siginfo, void *uctx);
       void (*handler)(int sig);
     };
     __sanitizer_sigset_t sa_mask;
     uptr sa_flags;
     void (*sa_restorer)();
   };
-#else // !SANITIZER_ANDROID
+#elif SANITIZER_NETBSD
+  struct __sanitizer_sigaction {
+    union {
+      void (*handler)(int sig);
+      void (*sigaction)(int sig, void *siginfo, void *uctx);
+    };
+    __sanitizer_sigset_t sa_mask;
+    int sa_flags;
+  };
+#else
   struct __sanitizer_sigaction {
 #if defined(__mips__) && !SANITIZER_FREEBSD
     unsigned int sa_flags;
 #endif
     union {
       void (*sigaction)(int sig, void *siginfo, void *uctx);
       void (*handler)(int sig);
     };
 #if SANITIZER_FREEBSD
     int sa_flags;
     __sanitizer_sigset_t sa_mask;
 #else
 #if defined(__s390x__)
     int sa_resv;
 #else
     __sanitizer_sigset_t sa_mask;
 #endif
 #ifndef __mips__
 #if defined(__sparc__)
 #if __GLIBC_PREREQ (2, 20)
     // On sparc glibc 2.19 and earlier sa_flags was unsigned long.
 #if defined(__arch64__)
     // To maintain ABI compatibility on sparc64 when switching to an int,
     // __glibc_reserved0 was added.
     int __glibc_reserved0;
 #endif
#if defined(__mips__) && (SANITIZER_WORDSIZE == 32)
     int sa_resv[1];
 #endif
 #if defined(__s390x__)
     __sanitizer_sigset_t sa_mask;
 #endif
   };
 #endif // !SANITIZER_ANDROID
 
-#if SANITIZER_FREEBSD
+#if SANITIZER_FREEBSD || SANITIZER_NETBSD
   typedef __sanitizer_sigset_t __sanitizer_kernel_sigset_t;
 #elif defined(__mips__)
   struct __sanitizer_kernel_sigset_t {
     uptr sig[2];
   };
 #else
   struct __sanitizer_kernel_sigset_t {
     u8 sig[8];

 #if SANITIZER_LINUX
   extern int e_tabsz;
 #endif
 
   extern int af_inet;
   extern int af_inet6;
   uptr __sanitizer_in_addr_sz(int af);
 
-#if SANITIZER_LINUX || SANITIZER_FREEBSD
+#if SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD
   struct __sanitizer_dl_phdr_info {
     uptr dlpi_addr;
     const char *dlpi_name;
     const void *dlpi_phdr;
     short dlpi_phnum;
   };
 
   extern unsigned struct_ElfW_Phdr_sz;
 #endif
 
   struct __sanitizer_addrinfo {
     int ai_flags;
     int ai_family;
     int ai_socktype;
     int ai_protocol;
-#if SANITIZER_ANDROID || SANITIZER_MAC || SANITIZER_FREEBSD
+#if SANITIZER_ANDROID || SANITIZER_MAC || SANITIZER_FREEBSD || SANITIZER_NETBSD
     unsigned ai_addrlen;
     char *ai_canonname;
     void *ai_addr;
 #else // LINUX
     unsigned ai_addrlen;
     void *ai_addr;
     char *ai_canonname;
 #endif
#endif
   };
 
   struct __sanitizer_pollfd {
     int fd;
     short events;
     short revents;
   };
 
-#if SANITIZER_ANDROID || SANITIZER_MAC || SANITIZER_FREEBSD
+#if SANITIZER_ANDROID || SANITIZER_MAC || SANITIZER_FREEBSD || SANITIZER_NETBSD
   typedef unsigned __sanitizer_nfds_t;
 #else
   typedef unsigned long __sanitizer_nfds_t;
 #endif
 
 #if !SANITIZER_ANDROID
 # if SANITIZER_LINUX
   struct __sanitizer_glob_t {
     uptr gl_pathc;
     char **gl_pathv;
     uptr gl_offs;
     int gl_flags;
 
     void (*gl_closedir)(void *dirp);
     void *(*gl_readdir)(void *dirp);
     void *(*gl_opendir)(const char *);
     int (*gl_lstat)(const char *, void *);
     int (*gl_stat)(const char *, void *);
   };
-# elif SANITIZER_FREEBSD
+#elif SANITIZER_FREEBSD || SANITIZER_NETBSD
   struct __sanitizer_glob_t {
     uptr gl_pathc;
     uptr gl_matchc;
     uptr gl_offs;
     int gl_flags;
     char **gl_pathv;
     int (*gl_errfunc)(const char*, int);
     void (*gl_closedir)(void *dirp);
     struct dirent *(*gl_readdir)(void *dirp);
     void *(*gl_opendir)(const char*);
     int (*gl_lstat)(const char*, void* /* struct stat* */);
     int (*gl_stat)(const char*, void* /* struct stat* */);
   };
-# endif  // SANITIZER_FREEBSD
+#endif  // SANITIZER_FREEBSD || SANITIZER_NETBSD
 
-# if SANITIZER_LINUX || SANITIZER_FREEBSD
+#if SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD
   extern int glob_nomatch;
   extern int glob_altdirfunc;
 # endif
 #endif  // !SANITIZER_ANDROID
 
   extern unsigned path_max;
 
   struct __sanitizer_wordexp_t {
     uptr we_wordc;
     char **we_wordv;
     uptr we_offs;
-#if SANITIZER_FREEBSD
+#if SANITIZER_FREEBSD || SANITIZER_NETBSD
     char *we_strings;
     uptr we_nbytes;
 #endif
   };
 
 #if SANITIZER_LINUX && !SANITIZER_ANDROID
   struct __sanitizer_FILE {
     int _flags;
#if SANITIZER_LINUX && !SANITIZER_ANDROID && \
   extern int ptrace_setfpxregs;
   extern int ptrace_getvfpregs;
   extern int ptrace_setvfpregs;
   extern int ptrace_getsiginfo;
   extern int ptrace_setsiginfo;
   extern int ptrace_getregset;
   extern int ptrace_setregset;
   extern int ptrace_geteventmsg;
 #endif
 
-#if (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID
+#if (SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD) && \
+    !SANITIZER_ANDROID
   extern unsigned struct_shminfo_sz;
   extern unsigned struct_shm_info_sz;
   extern int shmctl_ipc_stat;
   extern int shmctl_ipc_info;
   extern int shmctl_shm_info;
   extern int shmctl_shm_stat;
 #endif
 

 // least significant bit of DIR, so either IOC_READ or
 // IOC_WRITE shall be 1 in order to get a non-zero SIZE.
 #define IOC_SIZE(nr) \
   ((((((nr) >> 29) & 0x7) & (4U | 2U)) == 0) ? 0 : (((nr) >> 16) & 0x3fff))
 #else
 #define IOC_SIZE(nr) (((nr) >> IOC_SIZESHIFT) & IOC_SIZEMASK)
 #endif
 
-  extern unsigned struct_ifreq_sz;
-  extern unsigned struct_termios_sz;
-  extern unsigned struct_winsize_sz;
 
-#if SANITIZER_LINUX
-  extern unsigned struct_arpreq_sz;
-  extern unsigned struct_cdrom_msf_sz;
-  extern unsigned struct_cdrom_multisession_sz;
-  extern unsigned struct_cdrom_read_audio_sz;
-  extern unsigned struct_cdrom_subchnl_sz;
-  extern unsigned struct_cdrom_ti_sz;
-  extern unsigned struct_cdrom_tocentry_sz;
-  extern unsigned struct_cdrom_tochdr_sz;
-  extern unsigned struct_cdrom_volctrl_sz;
-  extern unsigned struct_ff_effect_sz;
-  extern unsigned struct_floppy_drive_params_sz;
-  extern unsigned struct_floppy_drive_struct_sz;
-  extern unsigned struct_floppy_fdc_state_sz;
-  extern unsigned struct_floppy_max_errors_sz;
-  extern unsigned struct_floppy_raw_cmd_sz;
-  extern unsigned struct_floppy_struct_sz;
-  extern unsigned struct_floppy_write_errors_sz;
-  extern unsigned struct_format_descr_sz;
-  extern unsigned struct_hd_driveid_sz;
-  extern unsigned struct_hd_geometry_sz;
-  extern unsigned struct_input_absinfo_sz;
-  extern unsigned struct_input_id_sz;
-  extern unsigned struct_mtpos_sz;
-  extern unsigned struct_termio_sz;
-  extern unsigned struct_vt_consize_sz;
-  extern unsigned struct_vt_sizes_sz;
-  extern unsigned struct_vt_stat_sz;
+#if SANITIZER_LINUX || SANITIZER_NETBSD
+#endif
+
+#if SANITIZER_LINUX
 #endif  // SANITIZER_LINUX
 
 #if SANITIZER_LINUX || SANITIZER_FREEBSD
   extern unsigned struct_copr_buffer_sz;
   extern unsigned struct_copr_debug_buf_sz;
   extern unsigned struct_copr_msg_sz;
   extern unsigned struct_midi_info_sz;
+#endif
+
+#if SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD
   extern unsigned struct_mtget_sz;
   extern unsigned struct_mtop_sz;
   extern unsigned struct_rtentry_sz;
   extern unsigned struct_sbi_instrument_sz;
   extern unsigned struct_seq_event_rec_sz;
   extern unsigned struct_synth_info_sz;
   extern unsigned struct_vt_mode_sz;
-#endif // SANITIZER_LINUX || SANITIZER_FREEBSD
+#endif  // SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD
 
 #if SANITIZER_LINUX && !SANITIZER_ANDROID
   extern unsigned struct_ax25_parms_struct_sz;
   extern unsigned struct_cyclades_monitor_sz;
   extern unsigned struct_input_keymap_entry_sz;
   extern unsigned struct_ipx_config_data_sz;
   extern unsigned struct_kbdiacrs_sz;
   extern unsigned struct_kbentry_sz;
   extern unsigned struct_kbkeycode_sz;
   extern unsigned struct_kbsentry_sz;
   extern unsigned struct_mtconfiginfo_sz;
   extern unsigned struct_nr_parms_struct_sz;
   extern unsigned struct_scc_modem_sz;
   extern unsigned struct_scc_stat_sz;
   extern unsigned struct_serial_multiport_struct_sz;
   extern unsigned struct_serial_struct_sz;
   extern unsigned struct_sockaddr_ax25_sz;
   extern unsigned struct_unimapdesc_sz;
   extern unsigned struct_unimapinit_sz;
 #endif  // SANITIZER_LINUX && !SANITIZER_ANDROID
 
-#if (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID
+#if (SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD) && \
+    !SANITIZER_ANDROID
   extern unsigned struct_audio_buf_info_sz;
   extern unsigned struct_ppp_stats_sz;
-#endif  // (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID
+#endif  // (SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD) &&
+        // !SANITIZER_ANDROID
 
 #if !SANITIZER_ANDROID && !SANITIZER_MAC
   extern unsigned struct_sioc_sg_req_sz;
   extern unsigned struct_sioc_vif_req_sz;
 #endif
 
   // ioctl request identifiers
 
#endif
   extern unsigned IOCTL_TIOCNXCL;
   extern unsigned IOCTL_TIOCOUTQ;
   extern unsigned IOCTL_TIOCPKT;
   extern unsigned IOCTL_TIOCSCTTY;
   extern unsigned IOCTL_TIOCSETD;
   extern unsigned IOCTL_TIOCSPGRP;
   extern unsigned IOCTL_TIOCSTI;
   extern unsigned IOCTL_TIOCSWINSZ;
-#if (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID
+#if (SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD) && \
+    !SANITIZER_ANDROID
   extern unsigned IOCTL_SIOCGETSGCNT;
   extern unsigned IOCTL_SIOCGETVIFCNT;
 #endif
 #if SANITIZER_LINUX
   extern unsigned IOCTL_EVIOCGABS;
   extern unsigned IOCTL_EVIOCGBIT;
   extern unsigned IOCTL_EVIOCGEFFECTS;
   extern unsigned IOCTL_EVIOCGID;
#if SANITIZER_LINUX
   extern unsigned IOCTL_TIOCSLCKTRMIOS;
   extern unsigned IOCTL_TIOCSSOFTCAR;
   extern unsigned IOCTL_VT_DISALLOCATE;
   extern unsigned IOCTL_VT_GETSTATE;
   extern unsigned IOCTL_VT_RESIZE;
   extern unsigned IOCTL_VT_RESIZEX;
   extern unsigned IOCTL_VT_SENDSIG;
 #endif  // SANITIZER_LINUX
-#if SANITIZER_LINUX || SANITIZER_FREEBSD
+#if SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD
   extern unsigned IOCTL_MTIOCGET;
   extern unsigned IOCTL_MTIOCTOP;
   extern unsigned IOCTL_SIOCADDRT;
   extern unsigned IOCTL_SIOCDELRT;
   extern unsigned IOCTL_SNDCTL_DSP_GETBLKSIZE;
   extern unsigned IOCTL_SNDCTL_DSP_GETFMTS;
   extern unsigned IOCTL_SNDCTL_DSP_NONBLOCK;
   extern unsigned IOCTL_SNDCTL_DSP_POST;
#if SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD
   extern unsigned IOCTL_SOUND_PCM_WRITE_CHANNELS;
   extern unsigned IOCTL_SOUND_PCM_WRITE_FILTER;
   extern unsigned IOCTL_VT_ACTIVATE;
   extern unsigned IOCTL_VT_GETMODE;
   extern unsigned IOCTL_VT_OPENQRY;
   extern unsigned IOCTL_VT_RELDISP;
   extern unsigned IOCTL_VT_SETMODE;
   extern unsigned IOCTL_VT_WAITACTIVE;
-#endif  // SANITIZER_LINUX || SANITIZER_FREEBSD
+#endif  // SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD
 
 #if SANITIZER_LINUX && !SANITIZER_ANDROID
   extern unsigned IOCTL_CYGETDEFTHRESH;
   extern unsigned IOCTL_CYGETDEFTIMEOUT;
   extern unsigned IOCTL_CYGETMON;
   extern unsigned IOCTL_CYGETTHRESH;
   extern unsigned IOCTL_CYGETTIMEOUT;
   extern unsigned IOCTL_CYSETDEFTHRESH;
#if SANITIZER_LINUX && !SANITIZER_ANDROID
   extern unsigned IOCTL_SNDCTL_DSP_GETISPACE;
   extern unsigned IOCTL_SNDCTL_DSP_GETOSPACE;
   extern unsigned IOCTL_TIOCGSERIAL;
   extern unsigned IOCTL_TIOCSERGETMULTI;
   extern unsigned IOCTL_TIOCSERSETMULTI;
   extern unsigned IOCTL_TIOCSSERIAL;
 #endif  // SANITIZER_LINUX && !SANITIZER_ANDROID
 
-#if (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID
+#if (SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD) && \
+    !SANITIZER_ANDROID
+#if !SANITIZER_NETBSD
   extern unsigned IOCTL_GIO_SCRNMAP;
+#endif
   extern unsigned IOCTL_KDDISABIO;
   extern unsigned IOCTL_KDENABIO;
   extern unsigned IOCTL_KDGETLED;
+#if !SANITIZER_NETBSD
   extern unsigned IOCTL_KDGETMODE;
+#endif
   extern unsigned IOCTL_KDGKBMODE;
   extern unsigned IOCTL_KDGKBTYPE;
   extern unsigned IOCTL_KDMKTONE;
   extern unsigned IOCTL_KDSETLED;
   extern unsigned IOCTL_KDSETMODE;
   extern unsigned IOCTL_KDSKBMODE;
+#if !SANITIZER_NETBSD
   extern unsigned IOCTL_KIOCSOUND;
   extern unsigned IOCTL_PIO_SCRNMAP;
 #endif
+#endif
 
   extern const int si_SEGV_MAPERR;
   extern const int si_SEGV_ACCERR;
 }  // namespace __sanitizer
 
 #define CHECK_TYPE_SIZE(TYPE) \
   COMPILER_CHECK(sizeof(__sanitizer_##TYPE) == sizeof(TYPE))
 

lib/sanitizer_common/sanitizer_platform_limits_posix.cc

 //===-- sanitizer_platform_limits_posix.cc --------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file is a part of Sanitizer common code.
 //
 // Sizes and layouts of platform-specific POSIX data structures.
 //===----------------------------------------------------------------------===//
 
 #include "sanitizer_platform.h"
 
-#if SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_MAC
+#if SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_MAC || SANITIZER_NETBSD
 // Tests in this file assume that off_t-dependent data structures match the
 // libc ABI. For example, struct dirent here is what readdir() function (as
 // exported from libc) returns, and not the user-facing "dirent", which
 // depends on _FILE_OFFSET_BITS setting.
 // To get this "true" dirent definition, we undefine _FILE_OFFSET_BITS below.
 #ifdef _FILE_OFFSET_BITS
 #undef _FILE_OFFSET_BITS
 #endif

 #include <linux/ioctl.h>
 #include <linux/soundcard.h>
 #include <linux/sysctl.h>
 #include <linux/utsname.h>
 #include <linux/posix_types.h>
 #include <net/if_arp.h>
 #endif
 
-#if SANITIZER_FREEBSD
+#if SANITIZER_FREEBSD || SANITIZER_NETBSD
 # include <sys/mount.h>
 # include <sys/sockio.h>
 # include <sys/socket.h>
 # include <sys/filio.h>
 # include <sys/signal.h>
 # include <sys/timespec.h>
 # include <sys/timex.h>
 # include <sys/mqueue.h>
 # include <sys/msg.h>
 # include <sys/ipc.h>
 # include <sys/msg.h>
 # include <sys/statvfs.h>
 # include <sys/soundcard.h>
 # include <sys/mtio.h>
-# include <sys/consio.h>
-# include <sys/kbio.h>
-# include <sys/link_elf.h>
 # include <netinet/ip_mroute.h>
 # include <netinet/in.h>
-# include <net/ethernet.h>
 # include <net/ppp_defs.h>
 # include <glob.h>
 # include <term.h>
+#endif
 
+#if SANITIZER_FREEBSD
+#include <net/ethernet.h>
+#include <sys/consio.h>
+#include <sys/kbio.h>
+#include <sys/link_elf.h>
 #define _KERNEL  // to declare 'shminfo' structure
 # include <sys/shm.h>
 #undef _KERNEL
 
 #undef INLINE  // to avoid clashes with sanitizers' definitions
 #endif
 
-#if SANITIZER_FREEBSD || SANITIZER_IOS
+#if SANITIZER_NETBSD
+#include <link_elf.h>
+#include <net/if_ether.h>
+#include <sys/shm.h>
+#define statfs statvfs
+#define d_ino d_fileno
+#endif
+
+#if SANITIZER_FREEBSD || SANITIZER_IOS || SANITIZER_NETBSD
 #undef IOC_DIRMASK
 #endif
 
-#if SANITIZER_LINUX || SANITIZER_FREEBSD
+#if SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD
 # include <utime.h>
 # include <sys/ptrace.h>
 # if defined(__mips64) || defined(__aarch64__) || defined(__arm__)
 #  include <asm/ptrace.h>
 #  ifdef __arm__
 typedef struct user_fpregs elf_fpregset_t;
 #   define ARM_VFPREGS_SIZE_ASAN (32 * 8 /*fpregs*/ + 4 /*fpscr*/)
 #   if !defined(ARM_VFPREGS_SIZE)

 
 // Include these after system headers to avoid name clashes and ambiguities.
 #include "sanitizer_internal_defs.h"
 #include "sanitizer_platform_limits_posix.h"
 
 namespace __sanitizer {
   unsigned struct_utsname_sz = sizeof(struct utsname);
   unsigned struct_stat_sz = sizeof(struct stat);
-#if !SANITIZER_IOS && !SANITIZER_FREEBSD
+#if !SANITIZER_IOS && !SANITIZER_FREEBSD && !SANITIZER_NETBSD
   unsigned struct_stat64_sz = sizeof(struct stat64);
-#endif // !SANITIZER_IOS && !SANITIZER_FREEBSD
+#endif  // !SANITIZER_IOS && !SANITIZER_FREEBSD && !SANITIZER_NETBSD
   unsigned struct_rusage_sz = sizeof(struct rusage);
   unsigned struct_tm_sz = sizeof(struct tm);
   unsigned struct_passwd_sz = sizeof(struct passwd);
   unsigned struct_group_sz = sizeof(struct group);
   unsigned siginfo_t_sz = sizeof(siginfo_t);
   unsigned struct_sigaction_sz = sizeof(struct sigaction);
   unsigned struct_itimerval_sz = sizeof(struct itimerval);
   unsigned pthread_t_sz = sizeof(pthread_t);
#if SANITIZER_LINUX
   unsigned __user_cap_header_struct_sz =
       sizeof(struct __user_cap_header_struct);
   unsigned __user_cap_data_struct_sz = sizeof(struct __user_cap_data_struct);
   unsigned struct_new_utsname_sz = sizeof(struct new_utsname);
   unsigned struct_old_utsname_sz = sizeof(struct old_utsname);
   unsigned struct_oldold_utsname_sz = sizeof(struct oldold_utsname);
 #endif // SANITIZER_LINUX
 
-#if SANITIZER_LINUX || SANITIZER_FREEBSD
+#if SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD
   unsigned struct_rlimit_sz = sizeof(struct rlimit);
   unsigned struct_timespec_sz = sizeof(struct timespec);
   unsigned struct_utimbuf_sz = sizeof(struct utimbuf);
   unsigned struct_itimerspec_sz = sizeof(struct itimerspec);
-#endif // SANITIZER_LINUX || SANITIZER_FREEBSD
+#endif  // SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD
 
 #if SANITIZER_LINUX && !SANITIZER_ANDROID
   unsigned struct_ustat_sz = sizeof(struct ustat);
   unsigned struct_rlimit64_sz = sizeof(struct rlimit64);
   unsigned struct_statvfs64_sz = sizeof(struct statvfs64);
 #endif // SANITIZER_LINUX && !SANITIZER_ANDROID
 
-#if (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID
+#if (SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD) && \
+    !SANITIZER_ANDROID
   unsigned struct_timex_sz = sizeof(struct timex);
   unsigned struct_msqid_ds_sz = sizeof(struct msqid_ds);
   unsigned struct_mq_attr_sz = sizeof(struct mq_attr);
   unsigned struct_statvfs_sz = sizeof(struct statvfs);
-#endif // (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID
+#endif  // (SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD) &&
+        // !SANITIZER_ANDROID
 
   uptr sig_ign = (uptr)SIG_IGN;
   uptr sig_dfl = (uptr)SIG_DFL;
   uptr sa_siginfo = (uptr)SA_SIGINFO;
 
 #if SANITIZER_LINUX
   int e_tabsz = (int)E_TABSZ;
 #endif
 
-
-#if (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID
+#if (SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD) && \
+    !SANITIZER_ANDROID
   unsigned struct_shminfo_sz = sizeof(struct shminfo);
+#if !SANITIZER_NETBSD
   unsigned struct_shm_info_sz = sizeof(struct shm_info);
+#else
+#define IPC_INFO -1
+#define SHM_INFO -1
+#define SHM_STAT -1
+  unsigned struct_shm_info_sz = -1;
+#endif
   int shmctl_ipc_stat = (int)IPC_STAT;
   int shmctl_ipc_info = (int)IPC_INFO;
   int shmctl_shm_info = (int)SHM_INFO;
   int shmctl_shm_stat = (int)SHM_STAT;
 #endif
 
 #if !SANITIZER_MAC && !SANITIZER_FREEBSD
   unsigned struct_utmp_sz = sizeof(struct utmp);
#endif
   }
 
 #if SANITIZER_LINUX
 unsigned struct_ElfW_Phdr_sz = sizeof(ElfW(Phdr));
 #elif SANITIZER_FREEBSD
 unsigned struct_ElfW_Phdr_sz = sizeof(Elf_Phdr);
 #endif
 
-#if (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID
-  int glob_nomatch = GLOB_NOMATCH;
-  int glob_altdirfunc = GLOB_ALTDIRFUNC;
+#if (SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD) && \
+    !SANITIZER_ANDROID
 #endif
 
 #if SANITIZER_LINUX && !SANITIZER_ANDROID && \
     (defined(__i386) || defined(__x86_64) || defined(__mips64) || \
       defined(__powerpc64__) || defined(__aarch64__) || defined(__arm__) || \
       defined(__s390__))
 #if defined(__mips64) || defined(__powerpc64__) || defined(__arm__)
   unsigned struct_user_regs_struct_sz = sizeof(struct pt_regs);

 #endif
   unsigned struct_midi_info_sz = sizeof(struct midi_info);
   unsigned struct_mtget_sz = sizeof(struct mtget);
   unsigned struct_mtop_sz = sizeof(struct mtop);
   unsigned struct_sbi_instrument_sz = sizeof(struct sbi_instrument);
   unsigned struct_seq_event_rec_sz = sizeof(struct seq_event_rec);
   unsigned struct_synth_info_sz = sizeof(struct synth_info);
   unsigned struct_vt_mode_sz = sizeof(struct vt_mode);
-#endif // SANITIZER_LINUX || SANITIZER_FREEBSD
+#endif  // SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD
 
 #if SANITIZER_LINUX && !SANITIZER_ANDROID
   unsigned struct_ax25_parms_struct_sz = sizeof(struct ax25_parms_struct);
   unsigned struct_cyclades_monitor_sz = sizeof(struct cyclades_monitor);
 #if EV_VERSION > (0x010000)
   unsigned struct_input_keymap_entry_sz = sizeof(struct input_keymap_entry);
 #else
   unsigned struct_input_keymap_entry_sz = 0;
#endif
   unsigned struct_serial_multiport_struct_sz
       = sizeof(struct serial_multiport_struct);
   unsigned struct_serial_struct_sz = sizeof(struct serial_struct);
   unsigned struct_sockaddr_ax25_sz = sizeof(struct sockaddr_ax25);
   unsigned struct_unimapdesc_sz = sizeof(struct unimapdesc);
   unsigned struct_unimapinit_sz = sizeof(struct unimapinit);
 #endif // SANITIZER_LINUX && !SANITIZER_ANDROID
 
-#if (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID
+#if (SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD) && \
+    !SANITIZER_ANDROID
   unsigned struct_audio_buf_info_sz = sizeof(struct audio_buf_info);
   unsigned struct_ppp_stats_sz = sizeof(struct ppp_stats);
 #endif // (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID
 
 #if !SANITIZER_ANDROID && !SANITIZER_MAC
   unsigned struct_sioc_sg_req_sz = sizeof(struct sioc_sg_req);
   unsigned struct_sioc_vif_req_sz = sizeof(struct sioc_vif_req);
 #endif
#endif
   unsigned IOCTL_TIOCNXCL = TIOCNXCL;
   unsigned IOCTL_TIOCOUTQ = TIOCOUTQ;
   unsigned IOCTL_TIOCPKT = TIOCPKT;
   unsigned IOCTL_TIOCSCTTY = TIOCSCTTY;
   unsigned IOCTL_TIOCSETD = TIOCSETD;
   unsigned IOCTL_TIOCSPGRP = TIOCSPGRP;
   unsigned IOCTL_TIOCSTI = TIOCSTI;
   unsigned IOCTL_TIOCSWINSZ = TIOCSWINSZ;
-#if ((SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID)
+#if ((SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD) && \
+     !SANITIZER_ANDROID)
   unsigned IOCTL_SIOCGETSGCNT = SIOCGETSGCNT;
   unsigned IOCTL_SIOCGETVIFCNT = SIOCGETVIFCNT;
 #endif
 
 #if SANITIZER_LINUX
   unsigned IOCTL_EVIOCGABS = EVIOCGABS(0);
   unsigned IOCTL_EVIOCGBIT = EVIOCGBIT(0, 0);
   unsigned IOCTL_EVIOCGEFFECTS = EVIOCGEFFECTS;

 COMPILER_CHECK(EVIOC_ABS_MAX == ABS_MAX);
 COMPILER_CHECK(EVIOC_EV_MAX == EV_MAX);
 COMPILER_CHECK(IOC_SIZE(0x12345678) == _IOC_SIZE(0x12345678));
 COMPILER_CHECK(IOC_DIR(0x12345678) == _IOC_DIR(0x12345678));
 COMPILER_CHECK(IOC_NR(0x12345678) == _IOC_NR(0x12345678));
 COMPILER_CHECK(IOC_TYPE(0x12345678) == _IOC_TYPE(0x12345678));
 #endif // SANITIZER_LINUX
 
-#if SANITIZER_LINUX || SANITIZER_FREEBSD
+#if SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD
 // There are more undocumented fields in dl_phdr_info that we are not interested
 // in.
 COMPILER_CHECK(sizeof(__sanitizer_dl_phdr_info) <= sizeof(dl_phdr_info));
 CHECK_SIZE_AND_OFFSET(dl_phdr_info, dlpi_addr);
 CHECK_SIZE_AND_OFFSET(dl_phdr_info, dlpi_name);
 CHECK_SIZE_AND_OFFSET(dl_phdr_info, dlpi_phdr);
 CHECK_SIZE_AND_OFFSET(dl_phdr_info, dlpi_phnum);
-#endif // SANITIZER_LINUX || SANITIZER_FREEBSD
+#endif  // SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD
 
-#if (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID
+#if (SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD) && \
+    !SANITIZER_ANDROID
 CHECK_TYPE_SIZE(glob_t);
 CHECK_SIZE_AND_OFFSET(glob_t, gl_pathc);
 CHECK_SIZE_AND_OFFSET(glob_t, gl_pathv);
 CHECK_SIZE_AND_OFFSET(glob_t, gl_offs);
 CHECK_SIZE_AND_OFFSET(glob_t, gl_flags);
 CHECK_SIZE_AND_OFFSET(glob_t, gl_closedir);
 CHECK_SIZE_AND_OFFSET(glob_t, gl_readdir);
 CHECK_SIZE_AND_OFFSET(glob_t, gl_opendir);

 CHECK_SIZE_AND_OFFSET(cmsghdr, cmsg_len);
 CHECK_SIZE_AND_OFFSET(cmsghdr, cmsg_level);
 CHECK_SIZE_AND_OFFSET(cmsghdr, cmsg_type);
 
 COMPILER_CHECK(sizeof(__sanitizer_dirent) <= sizeof(dirent));
 CHECK_SIZE_AND_OFFSET(dirent, d_ino);
 #if SANITIZER_MAC
 CHECK_SIZE_AND_OFFSET(dirent, d_seekoff);
-#elif SANITIZER_FREEBSD
+#elif SANITIZER_FREEBSD || SANITIZER_NETBSD
 // There is no 'd_off' field on FreeBSD.
 #else
 CHECK_SIZE_AND_OFFSET(dirent, d_off);
 #endif
 CHECK_SIZE_AND_OFFSET(dirent, d_reclen);
 
 #if SANITIZER_LINUX && !SANITIZER_ANDROID
 COMPILER_CHECK(sizeof(__sanitizer_dirent64) <= sizeof(dirent64));

 CHECK_SIZE_AND_OFFSET(mntent, mnt_type);
 CHECK_SIZE_AND_OFFSET(mntent, mnt_opts);
 CHECK_SIZE_AND_OFFSET(mntent, mnt_freq);
 CHECK_SIZE_AND_OFFSET(mntent, mnt_passno);
 #endif
 
 CHECK_TYPE_SIZE(ether_addr);
 
-#if (SANITIZER_LINUX || SANITIZER_FREEBSD) && !SANITIZER_ANDROID
+#if (SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD) && \
+    !SANITIZER_ANDROID
 CHECK_TYPE_SIZE(ipc_perm);
 # if SANITIZER_FREEBSD
 CHECK_SIZE_AND_OFFSET(ipc_perm, key);
 CHECK_SIZE_AND_OFFSET(ipc_perm, seq);
+#elif SANITIZER_NETBSD
+CHECK_SIZE_AND_OFFSET(ipc_perm, _key);
+CHECK_SIZE_AND_OFFSET(ipc_perm, _seq);
 # else
 CHECK_SIZE_AND_OFFSET(ipc_perm, __key);
 CHECK_SIZE_AND_OFFSET(ipc_perm, __seq);
 # endif
 CHECK_SIZE_AND_OFFSET(ipc_perm, uid);
 CHECK_SIZE_AND_OFFSET(ipc_perm, gid);
 CHECK_SIZE_AND_OFFSET(ipc_perm, cuid);
 CHECK_SIZE_AND_OFFSET(ipc_perm, cgid);

 #endif
 
 #if !SANITIZER_ANDROID
 CHECK_TYPE_SIZE(ifaddrs);
 CHECK_SIZE_AND_OFFSET(ifaddrs, ifa_next);
 CHECK_SIZE_AND_OFFSET(ifaddrs, ifa_name);
 CHECK_SIZE_AND_OFFSET(ifaddrs, ifa_addr);
 CHECK_SIZE_AND_OFFSET(ifaddrs, ifa_netmask);
-#if SANITIZER_LINUX || SANITIZER_FREEBSD
+#if SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_NETBSD
 // Compare against the union, because we can't reach into the union in a
 // compliant way.
 #ifdef ifa_dstaddr
 #undef ifa_dstaddr
 #endif
-# if SANITIZER_FREEBSD
+#if SANITIZER_FREEBSD || SANITIZER_NETBSD
 CHECK_SIZE_AND_OFFSET(ifaddrs, ifa_dstaddr);
 # else
 COMPILER_CHECK(sizeof(((__sanitizer_ifaddrs *)nullptr)->ifa_dstaddr) ==
                sizeof(((ifaddrs *)nullptr)->ifa_ifu));
 COMPILER_CHECK(offsetof(__sanitizer_ifaddrs, ifa_dstaddr) ==
                offsetof(ifaddrs, ifa_ifu));
-# endif // SANITIZER_FREEBSD
+#endif  // SANITIZER_FREEBSD || SANITIZER_NETBSD
 #else
 CHECK_SIZE_AND_OFFSET(ifaddrs, ifa_dstaddr);
 #endif // SANITIZER_LINUX
 CHECK_SIZE_AND_OFFSET(ifaddrs, ifa_data);
 #endif
 
 #if SANITIZER_LINUX
 COMPILER_CHECK(sizeof(__sanitizer_mallinfo) == sizeof(struct mallinfo));

 #if SANITIZER_LINUX || SANITIZER_FREEBSD
 CHECK_TYPE_SIZE(sem_t);
 #endif
 
 #if SANITIZER_LINUX && defined(__arm__)
 COMPILER_CHECK(ARM_VFPREGS_SIZE == ARM_VFPREGS_SIZE_ASAN);
 #endif
 
-#endif // SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_MAC
+#endif  // SANITIZER_LINUX || SANITIZER_FREEBSD || SANITIZER_MAC ||
+        // SANITIZER_NETBSD