--- a/.hgignore	Tue Apr 29 13:51:26 2008 +0400
+++ b/.hgignore	Sun May 04 03:29:31 2008 -0700
@@ -1,171 +1,4 @@
-^build/solaris/solaris_sparc_compiler1/
-^build/solaris/solaris_sparc_compiler2/
-^build/solaris/solaris_sparc_core/
-^build/solaris/solaris_sparc_kernel/
-^build/solaris/solaris_sparc_docs/
-^build/solaris/jdk-solaris-sparc/
-^build/solaris/export-solaris-sparc/
-^build/solaris/solaris_sparcv9_compiler1/
-^build/solaris/solaris_sparcv9_compiler2/
-^build/solaris/solaris_sparcv9_core/
-^build/solaris/solaris_sparcv9_kernel/
-^build/solaris/solaris_sparcv9_docs/
-^build/solaris/jdk-solaris-sparcv9/
-^build/solaris/export-solaris-sparcv9/
-^build/solaris/solaris_sparc32_compiler1/
-^build/solaris/solaris_sparc32_compiler2/
-^build/solaris/solaris_sparc32_core/
-^build/solaris/solaris_sparc32_kernel/
-^build/solaris/solaris_sparc32_docs/
-^build/solaris/jdk-solaris-sparc32/
-^build/solaris/export-solaris-sparc32/
-^build/solaris/solaris_sparc64_compiler1/
-^build/solaris/solaris_sparc64_compiler2/
-^build/solaris/solaris_sparc64_core/
-^build/solaris/solaris_sparc64_kernel/
-^build/solaris/solaris_sparc64_docs/
-^build/solaris/jdk-solaris-sparc64/
-^build/solaris/export-solaris-sparc64/
-^build/solaris/solaris_i486_compiler1/
-^build/solaris/solaris_i486_compiler2/
-^build/solaris/solaris_i486_core/
-^build/solaris/solaris_i486_kernel/
-^build/solaris/solaris_i486_docs/
-^build/solaris/jdk-solaris-i486/
-^build/solaris/export-solaris-i486/
-^build/solaris/solaris_i386_compiler1/
-^build/solaris/solaris_i386_compiler2/
-^build/solaris/solaris_i386_core/
-^build/solaris/solaris_i386_kernel/
-^build/solaris/solaris_i386_docs/
-^build/solaris/jdk-solaris-i386/
-^build/solaris/export-solaris-i386/
-^build/solaris/solaris_amd64_compiler1/
-^build/solaris/solaris_amd64_compiler2/
-^build/solaris/solaris_amd64_core/
-^build/solaris/solaris_amd64_kernel/
-^build/solaris/solaris_amd64_docs/
-^build/solaris/jdk-solaris-amd64/
-^build/solaris/export-solaris-amd64/
-^build/solaris/solaris_x64_compiler1/
-^build/solaris/solaris_x64_compiler2/
-^build/solaris/solaris_x64_core/
-^build/solaris/solaris_x64_kernel/
-^build/solaris/solaris_x64_docs/
-^build/solaris/jdk-solaris-x64/
-^build/solaris/export-solaris-x64/
-^build/windows/windows_sparc_compiler1/
-^build/windows/windows_sparc_compiler2/
-^build/windows/windows_sparc_core/
-^build/windows/windows_sparc_kernel/
-^build/windows/windows_sparc_docs/
-^build/windows/jdk-windows-sparc/
-^build/windows/export-windows-sparc/
-^build/windows/windows_sparcv9_compiler1/
-^build/windows/windows_sparcv9_compiler2/
-^build/windows/windows_sparcv9_core/
-^build/windows/windows_sparcv9_kernel/
-^build/windows/windows_sparcv9_docs/
-^build/windows/jdk-windows-sparcv9/
-^build/windows/export-windows-sparcv9/
-^build/windows/windows_sparc32_compiler1/
-^build/windows/windows_sparc32_compiler2/
-^build/windows/windows_sparc32_core/
-^build/windows/windows_sparc32_kernel/
-^build/windows/windows_sparc32_docs/
-^build/windows/jdk-windows-sparc32/
-^build/windows/export-windows-sparc32/
-^build/windows/windows_sparc64_compiler1/
-^build/windows/windows_sparc64_compiler2/
-^build/windows/windows_sparc64_core/
-^build/windows/windows_sparc64_kernel/
-^build/windows/windows_sparc64_docs/
-^build/windows/jdk-windows-sparc64/
-^build/windows/export-windows-sparc64/
-^build/windows/windows_i486_compiler1/
-^build/windows/windows_i486_compiler2/
-^build/windows/windows_i486_core/
-^build/windows/windows_i486_kernel/
-^build/windows/windows_i486_docs/
-^build/windows/jdk-windows-i486/
-^build/windows/export-windows-i486/
-^build/windows/windows_i386_compiler1/
-^build/windows/windows_i386_compiler2/
-^build/windows/windows_i386_core/
-^build/windows/windows_i386_kernel/
-^build/windows/windows_i386_docs/
-^build/windows/jdk-windows-i386/
-^build/windows/export-windows-i386/
-^build/windows/windows_amd64_compiler1/
-^build/windows/windows_amd64_compiler2/
-^build/windows/windows_amd64_core/
-^build/windows/windows_amd64_kernel/
-^build/windows/windows_amd64_docs/
-^build/windows/jdk-windows-amd64/
-^build/windows/export-windows-amd64/
-^build/windows/windows_x64_compiler1/
-^build/windows/windows_x64_compiler2/
-^build/windows/windows_x64_core/
-^build/windows/windows_x64_kernel/
-^build/windows/windows_x64_docs/
-^build/windows/jdk-windows-x64/
-^build/windows/export-windows-x64/
-^build/linux/linux_sparc_compiler1/
-^build/linux/linux_sparc_compiler2/
-^build/linux/linux_sparc_core/
-^build/linux/linux_sparc_kernel/
-^build/linux/linux_sparc_docs/
-^build/linux/jdk-linux-sparc/
-^build/linux/export-linux-sparc/
-^build/linux/linux_sparcv9_compiler1/
-^build/linux/linux_sparcv9_compiler2/
-^build/linux/linux_sparcv9_core/
-^build/linux/linux_sparcv9_kernel/
-^build/linux/linux_sparcv9_docs/
-^build/linux/jdk-linux-sparcv9/
-^build/linux/export-linux-sparcv9/
-^build/linux/linux_sparc32_compiler1/
-^build/linux/linux_sparc32_compiler2/
-^build/linux/linux_sparc32_core/
-^build/linux/linux_sparc32_kernel/
-^build/linux/linux_sparc32_docs/
-^build/linux/jdk-linux-sparc32/
-^build/linux/export-linux-sparc32/
-^build/linux/linux_sparc64_compiler1/
-^build/linux/linux_sparc64_compiler2/
-^build/linux/linux_sparc64_core/
-^build/linux/linux_sparc64_kernel/
-^build/linux/linux_sparc64_docs/
-^build/linux/jdk-linux-sparc64/
-^build/linux/export-linux-sparc64/
-^build/linux/linux_i486_compiler1/
-^build/linux/linux_i486_compiler2/
-^build/linux/linux_i486_core/
-^build/linux/linux_i486_kernel/
-^build/linux/linux_i486_docs/
-^build/linux/jdk-linux-i486/
-^build/linux/export-linux-i486/
-^build/linux/linux_i386_compiler1/
-^build/linux/linux_i386_compiler2/
-^build/linux/linux_i386_core/
-^build/linux/linux_i386_kernel/
-^build/linux/linux_i386_docs/
-^build/linux/jdk-linux-i386/
-^build/linux/export-linux-i386/
-^build/linux/linux_amd64_compiler1/
-^build/linux/linux_amd64_compiler2/
-^build/linux/linux_amd64_core/
-^build/linux/linux_amd64_kernel/
-^build/linux/linux_amd64_docs/
-^build/linux/jdk-linux-amd64/
-^build/linux/export-linux-amd64/
-^build/linux/linux_x64_compiler1/
-^build/linux/linux_x64_compiler2/
-^build/linux/linux_x64_core/
-^build/linux/linux_x64_kernel/
-^build/linux/linux_x64_docs/
-^build/linux/jdk-linux-x64/
-^build/linux/export-linux-x64/
+^build/
 ^dist/
 ^nbproject/private/
 ^src/share/tools/hsdis/bin/

--- a/.hgtags	Tue Apr 29 13:51:26 2008 +0400
+++ b/.hgtags	Sun May 04 03:29:31 2008 -0700
@@ -1,1 +1,2 @@
 a61af66fc99eb5ec9d50c05b0c599757b1289ceb jdk7-b24
+7836be3e92d0a4f9ee7566f602c91f5609534e66 jdk7-b25

--- a/agent/src/share/classes/sun/jvm/hotspot/CommandProcessor.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/CommandProcessor.java	Sun May 04 03:29:31 2008 -0700
@@ -885,7 +885,12 @@
                                         out.println("found at " + addr);
                                     }
                                 }
