ART: Add object reclaim support

Add support for the object free callback.

Refactor code in support. Add test.

Bug: 31384923
Test: m test-art-host
Test: m test-art-host-run-test-905-object-free
Test: m ART_USE_READ_BARRIER=true test-art-host-run-test-905-object-free
Change-Id: Icde40ad464c723cfe2f7660c07cd2f79b6dc2032

19 files changed, 443 insertions, 82 deletions

diff --git a/runtime/openjdkjvmti/Android.bp b/runtime/openjdkjvmti/Android.bp
index e1f9ba2b98..2d9149a1c5 100644
--- a/runtime/openjdkjvmti/Android.bp
+++ b/runtime/openjdkjvmti/Android.bp
@@ -18,6 +18,7 @@ cc_defaults {
     defaults: ["art_defaults"],
     host_supported: true,
     srcs: ["events.cc",
+           "object_tagging.cc",
            "OpenjdkJvmTi.cc",
            "transform.cc"],
     include_dirs: ["art/runtime"],
diff --git a/runtime/openjdkjvmti/OpenjdkJvmTi.cc b/runtime/openjdkjvmti/OpenjdkJvmTi.cc
index 6812a923b3..36be2a0127 100644
--- a/runtime/openjdkjvmti/OpenjdkJvmTi.cc
+++ b/runtime/openjdkjvmti/OpenjdkJvmTi.cc
@@ -54,8 +54,8 @@
 
 namespace openjdkjvmti {
 
-ObjectTagTable gObjectTagTable;
 EventHandler gEventHandler;
+ObjectTagTable gObjectTagTable(&gEventHandler);
 
 class JvmtiFunctions {
  private:
diff --git a/runtime/openjdkjvmti/object_tagging.cc b/runtime/openjdkjvmti/object_tagging.cc
new file mode 100644
index 0000000000..bb17cac476
--- /dev/null
+++ b/runtime/openjdkjvmti/object_tagging.cc
@@ -0,0 +1,127 @@
+/* Copyright (C) 2016 The Android Open Source Project
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This file implements interfaces from the file jvmti.h. This implementation
+ * is licensed under the same terms as the file jvmti.h.  The
+ * copyright and license information for the file jvmti.h follows.
+ *
+ * Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+#include "object_tagging.h"
+
+#include "art_jvmti.h"
+#include "base/logging.h"
+#include "events-inl.h"
+#include "gc/allocation_listener.h"
+#include "instrumentation.h"
+#include "jni_env_ext-inl.h"
+#include "mirror/class.h"
+#include "mirror/object.h"
+#include "runtime.h"
+#include "ScopedLocalRef.h"
+
+namespace openjdkjvmti {
+
+void ObjectTagTable::Add(art::mirror::Object* obj, jlong tag) {
+  art::Thread* self = art::Thread::Current();
+  art::MutexLock mu(self, allow_disallow_lock_);
+  Wait(self);
+
+  if (first_free_ == tagged_objects_.size()) {
+    tagged_objects_.push_back(Entry(art::GcRoot<art::mirror::Object>(obj), tag));
+    first_free_++;
+  } else {
+    DCHECK_LT(first_free_, tagged_objects_.size());
+    DCHECK(tagged_objects_[first_free_].first.IsNull());
+    tagged_objects_[first_free_] = Entry(art::GcRoot<art::mirror::Object>(obj), tag);
+    // TODO: scan for free elements.
+    first_free_ = tagged_objects_.size();
+  }
+}
+
+bool ObjectTagTable::Remove(art::mirror::Object* obj, jlong* tag) {
+  art::Thread* self = art::Thread::Current();
+  art::MutexLock mu(self, allow_disallow_lock_);
+  Wait(self);
+
+  for (auto it = tagged_objects_.begin(); it != tagged_objects_.end(); ++it) {
+    if (it->first.Read(nullptr) == obj) {
+      if (tag != nullptr) {
+        *tag = it->second;
+      }
+      it->first = art::GcRoot<art::mirror::Object>(nullptr);
+
+      size_t index = it - tagged_objects_.begin();
+      if (index < first_free_) {
+        first_free_ = index;
+      }
+
+      // TODO: compaction.
+
+      return true;
+    }
+  }
+
+  return false;
+}
+
+void ObjectTagTable::Sweep(art::IsMarkedVisitor* visitor) {
+  if (event_handler_->IsEventEnabledAnywhere(JVMTI_EVENT_OBJECT_FREE)) {
+    SweepImpl<true>(visitor);
+  } else {
+    SweepImpl<false>(visitor);
+  }
+}
+
+template <bool kHandleNull>
+void ObjectTagTable::SweepImpl(art::IsMarkedVisitor* visitor) {
+  art::Thread* self = art::Thread::Current();
+  art::MutexLock mu(self, allow_disallow_lock_);
+
+  for (auto it = tagged_objects_.begin(); it != tagged_objects_.end(); ++it) {
+    if (!it->first.IsNull()) {
+      art::mirror::Object* original_obj = it->first.Read<art::kWithoutReadBarrier>();
+      art::mirror::Object* target_obj = visitor->IsMarked(original_obj);
+      if (original_obj != target_obj) {
+        it->first = art::GcRoot<art::mirror::Object>(target_obj);
+
+        if (kHandleNull && target_obj == nullptr) {
+          HandleNullSweep(it->second);
+        }
+      }
+    } else {
+      size_t index = it - tagged_objects_.begin();
+      if (index < first_free_) {
+        first_free_ = index;
+      }
+    }
+  }
+}
+
+void ObjectTagTable::HandleNullSweep(jlong tag) {
+  event_handler_->DispatchEvent(nullptr, JVMTI_EVENT_OBJECT_FREE, tag);
+}
+
+}  // namespace openjdkjvmti
diff --git a/runtime/openjdkjvmti/object_tagging.h b/runtime/openjdkjvmti/object_tagging.h
index 523e15f6df..45f3e4f42d 100644
--- a/runtime/openjdkjvmti/object_tagging.h
+++ b/runtime/openjdkjvmti/object_tagging.h
@@ -25,29 +25,22 @@
 
 namespace openjdkjvmti {
 
+class EventHandler;
+
 class ObjectTagTable : public art::gc::SystemWeakHolder {
  public:
-  ObjectTagTable() : art::gc::SystemWeakHolder(art::LockLevel::kAllocTrackerLock) {
+  explicit ObjectTagTable(EventHandler* event_handler)
+      : art::gc::SystemWeakHolder(art::LockLevel::kAllocTrackerLock),
+        event_handler_(event_handler) {
   }
 
   void Add(art::mirror::Object* obj, jlong tag)
       REQUIRES_SHARED(art::Locks::mutator_lock_)
-      REQUIRES(!allow_disallow_lock_) {
-    art::Thread* self = art::Thread::Current();
-    art::MutexLock mu(self, allow_disallow_lock_);
-    Wait(self);
+      REQUIRES(!allow_disallow_lock_);
 
-    if (first_free_ == tagged_objects_.size()) {
-      tagged_objects_.push_back(Entry(art::GcRoot<art::mirror::Object>(obj), tag));
-      first_free_++;
-    } else {
-      DCHECK_LT(first_free_, tagged_objects_.size());
-      DCHECK(tagged_objects_[first_free_].first.IsNull());
-      tagged_objects_[first_free_] = Entry(art::GcRoot<art::mirror::Object>(obj), tag);
-      // TODO: scan for free elements.
-      first_free_ = tagged_objects_.size();
-    }
-  }
+  bool Remove(art::mirror::Object* obj, jlong* tag)
+      REQUIRES_SHARED(art::Locks::mutator_lock_)
+      REQUIRES(!allow_disallow_lock_);
 
   bool GetTag(art::mirror::Object* obj, jlong* result)
       REQUIRES_SHARED(art::Locks::mutator_lock_)
@@ -66,70 +59,23 @@ class ObjectTagTable : public art::gc::SystemWeakHolder {
     return false;
   }
 
-  bool Remove(art::mirror::Object* obj, jlong* tag)
-      REQUIRES_SHARED(art::Locks::mutator_lock_)
-      REQUIRES(!allow_disallow_lock_) {
-    art::Thread* self = art::Thread::Current();
-    art::MutexLock mu(self, allow_disallow_lock_);
-    Wait(self);
-
-    for (auto it = tagged_objects_.begin(); it != tagged_objects_.end(); ++it) {
-      if (it->first.Read(nullptr) == obj) {
-        if (tag != nullptr) {
-          *tag = it->second;
-        }
-        it->first = art::GcRoot<art::mirror::Object>(nullptr);
-
-        size_t index = it - tagged_objects_.begin();
-        if (index < first_free_) {
-          first_free_ = index;
-        }
-
-        // TODO: compaction.
-
-        return true;
-      }
-    }
-
-    return false;
-  }
-
   void Sweep(art::IsMarkedVisitor* visitor)
       REQUIRES_SHARED(art::Locks::mutator_lock_)
-      REQUIRES(!allow_disallow_lock_) {
-    art::Thread* self = art::Thread::Current();
-    art::MutexLock mu(self, allow_disallow_lock_);
-
-    for (auto it = tagged_objects_.begin(); it != tagged_objects_.end(); ++it) {
-      if (!it->first.IsNull()) {
-        art::mirror::Object* original_obj = it->first.Read<art::kWithoutReadBarrier>();
-        art::mirror::Object* target_obj = visitor->IsMarked(original_obj);
-        if (original_obj != target_obj) {
-          it->first = art::GcRoot<art::mirror::Object>(target_obj);
-
-          if (target_obj == nullptr) {
-            HandleNullSweep(it->second);
-          }
-        }
-      } else {
-        size_t index = it - tagged_objects_.begin();
-        if (index < first_free_) {
-          first_free_ = index;
-        }
-      }
-    }
-  }
+      REQUIRES(!allow_disallow_lock_);
 
  private:
   using Entry = std::pair<art::GcRoot<art::mirror::Object>, jlong>;
 
-  void HandleNullSweep(jlong tag ATTRIBUTE_UNUSED) {
-    // TODO: Handle deallocation reporting here. We'll have to enqueue tags temporarily, as we
-    //       probably shouldn't call the callbacks directly (to avoid any issues).
-  }
+  template <bool kHandleNull>
+  void SweepImpl(art::IsMarkedVisitor* visitor)
+        REQUIRES_SHARED(art::Locks::mutator_lock_)
+        REQUIRES(!allow_disallow_lock_);
+  void HandleNullSweep(jlong tag);
 
   std::vector<Entry> tagged_objects_ GUARDED_BY(allow_disallow_lock_);
   size_t first_free_ = 0;
+
+  EventHandler* event_handler_;
 };
 
 }  // namespace openjdkjvmti
diff --git a/test/902-hello-transformation/transform.cc b/test/902-hello-transformation/transform.cc
index e0d623e6e1..5b0d219d8f 100644
--- a/test/902-hello-transformation/transform.cc
+++ b/test/902-hello-transformation/transform.cc
@@ -23,6 +23,7 @@
 #include "base/logging.h"
 #include "jni.h"
 #include "openjdkjvmti/jvmti.h"
+#include "ti-agent/common_load.h"
 #include "utils.h"
 
 namespace art {
@@ -30,7 +31,6 @@ namespace Test902HelloTransformation {
 
 static bool RuntimeIsJvm = false;
 
-jvmtiEnv* jvmti_env;
 bool IsJVM() {
   return RuntimeIsJvm;
 }
diff --git a/test/903-hello-tagging/tagging.cc b/test/903-hello-tagging/tagging.cc
index 8ccdf49892..7d692fb5de 100644
--- a/test/903-hello-tagging/tagging.cc
+++ b/test/903-hello-tagging/tagging.cc
@@ -25,13 +25,12 @@
 #include "base/logging.h"
 #include "jni.h"
 #include "openjdkjvmti/jvmti.h"
+#include "ti-agent/common_load.h"
 #include "utils.h"
 
 namespace art {
 namespace Test903HelloTagging {
 
-static jvmtiEnv* jvmti_env;
-
 extern "C" JNIEXPORT void JNICALL Java_Main_setTag(JNIEnv* env ATTRIBUTE_UNUSED,
                                                    jclass,
                                                    jobject obj,
diff --git a/test/904-object-allocation/src/Main.java b/test/904-object-allocation/src/Main.java
index f15c1c213f..9a089bdd78 100644
--- a/test/904-object-allocation/src/Main.java
+++ b/test/904-object-allocation/src/Main.java
@@ -40,7 +40,7 @@ public class Main {
   }
 
   public static void doTest(ArrayList<Object> l) throws Exception {
-    setupCallback();
+    setupObjectAllocCallback();
 
     enableAllocationTracking(null, true);
 
@@ -127,6 +127,6 @@ public class Main {
     }
   }
 
-  private static native void setupCallback();
+  private static native void setupObjectAllocCallback();
   private static native void enableAllocationTracking(Thread thread, boolean enable);
 }
diff --git a/test/904-object-allocation/tracking.cc b/test/904-object-allocation/tracking.cc
index c392cd48a7..b22fc6c8c0 100644
--- a/test/904-object-allocation/tracking.cc
+++ b/test/904-object-allocation/tracking.cc
@@ -26,13 +26,12 @@
 #include "openjdkjvmti/jvmti.h"
 #include "ScopedLocalRef.h"
 #include "ScopedUtfChars.h"
+#include "ti-agent/common_load.h"
 #include "utils.h"
 
 namespace art {
 namespace Test904ObjectAllocation {
 
-static jvmtiEnv* jvmti_env;
-
 static std::string GetClassName(JNIEnv* jni_env, jclass cls) {
   ScopedLocalRef<jclass> class_class(jni_env, jni_env->GetObjectClass(cls));
   jmethodID mid = jni_env->GetMethodID(class_class.get(), "getName", "()Ljava/lang/String;");
@@ -58,7 +57,8 @@ static void JNICALL ObjectAllocated(jvmtiEnv* ti_env ATTRIBUTE_UNUSED,
          static_cast<size_t>(size));
 }
 
-extern "C" JNIEXPORT void JNICALL Java_Main_setupCallback(JNIEnv* env ATTRIBUTE_UNUSED, jclass) {
+extern "C" JNIEXPORT void JNICALL Java_Main_setupObjectAllocCallback(
+    JNIEnv* env ATTRIBUTE_UNUSED, jclass klass ATTRIBUTE_UNUSED) {
   jvmtiEventCallbacks callbacks;
   memset(&callbacks, 0, sizeof(jvmtiEventCallbacks));
   callbacks.VMObjectAlloc = ObjectAllocated;
@@ -82,7 +82,7 @@ extern "C" JNIEXPORT void JNICALL Java_Main_enableAllocationTracking(JNIEnv* env
   if (ret != JVMTI_ERROR_NONE) {
     char* err;
     jvmti_env->GetErrorName(ret, &err);
-    printf("Error getting tag: %s\n", err);
+    printf("Error enabling/disabling allocation tracking: %s\n", err);
   }
 }
 
diff --git a/test/905-object-free/build b/test/905-object-free/build
new file mode 100755
index 0000000000..898e2e54a2
--- /dev/null
+++ b/test/905-object-free/build
@@ -0,0 +1,17 @@
+#!/bin/bash
+#
+# Copyright 2016 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.
+
+./default-build "$@" --experimental agents
diff --git a/test/905-object-free/expected.txt b/test/905-object-free/expected.txt
new file mode 100644
index 0000000000..31b73185f9
--- /dev/null
+++ b/test/905-object-free/expected.txt
@@ -0,0 +1,10 @@
+ObjectFree tag=1
+---
+ObjectFree tag=10
+ObjectFree tag=100
+ObjectFree tag=1000
+---
+---
+---
+---
+---
diff --git a/test/905-object-free/info.txt b/test/905-object-free/info.txt
new file mode 100644
index 0000000000..875a5f6ec1
--- /dev/null
+++ b/test/905-object-free/info.txt
@@ -0,0 +1 @@
+Tests basic functions in the jvmti plugin.
diff --git a/test/905-object-free/run b/test/905-object-free/run
new file mode 100755
index 0000000000..753b742681
--- /dev/null
+++ b/test/905-object-free/run
@@ -0,0 +1,43 @@
+#!/bin/bash
+#
+# Copyright 2016 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.
+
+plugin=libopenjdkjvmtid.so
+agent=libtiagentd.so
+lib=tiagentd
+if  [[ "$@" == *"-O"* ]]; then
+  agent=libtiagent.so
+  plugin=libopenjdkjvmti.so
+  lib=tiagent
+fi
+
+if [[ "$@" == *"--jvm"* ]]; then
+  arg="jvm"
+else
+  arg="art"
+fi
+
+if [[ "$@" != *"--debuggable"* ]]; then
+  other_args=" -Xcompiler-option --debuggable "
+else
+  other_args=""
+fi
+
+./default-run "$@" --experimental agents \
+                   --experimental runtime-plugins \
+                   --runtime-option -agentpath:${agent}=905-object-free,${arg} \
+                   --android-runtime-option -Xplugin:${plugin} \
+                   ${other_args} \
+                   --args ${lib}
diff --git a/test/905-object-free/src/Main.java b/test/905-object-free/src/Main.java
new file mode 100644
index 0000000000..7b52e29285
--- /dev/null
+++ b/test/905-object-free/src/Main.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2016 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.
+ */
+
+import java.util.ArrayList;
+
+public class Main {
+  public static void main(String[] args) throws Exception {
+    System.loadLibrary(args[1]);
+
+    doTest();
+  }
+
+  public static void doTest() throws Exception {
+    // Use a list to ensure objects must be allocated.
+    ArrayList<Object> l = new ArrayList<>(100);
+
+    setupObjectFreeCallback();
+
+    enableFreeTracking(true);
+    run(l);
+
+    enableFreeTracking(false);
+    run(l);
+  }
+
+  private static void run(ArrayList<Object> l) {
+    allocate(l, 1);
+    l.clear();
+
+    Runtime.getRuntime().gc();
+
+    System.out.println("---");
+
+    // Note: the reporting will not depend on the heap layout (which could be unstable). Walking
+    //       the tag table should give us a stable output order.
+    for (int i = 10; i <= 1000; i *= 10) {
+      allocate(l, i);
+    }
+    l.clear();
+
+    Runtime.getRuntime().gc();
+
+    System.out.println("---");
+
+    Runtime.getRuntime().gc();
+
+    System.out.println("---");
+  }
+
+  private static void allocate(ArrayList<Object> l, long tag) {
+    Object obj = new Object();
+    l.add(obj);
+    setTag(obj, tag);
+  }
+
+  private static native void setupObjectFreeCallback();
+  private static native void enableFreeTracking(boolean enable);
+  private static native void setTag(Object o, long tag);
+}
diff --git a/test/905-object-free/tracking_free.cc b/test/905-object-free/tracking_free.cc
new file mode 100644
index 0000000000..5905d481cf
--- /dev/null
+++ b/test/905-object-free/tracking_free.cc
@@ -0,0 +1,79 @@
+/*
+ * Copyright (C) 2013 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 "tracking_free.h"
+
+#include <iostream>
+#include <pthread.h>
+#include <stdio.h>
+#include <vector>
+
+#include "base/logging.h"
+#include "jni.h"
+#include "openjdkjvmti/jvmti.h"
+#include "ScopedLocalRef.h"
+#include "ScopedUtfChars.h"
+#include "ti-agent/common_load.h"
+#include "utils.h"
+
+namespace art {
+namespace Test905ObjectFree {
+
+static void JNICALL ObjectFree(jvmtiEnv* ti_env ATTRIBUTE_UNUSED, jlong tag) {
+  printf("ObjectFree tag=%zu\n", static_cast<size_t>(tag));
+}
+
+extern "C" JNIEXPORT void JNICALL Java_Main_setupObjectFreeCallback(
+    JNIEnv* env ATTRIBUTE_UNUSED, jclass klass ATTRIBUTE_UNUSED) {
+  jvmtiEventCallbacks callbacks;
+  memset(&callbacks, 0, sizeof(jvmtiEventCallbacks));
+  callbacks.ObjectFree = ObjectFree;
+
+  jvmtiError ret = jvmti_env->SetEventCallbacks(&callbacks, sizeof(callbacks));
+  if (ret != JVMTI_ERROR_NONE) {
+    char* err;
+    jvmti_env->GetErrorName(ret, &err);
+    printf("Error setting callbacks: %s\n", err);
+  }
+}
+
+extern "C" JNIEXPORT void JNICALL Java_Main_enableFreeTracking(JNIEnv* env ATTRIBUTE_UNUSED,
+                                                               jclass klass ATTRIBUTE_UNUSED,
+                                                               jboolean enable) {
+  jvmtiError ret = jvmti_env->SetEventNotificationMode(
+      enable ? JVMTI_ENABLE : JVMTI_DISABLE,
+      JVMTI_EVENT_OBJECT_FREE,
+      nullptr);
+  if (ret != JVMTI_ERROR_NONE) {
+    char* err;
+    jvmti_env->GetErrorName(ret, &err);
+    printf("Error enabling/disabling object-free callbacks: %s\n", err);
+  }
+}
+
+// Don't do anything
+jint OnLoad(JavaVM* vm,
+            char* options ATTRIBUTE_UNUSED,
+            void* reserved ATTRIBUTE_UNUSED) {
+  if (vm->GetEnv(reinterpret_cast<void**>(&jvmti_env), JVMTI_VERSION_1_0)) {
+    printf("Unable to get jvmti env!\n");
+    return 1;
+  }
+  return 0;
+}
+
+}  // namespace Test905ObjectFree
+}  // namespace art
diff --git a/test/905-object-free/tracking_free.h b/test/905-object-free/tracking_free.h
new file mode 100644
index 0000000000..ba4aa43ffe
--- /dev/null
+++ b/test/905-object-free/tracking_free.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2016 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_TEST_905_OBJECT_FREE_TRACKING_FREE_H_
+#define ART_TEST_905_OBJECT_FREE_TRACKING_FREE_H_
+
+#include <jni.h>
+
+namespace art {
+namespace Test905ObjectFree {
+
+jint OnLoad(JavaVM* vm, char* options, void* reserved);
+
+}  // namespace Test905ObjectFree
+}  // namespace art
+
+#endif  // ART_TEST_905_OBJECT_FREE_TRACKING_FREE_H_
diff --git a/test/Android.bp b/test/Android.bp
index b2152e875b..4457e8a655 100644
--- a/test/Android.bp
+++ b/test/Android.bp
@@ -247,6 +247,7 @@ art_cc_test_library {
         "902-hello-transformation/transform.cc",
         "903-hello-tagging/tagging.cc",
         "904-object-allocation/tracking.cc",
+        "905-object-free/tracking_free.cc",
     ],
     shared_libs: [
         "libart",
@@ -267,6 +268,7 @@ art_cc_test_library {
         "902-hello-transformation/transform.cc",
         "903-hello-tagging/tagging.cc",
         "904-object-allocation/tracking.cc",
+        "905-object-free/tracking_free.cc",
     ],
     shared_libs: [
         "libartd",
diff --git a/test/Android.run-test.mk b/test/Android.run-test.mk
index 935d6ad440..29000f053e 100644
--- a/test/Android.run-test.mk
+++ b/test/Android.run-test.mk
@@ -263,7 +263,7 @@ endif
 # 147-stripped-dex-fallback isn't supported on device because --strip-dex
 # requires the zip command.
 # 569-checker-pattern-replacement tests behaviour present only on host.
-# 90{2,3,4} are not supported in current form due to linker
+# 90{2,3,4,5} are not supported in current form due to linker
 # restrictions. See b/31681198
 TEST_ART_BROKEN_TARGET_TESTS := \
   147-stripped-dex-fallback \
@@ -271,6 +271,7 @@ TEST_ART_BROKEN_TARGET_TESTS := \
   902-hello-transformation \
   903-hello-tagging \
   904-object-allocation \
+  905-object-free \
 
 ifneq (,$(filter target,$(TARGET_TYPES)))
   ART_TEST_KNOWN_BROKEN += $(call all-run-test-names,target,$(RUN_TYPES),$(PREBUILD_TYPES), \
diff --git a/test/ti-agent/common_load.cc b/test/ti-agent/common_load.cc
index fde3c6bb38..2b8947ec96 100644
--- a/test/ti-agent/common_load.cc
+++ b/test/ti-agent/common_load.cc
@@ -22,14 +22,18 @@
 #include "art_method-inl.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "common_load.h"
 
 #include "901-hello-ti-agent/basics.h"
 #include "902-hello-transformation/transform.h"
 #include "903-hello-tagging/tagging.h"
 #include "904-object-allocation/tracking.h"
+#include "905-object-free/tracking_free.h"
 
 namespace art {
 
+jvmtiEnv* jvmti_env;
+
 using OnLoad   = jint (*)(JavaVM* vm, char* options, void* reserved);
 using OnAttach = jint (*)(JavaVM* vm, char* options, void* reserved);
 
@@ -45,6 +49,7 @@ AgentLib agents[] = {
   { "902-hello-transformation", Test902HelloTransformation::OnLoad, nullptr },
   { "903-hello-tagging", Test903HelloTagging::OnLoad, nullptr },
   { "904-object-allocation", Test904ObjectAllocation::OnLoad, nullptr },
+  { "905-object-free", Test905ObjectFree::OnLoad, nullptr },
 };
 
 static AgentLib* FindAgent(char* name) {
diff --git a/test/ti-agent/common_load.h b/test/ti-agent/common_load.h
new file mode 100644
index 0000000000..fac94b4c6e
--- /dev/null
+++ b/test/ti-agent/common_load.h
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2016 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_TEST_TI_AGENT_COMMON_LOAD_H_
+#define ART_TEST_TI_AGENT_COMMON_LOAD_H_
+
+#include "openjdkjvmti/jvmti.h"
+
+namespace art {
+
+extern jvmtiEnv* jvmti_env;
+
+}  // namespace art
+
+#endif  // ART_TEST_TI_AGENT_COMMON_LOAD_H_