diff --git a/src/class_linker.cc b/src/class_linker.cc
index ce9b37b..689b928 100644
--- a/src/class_linker.cc
+++ b/src/class_linker.cc
@@ -1577,12 +1577,12 @@
   for (size_t i = 0; it.HasNextDirectMethod(); i++, it.Next()) {
     AbstractMethod* method = klass->GetDirectMethod(i);
     if (Runtime::Current()->IsMethodTracingActive()) {
-      Trace* tracer = Runtime::Current()->GetTracer();
-      if (tracer->GetSavedCodeFromMap(method) == trampoline) {
+      Instrumentation* instrumentation = Runtime::Current()->GetInstrumentation();
+      if (instrumentation->GetSavedCodeFromMap(method) == trampoline) {
         const void* code = oat_class->GetOatMethod(method_index).GetCode();
-        tracer->ResetSavedCode(method);
+        instrumentation->ResetSavedCode(method);
         method->SetCode(code);
-        tracer->SaveAndUpdateCode(method);
+        instrumentation->SaveAndUpdateCode(method);
       }
     } else if (method->GetCode() == trampoline) {
       const void* code = oat_class->GetOatMethod(method_index).GetCode();
@@ -1618,8 +1618,8 @@
   }
 
   if (Runtime::Current()->IsMethodTracingActive()) {
-    Trace* tracer = Runtime::Current()->GetTracer();
-    tracer->SaveAndUpdateCode(method.get());
+    Instrumentation* instrumentation = Runtime::Current()->GetInstrumentation();
+    instrumentation->SaveAndUpdateCode(method.get());
   }
 }
 
diff --git a/src/compiler_llvm/runtime_support_llvm.cc b/src/compiler_llvm/runtime_support_llvm.cc
index 0e0500c..43d1a4c 100644
--- a/src/compiler_llvm/runtime_support_llvm.cc
+++ b/src/compiler_llvm/runtime_support_llvm.cc
@@ -150,7 +150,7 @@
 void art_throw_null_pointer_exception_from_code(uint32_t dex_pc)
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   Thread* thread = art_get_current_thread_from_code();
-  NthCallerVisitor visitor(thread->GetManagedStack(), thread->GetTraceStack(), 0);
+  NthCallerVisitor visitor(thread->GetManagedStack(), thread->GetInstrumentationStack(), 0);
   visitor.WalkStack();
   AbstractMethod* throw_method = visitor.caller;
   ThrowNullPointerExceptionFromDexPC(throw_method, dex_pc);
@@ -160,7 +160,7 @@
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   Thread* thread = art_get_current_thread_from_code();
   if (Runtime::Current()->IsMethodTracingActive()) {
-    TraceMethodUnwindFromCode(thread);
+    InstrumentationMethodUnwindFromCode(thread);
   }
   thread->SetStackEndForStackOverflow();  // Allow space on the stack for constructor to execute.
   thread->ThrowNewExceptionF("Ljava/lang/StackOverflowError;", "stack size %s",
diff --git a/src/debugger.cc b/src/debugger.cc
index 7de675c..1d8b997 100644
--- a/src/debugger.cc
+++ b/src/debugger.cc
@@ -1543,8 +1543,8 @@
     SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
   struct CountStackDepthVisitor : public StackVisitor {
     CountStackDepthVisitor(const ManagedStack* stack,
-                           const std::vector<TraceStackFrame>* trace_stack)
-        : StackVisitor(stack, trace_stack, NULL), depth(0) {}
+                           const std::vector<InstrumentationStackFrame>* instrumentation_stack)
+        : StackVisitor(stack, instrumentation_stack, NULL), depth(0) {}
 
     bool VisitFrame() {
       if (!GetMethod()->IsRuntimeMethod()) {
@@ -1559,7 +1559,7 @@
     MutexLock mu(Thread::Current(), *Locks::thread_suspend_count_lock_);
     CHECK(thread->IsSuspended());
   }
-  CountStackDepthVisitor visitor(thread->GetManagedStack(), thread->GetTraceStack());
+  CountStackDepthVisitor visitor(thread->GetManagedStack(), thread->GetInstrumentationStack());
   visitor.WalkStack();
   return visitor.depth;
 }
@@ -1572,10 +1572,10 @@
 JDWP::JdwpError Dbg::GetThreadFrames(JDWP::ObjectId thread_id, size_t start_frame, size_t frame_count, JDWP::ExpandBuf* buf) {
   class GetFrameVisitor : public StackVisitor {
    public:
-    GetFrameVisitor(const ManagedStack* stack, const std::vector<TraceStackFrame>* trace_stack,
+    GetFrameVisitor(const ManagedStack* stack, const std::vector<InstrumentationStackFrame>* instrumentation_stack,
                     size_t start_frame, size_t frame_count, JDWP::ExpandBuf* buf)
         SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
-        : StackVisitor(stack, trace_stack, NULL), depth_(0),
+        : StackVisitor(stack, instrumentation_stack, NULL), depth_(0),
           start_frame_(start_frame), frame_count_(frame_count), buf_(buf) {
       expandBufAdd4BE(buf_, frame_count_);
     }
@@ -1610,7 +1610,7 @@
 
   ScopedObjectAccessUnchecked soa(Thread::Current());
   Thread* thread = DecodeThread(soa, thread_id);  // Caller already checked thread is suspended.
-  GetFrameVisitor visitor(thread->GetManagedStack(), thread->GetTraceStack(), start_frame, frame_count, buf);
+  GetFrameVisitor visitor(thread->GetManagedStack(), thread->GetInstrumentationStack(), start_frame, frame_count, buf);
   visitor.WalkStack();
   return JDWP::ERR_NONE;
 }
@@ -1675,10 +1675,10 @@
 }
 
 struct GetThisVisitor : public StackVisitor {
-  GetThisVisitor(const ManagedStack* stack, const std::vector<TraceStackFrame>* trace_stack,
+  GetThisVisitor(const ManagedStack* stack, const std::vector<InstrumentationStackFrame>* instrumentation_stack,
                  Context* context, JDWP::FrameId frameId)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
-      : StackVisitor(stack, trace_stack, context), this_object(NULL), frame_id(frameId) {}
+      : StackVisitor(stack, instrumentation_stack, context), this_object(NULL), frame_id(frameId) {}
 
   // TODO: Enable annotalysis. We know lock is held in constructor, but abstraction confuses
   // annotalysis.
@@ -1708,7 +1708,7 @@
   }
 
   UniquePtr<Context> context(Context::Create());
-  GetThisVisitor visitor(self->GetManagedStack(), self->GetTraceStack(), context.get(), frame_id);
+  GetThisVisitor visitor(self->GetManagedStack(), self->GetInstrumentationStack(), context.get(), frame_id);
   visitor.WalkStack();
   return visitor.this_object;
 }
@@ -1729,7 +1729,7 @@
     }
   }
   UniquePtr<Context> context(Context::Create());
-  GetThisVisitor visitor(thread->GetManagedStack(), thread->GetTraceStack(), context.get(), frame_id);
+  GetThisVisitor visitor(thread->GetManagedStack(), thread->GetInstrumentationStack(), context.get(), frame_id);
   visitor.WalkStack();
   *result = gRegistry->Add(visitor.this_object);
   return JDWP::ERR_NONE;
@@ -1738,11 +1738,11 @@
 void Dbg::GetLocalValue(JDWP::ObjectId threadId, JDWP::FrameId frameId, int slot, JDWP::JdwpTag tag,
                         uint8_t* buf, size_t width) {
   struct GetLocalVisitor : public StackVisitor {
-    GetLocalVisitor(const ManagedStack* stack, const std::vector<TraceStackFrame>* trace_stack,
+    GetLocalVisitor(const ManagedStack* stack, const std::vector<InstrumentationStackFrame>* instrumentation_stack,
                     Context* context, JDWP::FrameId frameId, int slot, JDWP::JdwpTag tag,
                     uint8_t* buf, size_t width)
         SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
-        : StackVisitor(stack, trace_stack, context), frame_id_(frameId), slot_(slot), tag_(tag),
+        : StackVisitor(stack, instrumentation_stack, context), frame_id_(frameId), slot_(slot), tag_(tag),
           buf_(buf), width_(width) {}
 
     // TODO: Enable annotalysis. We know lock is held in constructor, but abstraction confuses
@@ -1849,7 +1849,7 @@
   ScopedObjectAccessUnchecked soa(Thread::Current());
   Thread* thread = DecodeThread(soa, threadId);
   UniquePtr<Context> context(Context::Create());
-  GetLocalVisitor visitor(thread->GetManagedStack(), thread->GetTraceStack(), context.get(),
+  GetLocalVisitor visitor(thread->GetManagedStack(), thread->GetInstrumentationStack(), context.get(),
                           frameId, slot, tag, buf, width);
   visitor.WalkStack();
 }
@@ -1857,11 +1857,11 @@
 void Dbg::SetLocalValue(JDWP::ObjectId threadId, JDWP::FrameId frameId, int slot, JDWP::JdwpTag tag,
                         uint64_t value, size_t width) {
   struct SetLocalVisitor : public StackVisitor {
-    SetLocalVisitor(const ManagedStack* stack, const std::vector<TraceStackFrame>* trace_stack, Context* context,
+    SetLocalVisitor(const ManagedStack* stack, const std::vector<InstrumentationStackFrame>* instrumentation_stack, Context* context,
                     JDWP::FrameId frame_id, int slot, JDWP::JdwpTag tag, uint64_t value,
                     size_t width)
         SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
-        : StackVisitor(stack, trace_stack, context),
+        : StackVisitor(stack, instrumentation_stack, context),
           frame_id_(frame_id), slot_(slot), tag_(tag), value_(value), width_(width) {}
 
     // TODO: Enable annotalysis. We know lock is held in constructor, but abstraction confuses
@@ -1925,7 +1925,7 @@
   ScopedObjectAccessUnchecked soa(Thread::Current());
   Thread* thread = DecodeThread(soa, threadId);
   UniquePtr<Context> context(Context::Create());
-  SetLocalVisitor visitor(thread->GetManagedStack(), thread->GetTraceStack(), context.get(),
+  SetLocalVisitor visitor(thread->GetManagedStack(), thread->GetInstrumentationStack(), context.get(),
                           frameId, slot, tag, value, width);
   visitor.WalkStack();
 }
@@ -1965,7 +1965,7 @@
 
   // We need 'this' for InstanceOnly filters.
   UniquePtr<Context> context(Context::Create());
-  GetThisVisitor visitor(thread->GetManagedStack(), thread->GetTraceStack(), context.get(), throw_frame_id);
+  GetThisVisitor visitor(thread->GetManagedStack(), thread->GetInstrumentationStack(), context.get(), throw_frame_id);
   visitor.WalkStack();
   JDWP::ObjectId this_id = gRegistry->Add(visitor.this_object);
 
@@ -2147,10 +2147,10 @@
 
   struct SingleStepStackVisitor : public StackVisitor {
     SingleStepStackVisitor(const ManagedStack* stack,
-                           const std::vector<TraceStackFrame>* trace_stack)
+                           const std::vector<InstrumentationStackFrame>* instrumentation_stack)
         EXCLUSIVE_LOCKS_REQUIRED(gBreakpointsLock)
         SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
-        : StackVisitor(stack, trace_stack, NULL) {
+        : StackVisitor(stack, instrumentation_stack, NULL) {
       gBreakpointsLock.AssertHeld(Thread::Current());
       gSingleStepControl.method = NULL;
       gSingleStepControl.stack_depth = 0;
@@ -2176,7 +2176,7 @@
       return true;
     }
   };
-  SingleStepStackVisitor visitor(thread->GetManagedStack(), thread->GetTraceStack());
+  SingleStepStackVisitor visitor(thread->GetManagedStack(), thread->GetInstrumentationStack());
   visitor.WalkStack();
 
   //
@@ -2679,7 +2679,7 @@
     ScopedObjectAccessUnchecked soa(Thread::Current());
     SirtRef<String> name(soa.Self(), t->GetThreadName(soa));
     size_t char_count = (name.get() != NULL) ? name->GetLength() : 0;
-    const jchar* chars = name->GetCharArray()->GetData();
+    const jchar* chars = (name.get() != NULL) ? name->GetCharArray()->GetData() : NULL;
 
     std::vector<uint8_t> bytes;
     JDWP::Append4BE(bytes, t->GetThinLockId());
@@ -3130,9 +3130,9 @@
 
 struct AllocRecordStackVisitor : public StackVisitor {
   AllocRecordStackVisitor(const ManagedStack* stack,
-                          const std::vector<TraceStackFrame>* trace_stack, AllocRecord* record)
+                          const std::vector<InstrumentationStackFrame>* instrumentation_stack, AllocRecord* record)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
-      : StackVisitor(stack, trace_stack, NULL), record(record), depth(0) {}
+      : StackVisitor(stack, instrumentation_stack, NULL), record(record), depth(0) {}
 
   // TODO: Enable annotalysis. We know lock is held in constructor, but abstraction confuses
   // annotalysis.
@@ -3182,7 +3182,7 @@
   record->thin_lock_id = self->GetThinLockId();
 
   // Fill in the stack trace.
-  AllocRecordStackVisitor visitor(self->GetManagedStack(), self->GetTraceStack(), record);
+  AllocRecordStackVisitor visitor(self->GetManagedStack(), self->GetInstrumentationStack(), record);
   visitor.WalkStack();
 
   if (gAllocRecordCount < kNumAllocRecords) {
diff --git a/src/instrumentation.cc b/src/instrumentation.cc
new file mode 100644
index 0000000..d796aef
--- /dev/null
+++ b/src/instrumentation.cc
@@ -0,0 +1,174 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "instrumentation.h"
+
+#include <sys/uio.h>
+
+#include "class_linker.h"
+#include "debugger.h"
+#include "dex_cache.h"
+#if !defined(ART_USE_LLVM_COMPILER)
+#include "oat/runtime/oat_support_entrypoints.h"
+#endif
+#include "object_utils.h"
+#include "os.h"
+#include "scoped_thread_state_change.h"
+#include "thread.h"
+#include "thread_list.h"
+#include "trace.h"
+
+namespace art {
+
+static bool InstallStubsClassVisitor(Class* klass, void*)
+    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+  Instrumentation* instrumentation = Runtime::Current()->GetInstrumentation();
+  for (size_t i = 0; i < klass->NumDirectMethods(); i++) {
+    AbstractMethod* method = klass->GetDirectMethod(i);
+    if (instrumentation->GetSavedCodeFromMap(method) == NULL) {
+      instrumentation->SaveAndUpdateCode(method);
+    }
+  }
+
+  for (size_t i = 0; i < klass->NumVirtualMethods(); i++) {
+    AbstractMethod* method = klass->GetVirtualMethod(i);
+    if (instrumentation->GetSavedCodeFromMap(method) == NULL) {
+      instrumentation->SaveAndUpdateCode(method);
+    }
+  }
+  return true;
+}
+
+static bool UninstallStubsClassVisitor(Class* klass, void*)
+    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
+  Instrumentation* instrumentation = Runtime::Current()->GetInstrumentation();
+  for (size_t i = 0; i < klass->NumDirectMethods(); i++) {
+    AbstractMethod* method = klass->GetDirectMethod(i);
+    if (instrumentation->GetSavedCodeFromMap(method) != NULL) {
+      instrumentation->ResetSavedCode(method);
+    }
+  }
+
+  for (size_t i = 0; i < klass->NumVirtualMethods(); i++) {
+    AbstractMethod* method = klass->GetVirtualMethod(i);
+    if (instrumentation->GetSavedCodeFromMap(method) != NULL) {
+      instrumentation->ResetSavedCode(method);
+    }
+  }
+  return true;
+}
+
+static void InstrumentationRestoreStack(Thread* self, void*) NO_THREAD_SAFETY_ANALYSIS {
+  struct RestoreStackVisitor : public StackVisitor {
+    RestoreStackVisitor(Thread* self)
+        : StackVisitor(self->GetManagedStack(), self->GetInstrumentationStack(), NULL), self_(self) {}
+
+    virtual bool VisitFrame() {
+      if (self_->IsInstrumentationStackEmpty()) {
+        return false;  // Stop.
+      }
+      uintptr_t pc = GetReturnPc();
+      if (IsInstrumentationExitPc(pc)) {
+        InstrumentationStackFrame instrumentation_frame = self_->PopInstrumentationStackFrame();
+        SetReturnPc(instrumentation_frame.return_pc_);
+        CHECK(GetMethod() == instrumentation_frame.method_);
+      }
+      return true;  // Continue.
+    }
+
+    Thread* self_;
+  };
+  RestoreStackVisitor visitor(self);
+  visitor.WalkStack();
+}
+
+Instrumentation::~Instrumentation() {
+  delete trace_;
+}
+
+void Instrumentation::InstallStubs() {
+  Runtime::Current()->GetClassLinker()->VisitClasses(InstallStubsClassVisitor, NULL);
+}
+
+void Instrumentation::UninstallStubs() {
+  Thread* self = Thread::Current();
+  Locks::thread_list_lock_->AssertNotHeld(self);
+  Runtime::Current()->GetClassLinker()->VisitClasses(UninstallStubsClassVisitor, NULL);
+  MutexLock mu(self, *Locks::thread_list_lock_);
+  Runtime::Current()->GetThreadList()->ForEach(InstrumentationRestoreStack, NULL);
+}
+
+void Instrumentation::AddSavedCodeToMap(const AbstractMethod* method, const void* code) {
+  saved_code_map_.Put(method, code);
+}
+
+void Instrumentation::RemoveSavedCodeFromMap(const AbstractMethod* method) {
+  saved_code_map_.erase(method);
+}
+
+const void* Instrumentation::GetSavedCodeFromMap(const AbstractMethod* method) {
+  typedef SafeMap<const AbstractMethod*, const void*>::const_iterator It; // TODO: C++0x auto
+  It it = saved_code_map_.find(method);
+  if (it == saved_code_map_.end()) {
+    return NULL;
+  } else {
+    return it->second;
+  }
+}
+
+void Instrumentation::SaveAndUpdateCode(AbstractMethod* method) {
+#if defined(ART_USE_LLVM_COMPILER)
+  UNUSED(method);
+  UNIMPLEMENTED(FATAL);
+#else
+  void* instrumentation_stub = GetInstrumentationEntryPoint();
+  CHECK(GetSavedCodeFromMap(method) == NULL);
+  AddSavedCodeToMap(method, method->GetCode());
+  method->SetCode(instrumentation_stub);
+#endif
+}
+
+void Instrumentation::ResetSavedCode(AbstractMethod* method) {
+  CHECK(GetSavedCodeFromMap(method) != NULL);
+  method->SetCode(GetSavedCodeFromMap(method));
+  RemoveSavedCodeFromMap(method);
+}
+
+Trace* Instrumentation::GetTrace() const {
+  return trace_;
+}
+
+void Instrumentation::SetTrace(Trace* trace) {
+  trace_ = trace;
+}
+
+void Instrumentation::RemoveTrace() {
+  delete trace_;
+  trace_ = NULL;
+}
+
+uint32_t InstrumentationMethodUnwindFromCode(Thread* self) {
+  Trace* trace = Runtime::Current()->GetInstrumentation()->GetTrace();
+  InstrumentationStackFrame instrumentation_frame = self->PopInstrumentationStackFrame();
+  AbstractMethod* method = instrumentation_frame.method_;
+  uint32_t lr = instrumentation_frame.return_pc_;
+
+  trace->LogMethodTraceEvent(self, method, Trace::kMethodTraceUnwind);
+
+  return lr;
+}
+
+}  // namespace art
diff --git a/src/instrumentation.h b/src/instrumentation.h
new file mode 100644
index 0000000..a5ab650
--- /dev/null
+++ b/src/instrumentation.h
@@ -0,0 +1,80 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ART_SRC_INSTRUMENTATION_H_
+#define ART_SRC_INSTRUMENTATION_H_
+
+#include <ostream>
+#include <set>
+#include <string>
+
+#include "file.h"
+#include "globals.h"
+#include "macros.h"
+#include "safe_map.h"
+#include "trace.h"
+#include "UniquePtr.h"
+
+namespace art {
+
+class AbstractMethod;
+class Thread;
+
+uint32_t InstrumentationMethodUnwindFromCode(Thread* self);
+
+struct InstrumentationStackFrame {
+  InstrumentationStackFrame(AbstractMethod* method, uintptr_t return_pc)
+      : method_(method), return_pc_(return_pc) {
+  }
+
+  AbstractMethod* method_;
+  uintptr_t return_pc_;
+};
+
+class Instrumentation {
+ public:
+  Instrumentation() {}
+  ~Instrumentation();
+
+  // Replaces code of each method with a pointer to a stub for method tracing.
+  void InstallStubs();
+
+  // Restores original code for each method and fixes the return values of each thread's stack.
+  void UninstallStubs() LOCKS_EXCLUDED(Locks::thread_list_lock_);
+
+  const void* GetSavedCodeFromMap(const AbstractMethod* method);
+  void SaveAndUpdateCode(AbstractMethod* method);
+  void ResetSavedCode(AbstractMethod* method);
+
+  Trace* GetTrace() const;
+  void SetTrace(Trace* trace);
+  void RemoveTrace();
+
+ private:
+  void AddSavedCodeToMap(const AbstractMethod* method, const void* code);
+  void RemoveSavedCodeFromMap(const AbstractMethod* method);
+
+  // Maps a method to its original code pointer.
+  SafeMap<const AbstractMethod*, const void*> saved_code_map_;
+
+  Trace* trace_;
+
+  DISALLOW_COPY_AND_ASSIGN(Instrumentation);
+};
+
+}  // namespace art
+
+#endif  // ART_SRC_INSTRUMENTATION_H_
diff --git a/src/native/dalvik_system_VMStack.cc b/src/native/dalvik_system_VMStack.cc
index 24aa730..5ef512a 100644
--- a/src/native/dalvik_system_VMStack.cc
+++ b/src/native/dalvik_system_VMStack.cc
@@ -63,7 +63,7 @@
 // Returns the defining class loader of the caller's caller.
 static jobject VMStack_getCallingClassLoader(JNIEnv* env, jclass) {
   ScopedObjectAccess soa(env);
-  NthCallerVisitor visitor(soa.Self()->GetManagedStack(), soa.Self()->GetTraceStack(), 2);
+  NthCallerVisitor visitor(soa.Self()->GetManagedStack(), soa.Self()->GetInstrumentationStack(), 2);
   visitor.WalkStack();
   return soa.AddLocalReference<jobject>(visitor.caller->GetDeclaringClass()->GetClassLoader());
 }
@@ -71,9 +71,9 @@
 static jobject VMStack_getClosestUserClassLoader(JNIEnv* env, jclass, jobject javaBootstrap, jobject javaSystem) {
   struct ClosestUserClassLoaderVisitor : public StackVisitor {
     ClosestUserClassLoaderVisitor(const ManagedStack* stack,
-                                  const std::vector<TraceStackFrame>* trace_stack,
+                                  const std::vector<InstrumentationStackFrame>* instrumentation_stack,
                                   Object* bootstrap, Object* system)
-      : StackVisitor(stack, trace_stack, NULL),
+      : StackVisitor(stack, instrumentation_stack, NULL),
         bootstrap(bootstrap), system(system), class_loader(NULL) {}
 
     bool VisitFrame() {
@@ -94,7 +94,7 @@
   ScopedObjectAccess soa(env);
   Object* bootstrap = soa.Decode<Object*>(javaBootstrap);
   Object* system = soa.Decode<Object*>(javaSystem);
-  ClosestUserClassLoaderVisitor visitor(soa.Self()->GetManagedStack(), soa.Self()->GetTraceStack(),
+  ClosestUserClassLoaderVisitor visitor(soa.Self()->GetManagedStack(), soa.Self()->GetInstrumentationStack(),
                                         bootstrap, system);
   visitor.WalkStack();
   return soa.AddLocalReference<jobject>(visitor.class_loader);
@@ -103,7 +103,7 @@
 // Returns the class of the caller's caller's caller.
 static jclass VMStack_getStackClass2(JNIEnv* env, jclass) {
   ScopedObjectAccess soa(env);
-  NthCallerVisitor visitor(soa.Self()->GetManagedStack(), soa.Self()->GetTraceStack(), 3);
+  NthCallerVisitor visitor(soa.Self()->GetManagedStack(), soa.Self()->GetInstrumentationStack(), 3);
   visitor.WalkStack();
   return soa.AddLocalReference<jclass>(visitor.caller->GetDeclaringClass());
 }
diff --git a/src/nth_caller_visitor.h b/src/nth_caller_visitor.h
index 6b3894e..3c1f2e0 100644
--- a/src/nth_caller_visitor.h
+++ b/src/nth_caller_visitor.h
@@ -24,8 +24,8 @@
 
 // Walks up the stack 'n' callers, when used with Thread::WalkStack.
 struct NthCallerVisitor : public StackVisitor {
-  NthCallerVisitor(const ManagedStack* stack, const std::vector<TraceStackFrame>* trace_stack, size_t n)
-      : StackVisitor(stack, trace_stack, NULL), n(n), count(0), caller(NULL) {}
+  NthCallerVisitor(const ManagedStack* stack, const std::vector<InstrumentationStackFrame>* instrumentation_stack, size_t n)
+      : StackVisitor(stack, instrumentation_stack, NULL), n(n), count(0), caller(NULL) {}
 
   bool VisitFrame() {
     DCHECK(caller == NULL);
diff --git a/src/oat/runtime/arm/oat_support_entrypoints_arm.cc b/src/oat/runtime/arm/oat_support_entrypoints_arm.cc
index 39674b6..e363cbe 100644
--- a/src/oat/runtime/arm/oat_support_entrypoints_arm.cc
+++ b/src/oat/runtime/arm/oat_support_entrypoints_arm.cc
@@ -147,9 +147,9 @@
 extern "C" void art_throw_null_pointer_exception_from_code();
 extern "C" void art_throw_stack_overflow_from_code(void*);
 
-// Trace entrypoints.
-extern "C" void art_trace_entry_from_code(void*);
-extern "C" void art_trace_exit_from_code();
+// Instrumentation entrypoints.
+extern "C" void art_instrumentation_entry_from_code(void*);
+extern "C" void art_instrumentation_exit_from_code();
 
 void InitEntryPoints(EntryPoints* points) {
   // Alloc
@@ -275,13 +275,13 @@
   points->pUpdateDebuggerFromCode = (enabled ? art_update_debugger : NULL);
 }
 
-bool IsTraceExitPc(uintptr_t pc) {
-  uintptr_t trace_exit = reinterpret_cast<uintptr_t>(art_trace_exit_from_code);
+bool IsInstrumentationExitPc(uintptr_t pc) {
+  uintptr_t trace_exit = reinterpret_cast<uintptr_t>(art_instrumentation_exit_from_code);
   return pc == trace_exit;
 }
 
-void* GetLogTraceEntryPoint() {
-  return reinterpret_cast<void*>(art_trace_entry_from_code);
+void* GetInstrumentationEntryPoint() {
+  return reinterpret_cast<void*>(art_instrumentation_entry_from_code);
 }
 
 }  // namespace art
diff --git a/src/oat/runtime/arm/runtime_support_arm.S b/src/oat/runtime/arm/runtime_support_arm.S
index 7cb65e2..34caeac 100644
--- a/src/oat/runtime/arm/runtime_support_arm.S
+++ b/src/oat/runtime/arm/runtime_support_arm.S
@@ -771,25 +771,25 @@
     bxeq    lr                     @ return on success
     DELIVER_PENDING_EXCEPTION
 
-    .global art_trace_entry_from_code
-    .global art_trace_exit_from_code
-    .extern artTraceMethodEntryFromCode
-    .extern artTraceMethodExitFromCode
+    .global art_instrumentation_entry_from_code
+    .global art_instrumentation_exit_from_code
+    .extern artInstrumentationMethodEntryFromCode
+    .extern artInstrumentationMethodExitFromCode
     /*
      * Routine that intercepts method calls and returns.
      */
     ALIGN_FUNCTION_ENTRY
-art_trace_entry_from_code:
+art_instrumentation_entry_from_code:
     push  {r0-r3}        @ save arguments (4 words)
     mov   r1, r9         @ pass Thread::Current
     mov   r2, lr         @ pass LR
-    blx   artTraceMethodEntryFromCode  @ (Method*, Thread*, LR)
+    blx   artInstrumentationMethodEntryFromCode  @ (Method*, Thread*, LR)
     mov   r12, r0        @ r12 holds reference to code
     pop   {r0-r3}        @ restore arguments
     blx   r12            @ call method
-art_trace_exit_from_code:
+art_instrumentation_exit_from_code:
     push  {r0-r1}        @ save return value
-    blx   artTraceMethodExitFromCode  @ ()
+    blx   artInstrumentationMethodExitFromCode  @ ()
     mov   lr, r0         @ restore link register
     pop   {r0, r1}       @ restore return value
     bx    lr             @ return
diff --git a/src/oat/runtime/mips/oat_support_entrypoints_mips.cc b/src/oat/runtime/mips/oat_support_entrypoints_mips.cc
index 458933f..9327955 100644
--- a/src/oat/runtime/mips/oat_support_entrypoints_mips.cc
+++ b/src/oat/runtime/mips/oat_support_entrypoints_mips.cc
@@ -149,9 +149,9 @@
 extern "C" void art_throw_null_pointer_exception_from_code();
 extern "C" void art_throw_stack_overflow_from_code(void*);
 
-// Trace entrypoints.
-extern "C" void art_trace_entry_from_code(void*);
-extern "C" void art_trace_exit_from_code();
+// Instrumentation entrypoints.
+extern "C" void art_instrumentation_entry_from_code(void*);
+extern "C" void art_instrumentation_exit_from_code();
 
 void InitEntryPoints(EntryPoints* points) {
   // Alloc
@@ -276,12 +276,12 @@
   points->pUpdateDebuggerFromCode = (enabled ? art_update_debugger : NULL);
 }
 
-bool IsTraceExitPc(uintptr_t) {
+bool IsInstrumentationExitPc(uintptr_t) {
   UNIMPLEMENTED(FATAL);
   return false;
 }
 
-void* GetLogTraceEntryPoint() {
+void* GetInstrumentationEntryPoint() {
   UNIMPLEMENTED(FATAL);
   return NULL;
 }
diff --git a/src/oat/runtime/mips/runtime_support_mips.S b/src/oat/runtime/mips/runtime_support_mips.S
index bc0aecf..849e5c4 100644
--- a/src/oat/runtime/mips/runtime_support_mips.S
+++ b/src/oat/runtime/mips/runtime_support_mips.S
@@ -859,13 +859,15 @@
 1:
     DELIVER_PENDING_EXCEPTION
 
-    .global art_trace_entry_from_code
-    .extern artTraceMethodEntryFromCode
+    .global art_instrumentation_entry_from_code
+    .global art_instrumentation_exit_from_code
+    .extern artInstrumentationMethodEntryFromCode
+    .extern artInstrumentationMethodExitFromCode
     /*
-     * Routine that intercepts method calls
+     * Routine that intercepts method calls and returns.
      */
     ALIGN_FUNCTION_ENTRY
-art_trace_entry_from_code:
+art_instrumentation_entry_from_code:
     .cpload $25
     addiu    $sp, $sp, -16
     sw       $a0, 0($sp)
@@ -873,7 +875,7 @@
     sw       $a2, 8($sp)
     sw       $a3, 12($sp)
     move     $a2, $ra       # pass $ra
-    jal      artTraceMethodEntryFromCode  # (Method*, Thread*, LR)
+    jal      artInstrumentationMethodEntryFromCode  # (Method*, Thread*, LR)
     move     $a1, rSELF     # pass Thread::Current
     move     $t9, $v0       # $t9 holds reference to code
     lw       $a0, 0($sp)
@@ -883,18 +885,11 @@
     jalr     $t9            # call method
     addiu    $sp, $sp, 16
     /* intentional fallthrough */
-
-    .global art_trace_exit_from_code
-    .extern artTraceMethodExitFromCode
-    /*
-     * Routine that intercepts method returns
-     */
-    ALIGN_FUNCTION_ENTRY
-art_trace_exit_from_code:
+art_instrumentation_exit_from_code:
     .cpload $25
     addiu    $sp, $sp, -16
     sw       $v0, 0($sp)
-    jal      artTraceMethodExitFromCode  # ()
+    jal      artInstrumentationMethodExitFromCode  # ()
     sw       $v1, 4($sp)
     move     $ra, $v0         # restore link register
     lw       $v0, 0($sp)
diff --git a/src/oat/runtime/oat_support_entrypoints.h b/src/oat/runtime/oat_support_entrypoints.h
index 5042bd1..e63e1fd 100644
--- a/src/oat/runtime/oat_support_entrypoints.h
+++ b/src/oat/runtime/oat_support_entrypoints.h
@@ -158,11 +158,11 @@
 // Change the debugger entry point in the data structure.
 void ChangeDebuggerEntryPoint(EntryPoints* points, bool enabled);
 
-// Is the given return_pc the trace exit return pc?
-bool IsTraceExitPc(uintptr_t pc);
+// Is the given return_pc the instrumentation exit return pc?
+bool IsInstrumentationExitPc(uintptr_t pc);
 
-// Return address of stub that logs method entries.
-void* GetLogTraceEntryPoint();
+// Return address of instrumentation stub.
+void* GetInstrumentationEntryPoint();
 
 }  // namespace art
 
diff --git a/src/oat/runtime/support_instrumentation.cc b/src/oat/runtime/support_instrumentation.cc
new file mode 100644
index 0000000..8c5e442
--- /dev/null
+++ b/src/oat/runtime/support_instrumentation.cc
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "instrumentation.h"
+#include "runtime.h"
+#include "thread.h"
+#include "trace.h"
+
+namespace art {
+
+extern "C" const void* artInstrumentationMethodEntryFromCode(AbstractMethod* method, Thread* self,
+                                                             uintptr_t lr) {
+  Instrumentation* instrumentation = Runtime::Current()->GetInstrumentation();
+  Trace* trace = instrumentation->GetTrace();
+  InstrumentationStackFrame instrumentation_frame = InstrumentationStackFrame(method, lr);
+  self->PushInstrumentationStackFrame(instrumentation_frame);
+
+  trace->LogMethodTraceEvent(self, method, Trace::kMethodTraceEnter);
+
+  return instrumentation->GetSavedCodeFromMap(method);
+}
+
+extern "C" uintptr_t artInstrumentationMethodExitFromCode() {
+  Trace* trace = Runtime::Current()->GetInstrumentation()->GetTrace();
+  InstrumentationStackFrame instrumentation_frame = Thread::Current()->PopInstrumentationStackFrame();
+  AbstractMethod* method = instrumentation_frame.method_;
+  uintptr_t lr = instrumentation_frame.return_pc_;
+
+  trace->LogMethodTraceEvent(Thread::Current(), method, Trace::kMethodTraceExit);
+
+  return lr;
+}
+
+}  // namespace art
diff --git a/src/oat/runtime/support_throw.cc b/src/oat/runtime/support_throw.cc
index 887e743..420b442 100644
--- a/src/oat/runtime/support_throw.cc
+++ b/src/oat/runtime/support_throw.cc
@@ -94,7 +94,7 @@
   CHECK(!self->IsHandlingStackOverflow()) << "Recursive stack overflow.";
   // Remove extra entry pushed onto second stack during method tracing.
   if (Runtime::Current()->IsMethodTracingActive()) {
-    TraceMethodUnwindFromCode(self);
+    InstrumentationMethodUnwindFromCode(self);
   }
   self->SetStackEndForStackOverflow();  // Allow space on the stack for constructor to execute.
   JNIEnvExt* env = self->GetJniEnv();
diff --git a/src/oat/runtime/support_trace.cc b/src/oat/runtime/support_trace.cc
deleted file mode 100644
index 67317a9..0000000
--- a/src/oat/runtime/support_trace.cc
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
- * Copyright (C) 2012 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "runtime.h"
-#include "thread.h"
-#include "trace.h"
-
-namespace art {
-
-extern "C" const void* artTraceMethodEntryFromCode(AbstractMethod* method, Thread* self, uintptr_t lr) {
-  Trace* tracer = Runtime::Current()->GetTracer();
-  TraceStackFrame trace_frame = TraceStackFrame(method, lr);
-  self->PushTraceStackFrame(trace_frame);
-
-  tracer->LogMethodTraceEvent(self, method, Trace::kMethodTraceEnter);
-
-  return tracer->GetSavedCodeFromMap(method);
-}
-
-extern "C" uintptr_t artTraceMethodExitFromCode() {
-  Trace* tracer = Runtime::Current()->GetTracer();
-  TraceStackFrame trace_frame = Thread::Current()->PopTraceStackFrame();
-  AbstractMethod* method = trace_frame.method_;
-  uintptr_t lr = trace_frame.return_pc_;
-
-  tracer->LogMethodTraceEvent(Thread::Current(), method, Trace::kMethodTraceExit);
-
-  return lr;
-}
-
-}  // namespace art
diff --git a/src/oat/runtime/x86/oat_support_entrypoints_x86.cc b/src/oat/runtime/x86/oat_support_entrypoints_x86.cc
index 802c431..c2236d7 100644
--- a/src/oat/runtime/x86/oat_support_entrypoints_x86.cc
+++ b/src/oat/runtime/x86/oat_support_entrypoints_x86.cc
@@ -245,11 +245,11 @@
   UNIMPLEMENTED(FATAL);
 }
 
-bool IsTraceExitPc(uintptr_t) {
+bool IsInstrumentationExitPc(uintptr_t) {
   return false;
 }
 
-void* GetLogTraceEntryPoint() {
+void* GetInstrumentationEntryPoint() {
   return NULL;
 }
 
diff --git a/src/object.cc b/src/object.cc
index cebbb2a..aaaa245 100644
--- a/src/object.cc
+++ b/src/object.cc
@@ -540,8 +540,8 @@
   Runtime* runtime = Runtime::Current();
   const void* code = m->GetCode();
   // Peel off any method tracing trampoline.
-  if (runtime->IsMethodTracingActive() && runtime->GetTracer()->GetSavedCodeFromMap(m) != NULL) {
-    code = runtime->GetTracer()->GetSavedCodeFromMap(m);
+  if (runtime->IsMethodTracingActive() && runtime->GetInstrumentation()->GetSavedCodeFromMap(m) != NULL) {
+    code = runtime->GetInstrumentation()->GetSavedCodeFromMap(m);
   }
   // Peel off any resolution stub.
   if (code == runtime->GetResolutionStubArray(Runtime::kStaticMethod)->GetData()) {
diff --git a/src/runtime.cc b/src/runtime.cc
index c84f1f6..4cc3b4f 100644
--- a/src/runtime.cc
+++ b/src/runtime.cc
@@ -32,6 +32,7 @@
 #include "debugger.h"
 #include "heap.h"
 #include "image.h"
+#include "instrumentation.h"
 #include "intern_table.h"
 #include "jni_internal.h"
 #include "monitor.h"
@@ -88,7 +89,7 @@
       stats_enabled_(false),
       method_trace_(0),
       method_trace_file_size_(0),
-      tracer_(NULL),
+      instrumentation_(NULL),
       use_compile_time_class_path_(false),
       main_thread_group_(NULL),
       system_thread_group_(NULL)
@@ -128,6 +129,7 @@
   if (IsMethodTracingActive()) {
     Trace::Shutdown();
   }
+  delete instrumentation_;
 
   // Make sure to let the GC complete if it is running.
   heap_->WaitForConcurrentGcToComplete(self);
@@ -1149,15 +1151,26 @@
   callee_save_methods_[type] = method;
 }
 
-void Runtime::EnableMethodTracing(Trace* tracer) {
+void Runtime::EnableMethodTracing(Trace* trace) {
   CHECK(!IsMethodTracingActive());
-  tracer_ = tracer;
+  if (instrumentation_ == NULL) {
+    instrumentation_ = new Instrumentation();
+  }
+  instrumentation_->SetTrace(trace);
 }
 
 void Runtime::DisableMethodTracing() {
   CHECK(IsMethodTracingActive());
-  delete tracer_;
-  tracer_ = NULL;
+  instrumentation_->RemoveTrace();
+}
+
+bool Runtime::IsMethodTracingActive() const {
+  return instrumentation_ != NULL && instrumentation_->GetTrace() != NULL;
+}
+
+Instrumentation* Runtime::GetInstrumentation() const {
+  CHECK(IsMethodTracingActive());
+  return instrumentation_;
 }
 
 const std::vector<const DexFile*>& Runtime::GetCompileTimeClassPath(jobject class_loader) {
diff --git a/src/runtime.h b/src/runtime.h
index 94ab0c4..d2238ae 100644
--- a/src/runtime.h
+++ b/src/runtime.h
@@ -47,6 +47,7 @@
 class ClassLoader;
 class DexFile;
 class Heap;
+class Instrumentation;
 class InternTable;
 struct JavaVMExt;
 class AbstractMethod;
@@ -343,17 +344,10 @@
   void DidForkFromZygote();
   bool PreZygoteFork();
 
-  void EnableMethodTracing(Trace* tracer);
+  void EnableMethodTracing(Trace* trace);
   void DisableMethodTracing();
-
-  bool IsMethodTracingActive() const {
-    return tracer_ != NULL;
-  }
-
-  Trace* GetTracer() const {
-    CHECK(IsMethodTracingActive());
-    return tracer_;
-  }
+  bool IsMethodTracingActive() const;
+  Instrumentation* GetInstrumentation() const;
 
   bool UseCompileTimeClassPath() const {
     return use_compile_time_class_path_;
@@ -465,7 +459,7 @@
   bool method_trace_;
   std::string method_trace_file_;
   size_t method_trace_file_size_;
-  Trace* tracer_;
+  Instrumentation* instrumentation_;
 
   typedef SafeMap<jobject, std::vector<const DexFile*>, JobjectComparator> CompileTimeClassPaths;
   CompileTimeClassPaths compile_time_class_paths_;
diff --git a/src/stack.cc b/src/stack.cc
index 7ec57b4..b244975 100644
--- a/src/stack.cc
+++ b/src/stack.cc
@@ -145,8 +145,8 @@
 size_t StackVisitor::ComputeNumFrames() const {
   struct NumFramesVisitor : public StackVisitor {
     explicit NumFramesVisitor(const ManagedStack* stack,
-                              const std::vector<TraceStackFrame>* trace_stack)
-        : StackVisitor(stack, trace_stack, NULL), frames(0) {}
+                              const std::vector<InstrumentationStackFrame>* instrumentation_stack)
+        : StackVisitor(stack, instrumentation_stack, NULL), frames(0) {}
 
     virtual bool VisitFrame() {
       frames++;
@@ -156,7 +156,7 @@
     size_t frames;
   };
 
-  NumFramesVisitor visitor(stack_start_, trace_stack_);
+  NumFramesVisitor visitor(stack_start_, instrumentation_stack_);
   visitor.WalkStack(true);
   return visitor.frames;
 }
@@ -180,7 +180,7 @@
 
 void StackVisitor::WalkStack(bool include_transitions) {
   bool method_tracing_active = Runtime::Current()->IsMethodTracingActive();
-  uint32_t trace_stack_depth = 0;
+  uint32_t instrumentation_stack_depth = 0;
   for (const ManagedStack* current_fragment = stack_start_; current_fragment != NULL;
        current_fragment = current_fragment->GetLink()) {
     cur_shadow_frame_ = current_fragment->GetTopShadowFrame();
@@ -208,13 +208,13 @@
           // While profiling, the return pc is restored from the side stack, except when walking
           // the stack for an exception where the side stack will be unwound in VisitFrame.
           // TODO: stop using include_transitions as a proxy for is this the catch block visitor.
-          if (IsTraceExitPc(return_pc) && !include_transitions) {
+          if (IsInstrumentationExitPc(return_pc) && !include_transitions) {
             // TODO: unify trace and managed stack.
-            TraceStackFrame trace_frame = GetTraceStackFrame(trace_stack_depth);
-            trace_stack_depth++;
-            CHECK(trace_frame.method_ == GetMethod()) << "Excepted: " << PrettyMethod(method)
+            InstrumentationStackFrame instrumentation_frame = GetInstrumentationStackFrame(instrumentation_stack_depth);
+            instrumentation_stack_depth++;
+            CHECK(instrumentation_frame.method_ == GetMethod()) << "Excepted: " << PrettyMethod(method)
                 << " Found: " << PrettyMethod(GetMethod());
-            return_pc = trace_frame.return_pc_;
+            return_pc = instrumentation_frame.return_pc_;
           }
         }
         cur_quick_frame_pc_ = return_pc;
diff --git a/src/stack.h b/src/stack.h
index 3cf8577..fd2fd15 100644
--- a/src/stack.h
+++ b/src/stack.h
@@ -19,10 +19,10 @@
 
 #include "dex_file.h"
 #include "heap.h"
+#include "instrumentation.h"
 #include "jni.h"
 #include "macros.h"
 #include "oat/runtime/context.h"
-#include "trace.h"
 
 #include <stdint.h>
 
@@ -303,10 +303,10 @@
 
 class StackVisitor {
  protected:
-  StackVisitor(const ManagedStack* stack, const std::vector<TraceStackFrame>* trace_stack,
+  StackVisitor(const ManagedStack* stack, const std::vector<InstrumentationStackFrame>* instrumentation_stack,
                Context* context)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
-      : stack_start_(stack), trace_stack_(trace_stack), cur_shadow_frame_(NULL),
+      : stack_start_(stack), instrumentation_stack_(instrumentation_stack), cur_shadow_frame_(NULL),
         cur_quick_frame_(NULL), cur_quick_frame_pc_(0), num_frames_(0), cur_depth_(0),
         context_(context) {}
 
@@ -463,14 +463,14 @@
  private:
   size_t ComputeNumFrames() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  TraceStackFrame GetTraceStackFrame(uint32_t depth) const {
-    return trace_stack_->at(trace_stack_->size() - depth - 1);
+  InstrumentationStackFrame GetInstrumentationStackFrame(uint32_t depth) const {
+    return instrumentation_stack_->at(instrumentation_stack_->size() - depth - 1);
   }
 
   void SanityCheckFrame() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
   const ManagedStack* const stack_start_;
-  const std::vector<TraceStackFrame>* const trace_stack_;
+  const std::vector<InstrumentationStackFrame>* const instrumentation_stack_;
   ShadowFrame* cur_shadow_frame_;
   AbstractMethod** cur_quick_frame_;
   uintptr_t cur_quick_frame_pc_;
diff --git a/src/thread.cc b/src/thread.cc
index 00aaabd..0d06e42 100644
--- a/src/thread.cc
+++ b/src/thread.cc
@@ -808,7 +808,7 @@
 struct StackDumpVisitor : public StackVisitor {
   StackDumpVisitor(std::ostream& os, const Thread* thread, Context* context, bool can_allocate)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
-      : StackVisitor(thread->GetManagedStack(), thread->GetTraceStack(), context),
+      : StackVisitor(thread->GetManagedStack(), thread->GetInstrumentationStack(), context),
         os(os), thread(thread), can_allocate(can_allocate),
         last_method(NULL), last_line_number(0), repetition_count(0), frame_count(0) {
   }
@@ -953,7 +953,7 @@
       throwing_OutOfMemoryError_(false),
       debug_suspend_count_(0),
       debug_invoke_req_(new DebugInvokeReq),
-      trace_stack_(new std::vector<TraceStackFrame>),
+      instrumentation_stack_(new std::vector<InstrumentationStackFrame>),
       name_(new std::string(kThreadNameDuringStartup)),
       daemon_(daemon),
       pthread_self_(0),
@@ -1055,7 +1055,7 @@
 #endif
 
   delete debug_invoke_req_;
-  delete trace_stack_;
+  delete instrumentation_stack_;
   delete name_;
 
   TearDownAlternateSignalStack();
@@ -1229,9 +1229,9 @@
 class CountStackDepthVisitor : public StackVisitor {
  public:
   CountStackDepthVisitor(const ManagedStack* stack,
-                         const std::vector<TraceStackFrame>* trace_stack)
+                         const std::vector<InstrumentationStackFrame>* instrumentation_stack)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
-      : StackVisitor(stack, trace_stack, NULL),
+      : StackVisitor(stack, instrumentation_stack, NULL),
         depth_(0), skip_depth_(0), skipping_(true) {}
 
   bool VisitFrame() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
@@ -1270,9 +1270,9 @@
 class BuildInternalStackTraceVisitor : public StackVisitor {
  public:
   explicit BuildInternalStackTraceVisitor(Thread* self, const ManagedStack* stack,
-                                          const std::vector<TraceStackFrame>* trace_stack,
+                                          const std::vector<InstrumentationStackFrame>* instrumentation_stack,
                                           int skip_depth)
-      : StackVisitor(stack, trace_stack, NULL), self_(self),
+      : StackVisitor(stack, instrumentation_stack, NULL), self_(self),
         skip_depth_(skip_depth), count_(0), dex_pc_trace_(NULL), method_trace_(NULL) {}
 
   bool Init(int depth)
@@ -1343,13 +1343,13 @@
 
 jobject Thread::CreateInternalStackTrace(const ScopedObjectAccessUnchecked& soa) const {
   // Compute depth of stack
-  CountStackDepthVisitor count_visitor(GetManagedStack(), GetTraceStack());
+  CountStackDepthVisitor count_visitor(GetManagedStack(), GetInstrumentationStack());
   count_visitor.WalkStack();
   int32_t depth = count_visitor.GetDepth();
   int32_t skip_depth = count_visitor.GetSkipDepth();
 
   // Build internal stack trace.
-  BuildInternalStackTraceVisitor build_trace_visitor(soa.Self(), GetManagedStack(), GetTraceStack(),
+  BuildInternalStackTraceVisitor build_trace_visitor(soa.Self(), GetManagedStack(), GetInstrumentationStack(),
                                                      skip_depth);
   if (!build_trace_visitor.Init(depth)) {
     return NULL;  // Allocation failed.
@@ -1667,7 +1667,7 @@
  public:
   CatchBlockStackVisitor(Thread* self, Throwable* exception)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
-      : StackVisitor(self->GetManagedStack(), self->GetTraceStack(), self->GetLongJumpContext()),
+      : StackVisitor(self->GetManagedStack(), self->GetInstrumentationStack(), self->GetLongJumpContext()),
         self_(self), exception_(exception), to_find_(exception->GetClass()), throw_method_(NULL),
         throw_frame_id_(0), throw_dex_pc_(0), handler_quick_frame_(NULL),
         handler_quick_frame_pc_(0), handler_dex_pc_(0), native_method_count_(0),
@@ -1702,9 +1702,9 @@
       if (method->IsNative()) {
         native_method_count_++;
       } else {
-        // Unwind stack when an exception occurs during method tracing
-        if (UNLIKELY(method_tracing_active_ && IsTraceExitPc(GetCurrentQuickFramePc()))) {
-          uintptr_t pc = TraceMethodUnwindFromCode(Thread::Current());
+        // Unwind stack when an exception occurs during instrumentation
+        if (UNLIKELY(method_tracing_active_ && IsInstrumentationExitPc(GetCurrentQuickFramePc()))) {
+          uintptr_t pc = InstrumentationMethodUnwindFromCode(Thread::Current());
           dex_pc = method->ToDexPc(pc);
         } else {
           dex_pc = GetDexPc();
@@ -1800,9 +1800,9 @@
 AbstractMethod* Thread::GetCurrentMethod(uint32_t* dex_pc, size_t* frame_id) const {
   struct CurrentMethodVisitor : public StackVisitor {
     CurrentMethodVisitor(const ManagedStack* stack,
-                         const std::vector<TraceStackFrame>* trace_stack)
+                         const std::vector<InstrumentationStackFrame>* instrumentation_stack)
         SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
-        : StackVisitor(stack, trace_stack, NULL), method_(NULL), dex_pc_(0), frame_id_(0) {}
+        : StackVisitor(stack, instrumentation_stack, NULL), method_(NULL), dex_pc_(0), frame_id_(0) {}
 
     virtual bool VisitFrame() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
       AbstractMethod* m = GetMethod();
@@ -1820,7 +1820,7 @@
     size_t frame_id_;
   };
 
-  CurrentMethodVisitor visitor(GetManagedStack(), GetTraceStack());
+  CurrentMethodVisitor visitor(GetManagedStack(), GetInstrumentationStack());
   visitor.WalkStack(false);
   if (dex_pc != NULL) {
     *dex_pc = visitor.dex_pc_;
@@ -1842,10 +1842,10 @@
 template <typename Visitor>
 class ReferenceMapVisitor : public StackVisitor {
  public:
-  ReferenceMapVisitor(const ManagedStack* stack, const std::vector<TraceStackFrame>* trace_stack,
+  ReferenceMapVisitor(const ManagedStack* stack, const std::vector<InstrumentationStackFrame>* instrumentation_stack,
                       Context* context, const Visitor& visitor)
       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
-      : StackVisitor(stack, trace_stack, context), visitor_(visitor) {}
+      : StackVisitor(stack, instrumentation_stack, context), visitor_(visitor) {}
 
   bool VisitFrame() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     if (false) {
@@ -2006,7 +2006,7 @@
   // Visit roots on this thread's stack
   Context* context = GetLongJumpContext();
   VerifyCallbackVisitor visitorToCallback(visitor, arg);
-  ReferenceMapVisitor<VerifyCallbackVisitor> mapper(GetManagedStack(), GetTraceStack(), context,
+  ReferenceMapVisitor<VerifyCallbackVisitor> mapper(GetManagedStack(), GetInstrumentationStack(), context,
                                                   visitorToCallback);
   mapper.WalkStack();
   ReleaseLongJumpContext(context);
@@ -2027,7 +2027,7 @@
   // Visit roots on this thread's stack
   Context* context = GetLongJumpContext();
   RootCallbackVisitor visitorToCallback(visitor, arg);
-  ReferenceMapVisitor<RootCallbackVisitor> mapper(GetManagedStack(), GetTraceStack(), context,
+  ReferenceMapVisitor<RootCallbackVisitor> mapper(GetManagedStack(), GetInstrumentationStack(), context,
                                                   visitorToCallback);
   mapper.WalkStack();
   ReleaseLongJumpContext(context);
@@ -2042,7 +2042,7 @@
 void Thread::VerifyStack() {
   UniquePtr<Context> context(Context::Create());
   RootCallbackVisitor visitorToCallback(VerifyObject, Runtime::Current()->GetHeap());
-  ReferenceMapVisitor<RootCallbackVisitor> mapper(GetManagedStack(), GetTraceStack(), context.get(),
+  ReferenceMapVisitor<RootCallbackVisitor> mapper(GetManagedStack(), GetInstrumentationStack(), context.get(),
                                                   visitorToCallback);
   mapper.WalkStack();
 }
diff --git a/src/thread.h b/src/thread.h
index 84b88f2..3eabe08 100644
--- a/src/thread.h
+++ b/src/thread.h
@@ -27,6 +27,7 @@
 
 #include "closure.h"
 #include "globals.h"
+#include "instrumentation.h"
 #include "macros.h"
 #include "oat/runtime/oat_support_entrypoints.h"
 #include "locks.h"
@@ -34,7 +35,6 @@
 #include "runtime_stats.h"
 #include "stack.h"
 #include "stack_indirect_reference_table.h"
-#include "trace.h"
 #include "UniquePtr.h"
 
 namespace art {
@@ -548,21 +548,21 @@
 
   void SetDebuggerUpdatesEnabled(bool enabled);
 
-  const std::vector<TraceStackFrame>* GetTraceStack() const {
-    return trace_stack_;
+  const std::vector<InstrumentationStackFrame>* GetInstrumentationStack() const {
+    return instrumentation_stack_;
   }
 
-  bool IsTraceStackEmpty() const {
-    return trace_stack_->empty();
+  bool IsInstrumentationStackEmpty() const {
+    return instrumentation_stack_->empty();
   }
 
-  void PushTraceStackFrame(const TraceStackFrame& frame) {
-    trace_stack_->push_back(frame);
+  void PushInstrumentationStackFrame(const InstrumentationStackFrame& frame) {
+    instrumentation_stack_->push_back(frame);
   }
 
-  TraceStackFrame PopTraceStackFrame() {
-    TraceStackFrame frame = trace_stack_->back();
-    trace_stack_->pop_back();
+  InstrumentationStackFrame PopInstrumentationStackFrame() {
+    InstrumentationStackFrame frame = instrumentation_stack_->back();
+    instrumentation_stack_->pop_back();
     return frame;
   }
 
@@ -746,9 +746,9 @@
   // JDWP invoke-during-breakpoint support.
   DebugInvokeReq* debug_invoke_req_;
 
-  // Additional stack used by method tracer to store method and return pc values.
+  // Additional stack used by method instrumentation to store method and return pc values.
   // Stored as a pointer since std::vector is not PACKED.
-  std::vector<TraceStackFrame>* trace_stack_;
+  std::vector<InstrumentationStackFrame>* instrumentation_stack_;
 
   // A cached copy of the java.lang.Thread's name.
   std::string* name_;
diff --git a/src/thread_list.cc b/src/thread_list.cc
index 84d0054..2a5b6c9 100644
--- a/src/thread_list.cc
+++ b/src/thread_list.cc
@@ -121,7 +121,7 @@
   MutexLock mu2(self, *Locks::thread_suspend_count_lock_);
   for (It it = list_.begin(), end = list_.end(); it != end; ++it) {
     Thread* thread = *it;
-    if (thread != ignore1 || thread == ignore2) {
+    if (thread != ignore1 && thread != ignore2) {
       CHECK(thread->IsSuspended())
             << "\nUnsuspended thread: <<" << *thread << "\n"
             << "self: <<" << *Thread::Current();
diff --git a/src/trace.cc b/src/trace.cc
index 753b80f..f04b1db 100644
--- a/src/trace.cc
+++ b/src/trace.cc
@@ -21,6 +21,7 @@
 #include "class_linker.h"
 #include "debugger.h"
 #include "dex_cache.h"
+#include "instrumentation.h"
 #if !defined(ART_USE_LLVM_COMPILER)
 #include "oat/runtime/oat_support_entrypoints.h"
 #endif
@@ -158,105 +159,6 @@
   *buf++ = (uint8_t) (val >> 56);
 }
 
-static bool InstallStubsClassVisitor(Class* klass, void*)
-    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  Trace* tracer = Runtime::Current()->GetTracer();
-  for (size_t i = 0; i < klass->NumDirectMethods(); i++) {
-    AbstractMethod* method = klass->GetDirectMethod(i);
-    if (tracer->GetSavedCodeFromMap(method) == NULL) {
-      tracer->SaveAndUpdateCode(method);
-    }
-  }
-
-  for (size_t i = 0; i < klass->NumVirtualMethods(); i++) {
-    AbstractMethod* method = klass->GetVirtualMethod(i);
-    if (tracer->GetSavedCodeFromMap(method) == NULL) {
-      tracer->SaveAndUpdateCode(method);
-    }
-  }
-  return true;
-}
-
-static bool UninstallStubsClassVisitor(Class* klass, void*)
-    SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
-  Trace* tracer = Runtime::Current()->GetTracer();
-  for (size_t i = 0; i < klass->NumDirectMethods(); i++) {
-    AbstractMethod* method = klass->GetDirectMethod(i);
-    if (tracer->GetSavedCodeFromMap(method) != NULL) {
-      tracer->ResetSavedCode(method);
-    }
-  }
-
-  for (size_t i = 0; i < klass->NumVirtualMethods(); i++) {
-    AbstractMethod* method = klass->GetVirtualMethod(i);
-    if (tracer->GetSavedCodeFromMap(method) != NULL) {
-      tracer->ResetSavedCode(method);
-    }
-  }
-  return true;
-}
-
-static void TraceRestoreStack(Thread* self, void*) {
-  struct RestoreStackVisitor : public StackVisitor {
-    RestoreStackVisitor(Thread* self)
-        : StackVisitor(self->GetManagedStack(), self->GetTraceStack(), NULL), self_(self) {}
-
-    virtual bool VisitFrame() {
-      if (self_->IsTraceStackEmpty()) {
-        return false;  // Stop.
-      }
-      uintptr_t pc = GetReturnPc();
-      if (IsTraceExitPc(pc)) {
-        TraceStackFrame trace_frame = self_->PopTraceStackFrame();
-        SetReturnPc(trace_frame.return_pc_);
-        CHECK(GetMethod() == trace_frame.method_);
-      }
-      return true;  // Continue.
-    }
-
-    Thread* self_;
-  };
-  ScopedObjectAccess soa(self);
-  RestoreStackVisitor visitor(self);
-  visitor.WalkStack();
-}
-
-void Trace::AddSavedCodeToMap(const AbstractMethod* method, const void* code) {
-  saved_code_map_.Put(method, code);
-}
-
-void Trace::RemoveSavedCodeFromMap(const AbstractMethod* method) {
-  saved_code_map_.erase(method);
-}
-
-const void* Trace::GetSavedCodeFromMap(const AbstractMethod* method) {
-  typedef SafeMap<const AbstractMethod*, const void*>::const_iterator It; // TODO: C++0x auto
-  It it = saved_code_map_.find(method);
-  if (it == saved_code_map_.end()) {
-    return NULL;
-  } else {
-    return it->second;
-  }
-}
-
-void Trace::SaveAndUpdateCode(AbstractMethod* method) {
-#if defined(ART_USE_LLVM_COMPILER)
-  UNUSED(method);
-  UNIMPLEMENTED(FATAL);
-#else
-  void* trace_stub = GetLogTraceEntryPoint();
-  CHECK(GetSavedCodeFromMap(method) == NULL);
-  AddSavedCodeToMap(method, method->GetCode());
-  method->SetCode(trace_stub);
-#endif
-}
-
-void Trace::ResetSavedCode(AbstractMethod* method) {
-  CHECK(GetSavedCodeFromMap(method) != NULL);
-  method->SetCode(GetSavedCodeFromMap(method));
-  RemoveSavedCodeFromMap(method);
-}
-
 Trace::Trace(File* trace_file, int buffer_size, int flags)
     : trace_file_(trace_file), buf_(new uint8_t[buffer_size]()), flags_(flags),
       clock_source_(gDefaultTraceClockSource), overflow_(false),
@@ -269,7 +171,6 @@
     return;
   }
 
-  ScopedThreadStateChange tsc(Thread::Current(), kRunnable);
   Runtime::Current()->GetThreadList()->SuspendAll();
 
   // Open trace file if not going directly to ddms.
@@ -309,10 +210,9 @@
     return;
   }
 
-  ScopedThreadStateChange tsc(Thread::Current(), kRunnable);
   Runtime::Current()->GetThreadList()->SuspendAll();
 
-  Runtime::Current()->GetTracer()->FinishTracing();
+  Runtime::Current()->GetInstrumentation()->GetTrace()->FinishTracing();
   Runtime::Current()->DisableMethodTracing();
 
   Runtime::Current()->GetThreadList()->ResumeAll();
@@ -323,7 +223,7 @@
     LOG(INFO) << "Trace shutdown requested, but no trace currently running";
     return;
   }
-  Runtime::Current()->GetTracer()->FinishTracing();
+  Runtime::Current()->GetInstrumentation()->GetTrace()->FinishTracing();
   Runtime::Current()->DisableMethodTracing();
 }
 
@@ -354,12 +254,12 @@
   cur_offset_ = kTraceHeaderLength;
 
   // Install all method tracing stubs.
-  InstallStubs();
+  Runtime::Current()->GetInstrumentation()->InstallStubs();
 }
 
 void Trace::FinishTracing() {
   // Uninstall all method tracing stubs.
-  UninstallStubs();
+  Runtime::Current()->GetInstrumentation()->UninstallStubs();
 
   // Compute elapsed time.
   uint64_t elapsed = MicroTime() - start_time_;
@@ -496,27 +396,4 @@
   Runtime::Current()->GetThreadList()->ForEach(DumpThread, &os);
 }
 
-void Trace::InstallStubs() {
-  Runtime::Current()->GetClassLinker()->VisitClasses(InstallStubsClassVisitor, NULL);
-}
-
-void Trace::UninstallStubs() {
-  Thread* self = Thread::Current();
-  Locks::thread_list_lock_->AssertNotHeld(self);
-  Runtime::Current()->GetClassLinker()->VisitClasses(UninstallStubsClassVisitor, NULL);
-  MutexLock mu(self, *Locks::thread_list_lock_);
-  Runtime::Current()->GetThreadList()->ForEach(TraceRestoreStack, NULL);
-}
-
-uint32_t TraceMethodUnwindFromCode(Thread* self) {
-  Trace* tracer = Runtime::Current()->GetTracer();
-  TraceStackFrame trace_frame = self->PopTraceStackFrame();
-  AbstractMethod* method = trace_frame.method_;
-  uint32_t lr = trace_frame.return_pc_;
-
-  tracer->LogMethodTraceEvent(self, method, Trace::kMethodTraceUnwind);
-
-  return lr;
-}
-
 }  // namespace art
diff --git a/src/trace.h b/src/trace.h
index 43b0ff7..5dd29b9 100644
--- a/src/trace.h
+++ b/src/trace.h
@@ -32,17 +32,6 @@
 class AbstractMethod;
 class Thread;
 
-uint32_t TraceMethodUnwindFromCode(Thread* self);
-
-struct TraceStackFrame {
-  TraceStackFrame(AbstractMethod* method, uintptr_t return_pc)
-      : method_(method), return_pc_(return_pc) {
-  }
-
-  AbstractMethod* method_;
-  uintptr_t return_pc_;
-};
-
 enum ProfilerClockSource {
   kProfilerClockSourceThreadCpu,
   kProfilerClockSourceWall,
@@ -72,33 +61,17 @@
 
   void LogMethodTraceEvent(Thread* self, const AbstractMethod* method, TraceEvent event);
 
-  void AddSavedCodeToMap(const AbstractMethod* method, const void* code);
-  void RemoveSavedCodeFromMap(const AbstractMethod* method);
-  const void* GetSavedCodeFromMap(const AbstractMethod* method);
-
-  void SaveAndUpdateCode(AbstractMethod* method);
-  void ResetSavedCode(AbstractMethod* method);
-
  private:
   explicit Trace(File* trace_file, int buffer_size, int flags);
 
   void BeginTracing();
   void FinishTracing() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 
-  // Replaces code of each method with a pointer to a stub for method tracing.
-  void InstallStubs();
-
-  // Restores original code for each method and fixes the return values of each thread's stack.
-  void UninstallStubs() LOCKS_EXCLUDED(Locks::thread_list_lock_);
-
   // Methods to output traced methods and threads.
   void GetVisitedMethods(size_t end_offset);
   void DumpMethodList(std::ostream& os) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
   void DumpThreadList(std::ostream& os) LOCKS_EXCLUDED(Locks::thread_list_lock_);
 
-  // Maps a method to its original code pointer.
-  SafeMap<const AbstractMethod*, const void*> saved_code_map_;
-
   // Set of methods visited by the profiler.
   std::set<const AbstractMethod*> visited_methods_;