-
+                                public void visitCompOopAddress(Address addr) {
+                                    Address val = addr.getCompOopAddressAt(0);
+                                    if (AddressOps.equal(val, value)) {
+                                        out.println("found at " + addr);
+                                    }
+                                }
                                 public void epilogue() {
                                 }
                             };

--- a/agent/src/share/classes/sun/jvm/hotspot/HSDB.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/HSDB.java	Sun May 04 03:29:31 2008 -0700
@@ -1011,8 +1011,21 @@
                         Assert.that(addr.andWithMask(VM.getVM().getAddressSize() - 1) == null,
                                     "Address " + addr + "should have been aligned");
                       }
+                      OopHandle handle = addr.getOopHandleAt(0);
+                      addAnnotation(addr, handle);
+                    }
+
+                    public void visitCompOopAddress(Address addr) {
+                      if (Assert.ASSERTS_ENABLED) {
+                        Assert.that(addr.andWithMask(VM.getVM().getAddressSize() - 1) == null,
+                                    "Address " + addr + "should have been aligned");
+                      }
+                      OopHandle handle = addr.getCompOopHandleAt(0);
+                      addAnnotation(addr, handle);
+                    }
+
+                    public void addAnnotation(Address addr, OopHandle handle) {
                       // Check contents
-                      OopHandle handle = addr.getOopHandleAt(0);
                       String anno = "null oop";
                       if (handle != null) {
                         // Find location

--- a/agent/src/share/classes/sun/jvm/hotspot/HotSpotTypeDataBase.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/HotSpotTypeDataBase.java	Sun May 04 03:29:31 2008 -0700
@@ -306,6 +306,8 @@
 
       entryAddr = entryAddr.addOffsetTo(intConstantEntryArrayStride);
     } while (nameAddr != null);
+      String symbol = "heapOopSize"; // global int constant and value is initialized at runtime.
+      addIntConstant(symbol, (int)lookupInProcess(symbol).getCIntegerAt(0, 4, false));
   }
 
   private void readVMLongConstants() {

--- a/agent/src/share/classes/sun/jvm/hotspot/compiler/OopMapSet.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/compiler/OopMapSet.java	Sun May 04 03:29:31 2008 -0700
@@ -68,7 +68,8 @@
     public void visitValueLocation(Address valueAddr) {
     }
 
-    public void visitDeadLocation(Address deadAddr) {
+    public void visitNarrowOopLocation(Address narrowOopAddr) {
+      addressVisitor.visitCompOopAddress(narrowOopAddr);
     }
   }
 
@@ -197,9 +198,9 @@
       }
     }
 
-    // We want dead, value and oop oop_types
+    // We want narow oop, value and oop oop_types
     OopMapValue.OopTypes[] values = new OopMapValue.OopTypes[] {
-      OopMapValue.OopTypes.OOP_VALUE, OopMapValue.OopTypes.VALUE_VALUE, OopMapValue.OopTypes.DEAD_VALUE
+      OopMapValue.OopTypes.OOP_VALUE, OopMapValue.OopTypes.VALUE_VALUE, OopMapValue.OopTypes.NARROWOOP_VALUE
     };
 
     {
@@ -214,8 +215,8 @@
             visitor.visitOopLocation(loc);
           } else if (omv.getType() == OopMapValue.OopTypes.VALUE_VALUE) {
             visitor.visitValueLocation(loc);
-          } else if (omv.getType() == OopMapValue.OopTypes.DEAD_VALUE) {
-            visitor.visitDeadLocation(loc);
+          } else if (omv.getType() == OopMapValue.OopTypes.NARROWOOP_VALUE) {
+            visitor.visitNarrowOopLocation(loc);
           }
         }
       }

--- a/agent/src/share/classes/sun/jvm/hotspot/compiler/OopMapValue.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/compiler/OopMapValue.java	Sun May 04 03:29:31 2008 -0700
@@ -50,7 +50,7 @@
   static int UNUSED_VALUE;
   static int OOP_VALUE;
   static int VALUE_VALUE;
-  static int DEAD_VALUE;
+  static int NARROWOOP_VALUE;
   static int CALLEE_SAVED_VALUE;
   static int DERIVED_OOP_VALUE;
 
@@ -74,7 +74,7 @@
     UNUSED_VALUE           = db.lookupIntConstant("OopMapValue::unused_value").intValue();
     OOP_VALUE              = db.lookupIntConstant("OopMapValue::oop_value").intValue();
     VALUE_VALUE            = db.lookupIntConstant("OopMapValue::value_value").intValue();
-    DEAD_VALUE             = db.lookupIntConstant("OopMapValue::dead_value").intValue();
+    NARROWOOP_VALUE        = db.lookupIntConstant("OopMapValue::narrowoop_value").intValue();
     CALLEE_SAVED_VALUE     = db.lookupIntConstant("OopMapValue::callee_saved_value").intValue();
     DERIVED_OOP_VALUE      = db.lookupIntConstant("OopMapValue::derived_oop_value").intValue();
   }
@@ -83,7 +83,7 @@
     public static final OopTypes UNUSED_VALUE       = new OopTypes() { int getValue() { return OopMapValue.UNUSED_VALUE;       }};
     public static final OopTypes OOP_VALUE          = new OopTypes() { int getValue() { return OopMapValue.OOP_VALUE;          }};
     public static final OopTypes VALUE_VALUE        = new OopTypes() { int getValue() { return OopMapValue.VALUE_VALUE;        }};
-    public static final OopTypes DEAD_VALUE         = new OopTypes() { int getValue() { return OopMapValue.DEAD_VALUE;         }};
+    public static final OopTypes NARROWOOP_VALUE    = new OopTypes() { int getValue() { return OopMapValue.NARROWOOP_VALUE;         }};
     public static final OopTypes CALLEE_SAVED_VALUE = new OopTypes() { int getValue() { return OopMapValue.CALLEE_SAVED_VALUE; }};
     public static final OopTypes DERIVED_OOP_VALUE  = new OopTypes() { int getValue() { return OopMapValue.DERIVED_OOP_VALUE;  }};
 
@@ -106,7 +106,7 @@
   // Querying
   public boolean isOop()         { return (getValue() & TYPE_MASK_IN_PLACE) == OOP_VALUE;          }
   public boolean isValue()       { return (getValue() & TYPE_MASK_IN_PLACE) == VALUE_VALUE;        }
-  public boolean isDead()        { return (getValue() & TYPE_MASK_IN_PLACE) == DEAD_VALUE;         }
+  public boolean isNarrowOop()   { return (getValue() & TYPE_MASK_IN_PLACE) == NARROWOOP_VALUE;    }
   public boolean isCalleeSaved() { return (getValue() & TYPE_MASK_IN_PLACE) == CALLEE_SAVED_VALUE; }
   public boolean isDerivedOop()  { return (getValue() & TYPE_MASK_IN_PLACE) == DERIVED_OOP_VALUE;  }
 
@@ -118,7 +118,7 @@
          if (which == UNUSED_VALUE) return OopTypes.UNUSED_VALUE;
     else if (which == OOP_VALUE)    return OopTypes.OOP_VALUE;
     else if (which == VALUE_VALUE)  return OopTypes.VALUE_VALUE;
-    else if (which == DEAD_VALUE)   return OopTypes.DEAD_VALUE;
+    else if (which == NARROWOOP_VALUE)   return OopTypes.NARROWOOP_VALUE;
     else if (which == CALLEE_SAVED_VALUE) return OopTypes.CALLEE_SAVED_VALUE;
     else if (which == DERIVED_OOP_VALUE)  return OopTypes.DERIVED_OOP_VALUE;
     else throw new InternalError("unknown which " + which + " (TYPE_MASK_IN_PLACE = " + TYPE_MASK_IN_PLACE + ")");

--- a/agent/src/share/classes/sun/jvm/hotspot/compiler/OopMapVisitor.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/compiler/OopMapVisitor.java	Sun May 04 03:29:31 2008 -0700
@@ -32,5 +32,5 @@
   public void visitOopLocation(Address oopAddr);
   public void visitDerivedOopLocation(Address baseOopAddr, Address derivedOopAddr);
   public void visitValueLocation(Address valueAddr);
-  public void visitDeadLocation(Address deadAddr);
+  public void visitNarrowOopLocation(Address narrowOopAddr);
 }

--- a/agent/src/share/classes/sun/jvm/hotspot/debugger/Address.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/debugger/Address.java	Sun May 04 03:29:31 2008 -0700
@@ -87,6 +87,8 @@
     throws UnmappedAddressException, UnalignedAddressException;
   /** This returns null if the address at the given offset is NULL. */
   public Address    getAddressAt       (long offset) throws UnmappedAddressException, UnalignedAddressException;
+  /** Returns the decoded address at the given offset */
+  public Address    getCompOopAddressAt (long offset) throws UnmappedAddressException, UnalignedAddressException;
 
   //
   // Java-related routines
@@ -103,6 +105,8 @@
   /** This returns null if the address at the given offset is NULL. */
   public OopHandle  getOopHandleAt     (long offset)
     throws UnmappedAddressException, UnalignedAddressException, NotInHeapException;
