sa-jdi

return alignObjectSize(headerSize);
  }
  
  public void printValueOn(PrintStream tty)
  {
    tty.print("KlassKlass");
  }
}

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

public class LineNumberTableElement
{
  private int start_bci;
  private int line_number;
  
  public LineNumberTableElement(int start_bci, int line_number)
  {
    this.start_bci = start_bci;
    this.line_number = line_number;
  }
  
  public int getStartBCI()
  {
    return start_bci;
  }
  
  public int getLineNumber()
  {
    return line_number;
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.oops.LineNumberTableElement
 * 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 LocalVariableTableElement$1
  implements Observer
{
  public void update(Observable o, Object data)
  {
    LocalVariableTableElement.access$000(VM.getVM().getTypeDataBase());
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.oops.LocalVariableTableElement.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 LocalVariableTableElement
{
  private static long offsetOfStartBCI;
  private static long offsetOfLength;
  private static long offsetOfNameCPIndex;
  private static long offsetOfDescriptorCPIndex;
  private static long offsetOfSignatureCPIndex;
  private static long offsetOfSlot;
  private OopHandle handle;
  private long offset;
  
  static
  {
    VM.registerVMInitializedObserver(new Observer()
    {
      public void update(Observable o, Object data)
      {
        LocalVariableTableElement.initialize(VM.getVM().getTypeDataBase());
      }
    });
  }
  
  private static synchronized void initialize(TypeDataBase db)
    throws WrongTypeException
  {
    Type type = db.lookupType("LocalVariableTableElement");
    offsetOfStartBCI = type.getCIntegerField("start_bci").getOffset();
    offsetOfLength = type.getCIntegerField("length").getOffset();
    offsetOfNameCPIndex = type.getCIntegerField("name_cp_index").getOffset();
    offsetOfDescriptorCPIndex = type.getCIntegerField("descriptor_cp_index").getOffset();
    offsetOfSignatureCPIndex = type.getCIntegerField("signature_cp_index").getOffset();
    offsetOfSlot = type.getCIntegerField("slot").getOffset();
  }
  
  public LocalVariableTableElement(OopHandle handle, long offset)
  {
    this.handle = handle;
    this.offset = offset;
  }
  
  public int getStartBCI()
  {
    return (int)handle.getCIntegerAt(offset + offsetOfStartBCI, 2L, true);
  }
  
  public int getLength()
  {
    return (int)handle.getCIntegerAt(offset + offsetOfLength, 2L, true);
  }
  
  public int getNameCPIndex()
  {
    return (int)handle.getCIntegerAt(offset + offsetOfNameCPIndex, 2L, true);
  }
  
  public int getDescriptorCPIndex()
  {
    return (int)handle.getCIntegerAt(offset + offsetOfDescriptorCPIndex, 2L, true);
  }
  
  public int getSignatureCPIndex()
  {
    return (int)handle.getCIntegerAt(offset + offsetOfSignatureCPIndex, 2L, true);
  }
  
  public int getSlot()
  {
    return (int)handle.getCIntegerAt(offset + offsetOfSlot, 2L, true);
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.oops.LocalVariableTableElement
 * 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.JLongField;

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

/* Location:
 * Qualified Name:     sun.jvm.hotspot.oops.LongField
 * 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 Mark$1
  implements Observer
{
  public void update(Observable o, Object data)
  {
    Mark.access$000(VM.getVM().getTypeDataBase());
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.oops.Mark.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.Address;
import sun.jvm.hotspot.runtime.BasicLock;
import sun.jvm.hotspot.runtime.JavaThread;
import sun.jvm.hotspot.runtime.ObjectMonitor;
import sun.jvm.hotspot.runtime.Threads;
import sun.jvm.hotspot.runtime.VM;
import sun.jvm.hotspot.runtime.VMObject;
import sun.jvm.hotspot.types.CIntegerField;
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.Bits;

public class Mark
  extends VMObject
{
  private static CIntegerField markField;
  private static long ageBits;
  private static long lockBits;
  private static long biasedLockBits;
  private static long maxHashBits;
  private static long hashBits;
  private static long lockShift;
  private static long biasedLockShift;
  private static long ageShift;
  private static long hashShift;
  private static long lockMask;
  private static long lockMaskInPlace;
  private static long biasedLockMask;
  private static long biasedLockMaskInPlace;
  private static long biasedLockBitInPlace;
  private static long ageMask;
  private static long ageMaskInPlace;
  private static long hashMask;
  private static long hashMaskInPlace;
  private static long biasedLockAlignment;
  private static long lockedValue;
  private static long unlockedValue;
  private static long monitorValue;
  private static long markedValue;
  private static long biasedLockPattern;
  private static long noHash;
  private static long noHashInPlace;
  private static long noLockInPlace;
  private static long maxAge;
  private static long cmsShift;
  private static long cmsMask;
  private static long sizeShift;
  
  static
  {
    VM.registerVMInitializedObserver(new Observer()
    {
      public void update(Observable o, Object data)
      {
        Mark.initialize(VM.getVM().getTypeDataBase());
      }
    });
  }
  
  private static synchronized void initialize(TypeDataBase db)
    throws WrongTypeException
  {
    Type type = db.lookupType("oopDesc");
    markField = type.getCIntegerField("_mark");
    
    ageBits = db.lookupLongConstant("markOopDesc::age_bits").longValue();
    lockBits = db.lookupLongConstant("markOopDesc::lock_bits").longValue();
    biasedLockBits = db.lookupLongConstant("markOopDesc::biased_lock_bits").longValue();
    maxHashBits = db.lookupLongConstant("markOopDesc::max_hash_bits").longValue();
    hashBits = db.lookupLongConstant("markOopDesc::hash_bits").longValue();
    lockShift = db.lookupLongConstant("markOopDesc::lock_shift").longValue();
    biasedLockShift = db.lookupLongConstant("markOopDesc::biased_lock_shift").longValue();
    ageShift = db.lookupLongConstant("markOopDesc::age_shift").longValue();
    hashShift = db.lookupLongConstant("markOopDesc::hash_shift").longValue();
    lockMask = db.lookupLongConstant("markOopDesc::lock_mask").longValue();
    lockMaskInPlace = db.lookupLongConstant("markOopDesc::lock_mask_in_place").longValue();
    biasedLockMask = db.lookupLongConstant("markOopDesc::biased_lock_mask").longValue();
    biasedLockMaskInPlace = db.lookupLongConstant("markOopDesc::biased_lock_mask_in_place").longValue();
    biasedLockBitInPlace = db.lookupLongConstant("markOopDesc::biased_lock_bit_in_place").longValue();
    ageMask = db.lookupLongConstant("markOopDesc::age_mask").longValue();
    ageMaskInPlace = db.lookupLongConstant("markOopDesc::age_mask_in_place").longValue();
    hashMask = db.lookupLongConstant("markOopDesc::hash_mask").longValue();
    hashMaskInPlace = db.lookupLongConstant("markOopDesc::hash_mask_in_place").longValue();
    biasedLockAlignment = db.lookupLongConstant("markOopDesc::biased_lock_alignment").longValue();
    lockedValue = db.lookupLongConstant("markOopDesc::locked_value").longValue();
    unlockedValue = db.lookupLongConstant("markOopDesc::unlocked_value").longValue();
    monitorValue = db.lookupLongConstant("markOopDesc::monitor_value").longValue();
    markedValue = db.lookupLongConstant("markOopDesc::marked_value").longValue();
    biasedLockPattern = db.lookupLongConstant("markOopDesc::biased_lock_pattern").longValue();
    noHash = db.lookupLongConstant("markOopDesc::no_hash").longValue();
    noHashInPlace = db.lookupLongConstant("markOopDesc::no_hash_in_place").longValue();
    noLockInPlace = db.lookupLongConstant("markOopDesc::no_lock_in_place").longValue();
    maxAge = db.lookupLongConstant("markOopDesc::max_age").longValue();
    
    cmsShift = db.lookupLongConstant("markOopDesc::cms_shift").longValue();
    cmsMask = db.lookupLongConstant("markOopDesc::cms_mask").longValue();
    sizeShift = db.lookupLongConstant("markOopDesc::size_shift").longValue();
  }
  
  public Mark(Address addr)
  {
    super(addr);
  }
  
  public long value()
  {
    return markField.getValue(addr);
  }
  
  public Address valueAsAddress()
  {
    return addr.getAddressAt(markField.getOffset());
  }
  
  public boolean hasBiasPattern()
  {
    return Bits.maskBitsLong(value(), biasedLockMaskInPlace) == biasedLockPattern;
  }
  
  public JavaThread biasedLocker()
  {
    Threads threads = VM.getVM().getThreads();
    Address addr = valueAsAddress().andWithMask(biasedLockMaskInPlace & ageMaskInPlace ^ 0xFFFFFFFFFFFFFFFF);
    return threads.createJavaThreadWrapper(addr);
  }
  
  public boolean isBiasedAnonymously()
  {
    return (hasBiasPattern()) && (biasedLocker() == null);
  }
  
  public boolean isLocked()
  {
    return Bits.maskBitsLong(value(), lockMaskInPlace) != unlockedValue;
  }
  
  public boolean isUnlocked()
  {
    return Bits.maskBitsLong(value(), biasedLockMaskInPlace) == unlockedValue;
  }
  
  public boolean isMarked()
  {
    return Bits.maskBitsLong(value(), lockMaskInPlace) == markedValue;
  }
  
  public boolean isBeingInflated()
  {
    return value() == 0L;
  }
  
  public boolean mustBePreserved()
  {
    return (!isUnlocked()) || (!hasNoHash());
  }
  
  public boolean hasLocker()
  {
    return (value() & lockMaskInPlace) == lockedValue;
  }
  
  public BasicLock locker()
  {
    if (Assert.ASSERTS_ENABLED) {
      Assert.that(hasLocker(), "check");
    }
    return new BasicLock(valueAsAddress());
  }
  
  public boolean hasMonitor()
  {
    return (value() & monitorValue) != 0L;
  }
  
  public ObjectMonitor monitor()
  {
    if (Assert.ASSERTS_ENABLED) {
      Assert.that(hasMonitor(), "check");
    }
    Address monAddr = valueAsAddress().xorWithMask(monitorValue);
    return new ObjectMonitor(monAddr);
  }
  
  public boolean hasDisplacedMarkHelper()
  {
    return (value() & unlockedValue) == 0L;
  }
  
  public Mark displacedMarkHelper()
  {
    if (Assert.ASSERTS_ENABLED) {
      Assert.that(hasDisplacedMarkHelper(), "check");
    }
    Address addr = valueAsAddress().andWithMask(monitorValue ^ 0xFFFFFFFFFFFFFFFF);
    return new Mark(addr.getAddressAt(0L));
  }
  
  public int age()
  {
    return (int)Bits.maskBitsLong(value() >> (int)ageShift, ageMask);
  }
  
  public long hash()
  {
    return Bits.maskBitsLong(value() >> (int)hashShift, hashMask);
  }
  
  public boolean hasNoHash()
  {
    return hash() == noHash;
  }
  
  public void printOn(PrintStream tty)
  {
    if (isLocked())
    {
      tty.print("locked(0x" + Long.toHexString(value()) + ")->");
      
      displacedMarkHelper().printOn(tty);
    }
    else
    {
      if (Assert.ASSERTS_ENABLED) {
        Assert.that(isUnlocked(), "just checking");
      }
      tty.print("mark(");
      tty.print("hash " + Long.toHexString(hash()) + ",");
      tty.print("age " + age() + ")");
    }
  }
  
  public boolean isCmsFreeChunk()
  {
    return (isUnlocked()) && ((Bits.maskBitsLong(value() >> (int)cmsShift, cmsMask) & 1L) == 1L);
  }
  
  public long getSize()
  {
    return value() >> (int)sizeShift;
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.oops.Mark
 * 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 Method$1
  implements Observer
{
  public void update(Observable o, Object data)
  {
    Method.access$000(VM.getVM().getTypeDataBase());
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.oops.Method.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.code.NMethod;
import sun.jvm.hotspot.debugger.Address;
import sun.jvm.hotspot.debugger.OopHandle;
import sun.jvm.hotspot.interpreter.OopMapCacheEntry;
import sun.jvm.hotspot.memory.SymbolTable;
import sun.jvm.hotspot.runtime.SignatureConverter;
import sun.jvm.hotspot.runtime.VM;
import sun.jvm.hotspot.runtime.VMObjectFactory;
import sun.jvm.hotspot.types.AddressField;
import sun.jvm.hotspot.types.Type;
import sun.jvm.hotspot.types.TypeDataBase;
import sun.jvm.hotspot.types.WrongTypeException;
import sun.jvm.hotspot.utilities.Assert;

public class Method
  extends Oop
{
  private static OopField constMethod;
  private static OopField constants;
  private static CIntField methodSize;
  private static CIntField maxStack;
  private static CIntField maxLocals;
  private static CIntField sizeOfParameters;
  private static CIntField accessFlags;
  private static CIntField vtableIndex;
  private static CIntField invocationCounter;
  private static long bytecodeOffset;
  private static AddressField code;
  private static Symbol objectInitializerName;
  private static Symbol classInitializerName;
  
  static
  {
    VM.registerVMInitializedObserver(new Observer()
    {
      public void update(Observable o, Object data)
      {
        Method.initialize(VM.getVM().getTypeDataBase());
      }
    });
  }
  
  private static synchronized void initialize(TypeDataBase db)
    throws WrongTypeException
  {
    Type type = db.lookupType("methodOopDesc");
    constMethod = new OopField(type.getOopField("_constMethod"), 0L);
    constants = new OopField(type.getOopField("_constants"), 0L);
    methodSize = new CIntField(type.getCIntegerField("_method_size"), 0L);
    maxStack = new CIntField(type.getCIntegerField("_max_stack"), 0L);
    maxLocals = new CIntField(type.getCIntegerField("_max_locals"), 0L);
    sizeOfParameters = new CIntField(type.getCIntegerField("_size_of_parameters"), 0L);
    accessFlags = new CIntField(type.getCIntegerField("_access_flags"), 0L);
    code = type.getAddressField("_code");
    vtableIndex = new CIntField(type.getCIntegerField("_vtable_index"), 0L);
    if (!VM.getVM().isCore()) {
      invocationCounter = new CIntField(type.getCIntegerField("_invocation_counter"), 0L);
    }
    bytecodeOffset = type.getSize();
    
    objectInitializerName = null;
    classInitializerName = null;
  }
  
  Method(OopHandle handle, ObjectHeap heap)
  {
    super(handle, heap);
  }
  
  public boolean isMethod()
  {
    return true;
  }
  
  private static Symbol objectInitializerName()
  {
    if (objectInitializerName == null) {
      objectInitializerName = VM.getVM().getSymbolTable().probe("<init>");
    }
    return objectInitializerName;
  }
  
  private static Symbol classInitializerName()
  {
    if (classInitializerName == null) {
      classInitializerName = VM.getVM().getSymbolTable().probe("<clinit>");
    }
    return classInitializerName;
  }
  
  public ConstMethod getConstMethod()
  {
    return (ConstMethod)constMethod.getValue(this);
  }
  
  public ConstantPool getConstants()
  {
    return (ConstantPool)constants.getValue(this);
  }
  
  public TypeArray getExceptionTable()
  {
    return getConstMethod().getExceptionTable();
  }
  
  public long getMethodSize()
  {
    return methodSize.getValue(this);
  }
  
  public long getMaxStack()
  {
    return maxStack.getValue(this);
  }
  
  public long getMaxLocals()
  {
    return maxLocals.getValue(this);
  }
  
  public long getSizeOfParameters()
  {
    return sizeOfParameters.getValue(this);
  }
  
  public long getNameIndex()
  {
    return getConstMethod().getNameIndex();
  }
  
  public long getSignatureIndex()
  {
    return getConstMethod().getSignatureIndex();
  }
  
  public long getGenericSignatureIndex()
  {
    return getConstMethod().getGenericSignatureIndex();
  }
  
  public long getAccessFlags()
  {
    return accessFlags.getValue(this);
  }
  
  public long getCodeSize()
  {
    return getConstMethod().getCodeSize();
  }
  
  public long getVtableIndex()
  {
    return vtableIndex.getValue(this);
  }
  
  public long getInvocationCounter()
  {
    if (Assert.ASSERTS_ENABLED) {
      Assert.that(!VM.getVM().isCore(), "must not be used in core build");
    }
    return invocationCounter.getValue(this);
  }
  
  public NMethod getNativeMethod()
  {
    Address addr = code.getValue(getHandle());
    return (NMethod)VMObjectFactory.newObject(NMethod.class, addr);
  }
  
  public AccessFlags getAccessFlagsObj()
  {
    return new AccessFlags(getAccessFlags());
  }
  
  public int getBytecodeOrBPAt(int bci)
  {
    return getConstMethod().getBytecodeOrBPAt(bci);
  }
  
  public int getOrigBytecodeAt(int bci)
  {
    for (BreakpointInfo bp = ((InstanceKlass)getMethodHolder()).getBreakpoints(); bp != null; bp = bp.getNext()) {
      if (bp.match(this, bci)) {
        return bp.getOrigBytecode();
      }
    }
    System.err.println("Requested bci " + bci);
    for (; bp != null; bp = bp.getNext()) {
      System.err.println("Breakpoint at bci " + bp.getBCI() + ", bytecode " + bp.getOrigBytecode());
    }
    Assert.that(false, "Should not reach here");
    return -1;
  }
  
  public byte getBytecodeByteArg(int bci)
  {
    return getConstMethod().getBytecodeByteArg(bci);
  }
  
  public short getBytecodeShortArg(int bci)
  {
    return getConstMethod().getBytecodeShortArg(bci);
  }
  
  public int getBytecodeIntArg(int bci)
  {
    return getConstMethod().getBytecodeIntArg(bci);
  }
  
  public byte[] getByteCode()
  {
    return getConstMethod().getByteCode();
  }
  
  public Symbol getName()
  {
    return (Symbol)getConstants().getObjAt(getNameIndex());
  }
  
  public Symbol getSignature()
  {
    return (Symbol)getConstants().getObjAt(getSignatureIndex());
  }
  
  public Symbol getGenericSignature()
  {
    long index = getGenericSignatureIndex();
    return index != 0L ? (Symbol)getConstants().getObjAt(index) : null;
  }
  
  public Klass getMethodHolder()
  {
    return getConstants().getPoolHolder();
  }
  
  public boolean isPublic()
  {
    return getAccessFlagsObj().isPublic();
  }
  
  public boolean isPrivate()
  {
    return getAccessFlagsObj().isPrivate();
  }
  
  public boolean isProtected()
  {
    return getAccessFlagsObj().isProtected();
  }
  
  public boolean isPackagePrivate()
  {
    AccessFlags af = getAccessFlagsObj();
    return (!af.isPublic()) && (!af.isPrivate()) && (!af.isProtected());
  }
  
  public boolean isStatic()
  {
    return getAccessFlagsObj().isStatic();
  }
  
  public boolean isFinal()
  {
    return getAccessFlagsObj().isFinal();
  }
  
  public boolean isSynchronized()
  {
    return getAccessFlagsObj().isSynchronized();
  }
  
  public boolean isBridge()
  {
    return getAccessFlagsObj().isBridge();
  }
  
  public boolean isVarArgs()
  {
    return getAccessFlagsObj().isVarArgs();
  }
  
  public boolean isNative()
  {
    return getAccessFlagsObj().isNative();
  }
  
  public boolean isAbstract()
  {
    return getAccessFlagsObj().isAbstract();
  }
  
  public boolean isStrict()
  {
    return getAccessFlagsObj().isStrict();
  }
  
  public boolean isSynthetic()
  {
    return getAccessFlagsObj().isSynthetic();
  }
  
  public boolean isConstructor()
  {
    return (!isStatic()) && (getName().equals(objectInitializerName()));
  }
  
  public boolean isStaticInitializer()
  {
    return (isStatic()) && (getName().equals(classInitializerName()));
  }
  
  public boolean isObsolete()
  {
    return getAccessFlagsObj().isObsolete();
  }
  
  public OopMapCacheEntry getMaskFor(int bci)
  {
    OopMapCacheEntry entry = new OopMapCacheEntry();
    entry.fill(this, bci);
    return entry;
  }
  
  public long getObjectSize()
  {
    return getMethodSize() * getHeap().getOopSize();
  }
  
  public void printValueOn(PrintStream tty)
  {
    tty.print("Method " + getName().asString() + getSignature().asString() + "@" + getHandle());
  }
  
  public void iterateFields(OopVisitor visitor, boolean doVMFields)
  {
    super.iterateFields(visitor, doVMFields);
    if (doVMFields)
    {
      visitor.doOop(constMethod, true);
      visitor.doOop(constants, true);
      visitor.doCInt(methodSize, true);
      visitor.doCInt(maxStack, true);
      visitor.doCInt(maxLocals, true);
      visitor.doCInt(sizeOfParameters, true);
      visitor.doCInt(accessFlags, true);
    }
  }
  
  public boolean hasLineNumberTable()
  {
    return getConstMethod().hasLineNumberTable();
  }
  
  public int getLineNumberFromBCI(int bci)
  {
    return getConstMethod().getLineNumberFromBCI(bci);
  }
  
  public LineNumberTableElement[] getLineNumberTable()
  {
    return getConstMethod().getLineNumberTable();
  }
  
  public boolean hasLocalVariableTable()
  {
    return getConstMethod().hasLocalVariableTable();
  }
  
  public LocalVariableTableElement[] getLocalVariableTable()
  {
    return getConstMethod().getLocalVariableTable();
  }
  
  public Symbol getLocalVariableName(int bci, int slot)
  {
    if (!hasLocalVariableTable()) {
      return null;
    }
    LocalVariableTableElement[] locals = getLocalVariableTable();
    for (int l = 0; l < locals.length; l++)
    {
      LocalVariableTableElement local = locals[l];
      if ((bci >= local.getStartBCI()) && (bci < local.getStartBCI() + local.getLength()) && (slot == local.getSlot())) {
        return getConstants().getSymbolAt(local.getNameCPIndex());
      }
    }
    return null;
  }
  
  public boolean hasCheckedExceptions()
  {
    return getConstMethod().hasCheckedExceptions();
  }
  
  public CheckedExceptionElement[] getCheckedExceptions()
  {
    return getConstMethod().getCheckedExceptions();
  }
  
  public String externalNameAndSignature()
  {
    StringBuffer buf = new StringBuffer();
    buf.append(getMethodHolder().getName().asString());
    buf.append(".");
    buf.append(getName().asString());
    buf.append("(");
    new SignatureConverter(getSignature(), buf).iterateParameters();
    buf.append(")");
    return buf.toString().replace('/', '.');
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.oops.Method
 * 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 MethodData$1
  implements Observer
{
  public void update(Observable o, Object data)
  {
    MethodData.access$000(VM.getVM().getTypeDataBase());
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.oops.MethodData.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 MethodData
  extends Oop
{
  private static long baseOffset;
  private static CIntField size;
  private static OopField method;
  
  static
  {
    VM.registerVMInitializedObserver(new Observer()
    {
      public void update(Observable o, Object data)
      {
        MethodData.initialize(VM.getVM().getTypeDataBase());
      }
    });
  }
  
  private static synchronized void initialize(TypeDataBase db)
    throws WrongTypeException
  {
    Type type = db.lookupType("methodDataOopDesc");
    baseOffset = type.getSize();
    
    size = new CIntField(type.getCIntegerField("_size"), 0L);
    method = new OopField(type.getOopField("_method"), 0L);
  }
  
  MethodData(OopHandle handle, ObjectHeap heap)
  {
    super(handle, heap);
  }
  
  public boolean isMethodData()
  {
    return true;
  }
  
  public long getObjectSize()
  {
    return alignObjectSize(size.getValue(this));
  }
  
  public Method getMethod()
  {
    return (Method)method.getValue(this);
  }
  
  public void printValueOn(PrintStream tty)
  {
    Method m = getMethod();
    tty.print("MethodData for " + m.getName().asString() + m.getSignature().asString());
  }
  
  public void iterateFields(OopVisitor visitor, boolean doVMFields)
  {
    super.iterateFields(visitor, doVMFields);
    if (doVMFields)
    {
      visitor.doOop(method, true);
      visitor.doCInt(size, true);
    }
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.oops.MethodData
 * 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 MethodDataKlass$1
  implements Observer
{
  public void update(Observable o, Object data)
  {
    MethodDataKlass.access$000(VM.getVM().getTypeDataBase());
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.oops.MethodDataKlass.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 MethodDataKlass
  extends Klass
{
  private static long headerSize;
  
  static
  {
    VM.registerVMInitializedObserver(new Observer()
    {
      public void update(Observable o, Object data)
      {
        MethodDataKlass.initialize(VM.getVM().getTypeDataBase());
      }
    });
  }
  
  private static synchronized void initialize(TypeDataBase db)
    throws WrongTypeException
  {
    Type type = db.lookupType("methodDataKlass");
    headerSize = type.getSize() + Oop.getHeaderSize();
  }
  
  MethodDataKlass(OopHandle handle, ObjectHeap heap)
  {
    super(handle, heap);
  }
  
  public long getObjectSize()
  {
    return alignObjectSize(headerSize);
  }
  
  public void printValueOn(PrintStream tty)
  {
    tty.print("MethodDataKlass");
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.oops.MethodDataKlass
 * 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 MethodKlass$1
  implements Observer
{
  public void update(Observable o, Object data)
  {
    MethodKlass.access$000(VM.getVM().getTypeDataBase());
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.oops.MethodKlass.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 MethodKlass
  extends Klass
{
  private static long headerSize;
  
  static
  {
    VM.registerVMInitializedObserver(new Observer()
    {
      public void update(Observable o, Object data)
      {
        MethodKlass.initialize(VM.getVM().getTypeDataBase());
      }
    });
  }
  
  private static synchronized void initialize(TypeDataBase db)
    throws WrongTypeException
  {
    Type type = db.lookupType("methodKlass");
    headerSize = type.getSize() + Oop.getHeaderSize();
  }
  
  MethodKlass(OopHandle handle, ObjectHeap heap)
  {
    super(handle, heap);
  }
  
  public long getObjectSize()
  {
    return alignObjectSize(headerSize);
  }
  
  public void printValueOn(PrintStream tty)
  {
    tty.print("MethodKlass");
  }
}

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

public class MutationException
  extends RuntimeException
{
  public MutationException() {}
  
  public MutationException(String detail)
  {
    super(detail);
  }
}

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

import java.io.PrintStream;

public class NamedFieldIdentifier
  extends FieldIdentifier
{
  private String name;
  
  public NamedFieldIdentifier(String name)
  {
    this.name = name;
  }
  
  public String getName()
  {
    return name;
  }
  
  public void printOn(PrintStream tty)
  {
    tty.print(" - " + getName() + ":\t");
  }
  
  public boolean equals(Object obj)
  {
    if (obj == null) {
      return false;
    }
    if (!(obj instanceof NamedFieldIdentifier)) {
      return false;
    }
    return ((NamedFieldIdentifier)obj).getName().equals(name);
  }
  
  public int hashCode()
  {
    return name.hashCode();
  }
}

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

import sun.jvm.hotspot.debugger.OopHandle;

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));
  }
  
  public OopHandle getValueAsOopHandle(Oop obj)
  {
    return obj.getHandle().getCompOopHandleAt(getOffset());
  }
  
  public void setValue(Oop obj)
    throws MutationException
  {}
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.oops.NarrowOopField
 * 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 ObjArray$1
  implements Observer
{
  public void update(Observable o, Object data)
  {
    ObjArray.access$000(VM.getVM().getTypeDataBase());
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.oops.ObjArray.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.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 ObjArray
  extends Array
{
  private static long elementSize;
  
  static
  {
    VM.registerVMInitializedObserver(new Observer()
    {
      public void update(Observable o, Object data)
      {
        ObjArray.initialize(VM.getVM().getTypeDataBase());
      }
    });
  }
  
  private static synchronized void initialize(TypeDataBase db)
    throws WrongTypeException
  {
    Type type = db.lookupType("objArrayOopDesc");
    elementSize = VM.getVM().getHeapOopSize();
  }
  
  ObjArray(OopHandle handle, ObjectHeap heap)
  {
    super(handle, heap);
  }
  
  public boolean isObjArray()
  {
    return true;
  }
  
  public OopHandle getOopHandleAt(long index)
  {
    long offset = baseOffsetInBytes(BasicType.T_OBJECT) + index * elementSize;
    if (VM.getVM().isCompressedOopsEnabled()) {
      return getHandle().getCompOopHandleAt(offset);
    }
    return getHandle().getOopHandleAt(offset);
  }
  
  public Oop getObjAt(long index)
  {
    return getHeap().newOop(getOopHandleAt(index));
  }
  
  public void printValueOn(PrintStream tty)
  {
    tty.print("ObjArray");
  }
  
  public void iterateFields(OopVisitor visitor, boolean doVMFields)
  {
    super.iterateFields(visitor, doVMFields);
    int length = (int)getLength();
    long baseOffset = baseOffsetInBytes(BasicType.T_OBJECT);
    for (int index = 0; index < length; index++)
    {
      long offset = baseOffset + index * elementSize;
      OopField field;
      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);
    }
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.oops.ObjArray
 * 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 ObjArrayKlass$1
  implements Observer
{
  public void update(Observable o, Object data)
  {
    ObjArrayKlass.access$000(VM.getVM().getTypeDataBase());
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.oops.ObjArrayKlass.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;
import sun.jvm.hotspot.utilities.Assert;

public class ObjArrayKlass
  extends ArrayKlass
{
  private static OopField elementKlass;
  private static OopField bottomKlass;
  
  static
  {
    VM.registerVMInitializedObserver(new Observer()
    {
      public void update(Observable o, Object data)
      {
        ObjArrayKlass.initialize(VM.getVM().getTypeDataBase());
      }
    });
  }
  
  private static synchronized void initialize(TypeDataBase db)
    throws WrongTypeException
  {
    Type type = db.lookupType("objArrayKlass");
    elementKlass = new OopField(type.getOopField("_element_klass"), Oop.getHeaderSize());
    bottomKlass = new OopField(type.getOopField("_bottom_klass"), Oop.getHeaderSize());
  }
  
  ObjArrayKlass(OopHandle handle, ObjectHeap heap)
  {
    super(handle, heap);
  }
  
  public Klass getElementKlass()
  {
    return (Klass)elementKlass.getValue(this);
  }
  
  public Klass getBottomKlass()
  {
    return (Klass)bottomKlass.getValue(this);
  }
  
  public long computeModifierFlags()
  {
    long elementFlags = getElementKlass().computeModifierFlags();
    long arrayFlags = 0L;
    if ((elementFlags & 0x5) != 0L) {
      arrayFlags = 1041L;
    } else {
      arrayFlags = 1040L;
    }
    return arrayFlags;
  }
  
  public void iterateFields(OopVisitor visitor, boolean doVMFields)
  {
    super.iterateFields(visitor, doVMFields);
    if (doVMFields)
    {
      visitor.doOop(elementKlass, true);
      visitor.doOop(bottomKlass, true);
    }
  }
  
  public Klass arrayKlassImpl(boolean orNull, int n)
  {
    if (Assert.ASSERTS_ENABLED) {
      Assert.that(getDimension() <= n, "check order of chain");
    }
    int dimension = (int)getDimension();
    if (dimension == n) {
      return this;
    }
    ObjArrayKlass ak = (ObjArrayKlass)getHigherDimension();
    if (ak == null)
    {
      if (orNull) {
        return null;
      }
      throw new RuntimeException("Can not allocate array klasses in debugging system");
    }
    if (orNull) {
      return ak.arrayKlassOrNull(n);
    }
    return ak.arrayKlass(n);
  }
  
  public Klass arrayKlassImpl(boolean orNull)
  {
    return arrayKlassImpl(orNull, (int)(getDimension() + 1L));
  }
  
  public void printValueOn(PrintStream tty)
  {
    tty.print("ObjArrayKlass for ");
    getElementKlass().printValueOn(tty);
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.oops.ObjArrayKlass
 * 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 ObjArrayKlassKlass$1
  implements Observer
{
  public void update(Observable o, Object data)
  {
    ObjArrayKlassKlass.access$000(VM.getVM().getTypeDataBase());
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.oops.ObjArrayKlassKlass.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 ObjArrayKlassKlass
  extends ArrayKlassKlass
{
  private static long headerSize;
  
  static
  {
    VM.registerVMInitializedObserver(new Observer()
    {
      public void update(Observable o, Object data)
      {
        ObjArrayKlassKlass.initialize(VM.getVM().getTypeDataBase());
      }
    });
  }
  
  private static synchronized void initialize(TypeDataBase db)
    throws WrongTypeException
  {
    Type type = db.lookupType("objArrayKlassKlass");
    headerSize = type.getSize() + Oop.getHeaderSize();
  }
  
  ObjArrayKlassKlass(OopHandle handle, ObjectHeap heap)
  {
    super(handle, heap);
  }
  
  public long getObjectSize()
  {
    return alignObjectSize(headerSize);
  }
  
  public void printValueOn(PrintStream tty)
  {
    tty.print("ObjArrayKlassKlass");
  }
}

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

final class ObjectHeap$1
  implements ObjectHeap.ObjectFilter
{
  private final ObjectHeap this$0;
  
  ObjectHeap$1(ObjectHeap paramObjectHeap, Klass paramKlass) {}
  
  public boolean canInclude(Oop obj)
  {
    Klass tk = obj.getKlass();
    
    return (tk != null) && (tk.equals(val$k));
  }
}

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

final class ObjectHeap$2
  implements ObjectHeap.ObjectFilter
{
  private final ObjectHeap this$0;
  
  ObjectHeap$2(ObjectHeap paramObjectHeap, Klass paramKlass) {}
  
  public boolean canInclude(Oop obj)
  {
    Klass tk = obj.getKlass();
    
    return (tk != null) && (tk.isSubtypeOf(val$k));
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.oops.ObjectHeap.2
 * Java Class Vers
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