[safestack] Add ThreadId type as uint64_t

[krytarowski]

compiler-rt/lib/safestack/safestack_platform.h

23

We need additionally:

#if SANITIZER_NETBSD
#include <lwp.h>
#endif

[vitalybuka]

include lwp.h

compiler-rt/lib/safestack/safestack.cc

 }
 
 /// Linked list used to store exiting threads stack/thread information.
 struct thread_stack_ll {
   struct thread_stack_ll *next;
   void *stack_base;
   size_t size;
   pid_t pid;
-  pid_t tid;
+  ThreadId tid;
 };
 
 /// Linked list of unsafe stacks for threads that are exiting. We delay
 /// unmapping them until the thread exits.
 thread_stack_ll *thread_stacks = nullptr;
 pthread_mutex_t thread_stacks_mutex = PTHREAD_MUTEX_INITIALIZER;
 
 /// Thread-specific data destructor. We want to free the unsafe stack only after
 /// this thread is terminated. libc can call functions in safestack-instrumented
 /// code (like free) after thread-specific data destructors have run.
 void thread_cleanup_handler(void *_iter) {
   SFS_CHECK(unsafe_stack_start != nullptr);
   pthread_setspecific(thread_cleanup_key, NULL);
 
   pthread_mutex_lock(&thread_stacks_mutex);
   // Temporary list to hold the previous threads stacks so we don't hold the
   // thread_stacks_mutex for long.
   thread_stack_ll *temp_stacks = thread_stacks;
   thread_stacks = nullptr;
   pthread_mutex_unlock(&thread_stacks_mutex);
 
   pid_t pid = getpid();
-  pid_t tid = GetTid();
+  ThreadId tid = GetTid();
 
   // Free stacks for dead threads
   thread_stack_ll **stackp = &temp_stacks;
   while (*stackp) {
     thread_stack_ll *stack = *stackp;
     if (stack->pid != pid ||
         (-1 == TgKill(stack->pid, stack->tid, 0) && errno == ESRCH)) {
       munmap(stack->stack_base, stack->size);

compiler-rt/lib/safestack/safestack_platform.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SAFESTACK_PLATFORM_H
 #define SAFESTACK_PLATFORM_H
 
 #include "sanitizer_common/sanitizer_platform.h"
 
+#include <stdint.h>
 #include <sys/syscall.h>
 #include <sys/types.h>
 #include <unistd.h>
 
 namespace safestack {
 
-inline pid_t GetTid() {
+using ThreadId = uint64_t;
+
+inline ThreadId GetTid() {
 #if SANITIZER_NETBSD
   return _lwp_self();
 #elif SANITIZER_FREEBSD
   long Tid;
   thr_self(&Tid);
   return Tid;
 #elif SANITIZER_OPENBSD
   return syscall(SYS_getthrid);
 #elif SANITIZER_SOLARIS
   return thr_self();
 #else
   return syscall(SYS_gettid);
 #endif
 }
 
-inline int TgKill(pid_t pid, pid_t tid, int sig) {
+inline int TgKill(pid_t pid, ThreadId tid, int sig) {
 #if SANITIZER_NETBSD
   (void)pid;
   return _lwp_kill(tid, sig);
 #elif SANITIZER_LINUX
   return syscall(SYS_tgkill, pid, tid, sig);
 #elif SANITIZER_FREEBSD
   return syscall(SYS_thr_kill2, pid, tid, sig);
 #elif SANITIZER_OPENBSD