diff --git a/build/Android.common.mk b/build/Android.common.mk
index 33e59cc..b99a876 100644
--- a/build/Android.common.mk
+++ b/build/Android.common.mk
@@ -68,6 +68,8 @@
 	src/calling_convention_arm.cc \
 	src/calling_convention_x86.cc \
 	src/context.cc \
+	src/context_arm.cc.arm \
+	src/context_x86.cc \
 	src/check_jni.cc \
 	src/class_linker.cc \
 	src/class_loader.cc \
@@ -140,7 +142,6 @@
 
 LIBART_TARGET_SRC_FILES := \
 	$(LIBART_COMMON_SRC_FILES) \
-	src/context_arm.cc.arm \
 	src/logging_android.cc \
 	src/runtime_android.cc \
 	src/thread_android.cc \
@@ -148,7 +149,6 @@
 
 LIBART_HOST_SRC_FILES := \
 	$(LIBART_COMMON_SRC_FILES) \
-	src/context_x86.cc \
 	src/logging_linux.cc \
 	src/runtime_linux.cc \
 	src/thread_linux.cc \
diff --git a/src/context_arm.cc b/src/context_arm.cc
index 3c2af94..387b71d 100644
--- a/src/context_arm.cc
+++ b/src/context_arm.cc
@@ -32,6 +32,7 @@
 }
 
 void ArmContext::DoLongJump() {
+#if defined(__arm__)
   // TODO: Load all GPRs and FPRs, currently the code restores registers R4 to PC
   asm volatile ( "mov %%r0, %0\n"
                  "mov %%r1, %1\n"
@@ -50,6 +51,9 @@
         "w28"(fprs_[28]), "w29"(fprs_[29]), "w30"(fprs_[30]), "w31"(fprs_[31])
 #endif
       :);  // clobber
+#else
+  UNIMPLEMENTED(FATAL);
+#endif
 }
 
 }  // namespace arm
diff --git a/src/context_x86.cc b/src/context_x86.cc
index 2f328e1..43de4ba 100644
--- a/src/context_x86.cc
+++ b/src/context_x86.cc
@@ -2,16 +2,22 @@
 
 #include "context_x86.h"
 
+#include "logging.h"
+
 namespace art {
 namespace x86 {
 
 void X86Context::DoLongJump() {
+#if defined(__i386__)
   // Load ESP and EIP
   asm volatile ( "movl %%esp, %0\n"
                  "jmp *%1"
       : // output
       : "m"(esp_), "r"(&eip_)  // input
       :);  // clobber
+#else
+  UNIMPLEMENTED(FATAL);
+#endif
 }
 
 }  // namespace x86
diff --git a/src/heap.cc b/src/heap.cc
index 4778611..094790a 100644
--- a/src/heap.cc
+++ b/src/heap.cc
@@ -124,6 +124,8 @@
     RecordImageAllocations(image_spaces[i]);
   }
 
+  Heap::EnableObjectValidation();
+
   // It's still to early to take a lock because there are no threads yet,
   // but we can create the heap lock now. We don't create it earlier to
   // make it clear that you can't use locks during heap initialization.
@@ -167,10 +169,13 @@
   return true;
 }
 
-bool Heap::verify_object_disabled_;
+bool Heap::verify_objects_ = false;
 
 #if VERIFY_OBJECT_ENABLED
 void Heap::VerifyObject(const Object* obj) {
+  if (!verify_objects_) {
+    return;
+  }
   ScopedHeapLock lock;
   Heap::VerifyObjectLocked(obj);
 }
