src/jdk.hotspot.agent/share/classes/sun/jvm/hotspot/gc/z/ZPage.java

rev 48259 : SA for GC - patch 2

@@ -25,18 +25,25 @@
 package sun.jvm.hotspot.gc.z;
 
 import sun.jvm.hotspot.debugger.Address;
 import sun.jvm.hotspot.runtime.VM;
 import sun.jvm.hotspot.runtime.VMObject;
+import sun.jvm.hotspot.runtime.VMObjectFactory;
 import sun.jvm.hotspot.types.CIntegerField;
 import sun.jvm.hotspot.types.Type;
 import sun.jvm.hotspot.types.TypeDataBase;
 
 class ZPage extends VMObject {
     private static CIntegerField typeField;
     private static long virtualFieldOffset;
     private static long forwardingFieldOffset;
+    private static byte ZPageTypeSmall;
+    private static byte ZPageTypeMedium;
+    private static byte ZPageTypeLarge;
+    private static int ZObjectAlignmentSmallShift;
+    private static int ZObjectAlignmentMediumShift;
+    private static int ZObjectAlignmentLargeShift;
 
     static {
         VM.registerVMInitializedObserver((o, d) -> initialize(VM.getVM().getTypeDataBase()));
     }
 

@@ -44,10 +51,17 @@
         Type type = db.lookupType("ZPage");
 
         typeField = type.getCIntegerField("_type");
         virtualFieldOffset = type.getField("_virtual").getOffset();
         forwardingFieldOffset = type.getField("_forwarding").getOffset();
+
+        ZPageTypeSmall = db.lookupIntConstant("ZPageTypeSmall").byteValue();
+        ZPageTypeMedium = db.lookupIntConstant("ZPageTypeMedium").byteValue();
+        ZPageTypeLarge = db.lookupIntConstant("ZPageTypeLarge").byteValue();
+        ZObjectAlignmentSmallShift = db.lookupIntConstant("ZObjectAlignmentSmallShift").intValue();
+        ZObjectAlignmentMediumShift = db.lookupIntConstant("ZObjectAlignmentMediumShift").intValue();
+        ZObjectAlignmentLargeShift = db.lookupIntConstant("ZObjectAlignmentLargeShift").intValue();
     }
 
     ZPage(Address addr) {
         super(addr);
     }

@@ -55,55 +69,52 @@
     private byte type() {
         return typeField.getJByte(addr);
     }
 
     private ZVirtualMemory virtual() {
-        return new ZVirtualMemory(addr.addOffsetTo(virtualFieldOffset));
+        return (ZVirtualMemory)VMObjectFactory.newObject(ZVirtualMemory.class, addr.addOffsetTo(virtualFieldOffset));
     }
 
     private ZForwardingTable forwarding() {
-        return new ZForwardingTable(addr.addOffsetTo(forwardingFieldOffset));
+        return (ZForwardingTable)VMObjectFactory.newObject(ZForwardingTable.class, addr.addOffsetTo(forwardingFieldOffset));
     }
 
     private long start() {
         return virtual().start();
     }
 
     Address forward_object(Address from) {
         // Lookup address in forwarding table
-        long from_offset = ZAddress.offset(from);
+        long from_offset = ZAddress.offset(from).asLongValue();
         long from_index = (from_offset - start()) >> object_alignment_shift();
         ZForwardingTableEntry entry = forwarding().find(from_index);
         assert(!entry.is_empty());
         assert(entry.from_index() == from_index);
 
         return ZAddress.good(entry.to_offset());
     }
 
     Address relocate_object(Address from) {
         // Lookup address in forwarding table
-        long from_offset = ZAddress.offset(from);
+        long from_offset = ZAddress.offset(from).asLongValue();
         long from_index = (from_offset - start()) >> object_alignment_shift();
         ZForwardingTableEntry entry = forwarding().find(from_index);
         if (!entry.is_empty() && entry.from_index() == from_index) {
           return ZAddress.good(entry.to_offset());
         }
 
-        // There's no relocate operation in the SA. Simply use the from address and hope for the best.
-        return from;
+        // There's no relocate operation in the SA.
+        return ZAddress.good(from);
     }
 
 
     long object_alignment_shift() {
-        switch (type()) {
-        case ZGlobals.ZPageTypeSmall:
-            return ZGlobals.ZObjectAlignmentSmallShift();
-
-        case ZGlobals.ZPageTypeMedium:
-            return ZGlobals.ZObjectAlignmentMediumShift;
-
-        default:
-            assert(type() == ZGlobals.ZPageTypeLarge);
-            return ZGlobals.ZObjectAlignmentLargeShift;
+        if (type() == ZPageTypeSmall) {
+            return ZObjectAlignmentSmallShift;
+        } else if (type() == ZPageTypeMedium) {
+            return ZObjectAlignmentMediumShift;
+        } else {
+            assert(type() == ZPageTypeLarge);
+            return ZObjectAlignmentLargeShift;
         }
     }
 }