Remove unused code from dalvik.system.VMDebug.

Test: m
Bug: 165361458
Change-Id: Ic2cc2515a0af79d4541c16c0b3057980ada2a869

5 files changed, 0 insertions, 285 deletions

diff --git a/runtime/gc/heap.cc b/runtime/gc/heap.cc
index fcf4afcf4c..84d035165b 100644
--- a/runtime/gc/heap.cc
+++ b/runtime/gc/heap.cc
@@ -1984,67 +1984,6 @@ void Heap::CountInstances(const std::vector<Handle<mirror::Class>>& classes,
   VisitObjects(instance_counter);
 }
 
-void Heap::GetInstances(VariableSizedHandleScope& scope,
-                        Handle<mirror::Class> h_class,
-                        bool use_is_assignable_from,
-                        int32_t max_count,
-                        std::vector<Handle<mirror::Object>>& instances) {
-  DCHECK_GE(max_count, 0);
-  auto instance_collector = [&](mirror::Object* obj) REQUIRES_SHARED(Locks::mutator_lock_) {
-    if (MatchesClass(obj, h_class, use_is_assignable_from)) {
-      if (max_count == 0 || instances.size() < static_cast<size_t>(max_count)) {
-        instances.push_back(scope.NewHandle(obj));
-      }
-    }
-  };
-  VisitObjects(instance_collector);
-}
-
-void Heap::GetReferringObjects(VariableSizedHandleScope& scope,
-                               Handle<mirror::Object> o,
-                               int32_t max_count,
-                               std::vector<Handle<mirror::Object>>& referring_objects) {
-  class ReferringObjectsFinder {
-   public:
-    ReferringObjectsFinder(VariableSizedHandleScope& scope_in,
-                           Handle<mirror::Object> object_in,
-                           int32_t max_count_in,
-                           std::vector<Handle<mirror::Object>>& referring_objects_in)
-        REQUIRES_SHARED(Locks::mutator_lock_)
-        : scope_(scope_in),
-          object_(object_in),
-          max_count_(max_count_in),
-          referring_objects_(referring_objects_in) {}
-
-    // For Object::VisitReferences.
-    void operator()(ObjPtr<mirror::Object> obj,
-                    MemberOffset offset,
-                    bool is_static ATTRIBUTE_UNUSED) const
-        REQUIRES_SHARED(Locks::mutator_lock_) {
-      mirror::Object* ref = obj->GetFieldObject<mirror::Object>(offset);
-      if (ref == object_.Get() && (max_count_ == 0 || referring_objects_.size() < max_count_)) {
-        referring_objects_.push_back(scope_.NewHandle(obj));
-      }
-    }
-
-    void VisitRootIfNonNull(mirror::CompressedReference<mirror::Object>* root ATTRIBUTE_UNUSED)
-        const {}
-    void VisitRoot(mirror::CompressedReference<mirror::Object>* root ATTRIBUTE_UNUSED) const {}
-
-   private:
-    VariableSizedHandleScope& scope_;
-    Handle<mirror::Object> const object_;
-    const uint32_t max_count_;
-    std::vector<Handle<mirror::Object>>& referring_objects_;
-    DISALLOW_COPY_AND_ASSIGN(ReferringObjectsFinder);
-  };
-  ReferringObjectsFinder finder(scope, o, max_count, referring_objects);
-  auto referring_objects_finder = [&](mirror::Object* obj) REQUIRES_SHARED(Locks::mutator_lock_) {
-    obj->VisitReferences(finder, VoidFunctor());
-  };
-  VisitObjects(referring_objects_finder);
-}
-
 void Heap::CollectGarbage(bool clear_soft_references, GcCause cause) {
   // Even if we waited for a GC we still need to do another GC since weaks allocated during the
   // last GC will not have necessarily been cleared.
diff --git a/runtime/gc/heap.h b/runtime/gc/heap.h
index 9f558f3e68..65d08374fc 100644
--- a/runtime/gc/heap.h
+++ b/runtime/gc/heap.h
@@ -395,23 +395,6 @@ class Heap {
       REQUIRES(!Locks::heap_bitmap_lock_, !*gc_complete_lock_)
       REQUIRES_SHARED(Locks::mutator_lock_);
 
-  // Implements VMDebug.getInstancesOfClasses and JDWP RT_Instances.
-  void GetInstances(VariableSizedHandleScope& scope,
-                    Handle<mirror::Class> c,
-                    bool use_is_assignable_from,
-                    int32_t max_count,
-                    std::vector<Handle<mirror::Object>>& instances)
-      REQUIRES(!Locks::heap_bitmap_lock_, !*gc_complete_lock_)
-      REQUIRES_SHARED(Locks::mutator_lock_);
-
-  // Implements JDWP OR_ReferringObjects.
-  void GetReferringObjects(VariableSizedHandleScope& scope,
-                           Handle<mirror::Object> o,
-                           int32_t max_count,
-                           std::vector<Handle<mirror::Object>>& referring_objects)
-      REQUIRES(!Locks::heap_bitmap_lock_, !*gc_complete_lock_)
-      REQUIRES_SHARED(Locks::mutator_lock_);
-
   // Removes the growth limit on the alloc space so it may grow to its maximum capacity. Used to
   // implement dalvik.system.VMRuntime.clearGrowthLimit.
   void ClearGrowthLimit();
diff --git a/runtime/native/dalvik_system_VMDebug.cc b/runtime/native/dalvik_system_VMDebug.cc
index a090f356ac..d1683a92e6 100644
--- a/runtime/native/dalvik_system_VMDebug.cc
+++ b/runtime/native/dalvik_system_VMDebug.cc
@@ -178,27 +178,6 @@ static jlong VMDebug_lastDebuggerActivity(JNIEnv*, jclass) {
   return -1;
 }
 
-static void ThrowUnsupportedOperationException(JNIEnv* env) {
-  ScopedObjectAccess soa(env);
-  soa.Self()->ThrowNewException("Ljava/lang/UnsupportedOperationException;", nullptr);
-}
-
-static void VMDebug_startInstructionCounting(JNIEnv* env, jclass) {
-  ThrowUnsupportedOperationException(env);
-}
-
-static void VMDebug_stopInstructionCounting(JNIEnv* env, jclass) {
-  ThrowUnsupportedOperationException(env);
-}
-
-static void VMDebug_getInstructionCount(JNIEnv* env, jclass, jintArray /*javaCounts*/) {
-  ThrowUnsupportedOperationException(env);
-}
-
-static void VMDebug_resetInstructionCount(JNIEnv* env, jclass) {
-  ThrowUnsupportedOperationException(env);
-}
-
 static void VMDebug_printLoadedClasses(JNIEnv* env, jclass, jint flags) {
   class DumpClassVisitor : public ClassVisitor {
    public:
@@ -275,14 +254,6 @@ static void VMDebug_dumpReferenceTables(JNIEnv* env, jclass) {
   LOG(INFO) << "---";
 }
 
-static void VMDebug_crash(JNIEnv*, jclass) {
-  LOG(FATAL) << "Crashing runtime on request";
-}
-
-static void VMDebug_infopoint(JNIEnv*, jclass, jint id) {
-  LOG(INFO) << "VMDebug infopoint " << id << " hit";
-}
-
 static jlong VMDebug_countInstancesOfClass(JNIEnv* env,
                                            jclass,
                                            jclass javaClass,
@@ -332,123 +303,6 @@ static jlongArray VMDebug_countInstancesOfClasses(JNIEnv* env,
   return soa.AddLocalReference<jlongArray>(long_counts);
 }
 
-static jobjectArray VMDebug_getInstancesOfClasses(JNIEnv* env,
-                                                  jclass,
-                                                  jobjectArray javaClasses,
-                                                  jboolean includeAssignable) {
-  ScopedObjectAccess soa(env);
-  StackHandleScope<2> hs(soa.Self());
-  Handle<mirror::ObjectArray<mirror::Class>> classes = hs.NewHandle(
-      soa.Decode<mirror::ObjectArray<mirror::Class>>(javaClasses));
-  if (classes == nullptr) {
-    return nullptr;
-  }
-
-  jclass object_array_class = env->FindClass("[Ljava/lang/Object;");
-  if (env->ExceptionCheck() == JNI_TRUE) {
-    return nullptr;
-  }
-  CHECK(object_array_class != nullptr);
-
-  size_t num_classes = classes->GetLength();
-  jobjectArray result = env->NewObjectArray(num_classes, object_array_class, nullptr);
-  if (env->ExceptionCheck() == JNI_TRUE) {
-    return nullptr;
-  }
-
-  gc::Heap* const heap = Runtime::Current()->GetHeap();
-  MutableHandle<mirror::Class> h_class(hs.NewHandle<mirror::Class>(nullptr));
-  for (size_t i = 0; i < num_classes; ++i) {
-    h_class.Assign(classes->Get(i));
-
-    VariableSizedHandleScope hs2(soa.Self());
-    std::vector<Handle<mirror::Object>> raw_instances;
-    heap->GetInstances(hs2, h_class, includeAssignable, /* max_count= */ 0, raw_instances);
-    jobjectArray array = env->NewObjectArray(raw_instances.size(),
-                                             WellKnownClasses::java_lang_Object,
-                                             nullptr);
-    if (env->ExceptionCheck() == JNI_TRUE) {
-      return nullptr;
-    }
-
-    for (size_t j = 0; j < raw_instances.size(); ++j) {
-      env->SetObjectArrayElement(array, j, raw_instances[j].ToJObject());
-    }
-    env->SetObjectArrayElement(result, i, array);
-  }
-  return result;
-}
-
-// We export the VM internal per-heap-space size/alloc/free metrics
-// for the zygote space, alloc space (application heap), and the large
-// object space for dumpsys meminfo. The other memory region data such
-// as PSS, private/shared dirty/shared data are available via
-// /proc/<pid>/smaps.
-static void VMDebug_getHeapSpaceStats(JNIEnv* env, jclass, jlongArray data) {
-  jlong* arr = reinterpret_cast<jlong*>(env->GetPrimitiveArrayCritical(data, nullptr));
-  if (arr == nullptr || env->GetArrayLength(data) < 9) {
-    return;
-  }
-
-  size_t allocSize = 0;
-  size_t allocUsed = 0;
-  size_t zygoteSize = 0;
-  size_t zygoteUsed = 0;
-  size_t largeObjectsSize = 0;
-  size_t largeObjectsUsed = 0;
-  gc::Heap* heap = Runtime::Current()->GetHeap();
-  {
-    ScopedObjectAccess soa(env);
-    for (gc::space::ContinuousSpace* space : heap->GetContinuousSpaces()) {
-      if (space->IsImageSpace()) {
-        // Currently don't include the image space.
-      } else if (space->IsZygoteSpace()) {
-        gc::space::ZygoteSpace* zygote_space = space->AsZygoteSpace();
-        zygoteSize += zygote_space->Size();
-        zygoteUsed += zygote_space->GetBytesAllocated();
-      } else if (space->IsMallocSpace()) {
-        // This is a malloc space.
-        gc::space::MallocSpace* malloc_space = space->AsMallocSpace();
-        allocSize += malloc_space->GetFootprint();
-        allocUsed += malloc_space->GetBytesAllocated();
-      } else if (space->IsBumpPointerSpace()) {
-        gc::space::BumpPointerSpace* bump_pointer_space = space->AsBumpPointerSpace();
-        allocSize += bump_pointer_space->Size();
-        allocUsed += bump_pointer_space->GetBytesAllocated();
-      } else if (space->IsRegionSpace()) {
-        gc::space::RegionSpace* region_space = space->AsRegionSpace();
-        // When using the concurrent copying garbage collector, the corresponding allocation space
-        // uses a region space. The memory actually requested for the region space is to allow for
-        // a from-space and a to-space, and their sum is twice the actual available space. So here
-        // we need to divide by 2 to get the actual space size that can be used.
-        allocSize += region_space->Size() / 2;
-        allocUsed += region_space->GetBytesAllocated();
-      }
-    }
-    for (gc::space::DiscontinuousSpace* space : heap->GetDiscontinuousSpaces()) {
-      if (space->IsLargeObjectSpace()) {
-        largeObjectsSize += space->AsLargeObjectSpace()->GetBytesAllocated();
-        largeObjectsUsed += largeObjectsSize;
-      }
-    }
-  }
-  size_t allocFree = allocSize - allocUsed;
-  size_t zygoteFree = zygoteSize - zygoteUsed;
-  size_t largeObjectsFree = largeObjectsSize - largeObjectsUsed;
-
-  int j = 0;
-  arr[j++] = allocSize;
-  arr[j++] = allocUsed;
-  arr[j++] = allocFree;
-  arr[j++] = zygoteSize;
-  arr[j++] = zygoteUsed;
-  arr[j++] = zygoteFree;
-  arr[j++] = largeObjectsSize;
-  arr[j++] = largeObjectsUsed;
-  arr[j++] = largeObjectsFree;
-  env->ReleasePrimitiveArrayCritical(data, arr, 0);
-}
-
 // The runtime stat names for VMDebug.getRuntimeStat().
 enum class VMDebugRuntimeStatId {
   kArtGcGcCount = 0,
@@ -628,31 +482,23 @@ static void VMDebug_setAllocTrackerStackDepth(JNIEnv* env, jclass, jint stack_de
 static JNINativeMethod gMethods[] = {
   NATIVE_METHOD(VMDebug, countInstancesOfClass, "(Ljava/lang/Class;Z)J"),
   NATIVE_METHOD(VMDebug, countInstancesOfClasses, "([Ljava/lang/Class;Z)[J"),
-  NATIVE_METHOD(VMDebug, crash, "()V"),
   NATIVE_METHOD(VMDebug, dumpHprofData, "(Ljava/lang/String;I)V"),
   NATIVE_METHOD(VMDebug, dumpHprofDataDdms, "()V"),
   NATIVE_METHOD(VMDebug, dumpReferenceTables, "()V"),
   NATIVE_METHOD(VMDebug, getAllocCount, "(I)I"),
-  NATIVE_METHOD(VMDebug, getHeapSpaceStats, "([J)V"),
-  NATIVE_METHOD(VMDebug, getInstancesOfClasses, "([Ljava/lang/Class;Z)[[Ljava/lang/Object;"),
-  NATIVE_METHOD(VMDebug, getInstructionCount, "([I)V"),
   FAST_NATIVE_METHOD(VMDebug, getLoadedClassCount, "()I"),
   NATIVE_METHOD(VMDebug, getVmFeatureList, "()[Ljava/lang/String;"),
-  NATIVE_METHOD(VMDebug, infopoint, "(I)V"),
   FAST_NATIVE_METHOD(VMDebug, isDebuggerConnected, "()Z"),
   FAST_NATIVE_METHOD(VMDebug, isDebuggingEnabled, "()Z"),
   NATIVE_METHOD(VMDebug, getMethodTracingMode, "()I"),
   FAST_NATIVE_METHOD(VMDebug, lastDebuggerActivity, "()J"),
   FAST_NATIVE_METHOD(VMDebug, printLoadedClasses, "(I)V"),
   NATIVE_METHOD(VMDebug, resetAllocCount, "(I)V"),
-  NATIVE_METHOD(VMDebug, resetInstructionCount, "()V"),
   NATIVE_METHOD(VMDebug, startAllocCounting, "()V"),
-  NATIVE_METHOD(VMDebug, startInstructionCounting, "()V"),
   NATIVE_METHOD(VMDebug, startMethodTracingDdmsImpl, "(IIZI)V"),
   NATIVE_METHOD(VMDebug, startMethodTracingFd, "(Ljava/lang/String;IIIZIZ)V"),
   NATIVE_METHOD(VMDebug, startMethodTracingFilename, "(Ljava/lang/String;IIZI)V"),
   NATIVE_METHOD(VMDebug, stopAllocCounting, "()V"),
-  NATIVE_METHOD(VMDebug, stopInstructionCounting, "()V"),
   NATIVE_METHOD(VMDebug, stopMethodTracing, "()V"),
   FAST_NATIVE_METHOD(VMDebug, threadCpuTimeNanos, "()J"),
   NATIVE_METHOD(VMDebug, getRuntimeStatInternal, "(I)Ljava/lang/String;"),
diff --git a/test/099-vmdebug/expected.txt b/test/099-vmdebug/expected.txt
index f7801de62f..b8d72f66f8 100644
--- a/test/099-vmdebug/expected.txt
+++ b/test/099-vmdebug/expected.txt
@@ -23,9 +23,3 @@ Instances of null 0
 Instances of ClassA assignable 3
 Array counts [2, 1, 0]
 Array counts assignable [3, 1, 0]
-ClassD got 3, combined mask: 13
-ClassE got 2, combined mask: 18
-null got 0
-ClassD assignable got 5, combined mask: 31
-ClassE assignable got 2, combined mask: 18
-null assignable got 0
diff --git a/test/099-vmdebug/src/Main.java b/test/099-vmdebug/src/Main.java
index e0d829a0d6..8fed123852 100644
--- a/test/099-vmdebug/src/Main.java
+++ b/test/099-vmdebug/src/Main.java
@@ -33,7 +33,6 @@ public class Main {
         }
         testMethodTracing();
         testCountInstances();
-        testGetInstances();
         testRuntimeStat();
         testRuntimeStats();
     }
@@ -264,45 +263,6 @@ public class Main {
         }
     }
 
-    private static void testGetInstances() throws Exception {
-        ArrayList<Object> l = new ArrayList<Object>();
-        l.add(new ClassD(0x01));
-        l.add(new ClassE(0x02));
-        l.add(new ClassD(0x04));
-        l.add(new ClassD(0x08));
-        l.add(new ClassE(0x10));
-        Runtime.getRuntime().gc();
-        Class<?>[] classes = new Class<?>[] {ClassD.class, ClassE.class, null};
-        Object[][] instances = VMDebug.getInstancesOfClasses(classes, false);
-
-        int mask = 0;
-        for (Object instance : instances[0]) {
-            mask |= ((ClassD)instance).mask;
-        }
-        System.out.println("ClassD got " + instances[0].length + ", combined mask: " + mask);
-
-        mask = 0;
-        for (Object instance : instances[1]) {
-            mask |= ((ClassD)instance).mask;
-        }
-        System.out.println("ClassE got " + instances[1].length + ", combined mask: " + mask);
-        System.out.println("null got " + instances[2].length);
-
-        instances = VMDebug.getInstancesOfClasses(classes, true);
-        mask = 0;
-        for (Object instance : instances[0]) {
-            mask |= ((ClassD)instance).mask;
-        }
-        System.out.println("ClassD assignable got " + instances[0].length + ", combined mask: " + mask);
-
-        mask = 0;
-        for (Object instance : instances[1]) {
-            mask |= ((ClassD)instance).mask;
-        }
-        System.out.println("ClassE assignable got " + instances[1].length + ", combined mask: " + mask);
-        System.out.println("null assignable got " + instances[2].length);
-    }
-
     private static class VMDebug {
         private static final Method startMethodTracingMethod;
         private static final Method stopMethodTracingMethod;
@@ -311,7 +271,6 @@ public class Main {
         private static final Method getRuntimeStatsMethod;
         private static final Method countInstancesOfClassMethod;
         private static final Method countInstancesOfClassesMethod;
-        private static final Method getInstancesOfClassesMethod;
         static {
             try {
                 Class<?> c = Class.forName("dalvik.system.VMDebug");
@@ -325,8 +284,6 @@ public class Main {
                         Class.class, Boolean.TYPE);
                 countInstancesOfClassesMethod = c.getDeclaredMethod("countInstancesOfClasses",
                         Class[].class, Boolean.TYPE);
-                getInstancesOfClassesMethod = c.getDeclaredMethod("getInstancesOfClasses",
-                        Class[].class, Boolean.TYPE);
             } catch (Exception e) {
                 throw new RuntimeException(e);
             }
@@ -357,9 +314,5 @@ public class Main {
             return (long[]) countInstancesOfClassesMethod.invoke(
                     null, new Object[]{classes, assignable});
         }
-        public static Object[][] getInstancesOfClasses(Class<?>[] classes, boolean assignable) throws Exception {
-            return (Object[][]) getInstancesOfClassesMethod.invoke(
-                    null, new Object[]{classes, assignable});
-        }
     }
 }