@@ -178,7 +183,7 @@
 
 void Heap::VerifyObjectLocked(const Object* obj) {
   lock_->AssertHeld();
-  if (obj != NULL && !verify_object_disabled_) {
+  if (obj != NULL) {
     if (!IsAligned(obj, kObjectAlignment)) {
       LOG(FATAL) << "Object isn't aligned: " << obj;
     } else if (!live_bitmap_->Test(obj)) {
diff --git a/src/heap.h b/src/heap.h
index e95cfcc..e12ef4a 100644
--- a/src/heap.h
+++ b/src/heap.h
@@ -143,9 +143,12 @@
     return finalizer_reference_zombie_offset_;
   }
 
+  static void EnableObjectValidation() {
+    verify_objects_ = true;
+  }
+
   static void DisableObjectValidation() {
-    // TODO: remove this hack necessary for image writing
-    verify_object_disabled_ = true;
+    verify_objects_ = false;
   }
 
   // Callers must hold the heap lock.
@@ -220,7 +223,7 @@
   // offset of java.lang.ref.FinalizerReference.zombie
   static MemberOffset finalizer_reference_zombie_offset_;
 
-  static bool verify_object_disabled_;
+  static bool verify_objects_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(Heap);
 };
diff --git a/src/jni_internal.h b/src/jni_internal.h
index a0602e5..38e38fc 100644
--- a/src/jni_internal.h
+++ b/src/jni_internal.h
@@ -104,7 +104,7 @@
   JNIEnvExt(Thread* self, JavaVMExt* vm);
   ~JNIEnvExt();
 
-  Thread* self;
+  Thread* const self;
   JavaVMExt* vm;
 
   // Frequently-accessed fields cached from JavaVM.
diff --git a/src/macros.h b/src/macros.h
index 36afd27..9c5124b 100644
--- a/src/macros.h
+++ b/src/macros.h
@@ -123,4 +123,6 @@
 #define OFFSETOF_VOLATILE_MEMBER(t, f) \
   (reinterpret_cast<volatile char*>(&reinterpret_cast<t*>(16)->f) - reinterpret_cast<volatile char*>(16))
 
+#define PACKED __attribute__ ((__packed__))
+
 #endif  // ART_SRC_MACROS_H_
diff --git a/src/monitor.cc b/src/monitor.cc
index 1a5e6c9..cc74838 100644
--- a/src/monitor.cc
+++ b/src/monitor.cc
@@ -511,7 +511,7 @@
     self->SetState(Thread::kWaiting);
   }
 
-  self->wait_mutex_.Lock();
+  self->wait_mutex_->Lock();
 
   /*
    * Set wait_monitor_ to the monitor object we will be waiting on.
@@ -529,7 +529,7 @@
   if (self->interrupted_) {
     wasInterrupted = true;
     self->wait_monitor_ = NULL;
-    self->wait_mutex_.Unlock();
+    self->wait_mutex_->Unlock();
     goto done;
   }
 
@@ -540,9 +540,9 @@
   lock_.Unlock();
 
   if (!timed) {
-    self->wait_cond_.Wait(self->wait_mutex_);
+    self->wait_cond_->Wait(*self->wait_mutex_);
   } else {
-    self->wait_cond_.TimedWait(self->wait_mutex_, ts);
+    self->wait_cond_->TimedWait(*self->wait_mutex_, ts);
   }
   if (self->interrupted_) {
     wasInterrupted = true;
@@ -550,7 +550,7 @@
 
   self->interrupted_ = false;
   self->wait_monitor_ = NULL;
-  self->wait_mutex_.Unlock();
+  self->wait_mutex_->Unlock();
 
   // Reacquire the monitor lock.
   Lock(self);
@@ -601,9 +601,9 @@
     thread->wait_next_ = NULL;
 
     // Check to see if the thread is still waiting.
-    MutexLock mu(thread->wait_mutex_);
+    MutexLock mu(*thread->wait_mutex_);
     if (thread->wait_monitor_ != NULL) {
-      thread->wait_cond_.Signal();
+      thread->wait_cond_->Signal();
       return;
     }
   }
diff --git a/src/object.h b/src/object.h
index 02c98d8..8addcc6 100644
--- a/src/object.h
+++ b/src/object.h
@@ -185,7 +185,7 @@
 
 // Classes shared with the managed side of the world need to be packed
 // so that they don't have extra platform specific padding.
-#define MANAGED __attribute__ ((__packed__))
+#define MANAGED PACKED
 
 // C++ mirror of java.lang.Object
 class MANAGED Object {
diff --git a/src/runtime.cc b/src/runtime.cc
index d82f255..e0a0b20 100644
--- a/src/runtime.cc
+++ b/src/runtime.cc
@@ -187,13 +187,9 @@
   parsed->check_jni_ = false;
 #else
   // ...but on by default in debug builds.
-#if 0 // TODO: disabled for oatexec until the shorty's used by check_jni are managed heap allocated.
-      // Instead we turn on -Xcheck_jni in common_test.
   parsed->check_jni_ = true;
-#else
-  parsed->check_jni_ = false;
 #endif
-#endif
+
   parsed->heap_initial_size_ = Heap::kInitialSize;
   parsed->heap_maximum_size_ = Heap::kMaximumSize;
   parsed->stack_size_ = Thread::kDefaultStackSize;
@@ -338,6 +334,8 @@
     CreateClassPath(parsed->class_path_string_, parsed->class_path_);
   }
 
+  LOG(INFO) << "CheckJNI is " << (parsed->check_jni_ ? "on" : "off");
+
   return parsed.release();
 }
 
@@ -357,11 +355,25 @@
 void Runtime::Start() {
   started_ = true;
 
+  // Initialize both the built-in and libcore native methods.
+  InitLibraries();
+
   // Finish attaching the main thread.
-  Thread* main_thread = Thread::Current();
-  instance_->InitLibraries();
-  main_thread->CreatePeer("main", false);
-  instance_->signal_catcher_ = new SignalCatcher;
+  Thread::Current()->CreatePeer("main", false);
+
+  StartDaemonThreads();
+}
+
+void Runtime::StartDaemonThreads() {
+  signal_catcher_ = new SignalCatcher;
+
+  Class* c = class_linker_->FindSystemClass("Ljava/lang/Daemons;");
+  CHECK(c != NULL);
+  Method* m = c->FindDirectMethod("start", "()V");
+  CHECK(m != NULL);
+//  m->Invoke(Thread::Current(), NULL, NULL, NULL);
+
+  signal_catcher_->HandleSigQuit();
 }
 
 bool Runtime::IsStarted() {
diff --git a/src/runtime.h b/src/runtime.h
index 084e49c..35f8ef7 100644
--- a/src/runtime.h
+++ b/src/runtime.h
@@ -163,6 +163,7 @@
   bool Init(const Options& options, bool ignore_unrecognized);
   void InitLibraries();
   void RegisterRuntimeNativeMethods(JNIEnv*);
+  void StartDaemonThreads();
 
   std::string boot_class_path_;
   std::string class_path_;
diff --git a/src/thread.cc b/src/thread.cc
index 49c9605..83c1b81 100644
--- a/src/thread.cc
+++ b/src/thread.cc
@@ -830,8 +830,8 @@
 
 Thread::Thread()
     : peer_(NULL),
-      wait_mutex_("Thread wait mutex"),
-      wait_cond_("Thread wait condition variable"),
+      wait_mutex_(new Mutex("Thread wait mutex")),
+      wait_cond_(new ConditionVariable("Thread wait condition variable")),
       wait_monitor_(NULL),
       interrupted_(false),
       stack_end_(NULL),
@@ -842,7 +842,8 @@
       state_(Thread::kUnknown),
       exception_(NULL),
       suspend_count_(0),
-      class_loader_override_(NULL) {
+      class_loader_override_(NULL),
+      long_jump_context_(NULL) {
 }
 
 void MonitorExitVisitor(const Object* object, void*) {
@@ -896,6 +897,11 @@
   jni_env_ = NULL;
 
   SetState(Thread::kTerminated);
+
+  delete wait_cond_;
+  delete wait_mutex_;
+
+  delete long_jump_context_;
 }
 
 size_t Thread::NumSirtReferences() {
@@ -1235,10 +1241,10 @@
 }
 
 Context* Thread::GetLongJumpContext() {
-  Context* result = long_jump_context_.get();
+  Context* result = long_jump_context_;
   if (result == NULL) {
     result = Context::Create();
-    long_jump_context_.reset(result);
+    long_jump_context_ = result;
   }
   return result;
 }
diff --git a/src/thread.h b/src/thread.h
index ef2fa12..860a185 100644
--- a/src/thread.h
+++ b/src/thread.h
@@ -102,7 +102,7 @@
 };
 
 // Iterator over managed frames up to the first native-to-managed transition
-class Frame {
+class PACKED Frame {
  public:
   Frame() : sp_(NULL) {}
 
@@ -138,7 +138,7 @@
   Method** sp_;
 };
 
-class Thread {
+class PACKED Thread {
  public:
   /* thread priorities, from java.lang.Thread */
   enum Priority {
@@ -390,7 +390,7 @@
 
   // Implements java.lang.Thread.interrupted.
   bool Interrupted() {
-    MutexLock mu(wait_mutex_);
+    MutexLock mu(*wait_mutex_);
     bool interrupted = interrupted_;
     interrupted_ = false;
     return interrupted;
@@ -398,12 +398,12 @@
 
   // Implements java.lang.Thread.isInterrupted.
   bool IsInterrupted() {
-    MutexLock mu(wait_mutex_);
+    MutexLock mu(*wait_mutex_);
     return interrupted_;
   }
 
   void Interrupt() {
-    MutexLock mu(wait_mutex_);
+    MutexLock mu(*wait_mutex_);
     if (interrupted_) {
       return;
     }
@@ -412,7 +412,7 @@
   }
 
   void Notify() {
-    MutexLock mu(wait_mutex_);
+    MutexLock mu(*wait_mutex_);
     NotifyLocked();
   }
 
@@ -535,7 +535,7 @@
 
   void NotifyLocked() {
     if (wait_monitor_ != NULL) {
-      wait_cond_.Signal();
+      wait_cond_->Signal();
     }
   }
 
@@ -562,8 +562,8 @@
   Object* peer_;
 
   // Guards the 'interrupted_' and 'wait_monitor_' members.
-  mutable Mutex wait_mutex_;
-  ConditionVariable wait_cond_;
+  mutable Mutex* wait_mutex_;
+  ConditionVariable* wait_cond_;
   // Pointer to the monitor lock we're currently waiting on (or NULL), guarded by wait_mutex_.
   Monitor* wait_monitor_;
   // Thread "interrupted" status; stays raised until queried or thrown, guarded by wait_mutex_.
@@ -619,7 +619,7 @@
   const ClassLoader* class_loader_override_;
 
   // Thread local, lazily allocated, long jump context. Used to deliver exceptions.
-  UniquePtr<Context> long_jump_context_;
+  Context* long_jump_context_;
 
   // TLS key used to retrieve the VM thread object.
   static pthread_key_t pthread_key_self_;