asan: don't use thread user_id

[dvyukov]

Summary

asan does not use user_id for anything,
so don't pass it to ThreadCreate.
Passing a random uninitialized field of AsanThread
as user_id does not make much sense anyway.

Depends on D113921.

compiler-rt/lib/asan/asan_fuchsia.cpp

 }
 
 struct AsanThread::InitOptions {
   uptr stack_bottom, stack_size;
 };
 
 // Shared setup between thread creation and startup for the initial thread.
 static AsanThread *CreateAsanThread(StackTrace *stack, u32 parent_tid,
-                                    uptr user_id, bool detached,
-                                    const char *name) {
+                                    bool detached, const char *name) {
   // In lieu of AsanThread::Create.
   AsanThread *thread = (AsanThread *)MmapOrDie(AsanThreadMmapSize(), __func__);
 
   AsanThreadContext::CreateThreadContextArgs args = {thread, stack};
-  u32 tid =
-      asanThreadRegistry().CreateThread(user_id, detached, parent_tid, &args);
+  u32 tid = asanThreadRegistry().CreateThread(0, detached, parent_tid, &args);
   asanThreadRegistry().SetThreadName(tid, name);
 
   return thread;
 }
 
 // This gets the same arguments passed to Init by CreateAsanThread, above.
 // We're in the creator thread before the new thread is actually started,
 // but its stack address range is already known.  We don't bother tracking
 // the static TLS address range because the system itself already uses an
 // ASan-aware allocator for that.
 void AsanThread::SetThreadStackAndTls(const AsanThread::InitOptions *options) {
   DCHECK_NE(GetCurrentThread(), this);
   DCHECK_NE(GetCurrentThread(), nullptr);
   CHECK_NE(options->stack_bottom, 0);
   CHECK_NE(options->stack_size, 0);
   stack_bottom_ = options->stack_bottom;
   stack_top_ = options->stack_bottom + options->stack_size;
 }
 
 // Called by __asan::AsanInitInternal (asan_rtl.c).
 AsanThread *CreateMainThread() {
-  thrd_t self = thrd_current();
   char name[ZX_MAX_NAME_LEN];
   CHECK_NE(__sanitizer::MainThreadStackBase, 0);
   CHECK_GT(__sanitizer::MainThreadStackSize, 0);
   AsanThread *t = CreateAsanThread(
-      nullptr, 0, reinterpret_cast<uptr>(self), true,
+      nullptr, 0, true,
       _zx_object_get_property(thrd_get_zx_handle(self), ZX_PROP_NAME, name,
                               sizeof(name)) == ZX_OK
           ? name
           : nullptr);
   // We need to set the current thread before calling AsanThread::Init() below,
   // since it reads the thread ID.
   SetCurrentThread(t);
   DCHECK_EQ(t->tid(), 0);
static void *BeforeThreadCreateHook(uptr user_id, bool detached,
   EnsureMainThreadIDIsCorrect();
   // Strict init-order checking is thread-hostile.
   if (flags()->strict_init_order)
     StopInitOrderChecking();
 
   GET_STACK_TRACE_THREAD;
   u32 parent_tid = GetCurrentTidOrInvalid();
 
-  AsanThread *thread =
-      CreateAsanThread(&stack, parent_tid, user_id, detached, name);
+  AsanThread *thread = CreateAsanThread(&stack, parent_tid, detached, name);
 
   // On other systems, AsanThread::Init() is called from the new
   // thread itself.  But on Fuchsia we already know the stack address
   // range beforehand, so we can do most of the setup right now.
   const AsanThread::InitOptions options = {stack_bottom, stack_size};
   thread->Init(&options);
   return thread;
 }

compiler-rt/lib/asan/asan_thread.cpp

AsanThread *AsanThread::Create(thread_callback_t start_routine, void *arg,
                                u32 parent_tid, StackTrace *stack,
                                bool detached) {
   uptr PageSize = GetPageSizeCached();
   uptr size = RoundUpTo(sizeof(AsanThread), PageSize);
   AsanThread *thread = (AsanThread*)MmapOrDie(size, __func__);
   thread->start_routine_ = start_routine;
   thread->arg_ = arg;
   AsanThreadContext::CreateThreadContextArgs args = {thread, stack};
-  asanThreadRegistry().CreateThread(*reinterpret_cast<uptr *>(thread), detached,
-                                    parent_tid, &args);
+  asanThreadRegistry().CreateThread(0, detached, parent_tid, &args);
 
   return thread;
 }
 
 void AsanThread::TSDDtor(void *tsd) {
   AsanThreadContext *context = (AsanThreadContext*)tsd;
   VReport(1, "T%d TSDDtor\n", context->tid);
   if (context->thread)