+  public OopHandle  getCompOopHandleAt (long offset)
+    throws UnmappedAddressException, UnalignedAddressException, NotInHeapException;
 
   //
   // C/C++-related mutators. These throw UnmappedAddressException if

--- a/agent/src/share/classes/sun/jvm/hotspot/debugger/Debugger.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/debugger/Debugger.java	Sun May 04 03:29:31 2008 -0700
@@ -118,6 +118,9 @@
   public long getJIntSize();
   public long getJLongSize();
   public long getJShortSize();
+  public long getHeapBase();
+  public long getHeapOopSize();
+  public long getLogMinObjAlignmentInBytes();
 
   public ReadResult readBytesFromProcess(long address, long numBytes)
     throws DebuggerException;

--- a/agent/src/share/classes/sun/jvm/hotspot/debugger/DebuggerBase.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/debugger/DebuggerBase.java	Sun May 04 03:29:31 2008 -0700
@@ -37,6 +37,7 @@
     DbxDebugger interfaces. </P> */
 
 public abstract class DebuggerBase implements Debugger {
+
   // May be set lazily, but must be set before calling any of the read
   // routines below
   protected MachineDescription machDesc;
@@ -52,6 +53,11 @@
   protected long jlongSize;
   protected long jshortSize;
   protected boolean javaPrimitiveTypesConfigured;
+  // heap data.
+  protected long oopSize;
+  protected long heapOopSize;
+  protected long heapBase;                 // heap base for compressed oops.
+  protected long logMinObjAlignmentInBytes; // Used to decode compressed oops.
   // Should be initialized if desired by calling initCache()
   private PageCache cache;
 
@@ -153,6 +159,12 @@
     javaPrimitiveTypesConfigured = true;
   }
 
+  public void putHeapConst(long heapBase, long heapOopSize, long logMinObjAlignmentInBytes) {
+    this.heapBase = heapBase;
+    this.heapOopSize = heapOopSize;
+    this.logMinObjAlignmentInBytes = logMinObjAlignmentInBytes;
+  }
+
   /** May be called by subclasses if desired to initialize the page
       cache but may not be overridden */
   protected final void initCache(long pageSize, long maxNumPages) {
@@ -442,6 +454,16 @@
     return readCInteger(address, machDesc.getAddressSize(), true);
   }
 
+  protected long readCompOopAddressValue(long address)
+    throws UnmappedAddressException, UnalignedAddressException {
+    long value = readCInteger(address, getHeapOopSize(), true);
+    if (value != 0) {
+      // See oop.inline.hpp decode_heap_oop
+      value = (long)(heapBase + (long)(value << logMinObjAlignmentInBytes));
+    }
+    return value;
+  }
+
   protected void writeAddressValue(long address, long value)
     throws UnmappedAddressException, UnalignedAddressException {
     writeCInteger(address, machDesc.getAddressSize(), value);
@@ -518,4 +540,15 @@
   public long getJShortSize() {
     return jshortSize;
   }
+
+  public long getHeapOopSize() {
+    return heapOopSize;
+  }
+
+  public long getHeapBase() {
+    return heapBase;
+  }
+  public long getLogMinObjAlignmentInBytes() {
+    return logMinObjAlignmentInBytes;
+  }
 }

--- a/agent/src/share/classes/sun/jvm/hotspot/debugger/JVMDebugger.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/debugger/JVMDebugger.java	Sun May 04 03:29:31 2008 -0700
@@ -42,4 +42,5 @@
                                               long jintSize,
                                               long jlongSize,
                                               long jshortSize);
+  public void putHeapConst(long heapBase, long heapOopSize, long logMinObjAlignment);
 }

--- a/agent/src/share/classes/sun/jvm/hotspot/debugger/MachineDescription.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/debugger/MachineDescription.java	Sun May 04 03:29:31 2008 -0700
@@ -35,13 +35,6 @@
       able to traverse arrays of pointers or oops. */
   public long getAddressSize();
 
-  /** Returns the size of an address in bytes. Currently needed to be
-      able to traverse arrays of pointers or oops. (FIXME: since we're
-      already reading the Java primitive types' sizes from the remote
-      VM, it would be nice to remove this routine, using a similar
-      mechanism to how the TypeDataBase deals with primitive types.) */
-  public long getOopSize();
-
   /** Returns the maximum value of the C integer type with the given
       size in bytes and signedness. Throws IllegalArgumentException if
       the size in bytes is not legal for a C type (or can not be

--- a/agent/src/share/classes/sun/jvm/hotspot/debugger/MachineDescriptionAMD64.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/debugger/MachineDescriptionAMD64.java	Sun May 04 03:29:31 2008 -0700
@@ -29,10 +29,6 @@
     return 8;
   }
 
-  public long getOopSize() {
-    return 8;
-  }
-
   public boolean isLP64() {
     return true;
   }

--- a/agent/src/share/classes/sun/jvm/hotspot/debugger/MachineDescriptionIA64.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/debugger/MachineDescriptionIA64.java	Sun May 04 03:29:31 2008 -0700
@@ -29,10 +29,6 @@
     return 8;
   }
 
-  public long getOopSize() {
-    return 8;
-  }
-
   public boolean isLP64() {
     return true;
   }

--- a/agent/src/share/classes/sun/jvm/hotspot/debugger/MachineDescriptionIntelX86.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/debugger/MachineDescriptionIntelX86.java	Sun May 04 03:29:31 2008 -0700
@@ -29,10 +29,6 @@
     return 4;
   }
 
-  public long getOopSize() {
-    return 4;
-  }
-
   public boolean isBigEndian() {
     return false;
   }

--- a/agent/src/share/classes/sun/jvm/hotspot/debugger/MachineDescriptionSPARC32Bit.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/debugger/MachineDescriptionSPARC32Bit.java	Sun May 04 03:29:31 2008 -0700
@@ -29,10 +29,6 @@
     return 4;
   }
 
-  public long getOopSize() {
-    return 4;
-  }
-
   public boolean isBigEndian() {
     return true;
   }

--- a/agent/src/share/classes/sun/jvm/hotspot/debugger/MachineDescriptionSPARC64Bit.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/debugger/MachineDescriptionSPARC64Bit.java	Sun May 04 03:29:31 2008 -0700
@@ -29,9 +29,6 @@
     return 8;
   }
 
-  public long getOopSize() {
-    return 8;
-  }
 
   public boolean isBigEndian() {
     return true;

--- a/agent/src/share/classes/sun/jvm/hotspot/debugger/dbx/DbxAddress.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/debugger/dbx/DbxAddress.java	Sun May 04 03:29:31 2008 -0700
@@ -71,6 +71,9 @@
   public Address getAddressAt(long offset) throws UnalignedAddressException, UnmappedAddressException {
     return debugger.readAddress(addr + offset);
   }
+  public Address getCompOopAddressAt(long offset) throws UnalignedAddressException, UnmappedAddressException {
+    return debugger.readCompOopAddress(addr + offset);
+  }
 
   //
   // Java-related routines
@@ -113,6 +116,11 @@
     return debugger.readOopHandle(addr + offset);
   }
 
+  public OopHandle getCompOopHandleAt(long offset)
+    throws UnalignedAddressException, UnmappedAddressException, NotInHeapException {
+    return debugger.readCompOopHandle(addr + offset);
+  }
+
   // Mutators -- not implemented for now (FIXME)
   public void setCIntegerAt(long offset, long numBytes, long value) {
     throw new DebuggerException("Unimplemented");

--- a/agent/src/share/classes/sun/jvm/hotspot/debugger/dbx/DbxDebugger.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/debugger/dbx/DbxDebugger.java	Sun May 04 03:29:31 2008 -0700
@@ -43,7 +43,9 @@
   public long         readCInteger(long address, long numBytes, boolean isUnsigned)
     throws DebuggerException;
   public DbxAddress   readAddress(long address) throws DebuggerException;
+  public DbxAddress   readCompOopAddress(long address) throws DebuggerException;
   public DbxOopHandle readOopHandle(long address) throws DebuggerException;
+  public DbxOopHandle readCompOopHandle(long address) throws DebuggerException;
   public long[]       getThreadIntegerRegisterSet(int tid) throws DebuggerException;
   public Address      newAddress(long value) throws DebuggerException;
 

--- a/agent/src/share/classes/sun/jvm/hotspot/debugger/dbx/DbxDebuggerLocal.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/debugger/dbx/DbxDebuggerLocal.java	Sun May 04 03:29:31 2008 -0700
@@ -460,12 +460,23 @@
     return (value == 0 ? null : new DbxAddress(this, value));
   }
 
+  public DbxAddress readCompOopAddress(long address)
+    throws UnmappedAddressException, UnalignedAddressException {
+    long value = readCompOopAddressValue(address);
+    return (value == 0 ? null : new DbxAddress(this, value));
+  }
+
   /** From the DbxDebugger interface */
   public DbxOopHandle readOopHandle(long address)
     throws UnmappedAddressException, UnalignedAddressException, NotInHeapException {
     long value = readAddressValue(address);
     return (value == 0 ? null : new DbxOopHandle(this, value));
   }
