sa-jdi

());
  }
  
  public Oop systemObjArrayKlassObj()
  {
    return newOop(systemObjArrayKlassObjField.getValue());
  }
  
  public void basicTypeClassesDo(SystemDictionary.ClassVisitor visitor)
  {
    visitor.visit((Klass)newOop(boolArrayKlassObjField.getValue()));
    visitor.visit((Klass)newOop(byteArrayKlassObjField.getValue()));
    visitor.visit((Klass)newOop(charArrayKlassObjField.getValue()));
    visitor.visit((Klass)newOop(intArrayKlassObjField.getValue()));
    visitor.visit((Klass)newOop(shortArrayKlassObjField.getValue()));
    visitor.visit((Klass)newOop(longArrayKlassObjField.getValue()));
    visitor.visit((Klass)newOop(singleArrayKlassObjField.getValue()));
    visitor.visit((Klass)newOop(doubleArrayKlassObjField.getValue()));
  }
  
  public void print()
  {
    printOn(System.out);
  }
  
  public void printOn(PrintStream tty)
  {
    heap().printOn(tty);
  }
  
  public static boolean elementTypeShouldBeAligned(BasicType type)
  {
    return (type == BasicType.T_DOUBLE) || (type == BasicType.T_LONG);
  }
  
  public static boolean fieldTypeShouldBeAligned(BasicType type)
  {
    return (type == BasicType.T_DOUBLE) || (type == BasicType.T_LONG);
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.memory.Universe
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot;

public class ObjectHistogram
{
  public static void main(String[] args)
  {
    sun.jvm.hotspot.tools.ObjectHistogram.main(args);
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.ObjectHistogram
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot.oops;

import java.io.PrintStream;
import sun.jvm.hotspot.runtime.ClassConstants;

public class AccessFlags
  implements ClassConstants
{
  private long flags;
  
  public AccessFlags(long flags)
  {
    this.flags = flags;
  }
  
  public boolean isPublic()
  {
    return (flags & 1L) != 0L;
  }
  
  public boolean isPrivate()
  {
    return (flags & 0x2) != 0L;
  }
  
  public boolean isProtected()
  {
    return (flags & 0x4) != 0L;
  }
  
  public boolean isStatic()
  {
    return (flags & 0x8) != 0L;
  }
  
  public boolean isFinal()
  {
    return (flags & 0x10) != 0L;
  }
  
  public boolean isSynchronized()
  {
    return (flags & 0x20) != 0L;
  }
  
  public boolean isSuper()
  {
    return (flags & 0x20) != 0L;
  }
  
  public boolean isVolatile()
  {
    return (flags & 0x40) != 0L;
  }
  
  public boolean isBridge()
  {
    return (flags & 0x40) != 0L;
  }
  
  public boolean isTransient()
  {
    return (flags & 0x80) != 0L;
  }
  
  public boolean isVarArgs()
  {
    return (flags & 0x80) != 0L;
  }
  
  public boolean isNative()
  {
    return (flags & 0x100) != 0L;
  }
  
  public boolean isEnum()
  {
    return (flags & 0x4000) != 0L;
  }
  
  public boolean isAnnotation()
  {
    return (flags & 0x2000) != 0L;
  }
  
  public boolean isInterface()
  {
    return (flags & 0x200) != 0L;
  }
  
  public boolean isAbstract()
  {
    return (flags & 0x400) != 0L;
  }
  
  public boolean isStrict()
  {
    return (flags & 0x800) != 0L;
  }
  
  public boolean isSynthetic()
  {
    return (flags & 0x1000) != 0L;
  }
  
  public long getValue()
  {
    return flags;
  }
  
  public boolean isMonitorMatching()
  {
    return (flags & 0x10000000) != 0L;
  }
  
  public boolean hasMonitorBytecodes()
  {
    return (flags & 0x20000000) != 0L;
  }
  
  public boolean hasLoops()
  {
    return (flags & 0x40000000) != 0L;
  }
  
  public boolean loopsFlagInit()
  {
    return (flags & 0xFFFFFFFF80000000) != 0L;
  }
  
  public boolean queuedForCompilation()
  {
    return (flags & 0x1000000) != 0L;
  }
  
  public boolean isNotOsrCompilable()
  {
    return (flags & 0x8000000) != 0L;
  }
  
  public boolean hasLineNumberTable()
  {
    return (flags & 0x100000) != 0L;
  }
  
  public boolean hasCheckedExceptions()
  {
    return (flags & 0x400000) != 0L;
  }
  
  public boolean hasJsrs()
  {
    return (flags & 0x800000) != 0L;
  }
  
  public boolean isObsolete()
  {
    return (flags & 0x10000) != 0L;
  }
  
  public boolean hasMirandaMethods()
  {
    return (flags & 0x10000000) != 0L;
  }
  
  public boolean hasVanillaConstructor()
  {
    return (flags & 0x20000000) != 0L;
  }
  
  public boolean hasFinalizer()
  {
    return (flags & 0x40000000) != 0L;
  }
  
  public boolean isCloneable()
  {
    return (flags & 0xFFFFFFFF80000000) != 0L;
  }
  
  public boolean hasLocalVariableTable()
  {
    return (flags & 0x200000) != 0L;
  }
  
  public boolean fieldAccessWatched()
  {
    return (flags & 0x2000) != 0L;
  }
  
  public boolean fieldModificationWatched()
  {
    return (flags & 0x8000) != 0L;
  }
  
  public void printOn(PrintStream tty)
  {
    if (isPublic()) {
      tty.print("public ");
    }
    if (isPrivate()) {
      tty.print("private ");
    }
    if (isProtected()) {
      tty.print("protected ");
    }
    if (isStatic()) {
      tty.print("static ");
    }
    if (isFinal()) {
      tty.print("final ");
    }
    if (isSynchronized()) {
      tty.print("synchronized ");
    }
    if (isVolatile()) {
      tty.print("volatile ");
    }
    if (isBridge()) {
      tty.print("bridge ");
    }
    if (isTransient()) {
      tty.print("transient ");
    }
    if (isVarArgs()) {
      tty.print("varargs ");
    }
    if (isNative()) {
      tty.print("native ");
    }
    if (isEnum()) {
      tty.print("enum ");
    }
    if (isInterface()) {
      tty.print("interface ");
    }
    if (isAbstract()) {
      tty.print("abstract ");
    }
    if (isStrict()) {
      tty.print("strict ");
    }
    if (isSynthetic()) {
      tty.print("synthetic ");
    }
  }
  
  public int getStandardFlags()
  {
    return (int)(flags & 0x7FFF);
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.oops.AccessFlags
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot.oops;

import java.util.Observable;
import java.util.Observer;
import sun.jvm.hotspot.runtime.VM;

final class Array$1
  implements Observer
{
  public void update(Observable o, Object data)
  {
    Array.access$000(VM.getVM().getTypeDataBase());
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.oops.Array.1
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot.oops;

import java.util.Observable;
import java.util.Observer;
import sun.jvm.hotspot.debugger.OopHandle;
import sun.jvm.hotspot.memory.Universe;
import sun.jvm.hotspot.runtime.BasicType;
import sun.jvm.hotspot.runtime.VM;
import sun.jvm.hotspot.types.Type;
import sun.jvm.hotspot.types.TypeDataBase;
import sun.jvm.hotspot.types.WrongTypeException;

public class Array
  extends Oop
{
  static
  {
    VM.registerVMInitializedObserver(new Observer()
    {
      public void update(Observable o, Object data)
      {
        Array.initialize(VM.getVM().getTypeDataBase());
      }
    });
  }
  
  Array(OopHandle handle, ObjectHeap heap)
  {
    super(handle, heap);
  }
  
  private static void initialize(TypeDataBase db)
    throws WrongTypeException
  {
    Type type = db.lookupType("arrayOopDesc");
    typeSize = (int)type.getSize();
  }
  
  private static long headerSize = 0L;
  private static long lengthOffsetInBytes = 0L;
  private static long typeSize;
  
  private static long headerSizeInBytes()
  {
    if (headerSize != 0L) {
      return headerSize;
    }
    if (VM.getVM().isCompressedOopsEnabled()) {
      headerSize = typeSize;
    } else {
      headerSize = VM.getVM().alignUp(typeSize + VM.getVM().getIntSize(), VM.getVM().getHeapWordSize());
    }
    return headerSize;
  }
  
  private static long headerSize(BasicType type)
  {
    if (Universe.elementTypeShouldBeAligned(type)) {
      return alignObjectSize(headerSizeInBytes()) / VM.getVM().getHeapWordSize();
    }
    return headerSizeInBytes() / VM.getVM().getHeapWordSize();
  }
  
  private long lengthOffsetInBytes()
  {
    if (lengthOffsetInBytes != 0L) {
      return lengthOffsetInBytes;
    }
    if (VM.getVM().isCompressedOopsEnabled()) {
      lengthOffsetInBytes = typeSize - VM.getVM().getIntSize();
    } else {
      lengthOffsetInBytes = typeSize;
    }
    return lengthOffsetInBytes;
  }
  
  public long getLength()
  {
    boolean isUnsigned = true;
    return getHandle().getCIntegerAt(lengthOffsetInBytes(), VM.getVM().getIntSize(), isUnsigned);
  }
  
  public long getObjectSize()
  {
    ArrayKlass klass = (ArrayKlass)getKlass();
    
    long s = getLength() << klass.getLog2ElementSize();
    s += klass.getArrayHeaderInBytes();
    s = Oop.alignObjectSize(s);
    return s;
  }
  
  public static long baseOffsetInBytes(BasicType type)
  {
    return headerSize(type) * VM.getVM().getHeapWordSize();
  }
  
  public boolean isArray()
  {
    return true;
  }
  
  public void iterateFields(OopVisitor visitor, boolean doVMFields)
  {
    super.iterateFields(visitor, doVMFields);
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.oops.Array
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot.oops;

import java.util.Observable;
import java.util.Observer;
import sun.jvm.hotspot.runtime.VM;

final class ArrayKlass$1
  implements Observer
{
  public void update(Observable o, Object data)
  {
    ArrayKlass.access$000(VM.getVM().getTypeDataBase());
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.oops.ArrayKlass.1
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot.oops;

import java.io.PrintStream;
import java.util.Observable;
import java.util.Observer;
import sun.jvm.hotspot.debugger.OopHandle;
import sun.jvm.hotspot.memory.SymbolTable;
import sun.jvm.hotspot.memory.SystemDictionary;
import sun.jvm.hotspot.runtime.VM;
import sun.jvm.hotspot.types.Type;
import sun.jvm.hotspot.types.TypeDataBase;
import sun.jvm.hotspot.types.WrongTypeException;
import sun.jvm.hotspot.utilities.Bits;

public class ArrayKlass
  extends Klass
{
  private static CIntField dimension;
  private static OopField higherDimension;
  private static OopField lowerDimension;
  private static CIntField vtableLen;
  private static CIntField allocSize;
  private static OopField componentMirror;
  private static Symbol javaLangCloneableName;
  private static Symbol javaLangObjectName;
  private static Symbol javaIoSerializableName;
  
  static
  {
    VM.registerVMInitializedObserver(new Observer()
    {
      public void update(Observable o, Object data)
      {
        ArrayKlass.initialize(VM.getVM().getTypeDataBase());
      }
    });
  }
  
  private static synchronized void initialize(TypeDataBase db)
    throws WrongTypeException
  {
    Type type = db.lookupType("arrayKlass");
    dimension = new CIntField(type.getCIntegerField("_dimension"), Oop.getHeaderSize());
    higherDimension = new OopField(type.getOopField("_higher_dimension"), Oop.getHeaderSize());
    lowerDimension = new OopField(type.getOopField("_lower_dimension"), Oop.getHeaderSize());
    vtableLen = new CIntField(type.getCIntegerField("_vtable_len"), Oop.getHeaderSize());
    allocSize = new CIntField(type.getCIntegerField("_alloc_size"), Oop.getHeaderSize());
    componentMirror = new OopField(type.getOopField("_component_mirror"), Oop.getHeaderSize());
    javaLangCloneableName = null;
    javaLangObjectName = null;
    javaIoSerializableName = null;
  }
  
  ArrayKlass(OopHandle handle, ObjectHeap heap)
  {
    super(handle, heap);
  }
  
  public Klass getJavaSuper()
  {
    SystemDictionary sysDict = VM.getVM().getSystemDictionary();
    return SystemDictionary.getObjectKlass();
  }
  
  public long getDimension()
  {
    return dimension.getValue(this);
  }
  
  public Klass getHigherDimension()
  {
    return (Klass)higherDimension.getValue(this);
  }
  
  public Klass getLowerDimension()
  {
    return (Klass)lowerDimension.getValue(this);
  }
  
  public long getVtableLen()
  {
    return vtableLen.getValue(this);
  }
  
  public long getAllocSize()
  {
    return allocSize.getValue(this);
  }
  
  public Oop getComponentMirror()
  {
    return componentMirror.getValue(this);
  }
  
  private static Symbol javaLangCloneableName()
  {
    if (javaLangCloneableName == null) {
      javaLangCloneableName = VM.getVM().getSymbolTable().probe("java/lang/Cloneable");
    }
    return javaLangCloneableName;
  }
  
  private static Symbol javaLangObjectName()
  {
    if (javaLangObjectName == null) {
      javaLangObjectName = VM.getVM().getSymbolTable().probe("java/lang/Object");
    }
    return javaLangObjectName;
  }
  
  private static Symbol javaIoSerializableName()
  {
    if (javaIoSerializableName == null) {
      javaIoSerializableName = VM.getVM().getSymbolTable().probe("java/io/Serializable");
    }
    return javaIoSerializableName;
  }
  
  public int getClassStatus()
  {
    return 7;
  }
  
  public long computeModifierFlags()
  {
    return 1041L;
  }
  
  public long getArrayHeaderInBytes()
  {
    return Bits.maskBits(getLayoutHelper() >> LH_HEADER_SIZE_SHIFT, 255);
  }
  
  public int getLog2ElementSize()
  {
    return Bits.maskBits(getLayoutHelper() >> LH_LOG2_ELEMENT_SIZE_SHIFT, 255);
  }
  
  public int getElementType()
  {
    return Bits.maskBits(getLayoutHelper() >> LH_ELEMENT_TYPE_SHIFT, 255);
  }
  
  boolean computeSubtypeOf(Klass k)
  {
    Symbol name = k.getName();
    if ((name != null) && ((name.equals(javaIoSerializableName())) || (name.equals(javaLangCloneableName())) || (name.equals(javaLangObjectName())))) {
      return true;
    }
    return false;
  }
  
  public void printValueOn(PrintStream tty)
  {
    tty.print("ArrayKlass");
  }
  
  public long getObjectSize()
  {
    return alignObjectSize(InstanceKlass.getHeaderSize() + getVtableLen() * getHeap().getOopSize());
  }
  
  public void iterateFields(OopVisitor visitor, boolean doVMFields)
  {
    super.iterateFields(visitor, doVMFields);
    if (doVMFields)
    {
      visitor.doCInt(dimension, true);
      visitor.doOop(higherDimension, true);
      visitor.doOop(lowerDimension, true);
      visitor.doCInt(vtableLen, true);
      visitor.doCInt(allocSize, true);
      visitor.doOop(componentMirror, true);
    }
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.oops.ArrayKlass
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot.oops;

import java.util.Observable;
import java.util.Observer;
import sun.jvm.hotspot.runtime.VM;

final class ArrayKlassKlass$1
  implements Observer
{
  public void update(Observable o, Object data)
  {
    ArrayKlassKlass.access$000(VM.getVM().getTypeDataBase());
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.oops.ArrayKlassKlass.1
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot.oops;

import java.io.PrintStream;
import java.util.Observable;
import java.util.Observer;
import sun.jvm.hotspot.debugger.OopHandle;
import sun.jvm.hotspot.runtime.VM;
import sun.jvm.hotspot.types.Type;
import sun.jvm.hotspot.types.TypeDataBase;
import sun.jvm.hotspot.types.WrongTypeException;

public class ArrayKlassKlass
  extends KlassKlass
{
  private static long headerSize;
  
  static
  {
    VM.registerVMInitializedObserver(new Observer()
    {
      public void update(Observable o, Object data)
      {
        ArrayKlassKlass.initialize(VM.getVM().getTypeDataBase());
      }
    });
  }
  
  private static synchronized void initialize(TypeDataBase db)
    throws WrongTypeException
  {
    Type type = db.lookupType("arrayKlassKlass");
    headerSize = type.getSize() + Oop.getHeaderSize();
  }
  
  ArrayKlassKlass(OopHandle handle, ObjectHeap heap)
  {
    super(handle, heap);
  }
  
  public long getObjectSize()
  {
    return alignObjectSize(headerSize);
  }
  
  public void printValueOn(PrintStream tty)
  {
    tty.print("ArrayKlassKlass");
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.oops.ArrayKlassKlass
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot.oops;

import sun.jvm.hotspot.debugger.OopHandle;
import sun.jvm.hotspot.types.JBooleanField;

public class BooleanField
  extends Field
{
  public BooleanField(FieldIdentifier id, long offset, boolean isVMField)
  {
    super(id, offset, isVMField);
  }
  
  public BooleanField(JBooleanField vmField, long startOffset)
  {
    super(new NamedFieldIdentifier(vmField.getName()), vmField.getOffset() + startOffset, true);
  }
  
  public BooleanField(InstanceKlass holder, int fieldArrayIndex)
  {
    super(holder, fieldArrayIndex);
  }
  
  public boolean getValue(Oop obj)
  {
    return obj.getHandle().getJBooleanAt(getOffset());
  }
  
  public void setValue(Oop obj, boolean value)
    throws MutationException
  {}
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.oops.BooleanField
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot.oops;

import java.util.Observable;
import java.util.Observer;
import sun.jvm.hotspot.runtime.VM;

final class BreakpointInfo$1
  implements Observer
{
  public void update(Observable o, Object data)
  {
    BreakpointInfo.access$000(VM.getVM().getTypeDataBase());
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.oops.BreakpointInfo.1
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot.oops;

import java.util.Observable;
import java.util.Observer;
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.AddressField;
import sun.jvm.hotspot.types.CIntegerField;
import sun.jvm.hotspot.types.Type;
import sun.jvm.hotspot.types.TypeDataBase;
import sun.jvm.hotspot.types.WrongTypeException;

public class BreakpointInfo
  extends VMObject
{
  private static CIntegerField origBytecodeField;
  private static CIntegerField bciField;
  private static CIntegerField nameIndexField;
  private static CIntegerField signatureIndexField;
  private static AddressField nextField;
  
  static
  {
    VM.registerVMInitializedObserver(new Observer()
    {
      public void update(Observable o, Object data)
      {
        BreakpointInfo.initialize(VM.getVM().getTypeDataBase());
      }
    });
  }
  
  private static synchronized void initialize(TypeDataBase db)
    throws WrongTypeException
  {
    Type type = db.lookupType("BreakpointInfo");
    
    origBytecodeField = type.getCIntegerField("_orig_bytecode");
    bciField = type.getCIntegerField("_bci");
    nameIndexField = type.getCIntegerField("_name_index");
    signatureIndexField = type.getCIntegerField("_signature_index");
    nextField = type.getAddressField("_next");
  }
  
  public BreakpointInfo(Address addr)
  {
    super(addr);
  }
  
  public int getOrigBytecode()
  {
    return (int)origBytecodeField.getValue(addr);
  }
  
  public int getBCI()
  {
    return (int)bciField.getValue(addr);
  }
  
  public long getNameIndex()
  {
    return nameIndexField.getValue(addr);
  }
  
  public long getSignatureIndex()
  {
    return signatureIndexField.getValue(addr);
  }
  
  public BreakpointInfo getNext()
  {
    return (BreakpointInfo)VMObjectFactory.newObject(BreakpointInfo.class, nextField.getValue(addr));
  }
  
  public boolean match(Method m, int bci)
  {
    return (bci == getBCI()) && (match(m));
  }
  
  public boolean match(Method m)
  {
    return (getNameIndex() == m.getNameIndex()) && (getSignatureIndex() == m.getSignatureIndex());
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.oops.BreakpointInfo
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot.oops;

import sun.jvm.hotspot.debugger.OopHandle;
import sun.jvm.hotspot.types.JByteField;

public class ByteField
  extends Field
{
  public ByteField(FieldIdentifier id, long offset, boolean isVMField)
  {
    super(id, offset, isVMField);
  }
  
  public ByteField(JByteField vmField, long startOffset)
  {
    super(new NamedFieldIdentifier(vmField.getName()), vmField.getOffset() + startOffset, true);
  }
  
  public ByteField(InstanceKlass holder, int fieldArrayIndex)
  {
    super(holder, fieldArrayIndex);
  }
  
  public byte getValue(Oop obj)
  {
    return obj.getHandle().getJByteAt(getOffset());
  }
  
  public void setValue(Oop obj, char value)
    throws MutationException
  {}
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.oops.ByteField
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot.oops;

import java.io.PrintStream;
import sun.jvm.hotspot.utilities.Assert;
import sun.jvm.hotspot.utilities.Bits;

public class CellTypeState
{
  private int _state;
  private static final int info_mask = Bits.rightNBits(28);
  private static final int bits_mask = info_mask ^ 0xFFFFFFFF;
  private static final int uninit_bit = Bits.nthBit(31);
  private static final int ref_bit = Bits.nthBit(30);
  private static final int val_bit = Bits.nthBit(29);
  private static final int addr_bit = Bits.nthBit(28);
  private static final int live_bits_mask = bits_mask & (uninit_bit ^ 0xFFFFFFFF);
  private static final int top_info_bit = Bits.nthBit(27);
  private static final int not_bottom_info_bit = Bits.nthBit(26);
  private static final int info_data_mask = Bits.rightNBits(26);
  private static final int info_conflict = info_mask;
  private static final int ref_not_lock_bit = Bits.nthBit(25);
  private static final int ref_slot_bit = Bits.nthBit(24);
  private static final int ref_data_mask = Bits.rightNBits(24);
  private static final int bottom_value = 0;
  private static final int uninit_value = uninit_bit | info_conflict;
  private static final int ref_value = ref_bit;
  private static final int ref_conflict = ref_bit | info_conflict;
  private static final int val_value = val_bit | info_conflict;
  private static final int addr_value = addr_bit;
  private static final int addr_conflict = addr_bit | info_conflict;
  
  private CellTypeState() {}
  
  private CellTypeState(int state)
  {
    _state = state;
  }
  
  public CellTypeState copy()
  {
    return new CellTypeState(_state);
  }
  
  public static CellTypeState makeAny(int state)
  {
    CellTypeState s = new CellTypeState(state);
    if (Assert.ASSERTS_ENABLED) {
      Assert.that(s.isValidState(), "check to see if CellTypeState is valid");
    }
    return s;
  }
  
  public static CellTypeState makeBottom()
  {
    return makeAny(0);
  }
  
  public static CellTypeState makeTop()
  {
    return makeAny(-1);
  }
  
  public static CellTypeState makeAddr(int bci)
  {
    if (Assert.ASSERTS_ENABLED) {
      Assert.that((bci >= 0) && (bci < info_data_mask), "check to see if ret addr is valid");
    }
    return makeAny(addr_bit | not_bottom_info_bit | bci & info_data_mask);
  }
  
  public static CellTypeState makeSlotRef(int slot_num)
  {
    if (Assert.ASSERTS_ENABLED) {
      Assert.that((slot_num >= 0) && (slot_num < ref_data_mask), "slot out of range");
    }
    return makeAny(ref_bit | not_bottom_info_bit | ref_not_lock_bit | ref_slot_bit | slot_num & ref_data_mask);
  }
  
  public static CellTypeState makeLineRef(int bci)
  {
    if (Assert.ASSERTS_ENABLED) {
      Assert.that((bci >= 0) && (bci < ref_data_mask), "line out of range");
    }
    return makeAny(ref_bit | not_bottom_info_bit | ref_not_lock_bit | bci & ref_data_mask);
  }
  
  public static CellTypeState makeLockRef(int bci)
  {
    if (Assert.ASSERTS_ENABLED) {
      Assert.that((bci >= 0) && (bci < ref_data_mask), "line out of range");
    }
    return makeAny(ref_bit | not_bottom_info_bit | bci & ref_data_mask);
  }
  
  public boolean isBottom()
  {
    return _state == 0;
  }
  
  public boolean isLive()
  {
    return (_state & live_bits_mask) != 0;
  }
  
  public boolean isValidState()
  {
    if (((canBeUninit()) || (canBeValue())) && (!isInfoTop())) {
      return false;
    }
    if ((isInfoTop()) && ((_state & info_mask) != info_mask)) {
      return false;
    }
    if ((isInfoBottom()) && ((_state & info_mask) != 0)) {
      return false;
    }
    return true;
  }
  
  public boolean isAddress()
  {
    return (_state & bits_mask) == addr_bit;
  }
  
  public boolean isReference()
  {
    return (_state & bits_mask) == ref_bit;
  }
  
  public boolean isValue()
  {
    return (_state & bits_mask) == val_bit;
  }
  
  public boolean isUninit()
  {
    return (_state & bits_mask) == uninit_bit;
  }
  
  public boolean canBeAddress()
  {
    return (_state & addr_bit) != 0;
  }
  
  public boolean canBeReference()
  {
    return (_state & ref_bit) != 0;
  }
  
  public boolean canBeValue()
  {
    return (_state & val_bit) != 0;
  }
  
  public boolean canBeUninit()
  {
    return (_state & uninit_bit) != 0;
  }
  
  public boolean isInfoBottom()
  {
    return (_state & not_bottom_info_bit) == 0;
  }
  
  public boolean isInfoTop()
  {
    return (_state & top_info_bit) != 0;
  }
  
  public int getInfo()
  {
    if (Assert.ASSERTS_ENABLED) {
      Assert.that((!isInfoTop()) && (!isInfoBottom()), "check to make sure top/bottom info is not used");
    }
    return _state & info_data_mask;
  }
  
  public int getMonitorSource()
  {
    if (Assert.ASSERTS_ENABLED) {
      Assert.that(isLockReference(), "must be lock");
    }
    return getInfo();
  }
  
  public boolean isGoodAddress()
  {
    return (isAddress()) && (!isInfoTop());
  }
  
  public boolean isLockReference()
  {
    return (_state & (bits_mask | top_info_bit | ref_not_lock_bit)) == ref_bit;
  }
  
  public boolean isNonlockReference()
  {
    return (_state & (bits_mask | top_info_bit | ref_not_lock_bit)) == (ref_bit | ref_not_lock_bit);
  }
  
  public boolean equal(CellTypeState a)
  {
    return _state == _state;
  }
  
  public boolean equalKind(CellTypeState a)
  {
    return (_state & bits_mask) == (_state & bits_mask);
  }
  
  public char toChar()
  {
    if (canBeReference())
    {
      if ((canBeValue()) || (canBeAddress())) {
        return '#';
      }
      return 'r';
    }
    if (canBeValue()) {
      return 'v';
    }
    if (canBeAddress()) {
      return 'p';
    }
    if (canBeUninit()) {
      return ' ';
    }
    return '@';
  }
  
  public void set(CellTypeState cts)
  {
    _state = _state;
  }
  
  public CellTypeState merge(CellTypeState cts, int slot)
  {
    CellTypeState result = new CellTypeState();
    if (Assert.ASSERTS_ENABLED) {
      Assert.that((!isBottom()) && (!cts.isBottom()), "merge of bottom values is handled elsewhere");
    }
    _state |= _state;
    if (!result.isInfoTop())
    {
      Assert.that((result.canBeAddress()) || (result.canBeReference()), "only addresses and references have non-top info");
      if (!equal(cts)) {
        if (result.isReference()) {
          result = makeSlotRef(slot);
        } else {
          _state |= info_conflict;
        }
      }
    }
    if (Assert.ASSERTS_ENABLED) {
      Assert.that(result.isValidState(), "checking that CTS merge maintains legal state");
    }
    return result;
  }
  
  public void print(PrintStream tty)
  {
    if (canBeAddress()) {
      tty.print("(p");
    } else {
      tty.print("( ");
    }
    if (canBeReference()) {
      tty.print("r");
    } else {
      tty.print(" ");
    }
    if (canBeValue()) {
      tty.print("v");
    } else {
      tty.print(" ");
    }
    if (canBeUninit()) {
      tty.print("u|");
    } else {
      tty.print(" |");
    }
    if (isInfoTop())
    {
      tty.print("Top)");
    }
    else if (isInfoBottom())
    {
      tty.print("Bot)");
    }
    else if (isReference())
    {
      int info = getInfo();
      int data = info & ((ref_not_lock_bit | ref_slot_bit) ^ 0xFFFFFFFF);
      if ((info & ref_not_lock_bit) != 0)
      {
        if ((info & ref_slot_bit) != 0) {
          tty.print("slot" + data + ")");
        } else {
          tty.print("line" + data + ")");
        }
      }
      else {
        tty.print("lock" + data + ")");
      }
    }
    else
    {
      tty.print("" + getInfo() + ")");
    }
  }
  
  public static CellTypeState bottom = makeBottom();
  public static CellTypeState uninit = makeAny(uninit_value);
  public static CellTypeState ref = makeAny(ref_conflict);
  public static CellTypeState value = makeAny(val_value);
  public static CellTypeState refUninit = makeAny(ref_conflict | uninit_value);
  public static CellTypeState top = makeTop();
  public static CellTypeState addr = makeAny(addr_conflict);
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.oops.CellTypeState
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot.oops;

import java.util.ArrayList;
import java.util.List;

public class CellTypeStateList
{
  private List list;
  
  public CellTypeStateList(int size)
  {
    list = new ArrayList(size);
    for (int i = 0; i < size; i++) {
      list.add(i, CellTypeState.makeBottom());
    }
  }
  
  public int size()
  {
    return list.size();
  }
  
  public CellTypeState get(int i)
  {
    return (CellTypeState)list.get(i);
  }
  
  public CellTypeStateList subList(int fromIndex, int toIndex)
  {
    return new CellTypeStateList(list.subList(fromIndex, toIndex));
  }
  
  private CellTypeStateList(List list)
  {
    this.list = list;
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.oops.CellTypeStateList
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot.oops;

import sun.jvm.hotspot.debugger.OopHandle;
import sun.jvm.hotspot.types.JCharField;

public class CharField
  extends Field
{
  public CharField(FieldIdentifier id, long offset, boolean isVMField)
  {
    super(id, offset, isVMField);
  }
  
  public CharField(JCharField vmField, long startOffset)
  {
    super(new NamedFieldIdentifier(vmField.getName()), vmField.getOffset() + startOffset, true);
  }
  
  public CharField(InstanceKlass holder, int fieldArrayIndex)
  {
    super(holder, fieldArrayIndex);
  }
  
  public char getValue(Oop obj)
  {
    return obj.getHandle().getJCharAt(getOffset());
  }
  
  public void setValue(Oop obj, char value)
    throws MutationException
  {}
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.oops.CharField
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot.oops;

import java.util.Observable;
import java.util.Observer;
import sun.jvm.hotspot.runtime.VM;

final class CheckedExceptionElement$1
  implements Observer
{
  public void update(Observable o, Object data)
  {
    CheckedExceptionElement.access$000(VM.getVM().getTypeDataBase());
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.oops.CheckedExceptionElement.1
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot.oops;

import java.util.Observable;
import java.util.Observer;
import sun.jvm.hotspot.debugger.OopHandle;
import sun.jvm.hotspot.runtime.VM;
import sun.jvm.hotspot.types.CIntegerField;
import sun.jvm.hotspot.types.Type;
import sun.jvm.hotspot.types.TypeDataBase;
import sun.jvm.hotspot.types.WrongTypeException;

public class CheckedExceptionElement
{
  private static long offsetOfClassCPIndex;
  private OopHandle handle;
  private long offset;
  
  static
  {
    VM.registerVMInitializedObserver(new Observer()
    {
      public void update(Observable o, Object data)
      {
        CheckedExceptionElement.initialize(VM.getVM().getTypeDataBase());
      }
    });
  }
  
  private static synchronized void initialize(TypeDataBase db)
    throws WrongTypeException
  {
    Type type = db.lookupType("CheckedExceptionElement");
    offsetOfClassCPIndex = type.getCIntegerField("class_cp_index").getOffset();
  }
  
  public CheckedExceptionElement(OopHandle handle, long offset)
  {
    this.handle = handle;
    this.offset = offset;
  }
  
  public int getClassCPIndex()
  {
    return (int)handle.getCIntegerAt(offset + offsetOfClassCPIndex, 2L, true);
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.oops.CheckedExceptionElement
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot.oops;

import sun.jvm.hotspot.debugger.OopHandle;
import sun.jvm.hotspot.types.CIntegerField;
import sun.jvm.hotspot.types.CIntegerType;

public class CIntField
  extends Field
{
  private long size;
  private boolean isUnsigned;
  
  public CIntField(CIntegerField vmField, long startOffset)
  {
    super(new NamedFieldIdentifier(vmField.getName()), vmField.getOffset() + startOffset, true);
    size = vmField.getSize();
    isUnsigned = ((CIntegerType)vmField.getType()).isUnsigned();
  }
  
  public long getValue(Oop obj)
  {
    return obj.getHandle().getCIntegerAt(getOffset(), size, isUnsigned);
  }
  
  public void setValue(Oop obj, long value)
    throws MutationException
  {}
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.oops.CIntField
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot.oops;

import java.util.Observable;
import java.util.Observer;
import sun.jvm.hotspot.runtime.VM;

final class CompiledICHolder$1
  implements Observer
{
  public void update(Observable o, Object data)
  {
    CompiledICHolder.access$000(VM.getVM().getTypeDataBase());
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.oops.CompiledICHolder.1
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot.oops;

import java.io.PrintStream;
import java.util.Observable;
import java.util.Observer;
import sun.jvm.hotspot.debugger.OopHandle;
import sun.jvm.hotspot.runtime.VM;
import sun.jvm.hotspot.types.Type;
import sun.jvm.hotspot.types.TypeDataBase;
import sun.jvm.hotspot.types.WrongTypeException;

public class CompiledICHolder
  extends Oop
{
  private static long headerSize;
  private static OopField holderMethod;
  private static OopField holderKlass;
  
  static
  {
    VM.registerVMInitializedObserver(new Observer()
    {
      public void update(Observable o, Object data)
      {
        CompiledICHolder.initialize(VM.getVM().getTypeDataBase());
      }
    });
  }
  
  private static synchronized void initialize(TypeDataBase db)
    throws WrongTypeException
  {
    Type type = db.lookupType("compiledICHolderOopDesc");
    holderMethod = new OopField(type.getOopField("_holder_method"), 0L);
    holderKlass = new OopField(type.getOopField("_holder_klass"), 0L);
    headerSize = type.getSize();
  }
  
  CompiledICHolder(OopHandle handle, ObjectHeap heap)
  {
    super(handle, heap);
  }
  
  public boolean isCompiledICHolder()
  {
    return true;
  }
  
  public Method getHolderMethod()
  {
    return (Method)holderMethod.getValue(this);
  }
  
  public Klass getHolderKlass()
  {
    return (Klass)holderKlass.getValue(this);
  }
  
  public void printValueOn(PrintStream tty)
  {
    tty.print("CompiledICHolder");
  }
  
  public long getObjectSize()
  {
    return alignObjectSize(headerSize);
  }
  
  void iterateFields(OopVisitor visitor, boolean doVMFields)
  {
    super.iterateFields(visitor, doVMFields);
    if (doVMFields)
    {
      visitor.doOop(holderMethod, true);
      visitor.doOop(holderKlass, true);
    }
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.oops.CompiledICHolder
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot.oops;

import java.util.Observable;
import java.util.Observer;
import sun.jvm.hotspot.runtime.VM;

final class CompiledICHolderKlass$1
  implements Observer
{
  public void update(Observable o, Object data)
  {
    CompiledICHolderKlass.access$000(VM.getVM().getTypeDataBase());
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.oops.CompiledICHolderKlass.1
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot.oops;

import java.io.PrintStream;
import java.util.Observable;
import java.util.Observer;
import sun.jvm.hotspot.debugger.OopHandle;
import sun.jvm.hotspot.runtime.VM;
import sun.jvm.hotspot.types.Type;
import sun.jvm.hotspot.types.TypeDataBase;
import sun.jvm.hotspot.types.WrongTypeException;

public class CompiledICHolderKlass
  extends Klass
{
  private static long headerSize;
  
  static
  {
    VM.registerVMInitializedObserver(new Observer()
    {
      public void update(Observable o, Object data)
      {
        CompiledICHolderKlass.initialize(VM.getVM().getTypeDataBase());
      }
    });
  }
  
  private static synchronized void initialize(TypeDataBase db)
    throws WrongTypeException
  {
    Type type = db.lookupType("compiledICHolderKlass");
    headerSize = type.getSize() + Oop.getHeaderSize();
  }
  
  CompiledICHolderKlass(OopHandle handle, ObjectHeap heap)
  {
    super(handle, heap);
  }
  
  public long getObjectSize()
  {
    return alignObjectSize(headerSize);
  }
  
  public void printValueOn(PrintStream tty)
  {
    tty.print("CompilerICHolderKlass");
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.oops.CompiledICHolderKlass
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot.oops;

import sun.jvm.hotspot.code.CompressedReadStream;
import sun.jvm.hotspot.debugger.Address;

public class CompressedLineNumberReadStream
  extends CompressedReadStream
{
  private int bci;
  private int line;
  
  public CompressedLineNumberReadStream(Address buffer)
  {
    this(buffer, 0);
  }
  
  public CompressedLineNumberReadStream(Address buffer, int position)
  {
    super(buffer, position);
  }
  
  public boolean readPair()
  {
    int next = readByte() & 0xFF;
    if (next == 0) {
      return false;
    }
    if (next == 255)
    {
      bci += readSignedInt();
      line += readSignedInt();
    }
    else
    {
      bci += (next >> 3);
      line += (next & 0x7);
    }
    return true;
  }
  
  public int bci()
  {
    return bci;
  }
  
  public int line()
  {
    return line;
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.oops.CompressedLineNumberReadStream
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot.oops;

import java.util.Observable;
import java.util.Observer;
import sun.jvm.hotspot.runtime.VM;

final class ConstantPool$1
  implements Observer
{
  public void update(Observable o, Object data)
  {
    ConstantPool.access$000(VM.getVM().getTypeDataBase());
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.oops.ConstantPool.1
 * Java Class Version: 1.4 (48.0)
 * JD-Core Version:    0.7.1
 */
package sun.jvm.hotspot.oops;

import java.io.DataOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
import java.util.HashMap;
import java.util.Map;
import java.util.Observable;
import java.util.Observer;
import sun.jvm.hotspot.debugger.OopHandle;
import sun.jvm.hotspot.runtime.Bytes;
import sun.jvm.hotspot.runtime.ClassConstants;
import sun.jvm.hotspot.runtime.VM;
import sun.jvm.hotspot.types.Type;
import sun.jvm.hotspot.types.TypeDataBase;
import sun.jvm.hotspot.types.WrongTypeException;
import sun.jvm.hotspot.utilities.Assert;
import sun.jvm.hotspot.utilities.ConstantTag;

public class ConstantPool
  extends Oop
  implements ClassConstants
{
  private static final boolean DEBUG = false;
  private static OopField tags;
  private static OopField operands;
  private static OopField cache;
  private static OopField poolHolder;
  private static CIntField length;
  private static long headerSize;
  private static long elementSize;
  private static int INDY_BSM_OFFSET;
  private static int INDY_ARGC_OFFSET;
  private static int INDY_ARGV_OFFSET;
  
  protected void debugMessage(String message)
  {
    System.out.println(message);
  }
  
  static
  {
    VM.registerVMInitializedObserver(new Observer()
    {
      public void update(Observable o, Object data)
      {
        ConstantPool.initialize(VM.getVM().getTypeDataBase());
      }
    });
  }
  
  private static synchronized void initialize(TypeDataBase db)
    throws WrongT
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114

Further reading...

For more information on Java 1.5 Tiger, you may find Java 1.5 Tiger, A developer's Notebook by D. Flanagan and B. McLaughlin from O'Reilly of interest.

New!JAR listings


Copyright 2006-2019. Infinite Loop Ltd