[fix] Fix inspector to work with JDK 8

beehive-lab · Jul 10, 2018 · ea402c0 · ea402c0
1 parent 3ab6ca3
commit ea402c0
Show file tree

Hide file tree

Showing 3 changed files with 79 additions and 28 deletions.
diff --git a/com.oracle.max.tele.vm/src/com/sun/max/tele/field/VmFieldAccess.java b/com.oracle.max.tele.vm/src/com/sun/max/tele/field/VmFieldAccess.java
@@ -1,4 +1,6 @@
 /*
+ * Copyright (c) 2018, APT Group, School of Computer Science,
+ * The University of Manchester. All rights reserved.
  * Copyright (c) 2007, 2012, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
@@ -56,6 +58,7 @@
 import com.sun.max.vm.heap.gcx.rset.ctbl.*;
 import com.sun.max.vm.heap.sequential.gen.semiSpace.*;
 import com.sun.max.vm.heap.sequential.semiSpace.*;
+import com.sun.max.vm.jdk.JDK;
 import com.sun.max.vm.jni.*;
 import com.sun.max.vm.jni.DynamicLinker.LibInfo;
 import com.sun.max.vm.layout.*;
@@ -96,6 +99,18 @@ private VmFieldAccess(TeleVM vm) {
         super(vm);
         // Uncomment to enable verifying that the generated content in this class is up to date when running the inspector
         // updateSource(true);
+        if (JDK.JDK_VERSION == JDK.JDK_7) {
+            ConcurrentHashMap$Segment = Classes.getInnerClass(ConcurrentHashMap.class, "Segment");
+            ConcurrentHashMap_segments = new TeleInstanceReferenceFieldAccess(ConcurrentHashMap.class, "segments", Array.newInstance(ConcurrentHashMap$Segment, 0).getClass());
+            ConcurrentHashMap$Segment_table = new TeleInstanceReferenceFieldAccess(ConcurrentHashMap$Segment, "table", Array.newInstance(ConcurrentHashMap$HashEntry, 0).getClass());
+            ConcurrentHashMap$HashEntry_next = new TeleInstanceReferenceFieldAccess(ConcurrentHashMap$HashEntry, "next", ConcurrentHashMap$HashEntry);
+            ConcurrentHashMap$HashEntry_value = new TeleInstanceReferenceFieldAccess(ConcurrentHashMap$HashEntry, "value", Object.class);
+        } else {
+            ConcurrentHashMap$Node = Classes.getInnerClass(ConcurrentHashMap.class, "Node");
+            ConcurrentHashMap_table = new TeleInstanceReferenceFieldAccess(ConcurrentHashMap.class, "table", Array.newInstance(ConcurrentHashMap$Node, 0).getClass());
+            ConcurrentHashMap$Node_next = new TeleInstanceReferenceFieldAccess(ConcurrentHashMap$Node, "next", ConcurrentHashMap$Node);
+            ConcurrentHashMap$Node_val = new TeleInstanceReferenceFieldAccess(ConcurrentHashMap$Node, "val", Object.class);
+        }
     }
 
     // Checkstyle: stop field name check
@@ -302,12 +317,16 @@ private VmFieldAccess(TeleVM vm) {
 
     // Other JDK fields:
 
-    private final Class ConcurrentHashMap$Segment = Classes.getInnerClass(ConcurrentHashMap.class, "Segment");
+    private Class ConcurrentHashMap$Segment;
+    private Class ConcurrentHashMap$Node;
     private final Class ConcurrentHashMap$HashEntry = Classes.getInnerClass(ConcurrentHashMap.class, "HashEntry");
-    public final TeleInstanceReferenceFieldAccess ConcurrentHashMap_segments = new TeleInstanceReferenceFieldAccess(ConcurrentHashMap.class, "segments", Array.newInstance(ConcurrentHashMap$Segment, 0).getClass());
-    public final TeleInstanceReferenceFieldAccess ConcurrentHashMap$Segment_table = new TeleInstanceReferenceFieldAccess(ConcurrentHashMap$Segment, "table", Array.newInstance(ConcurrentHashMap$HashEntry, 0).getClass());
-    public final TeleInstanceReferenceFieldAccess ConcurrentHashMap$HashEntry_next = new TeleInstanceReferenceFieldAccess(ConcurrentHashMap$HashEntry, "next", ConcurrentHashMap$HashEntry);
-    public final TeleInstanceReferenceFieldAccess ConcurrentHashMap$HashEntry_value = new TeleInstanceReferenceFieldAccess(ConcurrentHashMap$HashEntry, "value", Object.class);
+    public TeleInstanceReferenceFieldAccess ConcurrentHashMap_segments;
+    public TeleInstanceReferenceFieldAccess ConcurrentHashMap_table;
+    public TeleInstanceReferenceFieldAccess ConcurrentHashMap$Segment_table;
+    public TeleInstanceReferenceFieldAccess ConcurrentHashMap$Node_next;
+    public TeleInstanceReferenceFieldAccess ConcurrentHashMap$Node_val;
+    public TeleInstanceReferenceFieldAccess ConcurrentHashMap$HashEntry_next;
+    public TeleInstanceReferenceFieldAccess ConcurrentHashMap$HashEntry_value;
     public final TeleInstanceIntFieldAccess Enum_ordinal = new TeleInstanceIntFieldAccess(Enum.class, "ordinal");
     public final TeleInstanceReferenceFieldAccess String_value = new TeleInstanceReferenceFieldAccess(String.class, "value", char[].class);
 

diff --git a/com.oracle.max.tele.vm/src/com/sun/max/tele/type/VmClassAccess.java b/com.oracle.max.tele.vm/src/com/sun/max/tele/type/VmClassAccess.java
@@ -1,4 +1,6 @@
 /*
+ * Copyright (c) 2018, APT Group, School of Computer Science,
+ * The University of Manchester. All rights reserved.
  * Copyright (c) 2007, 2012, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
@@ -40,6 +42,7 @@
 import com.sun.max.vm.actor.holder.*;
 import com.sun.max.vm.classfile.*;
 import com.sun.max.vm.hosted.*;
+import com.sun.max.vm.jdk.JDK;
 import com.sun.max.vm.runtime.*;
 import com.sun.max.vm.type.*;
 
@@ -175,33 +178,57 @@ private int processClassRegistry(RemoteReference classRegistryRef) {
         int count = 0;
         VmFieldAccess f = fields();
         final RemoteReference hashMapRef = f.ClassRegistry_typeDescriptorToClassActor.readRemoteReference(classRegistryRef);
-        RemoteReference segmentArrayRef = f.ConcurrentHashMap_segments.readRemoteReference(hashMapRef);
-        int segmentArrayLength = objects().unsafeReadArrayLength(segmentArrayRef);
-        for (int i = 0; i < segmentArrayLength; i++) {
-            final RemoteReference segmentRef = segmentArrayRef.readArrayAsRemoteReference(i);
-            if (!segmentRef.isZero()) {
-                RemoteReference entryArrayRef = f.ConcurrentHashMap$Segment_table.readRemoteReference(segmentRef);
-                if (!entryArrayRef.isZero()) {
-                    int entryArrayLength = objects().unsafeReadArrayLength(entryArrayRef);
-                    for (int j = 0; j != entryArrayLength; j++) {
-                        RemoteReference entryRef = entryArrayRef.readArrayAsRemoteReference(j);
-                        while (!entryRef.isZero()) {
-                            if (entryRef.isProvisional() && vm().isAttaching()) {
-                                // this is likely to be a reference in the dynamic heap that we can't see because TeleHeap is not
-                                // fully initialized yet so we add it to a fix-up list and handle it later
-                                attachFixupList.add(entryRef);
-                            } else {
-                                RemoteReference classActorRef = f.ConcurrentHashMap$HashEntry_value.readRemoteReference(entryRef);
-                                if (!classActorRef.isZero()) {
-                                    addToRegistry(classActorRef);
-                                    count++;
+        if (JDK.JDK_VERSION == JDK.JDK_7) {
+            RemoteReference segmentArrayRef = f.ConcurrentHashMap_segments.readRemoteReference(hashMapRef);
+            int segmentArrayLength = objects().unsafeReadArrayLength(segmentArrayRef);
+            for (int i = 0; i < segmentArrayLength; i++) {
+                final RemoteReference segmentRef = segmentArrayRef.readArrayAsRemoteReference(i);
+                if (!segmentRef.isZero()) {
+                    RemoteReference entryArrayRef = f.ConcurrentHashMap$Segment_table.readRemoteReference(segmentRef);
+                    if (!entryArrayRef.isZero()) {
+                        int entryArrayLength = objects().unsafeReadArrayLength(entryArrayRef);
+                        for (int j = 0; j != entryArrayLength; j++) {
+                            RemoteReference entryRef = entryArrayRef.readArrayAsRemoteReference(j);
+                            while (!entryRef.isZero()) {
+                                if (entryRef.isProvisional() && vm().isAttaching()) {
+                                    // this is likely to be a reference in the dynamic heap that we can't see because TeleHeap is not
+                                    // fully initialized yet so we add it to a fix-up list and handle it later
+                                    attachFixupList.add(entryRef);
+                                } else {
+                                    RemoteReference classActorRef = f.ConcurrentHashMap$HashEntry_value.readRemoteReference(entryRef);
+                                    if (!classActorRef.isZero()) {
+                                        addToRegistry(classActorRef);
+                                        count++;
+                                    }
                                 }
+                                entryRef = f.ConcurrentHashMap$HashEntry_next.readRemoteReference(entryRef);
                             }
-                            entryRef = f.ConcurrentHashMap$HashEntry_next.readRemoteReference(entryRef);
                         }
                     }
                 }
             }
+        } else {
+            RemoteReference entryArrayRef = f.ConcurrentHashMap_table.readRemoteReference(hashMapRef);
+            if (!entryArrayRef.isZero()) {
+                int entryArrayLength = objects().unsafeReadArrayLength(entryArrayRef);
+                for (int j = 0; j != entryArrayLength; j++) {
+                    RemoteReference entryRef = entryArrayRef.readArrayAsRemoteReference(j);
+                    while (!entryRef.isZero()) {
+                        if (entryRef.isProvisional() && vm().isAttaching()) {
+                            // this is likely to be a reference in the dynamic heap that we can't see because TeleHeap is not
+                            // fully initialized yet so we add it to a fix-up list and handle it later
+                            attachFixupList.add(entryRef);
+                        } else {
+                            RemoteReference classActorRef = f.ConcurrentHashMap$Node_val.readRemoteReference(entryRef);
+                            if (!classActorRef.isZero()) {
+                                addToRegistry(classActorRef);
+                                count++;
+                            }
+                        }
+                        entryRef = f.ConcurrentHashMap$Node_next.readRemoteReference(entryRef);
+                    }
+                }
+            }
         }
         return count;
     }
@@ -356,7 +383,12 @@ public void processAttachFixupList() {
             timedTrace.begin();
             for (RemoteReference entry : attachFixupList) {
                 if (!entry.isZero()) {
-                    RemoteReference classActorReference = fields().ConcurrentHashMap$HashEntry_value.readRemoteReference(entry);
+                    RemoteReference classActorReference;
+                    if (JDK.JDK_VERSION == JDK.JDK_7) {
+                        classActorReference = fields().ConcurrentHashMap$HashEntry_value.readRemoteReference(entry);
+                    } else {
+                        classActorReference = fields().ConcurrentHashMap$Node_val.readRemoteReference(entry);
+                    }
                     if (!classActorReference.isZero()) {
                         addToRegistry(classActorReference);
                     }

diff --git a/mxmaxine/projects b/mxmaxine/projects
@@ -59,7 +59,7 @@ project@com.oracle.max.tele.jdwp@checkstyle=com.oracle.max.base
 project@com.oracle.max.tele.jdwp@javaCompliance=1.7
 
 project@com.oracle.max.tele.vm@sourceDirs=src,test
-project@com.oracle.max.tele.vm@dependencies=com.oracle.max.vm.ext.jvmti,com.oracle.max.vmdi,com.oracle.max.elf
+project@com.oracle.max.tele.vm@dependencies=com.oracle.max.vm.ext.jvmti,com.oracle.max.vmdi,com.oracle.max.elf,com.oracle.max.vm
 project@com.oracle.max.tele.vm@checkstyle=com.oracle.max.base
 project@com.oracle.max.tele.vm@javaCompliance=1.7