diff --git a/src/debugger.cc b/src/debugger.cc
index 7c26bd0..7d6d344 100644
--- a/src/debugger.cc
+++ b/src/debugger.cc
@@ -18,8 +18,35 @@
 
 #include <sys/uio.h>
 
+#include "thread_list.h"
+
 namespace art {
 
+class ObjectRegistry {
+ public:
+  ObjectRegistry() : lock_("ObjectRegistry lock") {
+  }
+
+  JDWP::ObjectId Add(Object* o) {
+    if (o == NULL) {
+      return 0;
+    }
+    JDWP::ObjectId id = static_cast<JDWP::ObjectId>(reinterpret_cast<uintptr_t>(o));
+    MutexLock mu(lock_);
+    map_[id] = o;
+    return id;
+  }
+
+  bool Contains(JDWP::ObjectId id) {
+    MutexLock mu(lock_);
+    return map_.find(id) != map_.end();
+  }
+
+ private:
+  Mutex lock_;
+  std::map<JDWP::ObjectId, Object*> map_;
+};
+
 // JDWP is allowed unless the Zygote forbids it.
 static bool gJdwpAllowed = true;
 
@@ -34,6 +61,8 @@
 static bool gDebuggerConnected;  // debugger or DDMS is connected.
 static bool gDebuggerActive;     // debugger is making requests.
 
+static ObjectRegistry* gRegistry = NULL;
+
 /*
  * Handle one of the JDWP name/value pairs.
  *
@@ -146,12 +175,16 @@
     return;
   }
 
+  CHECK(gRegistry == NULL);
+  gRegistry = new ObjectRegistry;
+
   // Init JDWP if the debugger is enabled. This may connect out to a
   // debugger, passively listen for a debugger, or block waiting for a
   // debugger.
   gJdwpState = JDWP::JdwpState::Create(&gJdwpOptions);
   if (gJdwpState == NULL) {
     LOG(WARNING) << "debugger thread failed to initialize";
+    return;
   }
 
   // If a debugger has already attached, send the "welcome" message.
@@ -166,6 +199,8 @@
 
 void Dbg::StopJdwp() {
   delete gJdwpState;
+  delete gRegistry;
+  gRegistry = NULL;
 }
 
 void Dbg::SetJdwpAllowed(bool allowed) {
@@ -173,8 +208,15 @@
 }
 
 DebugInvokeReq* Dbg::GetInvokeReq() {
-  UNIMPLEMENTED(FATAL);
-  return NULL;
+  return Thread::Current()->GetInvokeReq();
+}
+
+Thread* Dbg::GetDebugThread() {
+  return (gJdwpState != NULL) ? gJdwpState->GetDebugThread() : NULL;
+}
+
+void Dbg::ClearWaitForEventThread() {
+  gJdwpState->ClearWaitForEventThread();
 }
 
 void Dbg::Connected() {
@@ -472,16 +514,15 @@
 }
 
 JDWP::ObjectId Dbg::GetThreadSelfId() {
-  UNIMPLEMENTED(FATAL);
-  return 0;
+  return gRegistry->Add(Thread::Current()->GetPeer());
 }
 
-void Dbg::SuspendVM(bool isEvent) {
-  UNIMPLEMENTED(FATAL);
+void Dbg::SuspendVM() {
+  Runtime::Current()->GetThreadList()->SuspendAll(true);
 }
 
 void Dbg::ResumeVM() {
-  UNIMPLEMENTED(FATAL);
+  Runtime::Current()->GetThreadList()->ResumeAll(true);
 }
 
 void Dbg::SuspendThread(JDWP::ObjectId threadId) {
@@ -493,7 +534,7 @@
 }
 
 void Dbg::SuspendSelf() {
-  UNIMPLEMENTED(FATAL);
+  Runtime::Current()->GetThreadList()->SuspendSelfForDebugger();
 }
 
 bool Dbg::GetThisObject(JDWP::ObjectId threadId, JDWP::FrameId frameId, JDWP::ObjectId* pThisId) {
diff --git a/src/debugger.h b/src/debugger.h
index fa870b1..6eabf33 100644
--- a/src/debugger.h
+++ b/src/debugger.h
@@ -36,26 +36,29 @@
  * Invoke-during-breakpoint support.
  */
 struct DebugInvokeReq {
+  DebugInvokeReq() : lock_("a DebugInvokeReq lock"), cond_("a DebugInvokeReq condition variable") {
+  }
+
   /* boolean; only set when we're in the tail end of an event handler */
   bool ready;
 
   /* boolean; set if the JDWP thread wants this thread to do work */
-  bool invokeNeeded;
+  bool invoke_needed;
 
   /* request */
   Object* obj;        /* not used for ClassType.InvokeMethod */
   Object* thread;
   Class* class_;
   Method* method;
-  uint32_t numArgs;
-  uint64_t* argArray;   /* will be NULL if numArgs==0 */
+  uint32_t num_args;
+  uint64_t* arg_array;   /* will be NULL if numArgs==0 */
   uint32_t options;
 
   /* result */
-  JDWP::JdwpError err;
-  uint8_t resultTag;
-  JValue resultValue;
-  JDWP::ObjectId exceptObj;
+  JDWP::JdwpError error;
+  uint8_t result_tag;
+  JValue result_value;
+  JDWP::ObjectId exception;
 
   /* condition variable to wait on while the method executes */
   Mutex lock_;
@@ -73,6 +76,9 @@
   // Return the DebugInvokeReq for the current thread.
   static DebugInvokeReq* GetInvokeReq();
 
+  static Thread* GetDebugThread();
+  static void ClearWaitForEventThread();
+
   /*
    * Enable/disable breakpoints and step modes.  Used to provide a heads-up
    * when the debugger attaches.
@@ -182,7 +188,7 @@
   static bool GetThreadFrame(JDWP::ObjectId threadId, int num, JDWP::FrameId* pFrameId, JDWP::JdwpLocation* pLoc);
 
   static JDWP::ObjectId GetThreadSelfId();
-  static void SuspendVM(bool isEvent);
+  static void SuspendVM();
   static void ResumeVM();
   static void SuspendThread(JDWP::ObjectId threadId);
   static void ResumeThread(JDWP::ObjectId threadId);
diff --git a/src/jdwp/jdwp.h b/src/jdwp/jdwp.h
index cd2bfa7..a590c27 100644
--- a/src/jdwp/jdwp.h
+++ b/src/jdwp/jdwp.h
@@ -31,6 +31,8 @@
 
 namespace art {
 
+struct Thread;
+
 namespace JDWP {
 
 /*
@@ -118,11 +120,10 @@
    */
   bool IsActive();
 
-  /*
-   * Return the debugger thread's handle, or 0 if the debugger thread isn't
-   * running.
+  /**
+   * Returns the Thread* for the JDWP daemon thread.
    */
-  pthread_t GetDebugThread();
+  Thread* GetDebugThread();
 
   /*
    * Get time, in milliseconds, since the last debugger activity.
@@ -247,7 +248,8 @@
   ConditionVariable thread_start_cond_;
 
   volatile int32_t debug_thread_started_;
-  pthread_t debugThreadHandle;
+  pthread_t pthread_;
+  Thread* thread_;
 public: // TODO: fix privacy
   ObjectId debugThreadId;
 private:
diff --git a/src/jdwp/jdwp_event.cc b/src/jdwp/jdwp_event.cc
index 835b182..c6bdddb 100644
--- a/src/jdwp/jdwp_event.cc
+++ b/src/jdwp/jdwp_event.cc
@@ -539,7 +539,7 @@
   }
 
   if (suspendPolicy == SP_ALL) {
-    Dbg::SuspendVM(true);
+    Dbg::SuspendVM();
   } else {
     CHECK_EQ(suspendPolicy, SP_EVENT_THREAD);
   }
@@ -560,7 +560,7 @@
      * The JDWP thread has told us (and possibly all other threads) to
      * resume.  See if it has left anything in our DebugInvokeReq mailbox.
      */
-    if (!pReq->invokeNeeded) {
+    if (!pReq->invoke_needed) {
       /*LOGD("suspendByPolicy: no invoke needed");*/
       break;
     }
@@ -568,14 +568,14 @@
     /* grab this before posting/suspending again */
     state->SetWaitForEventThread(Dbg::GetThreadSelfId());
 
-    /* leave pReq->invokeNeeded raised so we can check reentrancy */
+    /* leave pReq->invoke_needed raised so we can check reentrancy */
     LOG(VERBOSE) << "invoking method...";
     Dbg::ExecuteMethod(pReq);
 
-    pReq->err = ERR_NONE;
+    pReq->error = ERR_NONE;
 
     /* clear this before signaling */
-    pReq->invokeNeeded = false;
+    pReq->invoke_needed = false;
 
     LOG(VERBOSE) << "invoke complete, signaling and self-suspending";
     MutexLock mu(pReq->lock_);
@@ -587,12 +587,12 @@
  * Determine if there is a method invocation in progress in the current
  * thread.
  *
- * We look at the "invokeNeeded" flag in the per-thread DebugInvokeReq
+ * We look at the "invoke_needed" flag in the per-thread DebugInvokeReq
  * state.  If set, we're in the process of invoking a method.
  */
 static bool invokeInProgress(JdwpState* state) {
   DebugInvokeReq* pReq = Dbg::GetInvokeReq();
-  return pReq->invokeNeeded;
+  return pReq->invoke_needed;
 }
 
 /*
diff --git a/src/jdwp/jdwp_handler.cc b/src/jdwp/jdwp_handler.cc
index 5e566ae..7003151 100644
--- a/src/jdwp/jdwp_handler.cc
+++ b/src/jdwp/jdwp_handler.cc
@@ -310,7 +310,7 @@
  * This needs to increment the "suspend count" on all threads.
  */
 static JdwpError handleVM_Suspend(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) {
-  Dbg::SuspendVM(false);
+  Dbg::SuspendVM();
   return ERR_NONE;
 }
 
diff --git a/src/jdwp/jdwp_main.cc b/src/jdwp/jdwp_main.cc
index a7857a1..1df0d66 100644
--- a/src/jdwp/jdwp_main.cc
+++ b/src/jdwp/jdwp_main.cc
@@ -151,7 +151,7 @@
    * We have bound to a port, or are trying to connect outbound to a
    * debugger.  Create the JDWP thread and let it continue the mission.
    */
-  CHECK_PTHREAD_CALL(pthread_create, (&state->debugThreadHandle, NULL, StartJdwpThread, state), "JDWP thread");
+  CHECK_PTHREAD_CALL(pthread_create, (&state->pthread_, NULL, StartJdwpThread, state), "JDWP thread");
 
   /*
    * Wait until the thread finishes basic initialization.
@@ -238,7 +238,7 @@
     if (debug_thread_started_) {
       run = false;
       void* threadReturn;
-      if (pthread_join(debugThreadHandle, &threadReturn) != 0) {
+      if (pthread_join(pthread_, &threadReturn) != 0) {
         LOG(WARNING) << "JDWP thread join failed";
       }
     }
@@ -281,7 +281,7 @@
    * Finish initializing, then notify the creating thread that
    * we're running.
    */
-  debugThreadHandle = pthread_self();
+  thread_ = Thread::Current();
   run = true;
   android_atomic_release_store(true, &debug_thread_started_);
 
@@ -387,8 +387,8 @@
   runtime->DetachCurrentThread();
 }
 
-pthread_t JdwpState::GetDebugThread() {
-  return debugThreadHandle;
+Thread* JdwpState::GetDebugThread() {
+  return thread_;
 }
 
 /*
diff --git a/src/thread.cc b/src/thread.cc
index f4ca2ab..b8dbd6b 100644
--- a/src/thread.cc
+++ b/src/thread.cc
@@ -731,7 +731,8 @@
       class_loader_override_(NULL),
       long_jump_context_(NULL),
       throwing_OutOfMemoryError_(false),
-      pre_allocated_OutOfMemoryError_(NULL) {
+      pre_allocated_OutOfMemoryError_(NULL),
+      debug_invoke_req_(new DebugInvokeReq) {
   CHECK_EQ((sizeof(Thread) % 4), 0U) << sizeof(Thread);
 }
 
@@ -774,6 +775,8 @@
   delete wait_mutex_;
 
   delete long_jump_context_;
+
+  delete debug_invoke_req_;
 }
 
 void Thread::HandleUncaughtExceptions() {
diff --git a/src/thread.h b/src/thread.h
index 8edeaf2..d81fd9a 100644
--- a/src/thread.h
+++ b/src/thread.h
@@ -43,6 +43,7 @@
 class ClassLinker;
 class ClassLoader;
 class Context;
+class DebugInvokeReq;
 class Method;
 class Monitor;
 class Object;
@@ -455,6 +456,10 @@
 
   void WalkStack(StackVisitor* visitor) const;
 
+  DebugInvokeReq* GetInvokeReq() {
+    return debug_invoke_req_;
+  }
+
  private:
   Thread();
   ~Thread();
@@ -583,6 +588,9 @@
 
   Throwable* pre_allocated_OutOfMemoryError_;
 
+  // JDWP invoke-during-breakpoint support.
+  DebugInvokeReq* debug_invoke_req_;
+
   // TLS key used to retrieve the VM thread object.
   static pthread_key_t pthread_key_self_;
 
diff --git a/src/thread_list.cc b/src/thread_list.cc
index dfce2a2..f386547 100644
--- a/src/thread_list.cc
+++ b/src/thread_list.cc
@@ -18,6 +18,8 @@
 
 #include <unistd.h>
 
+#include "debugger.h"
+
 namespace art {
 
 // TODO: merge with ThreadListLock?
@@ -113,23 +115,24 @@
   }
 }
 
-void ThreadList::SuspendAll() {
+void ThreadList::SuspendAll(bool for_debugger) {
   Thread* self = Thread::Current();
 
   // TODO: add another thread_suspend_lock_ to avoid GC/debugger races.
 
   if (verbose_) {
-    LOG(INFO) << *self << " SuspendAll starting...";
+    LOG(INFO) << *self << " SuspendAll starting..." << (for_debugger ? " (debugger)" : "");
   }
 
   ThreadListLocker locker(this);
+  Thread* debug_thread = Dbg::GetDebugThread();
 
   {
     // Increment everybody's suspend count (except our own).
     MutexLock mu(thread_suspend_count_lock_);
     for (It it = list_.begin(), end = list_.end(); it != end; ++it) {
       Thread* thread = *it;
-      if (thread != self) {
+      if (thread != self && thread != debug_thread) {
         if (verbose_) {
           LOG(INFO) << "requesting thread suspend: " << *thread;
         }
@@ -154,7 +157,7 @@
    */
   for (It it = list_.begin(), end = list_.end(); it != end; ++it) {
     Thread* thread = *it;
-    if (thread != self) {
+    if (thread != self && thread != debug_thread) {
       thread->WaitUntilSuspended();
       if (verbose_) {
         LOG(INFO) << "thread suspended: " << *thread;
@@ -193,12 +196,56 @@
   }
 }
 
+void ThreadList::SuspendSelfForDebugger() {
+  Thread* self = Thread::Current();
 
-void ThreadList::ResumeAll() {
+  // The debugger thread must not suspend itself due to debugger activity!
+  Thread* debug_thread = Dbg::GetDebugThread();
+  CHECK(debug_thread != NULL);
+  CHECK(self != debug_thread);
+
+  // Collisions with other suspends aren't really interesting. We want
+  // to ensure that we're the only one fiddling with the suspend count
+  // though.
+  ThreadListLocker locker(this);
+  MutexLock mu(thread_suspend_count_lock_);
+  ++self->suspend_count_;
+
+  // Suspend ourselves.
+  CHECK_GT(self->suspend_count_, 0);
+  self->SetState(Thread::kSuspended);
+  if (verbose_) {
+    LOG(INFO) << *self << " self-suspending (dbg)";
+  }
+
+  // Tell JDWP that we've completed suspension. The JDWP thread can't
+  // tell us to resume before we're fully asleep because we hold the
+  // suspend count lock.
+  Dbg::ClearWaitForEventThread();
+
+  while (self->suspend_count_ != 0) {
+    thread_suspend_count_cond_.Wait(thread_suspend_count_lock_);
+    if (self->suspend_count_ != 0) {
+      // The condition was signaled but we're still suspended. This
+      // can happen if the debugger lets go while a SIGQUIT thread
+      // dump event is pending (assuming SignalCatcher was resumed for
+      // just long enough to try to grab the thread-suspend lock).
+      LOG(DEBUG) << *self << " still suspended after undo "
+                 << "(suspend count=" << self->suspend_count_ << ")";
+    }
+  }
+  CHECK_EQ(self->suspend_count_, 0);
+  self->SetState(Thread::kRunnable);
+  if (verbose_) {
+    LOG(INFO) << *self << " self-reviving (dbg)";
+  }
+}
+
+void ThreadList::ResumeAll(bool for_debugger) {
   Thread* self = Thread::Current();
 
   if (verbose_) {
-    LOG(INFO) << *self << " ResumeAll starting";
+    LOG(INFO) << *self << " ResumeAll starting" << (for_debugger ? " (debugger)" : "");
   }
 
   // Decrement the suspend counts for all threads.  No need for atomic
@@ -206,10 +253,11 @@
   // We do need to hold the thread list because of JNI attaches.
   {
     ThreadListLocker locker(this);
+    Thread* debug_thread = Dbg::GetDebugThread();
     MutexLock mu(thread_suspend_count_lock_);
     for (It it = list_.begin(), end = list_.end(); it != end; ++it) {
       Thread* thread = *it;
-      if (thread != self) {
+      if (thread != self && thread != debug_thread) {
         if (thread->suspend_count_ > 0) {
           --thread->suspend_count_;
         } else {
diff --git a/src/thread_list.h b/src/thread_list.h
index 3a20405..baa7dad 100644
--- a/src/thread_list.h
+++ b/src/thread_list.h
@@ -36,8 +36,9 @@
 
   // Thread suspension support.
   void FullSuspendCheck(Thread* thread);
-  void ResumeAll();
-  void SuspendAll();
+  void ResumeAll(bool for_debugger = false);
+  void SuspendAll(bool for_debugger = false);
+  void SuspendSelfForDebugger();
   void RunWhileSuspended(Thread* thread, void (*callback)(void*), void* arg);
 
   void Register();