Debug stub: associate NaClAppThread with IThread

src/trusted/debug_stub/win/thread_impl.cc

 /*
  * Copyright (c) 2012 The Native Client Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include <assert.h>
 #include <windows.h>
 #include <exception>
 #include <stdexcept>
 
+#include "native_client/src/shared/platform/nacl_log.h"
 #include "native_client/src/trusted/port/mutex.h"
 #include "native_client/src/trusted/port/thread.h"
 
 /*
  * Define the OS specific portions of IThread interface.
  */
 
 namespace {
 const int kDBG_PRINTEXCEPTION_C = 0x40010006;
 }
@@ skipping 180 matching lines @@
     case 15:return sizeof ctx->SegGs;
   }
 
   throw std::out_of_range("Register index out of range.");
 }
 #endif
 
 
 class Thread : public IThread {
  public:
-  explicit Thread(uint32_t id) : ref_(1), id_(id),
-                                 handle_(NULL), state_(RUNNING) {
+  Thread(uint32_t id, struct NaClAppThread *natp)
+      : ref_(1), id_(id), handle_(NULL), natp_(natp), state_(RUNNING) {
     handle_ = OpenThread(THREAD_ALL_ACCESS, false, id);
     memset(&context_, 0, sizeof(context_));
     context_.ContextFlags = CONTEXT_ALL;
     if (NULL == handle_) state_ = DEAD;
   }
 
   ~Thread() {
     if (NULL == handle_) return;
 
     // This should always succeed, so ignore the return.
@@ skipping 130 matching lines @@
 
     thread->state_ = old_state;
     Release(thread);
     return EXCEPTION_CONTINUE_EXECUTION;
   }
 
 
  private:
   uint32_t ref_;
   uint32_t id_;
+  struct NaClAppThread *natp_;
   State  state_;
   HANDLE handle_;
   CONTEXT context_;
 
   friend class IThread;
 };
 
-IThread* IThread::Acquire(uint32_t id, bool create) {
+IThread* IThread::Create(uint32_t id, struct NaClAppThread* natp) {
   MutexLock lock(ThreadGetLock());
   Thread* thread;
   ThreadMap_t &map = *ThreadGetMap();
 
-  // Check if we have that thread
   if (map.count(id)) {
-    thread = static_cast<Thread*>(map[id]);
-    thread->ref_++;
-    return thread;
+    NaClLog(LOG_ERROR, "IThread::Create: thread 0x%x already exists\n", id);

[Mark Seaborn, 2012/05/07 21:56:49]

Ditto

[eaeltsin, 2012/05/08 11:10:19]

Done.

+    return NULL;
   }
 
-  // If not, can we create it?
-  if (create) {
-    // If not add it to the map
-    thread = new Thread(id);
-    if (NULL == thread->handle_) {
-      delete thread;
-      return NULL;
-    }
-
-    map[id] = thread;
-    return thread;
+  thread = new Thread(id, natp);
+  if (NULL == thread->handle_) {
+    delete thread;

[Mark Seaborn, 2012/05/07 21:56:49]

FYI, this isn't consistent with the posix implementation, which doesn't have a
NULL check.

[eaeltsin, 2012/05/08 11:10:19]

This is the old code, kept as is.

Anyway, this code will be refactored very soon.

+    return NULL;
   }
 
-  return NULL;
+  map[id] = thread;
+  return thread;
+}
+
+IThread* IThread::Acquire(uint32_t id) {
+  MutexLock lock(ThreadGetLock());
+  Thread* thread;
+  ThreadMap_t &map = *ThreadGetMap();
+
+  if (map.count(id) == 0) {
+    NaClLog(LOG_ERROR, "IThread::Acquire: thread 0x%x does not exist\n", id);
+    return NULL;
+  }
+
+  thread = static_cast<Thread*>(map[id]);
+  thread->ref_++;
+  return thread;
 }
 
 void IThread::Release(IThread *ithread) {
   MutexLock lock(ThreadGetLock());
   Thread* thread = static_cast<Thread*>(ithread);
   thread->ref_--;
 
   if (thread->ref_ == 0) {
     ThreadGetMap()->erase(thread->id_);
     delete static_cast<IThread*>(thread);
   }
 }
 
 void IThread::SetExceptionCatch(IThread::CatchFunc_t func, void *cookie) {
   MutexLock lock(ThreadGetLock());
 
   // Remove our old catch if there is one, this allows us to add again
   if (NULL != s_OldCatch) RemoveVectoredExceptionHandler(s_OldCatch);
 
   // Add the new one, at the front of the list
   s_OldCatch = AddVectoredExceptionHandler(1, Thread::ExceptionCatch);
   s_CatchFunc = func;
   s_CatchCookie = cookie;
 }
 
 
 }  // End of port namespace