+  public DbxOopHandle readCompOopHandle(long address)
+    throws UnmappedAddressException, UnalignedAddressException, NotInHeapException {
+    long value = readCompOopAddressValue(address);
+    return (value == 0 ? null : new DbxOopHandle(this, value));
+  }
 
   //--------------------------------------------------------------------------------
   // Thread context access. Can not be package private, but should

--- a/agent/src/share/classes/sun/jvm/hotspot/debugger/dummy/DummyAddress.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/debugger/dummy/DummyAddress.java	Sun May 04 03:29:31 2008 -0700
@@ -76,6 +76,10 @@
     return new DummyAddress(debugger, badLong);
   }
 
+  public Address getCompOopAddressAt(long offset) throws UnalignedAddressException, UnmappedAddressException {
+    return new DummyAddress(debugger, badLong);
+  }
+
   //
   // Java-related routines
   //
@@ -116,6 +120,10 @@
     throws UnalignedAddressException, UnmappedAddressException, NotInHeapException {
     return new DummyOopHandle(debugger, badLong);
   }
+  public OopHandle getCompOopHandleAt(long offset)
+    throws UnalignedAddressException, UnmappedAddressException, NotInHeapException {
+    return new DummyOopHandle(debugger, badLong);
+  }
 
   // Mutators -- not implemented
   public void setCIntegerAt(long offset, long numBytes, long value) {

--- a/agent/src/share/classes/sun/jvm/hotspot/debugger/linux/LinuxAddress.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/debugger/linux/LinuxAddress.java	Sun May 04 03:29:31 2008 -0700
@@ -74,6 +74,11 @@
         return debugger.readAddress(addr + offset);
     }
 
+    public Address getCompOopAddressAt(long offset)
+            throws UnalignedAddressException, UnmappedAddressException {
+        return debugger.readCompOopAddress(addr + offset);
+    }
+
     //
     // Java-related routines
     //
@@ -115,6 +120,11 @@
     return debugger.readOopHandle(addr + offset);
   }
 
+  public OopHandle getCompOopHandleAt(long offset)
+    throws UnalignedAddressException, UnmappedAddressException, NotInHeapException {
+    return debugger.readCompOopHandle(addr + offset);
+  }
+
   // Mutators -- not implemented for now (FIXME)
   public void setCIntegerAt(long offset, long numBytes, long value) {
     throw new DebuggerException("Unimplemented");

--- a/agent/src/share/classes/sun/jvm/hotspot/debugger/linux/LinuxDebugger.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/debugger/linux/LinuxDebugger.java	Sun May 04 03:29:31 2008 -0700
@@ -45,7 +45,9 @@
   public long         readCInteger(long address, long numBytes, boolean isUnsigned)
     throws DebuggerException;
   public LinuxAddress readAddress(long address) throws DebuggerException;
+  public LinuxAddress readCompOopAddress(long address) throws DebuggerException;
   public LinuxOopHandle readOopHandle(long address) throws DebuggerException;
+  public LinuxOopHandle readCompOopHandle(long address) throws DebuggerException;
   public long[]       getThreadIntegerRegisterSet(int lwp_id) throws DebuggerException;
   public long         getAddressValue(Address addr) throws DebuggerException;
   public Address      newAddress(long value) throws DebuggerException;

--- a/agent/src/share/classes/sun/jvm/hotspot/debugger/linux/LinuxDebuggerLocal.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/debugger/linux/LinuxDebuggerLocal.java	Sun May 04 03:29:31 2008 -0700
@@ -423,6 +423,11 @@
         long value = readAddressValue(address);
         return (value == 0 ? null : new LinuxAddress(this, value));
     }
+    public LinuxAddress readCompOopAddress(long address)
+            throws UnmappedAddressException, UnalignedAddressException {
+        long value = readCompOopAddressValue(address);
+        return (value == 0 ? null : new LinuxAddress(this, value));
+    }
 
     /** From the LinuxDebugger interface */
     public LinuxOopHandle readOopHandle(long address)
@@ -431,6 +436,12 @@
         long value = readAddressValue(address);
         return (value == 0 ? null : new LinuxOopHandle(this, value));
     }
+    public LinuxOopHandle readCompOopHandle(long address)
+            throws UnmappedAddressException, UnalignedAddressException,
+                NotInHeapException {
+        long value = readCompOopAddressValue(address);
+        return (value == 0 ? null : new LinuxOopHandle(this, value));
+    }
 
     //----------------------------------------------------------------------
     // Thread context access

--- a/agent/src/share/classes/sun/jvm/hotspot/debugger/proc/ProcAddress.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/debugger/proc/ProcAddress.java	Sun May 04 03:29:31 2008 -0700
@@ -72,6 +72,10 @@
     return debugger.readAddress(addr + offset);
   }
 
+  public Address getCompOopAddressAt(long offset) throws UnalignedAddressException, UnmappedAddressException {
+    return debugger.readCompOopAddress(addr + offset);
+  }
+
   //
   // Java-related routines
   //
@@ -112,6 +116,10 @@
     throws UnalignedAddressException, UnmappedAddressException, NotInHeapException {
     return debugger.readOopHandle(addr + offset);
   }
+  public OopHandle getCompOopHandleAt(long offset)
+    throws UnalignedAddressException, UnmappedAddressException, NotInHeapException {
+    return debugger.readCompOopHandle(addr + offset);
+  }
 
   // Mutators -- not implemented for now (FIXME)
   public void setCIntegerAt(long offset, long numBytes, long value) {

--- a/agent/src/share/classes/sun/jvm/hotspot/debugger/proc/ProcDebugger.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/debugger/proc/ProcDebugger.java	Sun May 04 03:29:31 2008 -0700
@@ -46,7 +46,9 @@
   public long         readCInteger(long address, long numBytes, boolean isUnsigned)
     throws DebuggerException;
   public ProcAddress   readAddress(long address) throws DebuggerException;
+  public ProcAddress   readCompOopAddress(long address) throws DebuggerException;
   public ProcOopHandle readOopHandle(long address) throws DebuggerException;
+  public ProcOopHandle readCompOopHandle(long address) throws DebuggerException;
   public long[]       getThreadIntegerRegisterSet(int tid) throws DebuggerException;
   public long         getAddressValue(Address addr) throws DebuggerException;
   public Address      newAddress(long value) throws DebuggerException;

--- a/agent/src/share/classes/sun/jvm/hotspot/debugger/proc/ProcDebuggerLocal.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/debugger/proc/ProcDebuggerLocal.java	Sun May 04 03:29:31 2008 -0700
@@ -53,8 +53,6 @@
  */
 
 public class ProcDebuggerLocal extends DebuggerBase implements ProcDebugger {
-
-
     protected static final int cacheSize = 16 * 1024 * 1024; // 16 MB
 
     //------------------------------------------------------------------------
@@ -337,10 +335,21 @@
         return (value == 0 ? null : new ProcAddress(this, value));
     }
 
+    public ProcAddress readCompOopAddress(long address)
+    throws UnmappedAddressException, UnalignedAddressException {
+        long value = readCompOopAddressValue(address);
+        return (value == 0 ? null : new ProcAddress(this, value));
+    }
+
     /** From the ProcDebugger interface */
     public ProcOopHandle readOopHandle(long address)
     throws UnmappedAddressException, UnalignedAddressException, NotInHeapException {
-        long value = readAddressValue(address);
+        long   value = readAddressValue(address);
+        return (value == 0 ? null : new ProcOopHandle(this, value));
+    }
+
+    public ProcOopHandle readCompOopHandle(long address) {
+        long value = readCompOopAddressValue(address);
         return (value == 0 ? null : new ProcOopHandle(this, value));
     }
 

--- a/agent/src/share/classes/sun/jvm/hotspot/debugger/remote/RemoteAddress.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/debugger/remote/RemoteAddress.java	Sun May 04 03:29:31 2008 -0700
@@ -71,6 +71,9 @@
   public Address getAddressAt(long offset) throws UnalignedAddressException, UnmappedAddressException {
     return debugger.readAddress(addr + offset);
   }
+  public Address getCompOopAddressAt(long offset) throws UnalignedAddressException, UnmappedAddressException {
+    return debugger.readCompOopAddress(addr + offset);
+  }
 
   //
   // Java-related routines
@@ -112,6 +115,10 @@
     throws UnalignedAddressException, UnmappedAddressException, NotInHeapException {
     return debugger.readOopHandle(addr + offset);
   }
+  public OopHandle getCompOopHandleAt(long offset)
+    throws UnalignedAddressException, UnmappedAddressException, NotInHeapException {
+    return debugger.readCompOopHandle(addr + offset);
+  }
 
   // Mutators -- not implemented for now (FIXME)
   public void setCIntegerAt(long offset, long numBytes, long value) {

--- a/agent/src/share/classes/sun/jvm/hotspot/debugger/remote/RemoteDebugger.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/debugger/remote/RemoteDebugger.java	Sun May 04 03:29:31 2008 -0700
@@ -65,6 +65,9 @@
   public long      getJIntSize() throws RemoteException;
   public long      getJLongSize() throws RemoteException;
   public long      getJShortSize() throws RemoteException;
+  public long      getHeapBase() throws RemoteException;
+  public long      getHeapOopSize() throws RemoteException;
+  public long      getLogMinObjAlignmentInBytes() throws RemoteException;
   public boolean   areThreadsEqual(long addrOrId1, boolean isAddress1,
                                    long addrOrId2, boolean isAddress2) throws RemoteException;
   public int       getThreadHashCode(long addrOrId, boolean isAddress) throws RemoteException;

--- a/agent/src/share/classes/sun/jvm/hotspot/debugger/remote/RemoteDebuggerClient.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/debugger/remote/RemoteDebuggerClient.java	Sun May 04 03:29:31 2008 -0700
@@ -85,6 +85,9 @@
       jlongSize    = remoteDebugger.getJLongSize();
       jshortSize   = remoteDebugger.getJShortSize();
       javaPrimitiveTypesConfigured = true;
+      heapBase     = remoteDebugger.getHeapBase();
+      heapOopSize  = remoteDebugger.getHeapOopSize();
+      logMinObjAlignmentInBytes  = remoteDebugger.getLogMinObjAlignmentInBytes();
     }
     catch (RemoteException e) {
       throw new DebuggerException(e);
@@ -298,12 +301,24 @@
     return (value == 0 ? null : new RemoteAddress(this, value));
   }
 
+  RemoteAddress readCompOopAddress(long address)
+    throws UnmappedAddressException, UnalignedAddressException {
+    long value = readCompOopAddressValue(address);
+    return (value == 0 ? null : new RemoteAddress(this, value));
+  }
+
   RemoteOopHandle readOopHandle(long address)
     throws UnmappedAddressException, UnalignedAddressException, NotInHeapException {
     long value = readAddressValue(address);
     return (value == 0 ? null : new RemoteOopHandle(this, value));
   }
 
+  RemoteOopHandle readCompOopHandle(long address)
+    throws UnmappedAddressException, UnalignedAddressException, NotInHeapException {
+    long value = readCompOopAddressValue(address);
+    return (value == 0 ? null : new RemoteOopHandle(this, value));
+  }
+
   boolean areThreadsEqual(Address addr1, Address addr2) {
     try {
        return remoteDebugger.areThreadsEqual(getAddressValue(addr1), true,

--- a/agent/src/share/classes/sun/jvm/hotspot/debugger/remote/RemoteDebuggerServer.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/debugger/remote/RemoteDebuggerServer.java	Sun May 04 03:29:31 2008 -0700
@@ -114,6 +114,17 @@
     return debugger.getJShortSize();
   }
 
+  public long getHeapBase() throws RemoteException {
+    return debugger.getHeapBase();
+  }
+
+  public long getHeapOopSize() throws RemoteException {
+    return debugger.getHeapOopSize();
+  }
+
+  public long getLogMinObjAlignmentInBytes() throws RemoteException {
+    return debugger.getLogMinObjAlignmentInBytes();
+  }
   public boolean   areThreadsEqual(long addrOrId1, boolean isAddress1,
                                    long addrOrId2, boolean isAddress2) throws RemoteException {
     ThreadProxy t1 = getThreadProxy(addrOrId1, isAddress1);

--- a/agent/src/share/classes/sun/jvm/hotspot/debugger/win32/Win32Address.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/debugger/win32/Win32Address.java	Sun May 04 03:29:31 2008 -0700
@@ -72,6 +72,10 @@
     return debugger.readAddress(addr + offset);
   }
 
+  public Address getCompOopAddressAt(long offset) throws UnalignedAddressException, UnmappedAddressException {
+    return debugger.readCompOopAddress(addr + offset);
+  }
+
   //
   // Java-related routines
   //
@@ -112,6 +116,10 @@
     throws UnalignedAddressException, UnmappedAddressException, NotInHeapException {
     return debugger.readOopHandle(addr + offset);
   }
+  public OopHandle getCompOopHandleAt(long offset)
+    throws UnalignedAddressException, UnmappedAddressException, NotInHeapException {
+    return debugger.readCompOopHandle(addr + offset);
+  }
 
   //
   // C/C++-related mutators

--- a/agent/src/share/classes/sun/jvm/hotspot/debugger/win32/Win32Debugger.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/debugger/win32/Win32Debugger.java	Sun May 04 03:29:31 2008 -0700
@@ -45,7 +45,9 @@
   public long         readCInteger(long address, long numBytes, boolean isUnsigned)
     throws DebuggerException;
   public Win32Address readAddress(long address) throws DebuggerException;
+  public Win32Address readCompOopAddress(long address) throws DebuggerException;
   public Win32OopHandle readOopHandle(long address) throws DebuggerException;
+  public Win32OopHandle readCompOopHandle(long address) throws DebuggerException;
   public void         writeJBoolean(long address, boolean value) throws DebuggerException;
   public void         writeJByte(long address, byte value) throws DebuggerException;
   public void         writeJChar(long address, char value) throws DebuggerException;

--- a/agent/src/share/classes/sun/jvm/hotspot/debugger/win32/Win32DebuggerLocal.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/debugger/win32/Win32DebuggerLocal.java	Sun May 04 03:29:31 2008 -0700
@@ -306,12 +306,22 @@
     return (Win32Address) newAddress(readAddressValue(address));
   }
 
+  public Win32Address readCompOopAddress(long address)
+    throws UnmappedAddressException, UnalignedAddressException {
+    return (Win32Address) newAddress(readCompOopAddressValue(address));
+  }
+
   /** From the Win32Debugger interface */
   public Win32OopHandle readOopHandle(long address)
     throws UnmappedAddressException, UnalignedAddressException, NotInHeapException {
     long value = readAddressValue(address);
     return (value == 0 ? null : new Win32OopHandle(this, value));
   }
+  public Win32OopHandle readCompOopHandle(long address)
+    throws UnmappedAddressException, UnalignedAddressException, NotInHeapException {
+    long value = readCompOopAddressValue(address);
+    return (value == 0 ? null : new Win32OopHandle(this, value));
+  }
 
   /** From the Win32Debugger interface */
   public void writeAddress(long address, Win32Address value) {

--- a/agent/src/share/classes/sun/jvm/hotspot/debugger/windbg/WindbgAddress.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/debugger/windbg/WindbgAddress.java	Sun May 04 03:29:31 2008 -0700
@@ -72,6 +72,10 @@
     return debugger.readAddress(addr + offset);
   }
 
+  public Address getCompOopAddressAt(long offset) throws UnalignedAddressException, UnmappedAddressException {
+    return debugger.readCompOopAddress(addr + offset);
+  }
+
   //
   // Java-related routines
   //
@@ -113,6 +117,10 @@
     return debugger.readOopHandle(addr + offset);
   }
 
+  public OopHandle getCompOopHandleAt(long offset)
+    throws UnalignedAddressException, UnmappedAddressException, NotInHeapException {
+    return debugger.readCompOopHandle(addr + offset);
+  }
   //
   // C/C++-related mutators
   //

--- a/agent/src/share/classes/sun/jvm/hotspot/debugger/windbg/WindbgDebugger.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/debugger/windbg/WindbgDebugger.java	Sun May 04 03:29:31 2008 -0700
@@ -45,7 +45,9 @@
   public long         readCInteger(long address, long numBytes, boolean isUnsigned)
     throws DebuggerException;
   public WindbgAddress readAddress(long address) throws DebuggerException;
+  public WindbgAddress readCompOopAddress(long address) throws DebuggerException;
   public WindbgOopHandle readOopHandle(long address) throws DebuggerException;
+  public WindbgOopHandle readCompOopHandle(long address) throws DebuggerException;
 
   // The returned array of register contents is guaranteed to be in
   // the same order as in the DbxDebugger for Solaris/x86 or amd64; that is,

--- a/agent/src/share/classes/sun/jvm/hotspot/debugger/windbg/WindbgDebuggerLocal.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/debugger/windbg/WindbgDebuggerLocal.java	Sun May 04 03:29:31 2008 -0700
@@ -39,6 +39,7 @@
 import sun.jvm.hotspot.debugger.cdbg.basic.BasicDebugEvent;
 import sun.jvm.hotspot.utilities.*;
 import sun.jvm.hotspot.utilities.memo.*;
+import sun.jvm.hotspot.runtime.*;
 
 /** <P> An implementation of the JVMDebugger interface which talks to
     windbg and symbol table management is done in Java. </P>
@@ -315,12 +316,22 @@
     return (WindbgAddress) newAddress(readAddressValue(address));
   }
 
+  public WindbgAddress readCompOopAddress(long address)
+    throws UnmappedAddressException, UnalignedAddressException {
+    return (WindbgAddress) newAddress(readCompOopAddressValue(address));
+  }
+
   /** From the WindbgDebugger interface */
   public WindbgOopHandle readOopHandle(long address)
     throws UnmappedAddressException, UnalignedAddressException, NotInHeapException {
     long value = readAddressValue(address);
     return (value == 0 ? null : new WindbgOopHandle(this, value));
   }
+  public WindbgOopHandle readCompOopHandle(long address)
+    throws UnmappedAddressException, UnalignedAddressException, NotInHeapException {
+    long value = readCompOopAddressValue(address);
+    return (value == 0 ? null : new WindbgOopHandle(this, value));
+  }
 
   /** From the WindbgDebugger interface */
   public int getAddressSize() {

--- a/agent/src/share/classes/sun/jvm/hotspot/memory/SystemDictionary.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/memory/SystemDictionary.java	Sun May 04 03:29:31 2008 -0700
@@ -29,21 +29,27 @@
 import sun.jvm.hotspot.oops.*;
 import sun.jvm.hotspot.runtime.*;
 import sun.jvm.hotspot.types.*;
+import sun.jvm.hotspot.types.OopField; // resolve ambiguity with oops.OopField
+
+// following needed for on-the-fly field construction:
+import sun.jvm.hotspot.types.basic.BasicOopField;
+import sun.jvm.hotspot.types.basic.BasicTypeDataBase;
 
 public class SystemDictionary {
   private static AddressField dictionaryField;
   private static AddressField sharedDictionaryField;
   private static AddressField placeholdersField;
   private static AddressField loaderConstraintTableField;
-  private static sun.jvm.hotspot.types.OopField javaSystemLoaderField;
+  private static OopField javaSystemLoaderField;
   private static int nofBuckets;
 
-  private static sun.jvm.hotspot.types.OopField objectKlassField;
-  private static sun.jvm.hotspot.types.OopField classLoaderKlassField;
-  private static sun.jvm.hotspot.types.OopField stringKlassField;
-  private static sun.jvm.hotspot.types.OopField systemKlassField;
-  private static sun.jvm.hotspot.types.OopField threadKlassField;
-  private static sun.jvm.hotspot.types.OopField threadGroupKlassField;
+  private static OopField wellKnownKlasses;
+  private static OopField objectKlassField;
+  private static OopField classLoaderKlassField;
+  private static OopField stringKlassField;
+  private static OopField systemKlassField;
+  private static OopField threadKlassField;
+  private static OopField threadGroupKlassField;
 
   static {
     VM.registerVMInitializedObserver(new Observer() {
@@ -63,12 +69,20 @@
     javaSystemLoaderField = type.getOopField("_java_system_loader");
     nofBuckets = db.lookupIntConstant("SystemDictionary::_nof_buckets").intValue();
 
-    objectKlassField = type.getOopField("_object_klass");
-    classLoaderKlassField = type.getOopField("_classloader_klass");
-    stringKlassField = type.getOopField("_string_klass");
-    systemKlassField = type.getOopField("_system_klass");
-    threadKlassField = type.getOopField("_thread_klass");
-    threadGroupKlassField = type.getOopField("_threadGroup_klass");
+    wellKnownKlasses = type.getOopField("_well_known_klasses[0]");
+    objectKlassField = findWellKnownKlass("object_klass", type, db);
+    classLoaderKlassField = findWellKnownKlass("classloader_klass", type, db);
+    stringKlassField = findWellKnownKlass("string_klass", type, db);
+    systemKlassField = findWellKnownKlass("system_klass", type, db);
+    threadKlassField = findWellKnownKlass("thread_klass", type, db);
+    threadGroupKlassField = findWellKnownKlass("threadGroup_klass", type, db);
+  }
+
+  private static OopField findWellKnownKlass(String indexName, Type type, TypeDataBase db) {
+    Address wkk = wellKnownKlasses.getStaticFieldAddress();
+    int index = db.lookupIntConstant("SystemDictionary::#"+indexName).intValue();
+    return new BasicOopField((BasicTypeDataBase)db, type, indexName, type,
+                             true, index * db.getAddressSize(), wkk);
   }
 
   public Dictionary dictionary() {

--- a/agent/src/share/classes/sun/jvm/hotspot/memory/Universe.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/memory/Universe.java	Sun May 04 03:29:31 2008 -0700
@@ -53,6 +53,8 @@
   // system obj array klass object
   private static sun.jvm.hotspot.types.OopField systemObjArrayKlassObjField;
 
+  private static AddressField heapBaseField;
+
   static {
     VM.registerVMInitializedObserver(new Observer() {
         public void update(Observable o, Object data) {
@@ -83,6 +85,8 @@
     doubleArrayKlassObjField = type.getOopField("_doubleArrayKlassObj");
 
     systemObjArrayKlassObjField = type.getOopField("_systemObjArrayKlassObj");
+
+    heapBaseField = type.getAddressField("_heap_base");
   }
 
   public Universe() {
@@ -96,6 +100,14 @@
     }
   }
 
+  public static long getHeapBase() {
+    if (heapBaseField.getValue() == null) {
+      return 0;
+    } else {
+      return heapBaseField.getValue().minus(null);
+    }
+  }
+
   /** Returns "TRUE" iff "p" points into the allocated area of the heap. */
   public boolean isIn(Address p) {
     return heap().isIn(p);

--- a/agent/src/share/classes/sun/jvm/hotspot/oops/Array.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/oops/Array.java	Sun May 04 03:29:31 2008 -0700
@@ -47,18 +47,52 @@
 
   private static void initialize(TypeDataBase db) throws WrongTypeException {
     Type type   = db.lookupType("arrayOopDesc");
-    length      = new CIntField(type.getCIntegerField("_length"), 0);
-    headerSize  = type.getSize();
+    typeSize    = (int)type.getSize();
   }
 
   // Size of the arrayOopDesc
-  private static long headerSize;
+  private static long headerSize=0;
+  private static long lengthOffsetInBytes=0;
+  private static long typeSize;
+
+  private static long headerSizeInBytes() {
+    if (headerSize != 0) {
+      return headerSize;
+    }
+    if (VM.getVM().isCompressedOopsEnabled()) {
+      headerSize = typeSize;
+    } else {
+      headerSize = VM.getVM().alignUp(typeSize + VM.getVM().getIntSize(),
+                                      VM.getVM().getHeapWordSize());
+    }
+    return headerSize;
+  }
 
-  // Fields
-  private static CIntField length;
+  private static long headerSize(BasicType type) {
+    if (Universe.elementTypeShouldBeAligned(type)) {
+       return alignObjectSize(headerSizeInBytes())/VM.getVM().getHeapWordSize();
+    } else {
+      return headerSizeInBytes()/VM.getVM().getHeapWordSize();
+    }
+  }
+
+  private long lengthOffsetInBytes() {
+    if (lengthOffsetInBytes != 0) {
+      return lengthOffsetInBytes;
+    }
+    if (VM.getVM().isCompressedOopsEnabled()) {
+      lengthOffsetInBytes = typeSize - VM.getVM().getIntSize();
+    } else {
+      lengthOffsetInBytes = typeSize;
+    }
+    return lengthOffsetInBytes;
+  }
 
   // Accessors for declared fields
-  public long getLength() { return length.getValue(this); }
+  public long getLength() {
+    boolean isUnsigned = true;
+    return this.getHandle().getCIntegerAt(lengthOffsetInBytes(), VM.getVM().getIntSize(), isUnsigned);
+  }
 
   public long getObjectSize() {
     ArrayKlass klass = (ArrayKlass) getKlass();
@@ -72,20 +106,12 @@
   }
 
   public static long baseOffsetInBytes(BasicType type) {
-    if (Universe.elementTypeShouldBeAligned(type)) {
-      return (VM.getVM().isLP64()) ?  alignObjectSize(headerSize)
-                                   : VM.getVM().alignUp(headerSize, 8);
-    } else {
-      return headerSize;
-    }
+    return headerSize(type) * VM.getVM().getHeapWordSize();
   }
 
   public boolean isArray()             { return true; }
 
   public void iterateFields(OopVisitor visitor, boolean doVMFields) {
     super.iterateFields(visitor, doVMFields);
-    if (doVMFields) {
-      visitor.doCInt(length, true);
-    }
   }
 }

--- a/agent/src/share/classes/sun/jvm/hotspot/oops/ConstantPool.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/oops/ConstantPool.java	Sun May 04 03:29:31 2008 -0700
@@ -31,10 +31,10 @@
 import sun.jvm.hotspot.types.*;
 import sun.jvm.hotspot.utilities.*;
 
-// A ConstantPool is an array containing class constants
+// A ConstantPool is an oop containing class constants
 // as described in the class file
 
-public class ConstantPool extends Array implements ClassConstants {
+public class ConstantPool extends Oop implements ClassConstants {
   // Used for debugging this code
   private static final boolean DEBUG = false;
 
@@ -55,8 +55,9 @@
     tags        = new OopField(type.getOopField("_tags"), 0);
     cache       = new OopField(type.getOopField("_cache"), 0);
     poolHolder  = new OopField(type.getOopField("_pool_holder"), 0);
+    length      = new CIntField(type.getCIntegerField("_length"), 0);
     headerSize  = type.getSize();
-    elementSize = db.getOopSize();
+    elementSize = 0;
   }
 
   ConstantPool(OopHandle handle, ObjectHeap heap) {
@@ -68,7 +69,7 @@
   private static OopField tags;
   private static OopField cache;
   private static OopField poolHolder;
-
+  private static CIntField length; // number of elements in oop
 
   private static long headerSize;
   private static long elementSize;
@@ -76,12 +77,22 @@
   public TypeArray         getTags()       { return (TypeArray)         tags.getValue(this); }
   public ConstantPoolCache getCache()      { return (ConstantPoolCache) cache.getValue(this); }
   public Klass             getPoolHolder() { return (Klass)             poolHolder.getValue(this); }
+  public int               getLength()     { return (int)length.getValue(this); }
+
+  private long getElementSize() {
+    if (elementSize !=0 ) {
+      return elementSize;
+    } else {
+      elementSize = VM.getVM().getOopSize();
+    }
+    return elementSize;
+  }
 
   private long indexOffset(long index) {
     if (Assert.ASSERTS_ENABLED) {
-      Assert.that(index > 0 && index < getLength(),  "invalid cp index");
+      Assert.that(index > 0 && index < getLength(),  "invalid cp index " + index + " " + getLength());
     }
-    return (index * elementSize) + headerSize;
+    return (index * getElementSize()) + headerSize;
   }
 
   public ConstantTag getTagAt(long index) {
@@ -464,7 +475,7 @@
   }
 
   public long getObjectSize() {
-    return alignObjectSize(headerSize + (getLength() * elementSize));
+    return alignObjectSize(headerSize + (getLength() * getElementSize()));
   }
 
   //----------------------------------------------------------------------

--- a/agent/src/share/classes/sun/jvm/hotspot/oops/ConstantPoolCache.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/oops/ConstantPoolCache.java	Sun May 04 03:29:31 2008 -0700
@@ -31,10 +31,10 @@
 import sun.jvm.hotspot.types.*;
 import sun.jvm.hotspot.utilities.*;
 
-// A ConstantPool is an array containing class constants
-// as described in the class file
-
-public class ConstantPoolCache extends Array {
+//  ConstantPoolCache : A constant pool cache (constantPoolCacheOopDesc).
+//  See cpCacheOop.hpp for details about this class.
+//
+public class ConstantPoolCache extends Oop {
   static {
     VM.registerVMInitializedObserver(new Observer() {
         public void update(Observable o, Object data) {
@@ -47,9 +47,9 @@
     Type type      = db.lookupType("constantPoolCacheOopDesc");
     constants      = new OopField(type.getOopField("_constant_pool"), 0);
     baseOffset     = type.getSize();
-
     Type elType    = db.lookupType("ConstantPoolCacheEntry");
     elementSize    = elType.getSize();
+    length         = new CIntField(type.getCIntegerField("_length"), 0);
   }
 
   ConstantPoolCache(OopHandle handle, ObjectHeap heap) {
@@ -62,6 +62,8 @@
 
   private static long baseOffset;
   private static long elementSize;
+  private static CIntField length;
+
 
   public ConstantPool getConstants() { return (ConstantPool) constants.getValue(this); }
 
@@ -87,6 +89,10 @@
     tty.print("ConstantPoolCache for " + getConstants().getPoolHolder().getName().asString());
   }
 
+  public int getLength() {
+    return (int) length.getValue(this);
+  }
+
   public void iterateFields(OopVisitor visitor, boolean doVMFields) {
     super.iterateFields(visitor, doVMFields);
     if (doVMFields) {

--- a/agent/src/share/classes/sun/jvm/hotspot/oops/ConstantPoolCacheKlass.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/oops/ConstantPoolCacheKlass.java	Sun May 04 03:29:31 2008 -0700
@@ -32,7 +32,7 @@
 
 // A ConstantPoolCacheKlass is the klass of a ConstantPoolCache
 
-public class ConstantPoolCacheKlass extends ArrayKlass {
+public class ConstantPoolCacheKlass extends Klass {
   static {
     VM.registerVMInitializedObserver(new Observer() {
         public void update(Observable o, Object data) {
@@ -43,13 +43,20 @@
 
   private static synchronized void initialize(TypeDataBase db) throws WrongTypeException {
     Type type  = db.lookupType("constantPoolCacheKlass");
+    headerSize = type.getSize() + Oop.getHeaderSize();
   }
 
   ConstantPoolCacheKlass(OopHandle handle, ObjectHeap heap) {
     super(handle, heap);
   }
 
+  public long getObjectSize() { return alignObjectSize(headerSize); }
+
   public void printValueOn(PrintStream tty) {
     tty.print("ConstantPoolCacheKlass");
   }
+
+  private static long headerSize;
 }
+
+

--- a/agent/src/share/classes/sun/jvm/hotspot/oops/ConstantPoolKlass.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/oops/ConstantPoolKlass.java	Sun May 04 03:29:31 2008 -0700
@@ -32,7 +32,7 @@
 
 // A ConstantPoolKlass is the klass of a ConstantPool
 
-public class ConstantPoolKlass extends ArrayKlass {
+public class ConstantPoolKlass extends Klass {
   static {
     VM.registerVMInitializedObserver(new Observer() {
         public void update(Observable o, Object data) {
@@ -43,13 +43,19 @@
 
   private static synchronized void initialize(TypeDataBase db) throws WrongTypeException {
     Type type  = db.lookupType("constantPoolKlass");
+    headerSize = type.getSize() + Oop.getHeaderSize();
   }
 
   ConstantPoolKlass(OopHandle handle, ObjectHeap heap) {
     super(handle, heap);
   }
 
+  public long getObjectSize() { return alignObjectSize(headerSize); }
+
   public void printValueOn(PrintStream tty) {
     tty.print("ConstantPoolKlass");
   }
-};
+
+  private static long headerSize;
+}
+

--- a/agent/src/share/classes/sun/jvm/hotspot/oops/DefaultOopVisitor.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/oops/DefaultOopVisitor.java	Sun May 04 03:29:31 2008 -0700
@@ -46,6 +46,7 @@
 
   // Callback methods for each field type in an object
   public void doOop(OopField field, boolean isVMField)         {}
+  public void doOop(NarrowOopField field, boolean isVMField)   {}
   public void doByte(ByteField field, boolean isVMField)       {}
   public void doChar(CharField field, boolean isVMField)       {}
   public void doBoolean(BooleanField field, boolean isVMField) {}

--- a/agent/src/share/classes/sun/jvm/hotspot/oops/Instance.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/oops/Instance.java	Sun May 04 03:29:31 2008 -0700
@@ -40,15 +40,26 @@
         }
       });
   }
+  private static long typeSize;
 
   private static synchronized void initialize(TypeDataBase db) throws WrongTypeException {
     Type type = db.lookupType("instanceOopDesc");
+    typeSize = type.getSize();
   }
 
   Instance(OopHandle handle, ObjectHeap heap) {
     super(handle, heap);
   }
 
+  // Returns header size in bytes.
+  public static long getHeaderSize() {
+    if (VM.getVM().isCompressedOopsEnabled()) {
+      return typeSize - VM.getVM().getIntSize();
+    } else {
+      return typeSize;
+    }
+  }
+
   public boolean isInstance()          { return true; }
 
   public void iterateFields(OopVisitor visitor, boolean doVMFields) {

--- a/agent/src/share/classes/sun/jvm/hotspot/oops/InstanceKlass.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/oops/InstanceKlass.java	Sun May 04 03:29:31 2008 -0700
@@ -467,7 +467,6 @@
     for (int index = 0; index < length; index += NEXT_OFFSET) {
       short accessFlags    = fields.getShortAt(index + ACCESS_FLAGS_OFFSET);
       short signatureIndex = fields.getShortAt(index + SIGNATURE_INDEX_OFFSET);
-
       FieldType   type   = new FieldType((Symbol) getConstants().getObjAt(signatureIndex));
       AccessFlags access = new AccessFlags(accessFlags);
       if (access.isStatic()) {
@@ -790,7 +789,11 @@
     short signatureIndex = fields.getShortAt(index + SIGNATURE_INDEX_OFFSET);
     FieldType type = new FieldType((Symbol) getConstants().getObjAt(signatureIndex));
     if (type.isOop()) {
-      return new OopField(this, index);
+     if (VM.getVM().isCompressedOopsEnabled()) {
+        return new NarrowOopField(this, index);
+     } else {
+        return new OopField(this, index);
+     }
     }
     if (type.isByte()) {
       return new ByteField(this, index);

--- a/agent/src/share/classes/sun/jvm/hotspot/oops/Klass.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/oops/Klass.java	Sun May 04 03:29:31 2008 -0700
@@ -171,8 +171,7 @@
   }
 
   public long getObjectSize() {
-    System.out.println("should not reach here");
-    return 0;
+    throw new RuntimeException("should not reach here");
   }
 
   /** Array class with specific rank */

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/agent/src/share/classes/sun/jvm/hotspot/oops/NarrowOopField.java	Sun May 04 03:29:31 2008 -0700
@@ -0,0 +1,55 @@
+/*
+ * Copyright 2000-2008 Sun Microsystems, Inc.  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.
+ *
+ * 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
+ * CA 95054 USA or visit www.sun.com if you need additional information or
+ * have any questions.
+ *
+ */
+
+package sun.jvm.hotspot.oops;
+
+import sun.jvm.hotspot.debugger.*;
+
+// The class for an oop field simply provides access to the value.
+public class NarrowOopField extends OopField {
+  public NarrowOopField(FieldIdentifier id, long offset, boolean isVMField) {
+    super(id, offset, isVMField);
+  }
+
+  public NarrowOopField(sun.jvm.hotspot.types.OopField vmField, long startOffset) {
+    super(new NamedFieldIdentifier(vmField.getName()), vmField.getOffset() + startOffset, true);
+  }
+
+  public NarrowOopField(InstanceKlass holder, int fieldArrayIndex) {
+    super(holder, fieldArrayIndex);
+  }
+
+  public Oop getValue(Oop obj) {
+    return obj.getHeap().newOop(getValueAsOopHandle(obj));
+  }
+
+  /** Debugging support */
+  public OopHandle getValueAsOopHandle(Oop obj) {
+    return obj.getHandle().getCompOopHandleAt(getOffset());
+  }
+
+  public void setValue(Oop obj) throws MutationException {
+    // Fix this: setOopAt is missing in Address
+  }
+}

--- a/agent/src/share/classes/sun/jvm/hotspot/oops/ObjArray.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/oops/ObjArray.java	Sun May 04 03:29:31 2008 -0700
@@ -43,7 +43,7 @@
 
   private static synchronized void initialize(TypeDataBase db) throws WrongTypeException {
     Type type   = db.lookupType("objArrayOopDesc");
-    elementSize = db.getOopSize();
+    elementSize = VM.getVM().getHeapOopSize();
   }
 
   ObjArray(OopHandle handle, ObjectHeap heap) {
@@ -54,9 +54,17 @@
 
   private static long elementSize;
 
-  public Oop getObjAt(long index) {
+  public OopHandle getOopHandleAt(long index) {
     long offset = baseOffsetInBytes(BasicType.T_OBJECT) + (index * elementSize);
-    return getHeap().newOop(getHandle().getOopHandleAt(offset));
+    if (VM.getVM().isCompressedOopsEnabled()) {
+      return getHandle().getCompOopHandleAt(offset);
+    } else {
+      return getHandle().getOopHandleAt(offset);
+    }
+  }
+
+  public Oop getObjAt(long index) {
+      return getHeap().newOop(getOopHandleAt(index));
   }
 
   public void printValueOn(PrintStream tty) {
@@ -69,7 +77,13 @@
     long baseOffset = baseOffsetInBytes(BasicType.T_OBJECT);
     for (int index = 0; index < length; index++) {
       long offset = baseOffset + (index * elementSize);
-      visitor.doOop(new OopField(new IndexableFieldIdentifier(index), offset, false), false);
+      OopField field;
+      if (VM.getVM().isCompressedOopsEnabled()) {
+        field = new NarrowOopField(new IndexableFieldIdentifier(index), offset, false);
+      } else {
+        field = new OopField(new IndexableFieldIdentifier(index), offset, false);
+      }
+      visitor.doOop(field, false);
     }
   }
 }

--- a/agent/src/share/classes/sun/jvm/hotspot/oops/ObjectHeap.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/oops/ObjectHeap.java	Sun May 04 03:29:31 2008 -0700
@@ -41,6 +41,12 @@
 
 public class ObjectHeap {
 
+  private static final boolean DEBUG;
+
+  static {
+    DEBUG = System.getProperty("sun.jvm.hotspot.oops.ObjectHeap.DEBUG") != null;
+  }
+
   private OopHandle              symbolKlassHandle;
   private OopHandle              methodKlassHandle;
   private OopHandle              constMethodKlassHandle;
@@ -152,7 +158,7 @@
 
   public ObjectHeap(TypeDataBase db) throws WrongTypeException {
     // Get commonly used sizes of basic types
-    oopSize     = db.getOopSize();
+    oopSize     = VM.getVM().getOopSize();
     byteSize    = db.getJByteType().getSize();
     charSize    = db.getJCharType().getSize();
     booleanSize = db.getJBooleanType().getSize();
@@ -440,12 +446,16 @@
       try {
         // Traverses the space from bottom to top
         OopHandle handle = bottom.addOffsetToAsOopHandle(0);
+
         while (handle.lessThan(top)) {
         Oop obj = null;
 
           try {
             obj = newOop(handle);
           } catch (UnknownOopException exp) {
+            if (DEBUG) {
+              throw new RuntimeException(" UnknownOopException  " + exp);
+            }
           }
           if (obj == null) {
              //Find the object size using Printezis bits and skip over

--- a/agent/src/share/classes/sun/jvm/hotspot/oops/ObjectHistogram.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/oops/ObjectHistogram.java	Sun May 04 03:29:31 2008 -0700
@@ -64,8 +64,17 @@
     List list = getElements();
     ObjectHistogramElement.titleOn(tty);
     Iterator iterator = list.listIterator();
+    int num=0;
+    int totalCount=0;
+    int totalSize=0;
     while (iterator.hasNext()) {
-      ((ObjectHistogramElement) iterator.next()).printOn(tty);
+      ObjectHistogramElement el = (ObjectHistogramElement) iterator.next();
+      num++;
+      totalCount+=el.getCount();
+      totalSize+=el.getSize();
+      tty.print(num + ":" + "\t\t");
+      el.printOn(tty);
     }
+    tty.println("Total : " + "\t" + totalCount + "\t" + totalSize);
   }
 }

--- a/agent/src/share/classes/sun/jvm/hotspot/oops/ObjectHistogramElement.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/oops/ObjectHistogramElement.java	Sun May 04 03:29:31 2008 -0700
@@ -110,12 +110,12 @@
   public static void titleOn(PrintStream tty) {
     tty.println("Object Histogram:");
     tty.println();
-    tty.println("Size" + "\t" + "Count" + "\t" + "Class description");
-    tty.println("-------------------------------------------------------");
+    tty.println("num " + "\t" + "  #instances" + "\t" + "#bytes" + "\t" + "Class description");
+    tty.println("--------------------------------------------------------------------------");
   }
 
   public void printOn(PrintStream tty) {
-    tty.print(size + "\t" + count + "\t");
+    tty.print(count + "\t" + size + "\t");
     tty.print(getDescription());
     tty.println();
   }

--- a/agent/src/share/classes/sun/jvm/hotspot/oops/Oop.java	Tue Apr 29 13:51:26 2008 +0400
+++ b/agent/src/share/classes/sun/jvm/hotspot/oops/Oop.java	Sun May 04 03:29:31 2008 -0700
@@ -47,7 +47,8 @@
   private static synchronized void initialize(TypeDataBase db) throws WrongTypeException {
     Type type  = db.lookupType("oopDesc");
     mark       = new CIntField(type.getCIntegerField("_mark"), 0);
-    klass      = new OopField(type.getOopField("_klass"), 0);
+    klass      = new OopField(type.getOopField("_metadata._klass"), 0);
+    compressedKlass  = new NarrowOopField(type.getOopField("_metadata._compressed_klass"), 0);
     headerSize = type.getSize();
   }
 
@@ -67,10 +68,11 @@
   public OopHandle getHandle() { return handle; }
 
   private static long headerSize;
-  public  static long getHeaderSize() { return headerSize; }
+  public  static long getHeaderSize() { return headerSize; } // Header size in bytes.
 
   private static CIntField mark;
   private static OopField  klass;
+  private static NarrowOopField compressedKlass;
 
   public boolean isShared() {
     return CompactingPermGenGen.isShared(handle);
@@ -86,7 +88,13 @@
 
   // Accessors for declared fields
   public Mark  getMark()   { return new Mark(getHandle()); }
-  public Klass getKlass()  { return (Klass) klass.getValue(this); }
+  public Klass getKlass() {
+    if (VM.getVM().isCompressedOopsEnabled()) {
+      return (Klass) compressedKlass.getValue(this);
+    } else {
+      return (Klass) klass.getValue(this);
+    }
+  }
 
   public boolean isA(Klass k) {
     return getKlass().isSubtypeOf(k);
@@ -120,7 +128,7 @@
 
   // Align the object size.
   public static long alignObjectSize(long size) {
-    return VM.getVM().alignUp(size, VM.getVM().getMinObjAlignmentInBytes());
+    return VM.getVM().alignUp(size, VM.getVM().getMinObjAlignment());
   }
 
   // All vm's align longs, so pad out certain offsets.
@@ -163,7 +171,11 @@
   void iterateFields(OopVisitor visitor, boolean doVMFields) {
     if (doVMFields) {
       visitor.doCInt(mark, true);
-      visitor.doOop(klass, true);
+      if (VM.getVM().isCompressedOopsEnabled()) {
+        visitor.doOop(compressedKlass, true);
+      } else {
+        visitor.doOop(klass, true);
+      }
     }
   }
 
@@ -219,6 +231,10 @@
     if (handle == null) {
       return null;
     }
-    return handle.getOopHandleAt(klass.getOffset());
+    if (VM.getVM().isCompressedOopsEnabled()) {
+      return handle.getCompOopHandleAt(compressedKlass.getOffset());
+    } else {
+      return handle.getOopHandleAt(klass.getOffset());
+    }
   }
 };