sa-jdi

tCharAt(index, 'l');
        } else {
          newName.setCharAt(index, 'w');
        }
        index++;
      }
    }
    return newName.toString();
  }
  
  private Operand getOperand(byte[] bytesArray, int addrMode, int operandType, boolean operandSize, boolean addrSize)
  {
    Operand op = null;
    switch (addrMode)
    {
    case 1: 
    case 19: 
    case 20: 
      X86SegmentRegister segReg = getSegmentRegisterFromPrefix(prefixes);
      if (mod == 3)
      {
        if (addrMode == 1) {
          switch (operandType)
          {
          case 1: 
            op = X86Registers.getRegister8(rm);
            break;
          case 3: 
            op = X86Registers.getRegister16(rm);
            break;
          case 2: 
            if (operandSize == true) {
              op = X86Registers.getRegister32(rm);
            } else {
              op = X86Registers.getRegister16(rm);
            }
            break;
          case 5: 
            X86Register reg;
            X86Register reg;
            if (operandSize == true) {
              reg = X86Registers.getRegister32(rm);
            } else {
              reg = X86Registers.getRegister16(rm);
            }
            op = new X86RegisterIndirectAddress(segReg, reg, null, 0L);
            break;
          }
        } else if (addrMode == 19) {
          op = X86XMMRegisters.getRegister(rm);
        } else if (addrMode == 20) {
          op = X86MMXRegisters.getRegister(rm);
        }
      }
      else
      {
        int scale = 0;
        int index = 0;
        int base = 0;
        long disp = 0L;
        if (rm == 4)
        {
          int sib = readByte(bytesArray, byteIndex);
          byteIndex += 1;
          scale = sib >> 6 & 0x3;
          index = sib >> 3 & 0x7;
          base = sib & 0x7;
        }
        switch (mod)
        {
        case 0: 
          switch (rm)
          {
          case 4: 
            if (base == 5)
            {
              disp = readInt32(bytesArray, byteIndex);
              byteIndex += 4;
              if (index != 4) {
                op = new X86RegisterIndirectAddress(segReg, null, X86Registers.getRegister32(index), disp, scale);
              } else {
                op = new X86RegisterIndirectAddress(segReg, null, null, disp, scale);
              }
            }
            else if (index != 4)
            {
              op = new X86RegisterIndirectAddress(segReg, X86Registers.getRegister32(base), X86Registers.getRegister32(index), 0L, scale);
            }
            else
            {
              op = new X86RegisterIndirectAddress(segReg, X86Registers.getRegister32(base), null, 0L, scale);
            }
            break;
          case 5: 
            disp = readInt32(bytesArray, byteIndex);
            byteIndex += 4;
            
            op = new X86RegisterIndirectAddress(segReg, null, null, disp);
            break;
          default: 
            base = rm;
            
            op = new X86RegisterIndirectAddress(segReg, X86Registers.getRegister32(base), null, 0L);
          }
          break;
        case 1: 
          disp = (byte)readByte(bytesArray, byteIndex);
          byteIndex += 1;
          if (rm != 4)
          {
            base = rm;
            
            op = new X86RegisterIndirectAddress(segReg, X86Registers.getRegister32(base), null, disp);
          }
          else if (index != 4)
          {
            op = new X86RegisterIndirectAddress(segReg, X86Registers.getRegister32(base), X86Registers.getRegister32(index), disp, scale);
          }
          else
          {
            op = new X86RegisterIndirectAddress(segReg, X86Registers.getRegister32(base), null, disp, scale);
          }
          break;
        case 2: 
          disp = readInt32(bytesArray, byteIndex);
          byteIndex += 4;
          if (rm != 4)
          {
            base = rm;
            
            op = new X86RegisterIndirectAddress(segReg, X86Registers.getRegister32(base), null, disp);
          }
          else if (index != 4)
          {
            op = new X86RegisterIndirectAddress(segReg, X86Registers.getRegister32(base), X86Registers.getRegister32(index), disp, scale);
          }
          else
          {
            op = new X86RegisterIndirectAddress(segReg, X86Registers.getRegister32(base), null, disp, scale);
          }
          break;
        }
      }
      break;
    case 2: 
      switch (operandType)
      {
      case 1: 
        op = new Immediate(new Integer(readByte(bytesArray, byteIndex)));
        byteIndex += 1;
        break;
      case 3: 
        op = new Immediate(new Integer(readInt16(bytesArray, byteIndex)));
        byteIndex += 2;
        break;
      case 2: 
        if (operandSize == true)
        {
          op = new Immediate(new Integer(readInt32(bytesArray, byteIndex)));
          byteIndex += 4;
        }
        else
        {
          op = new Immediate(new Integer(readInt16(bytesArray, byteIndex)));
          byteIndex += 2;
        }
        break;
      }
      break;
    case 6: 
      switch (operandType)
      {
      case 0: 
      case 1: 
      case 2: 
      case 3: 
      case 4: 
      case 5: 
      case 6: 
      case 7: 
        if (operandSize == true) {
          op = X86Registers.getRegister32(operandType - 0);
        } else {
          op = X86Registers.getRegister16(operandType - 0);
        }
        break;
      case 8: 
      case 9: 
      case 10: 
      case 11: 
      case 12: 
      case 13: 
      case 14: 
      case 15: 
        op = X86Registers.getRegister16(operandType - 8);
        break;
      case 16: 
      case 17: 
      case 18: 
      case 19: 
      case 20: 
      case 21: 
      case 22: 
      case 23: 
        op = X86Registers.getRegister8(operandType - 16);
        break;
      case 24: 
      case 25: 
      case 26: 
      case 27: 
      case 28: 
      case 29: 
        op = X86SegmentRegisters.getSegmentRegister(operandType - 24);
      }
      break;
    case 3: 
      long segment = 0L;
      long offset = 0L;
      switch (operandType)
      {
      case 5: 
        if (addrSize == true)
        {
          offset = readInt32(bytesArray, byteIndex);
          byteIndex += 4;
          segment = readInt16(bytesArray, byteIndex);
          byteIndex += 2;
        }
        else
        {
          offset = readInt16(bytesArray, byteIndex);
          byteIndex += 2;
          segment = readInt16(bytesArray, byteIndex);
          byteIndex += 2;
        }
        op = new X86DirectAddress(segment, offset);
        break;
      case 2: 
        if (addrSize == true)
        {
          offset = readInt32(bytesArray, byteIndex);
          byteIndex += 4;
        }
        else
        {
          offset = readInt16(bytesArray, byteIndex);
          byteIndex += 2;
        }
        op = new X86DirectAddress(offset);
      }
      break;
    case 5: 
      switch (operandType)
      {
      case 1: 
        op = X86Registers.getRegister8(regOrOpcode);
        break;
      case 3: 
        op = X86Registers.getRegister16(regOrOpcode);
        break;
      case 4: 
        op = X86Registers.getRegister32(regOrOpcode);
        break;
      case 2: 
        if (operandSize == true) {
          op = X86Registers.getRegister32(regOrOpcode);
        } else {
          op = X86Registers.getRegister16(regOrOpcode);
        }
        break;
      }
      break;
    case 9: 
      op = X86SegmentRegisters.getSegmentRegister(regOrOpcode);
      break;
    case 10: 
      int off = 0;
      if (addrSize == true)
      {
        off = readInt32(bytesArray, byteIndex);
        byteIndex += 4;
      }
      else
      {
        off = readInt16(bytesArray, byteIndex);
        byteIndex += 2;
      }
      op = new X86DirectAddress(off);
      break;
    case 4: 
      long disp = 0L;
      switch (operandType)
      {
      case 1: 
        disp = (byte)readByte(bytesArray, byteIndex);
        byteIndex += 1;
        break;
      case 2: 
        if (operandSize == true)
        {
          disp = readInt32(bytesArray, byteIndex);
          byteIndex += 4;
        }
        else
        {
          disp = readInt16(bytesArray, byteIndex);
          byteIndex += 2;
        }
        break;
      }
      op = new X86PCRelativeAddress(disp);
      break;
    case 7: 
      op = new X86SegmentRegisterAddress(X86SegmentRegisters.ES, X86Registers.DI);
      break;
    case 8: 
      op = new X86SegmentRegisterAddress(X86SegmentRegisters.DS, X86Registers.SI);
      break;
    case 13: 
      switch (operandType)
      {
      case 1: 
        op = X86Registers.getRegister8(mod);
        break;
      case 3: 
        op = X86Registers.getRegister16(mod);
        break;
      case 4: 
        op = X86Registers.getRegister32(mod);
        break;
      case 2: 
        if (operandSize == true) {
          op = X86Registers.getRegister32(mod);
        } else {
          op = X86Registers.getRegister16(mod);
        }
        break;
      }
      break;
    case 18: 
      switch (operandType)
      {
      case 0: 
        op = X86FloatRegisters.getRegister(0);
        break;
      case 1: 
        op = X86FloatRegisters.getRegister(rm);
      }
      break;
    case 21: 
      op = X86XMMRegisters.getRegister(regOrOpcode);
      break;
    case 22: 
      op = X86MMXRegisters.getRegister(regOrOpcode);
    }
    return op;
  }
  
  private X86SegmentRegister getSegmentRegisterFromPrefix(int prefixes)
  {
    X86SegmentRegister segRegister = null;
    if ((prefixes & 0x8) != 0) {
      segRegister = X86SegmentRegisters.CS;
    }
    if ((prefixes & 0x20) != 0) {
      segRegister = X86SegmentRegisters.DS;
    }
    if ((prefixes & 0x40) != 0) {
      segRegister = X86SegmentRegisters.ES;
    }
    if ((prefixes & 0x80) != 0) {
      segRegister = X86SegmentRegisters.FS;
    }
    if ((prefixes & 0x10) != 0) {
      segRegister = X86SegmentRegisters.SS;
    }
    if ((prefixes & 0x100) != 0) {
      segRegister = X86SegmentRegisters.GS;
    }
    return segRegister;
  }
}

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

import sun.jvm.hotspot.asm.Address;
import sun.jvm.hotspot.asm.Instruction;
import sun.jvm.hotspot.asm.Operand;

public class JmpDecoder
  extends InstructionDecoder
{
  public JmpDecoder(String name, int addrMode1, int operandType1)
  {
    super(name, addrMode1, operandType1);
  }
  
  protected Instruction decodeInstruction(byte[] bytesArray, boolean operandSize, boolean addrSize, X86InstructionFactory factory)
  {
    Operand operand = getOperand1(bytesArray, operandSize, addrSize);
    int size = byteIndex - instrStartIndex;
    Address address;
    Address address;
    if ((operand instanceof X86Register)) {
      address = new X86RegisterDirectAddress((X86Register)operand);
    } else {
      address = (Address)operand;
    }
    return factory.newJmpInstruction(name, address, size, prefixes);
  }
}

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

import sun.jvm.hotspot.asm.Instruction;
import sun.jvm.hotspot.asm.Operand;

public class LogicalDecoder
  extends InstructionDecoder
{
  private int rtlOperation;
  
  public LogicalDecoder(String name, int addrMode1, int operandType1, int rtlOperation)
  {
    super(name, addrMode1, operandType1);
    this.rtlOperation = rtlOperation;
  }
  
  public LogicalDecoder(String name, int addrMode1, int operandType1, int addrMode2, int operandType2, int rtlOperation)
  {
    super(name, addrMode1, operandType1, addrMode2, operandType2);
    this.rtlOperation = rtlOperation;
  }
  
  protected Instruction decodeInstruction(byte[] bytesArray, boolean operandSize, boolean addrSize, X86InstructionFactory factory)
  {
    Operand op1 = getOperand1(bytesArray, operandSize, addrSize);
    Operand op2 = getOperand2(bytesArray, operandSize, addrSize);
    int size = byteIndex - instrStartIndex;
    return factory.newLogicInstruction(name, rtlOperation, op1, op2, size, prefixes);
  }
}

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

import sun.jvm.hotspot.asm.Address;
import sun.jvm.hotspot.asm.Immediate;
import sun.jvm.hotspot.asm.ImmediateOrRegister;
import sun.jvm.hotspot.asm.Instruction;
import sun.jvm.hotspot.asm.Operand;

public class MoveDecoder
  extends InstructionDecoder
{
  public MoveDecoder(String name, int addrMode1, int operandType1, int addrMode2, int operandType2)
  {
    super(name, addrMode1, operandType1, addrMode2, operandType2);
  }
  
  protected Instruction decodeInstruction(byte[] bytesArray, boolean operandSize, boolean addrSize, X86InstructionFactory factory)
  {
    Operand op1 = getOperand1(bytesArray, operandSize, addrSize);
    Operand op2 = getOperand2(bytesArray, operandSize, addrSize);
    int size = byteIndex - instrStartIndex;
    if (((op1 instanceof X86Register)) && ((op2 instanceof ImmediateOrRegister))) {
      return factory.newMoveInstruction(name, (X86Register)op1, (ImmediateOrRegister)op2, size, prefixes);
    }
    if (((op1 instanceof Address)) && ((op2 instanceof Immediate))) {
      return factory.newGeneralInstruction(name, op1, op2, size, prefixes);
    }
    if (((op1 instanceof Address)) && ((op2 instanceof X86Register))) {
      return factory.newMoveStoreInstruction(name, (Address)op1, (X86Register)op2, 0, size, prefixes);
    }
    if (((op1 instanceof X86Register)) && ((op2 instanceof Address))) {
      return factory.newMoveLoadInstruction(name, (X86Register)op1, (Address)op2, 0, size, prefixes);
    }
    return null;
  }
}

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

import sun.jvm.hotspot.asm.ImmediateOrRegister;
import sun.jvm.hotspot.asm.Instruction;
import sun.jvm.hotspot.asm.Operand;

public class RotateDecoder
  extends InstructionDecoder
{
  public RotateDecoder(String name, int addrMode1, int operandType1)
  {
    super(name, addrMode1, operandType1);
  }
  
  public RotateDecoder(String name, int addrMode1, int operandType1, int addrMode2, int operandType2)
  {
    super(name, addrMode1, operandType1, addrMode2, operandType2);
  }
  
  protected Instruction decodeInstruction(byte[] bytesArray, boolean operandSize, boolean addrSize, X86InstructionFactory factory)
  {
    Operand op1 = getOperand1(bytesArray, operandSize, addrSize);
    Operand op2 = getOperand2(bytesArray, operandSize, addrSize);
    int size = byteIndex - instrStartIndex;
    return factory.newRotateInstruction(name, op1, (ImmediateOrRegister)op2, size, prefixes);
  }
}

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

import sun.jvm.hotspot.asm.ImmediateOrRegister;
import sun.jvm.hotspot.asm.Instruction;
import sun.jvm.hotspot.asm.Operand;

public class ShiftDecoder
  extends InstructionDecoder
{
  private int rtlOperation;
  
  public ShiftDecoder(String name, int addrMode1, int operandType1, int rtlOperation)
  {
    super(name, addrMode1, operandType1);
    this.rtlOperation = rtlOperation;
  }
  
  public ShiftDecoder(String name, int addrMode1, int operandType1, int addrMode2, int operandType2, int rtlOperation)
  {
    super(name, addrMode1, operandType1, addrMode2, operandType2);
    this.rtlOperation = rtlOperation;
  }
  
  protected Instruction decodeInstruction(byte[] bytesArray, boolean operandSize, boolean addrSize, X86InstructionFactory factory)
  {
    Operand op1 = getOperand1(bytesArray, operandSize, addrSize);
    Operand op2 = getOperand2(bytesArray, operandSize, addrSize);
    int size = byteIndex - instrStartIndex;
    return factory.newShiftInstruction(name, rtlOperation, op1, (ImmediateOrRegister)op2, size, prefixes);
  }
}

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

import sun.jvm.hotspot.asm.Instruction;
import sun.jvm.hotspot.asm.Operand;

public class SSEArithmeticDecoder
  extends SSEInstructionDecoder
{
  private int rtlOperation;
  
  public SSEArithmeticDecoder(String name, int addrMode1, int operandType1, int rtlOperation)
  {
    super(name, addrMode1, operandType1);
    this.rtlOperation = rtlOperation;
  }
  
  public SSEArithmeticDecoder(String name, int addrMode1, int operandType1, int addrMode2, int operandType2, int rtlOperation)
  {
    super(name, addrMode1, operandType1, addrMode2, operandType2);
    this.rtlOperation = rtlOperation;
  }
  
  protected Instruction decodeInstruction(byte[] bytesArray, boolean operandSize, boolean addrSize, X86InstructionFactory factory)
  {
    Operand op1 = getOperand1(bytesArray, operandSize, addrSize);
    Operand op2 = getOperand2(bytesArray, operandSize, addrSize);
    int size = byteIndex - instrStartIndex;
    return factory.newArithmeticInstruction(name, rtlOperation, op1, op2, size, prefixes);
  }
}

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

import sun.jvm.hotspot.asm.Instruction;
import sun.jvm.hotspot.asm.Operand;

public class SSEInstructionDecoder
  extends InstructionDecoder
{
  public SSEInstructionDecoder(String name)
  {
    super(name);
  }
  
  public SSEInstructionDecoder(String name, int addrMode1, int operandType1)
  {
    super(name, addrMode1, operandType1);
  }
  
  public SSEInstructionDecoder(String name, int addrMode1, int operandType1, int addrMode2, int operandType2)
  {
    super(name, addrMode1, operandType1, addrMode2, operandType2);
  }
  
  public SSEInstructionDecoder(String name, int addrMode1, int operandType1, int addrMode2, int operandType2, int addrMode3, int operandType3)
  {
    super(name, addrMode1, operandType1, addrMode2, operandType2, addrMode3, operandType3);
  }
  
  protected Instruction decodeInstruction(byte[] bytesArray, boolean operandSize, boolean addrSize, X86InstructionFactory factory)
  {
    Operand op1 = getOperand1(bytesArray, operandSize, addrSize);
    Operand op2 = getOperand2(bytesArray, operandSize, addrSize);
    Operand op3 = getOperand3(bytesArray, operandSize, addrSize);
    int size = byteIndex - instrStartIndex;
    return factory.newGeneralInstruction(name, op1, op2, op3, size, 0);
  }
}

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

import sun.jvm.hotspot.asm.Instruction;
import sun.jvm.hotspot.asm.Operand;

public class SSELogicalDecoder
  extends SSEInstructionDecoder
{
  private int rtlOperation;
  
  public SSELogicalDecoder(String name, int addrMode1, int operandType1, int addrMode2, int operandType2, int rtlOperation)
  {
    super(name, addrMode1, operandType1, addrMode2, operandType2);
    this.rtlOperation = rtlOperation;
  }
  
  protected Instruction decodeInstruction(byte[] bytesArray, boolean operandSize, boolean addrSize, X86InstructionFactory factory)
  {
    Operand op1 = getOperand1(bytesArray, operandSize, addrSize);
    Operand op2 = getOperand2(bytesArray, operandSize, addrSize);
    int size = byteIndex - instrStartIndex;
    return factory.newLogicInstruction(name, rtlOperation, op1, op2, size, prefixes);
  }
}

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

import sun.jvm.hotspot.asm.Address;
import sun.jvm.hotspot.asm.Immediate;
import sun.jvm.hotspot.asm.ImmediateOrRegister;
import sun.jvm.hotspot.asm.Instruction;
import sun.jvm.hotspot.asm.Operand;

public class SSEMoveDecoder
  extends SSEInstructionDecoder
{
  public SSEMoveDecoder(String name, int addrMode1, int operandType1, int addrMode2, int operandType2)
  {
    super(name, addrMode1, operandType1, addrMode2, operandType2);
  }
  
  protected Instruction decodeInstruction(byte[] bytesArray, boolean operandSize, boolean addrSize, X86InstructionFactory factory)
  {
    Operand op1 = getOperand1(bytesArray, operandSize, addrSize);
    Operand op2 = getOperand2(bytesArray, operandSize, addrSize);
    int size = byteIndex - instrStartIndex;
    if (((op1 instanceof X86Register)) && ((op2 instanceof ImmediateOrRegister))) {
      return factory.newMoveInstruction(name, (X86Register)op1, (ImmediateOrRegister)op2, size, 0);
    }
    if (((op1 instanceof Address)) && ((op2 instanceof Immediate))) {
      return factory.newGeneralInstruction(name, op1, op2, size, 0);
    }
    if (((op1 instanceof Address)) && ((op2 instanceof X86Register))) {
      return factory.newMoveStoreInstruction(name, (Address)op1, (X86Register)op2, 0, size, 0);
    }
    if (((op1 instanceof X86Register)) && ((op2 instanceof Address))) {
      return factory.newMoveLoadInstruction(name, (X86Register)op1, (Address)op2, 0, size, 0);
    }
    return null;
  }
}

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

import sun.jvm.hotspot.asm.ImmediateOrRegister;
import sun.jvm.hotspot.asm.Instruction;
import sun.jvm.hotspot.asm.Operand;

public class SSEShiftDecoder
  extends SSEInstructionDecoder
{
  private int rtlOperation;
  
  public SSEShiftDecoder(String name, int addrMode1, int operandType1, int addrMode2, int operandType2, int rtlOperation)
  {
    super(name, addrMode1, operandType1, addrMode2, operandType2);
    this.rtlOperation = rtlOperation;
  }
  
  protected Instruction decodeInstruction(byte[] bytesArray, boolean operandSize, boolean addrSize, X86InstructionFactory factory)
  {
    Operand op1 = getOperand1(bytesArray, operandSize, addrSize);
    Operand op2 = getOperand2(bytesArray, operandSize, addrSize);
    int size = byteIndex - instrStartIndex;
    return factory.newShiftInstruction(name, rtlOperation, op1, (ImmediateOrRegister)op2, size, 0);
  }
}

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

import sun.jvm.hotspot.asm.ArithmeticInstruction;
import sun.jvm.hotspot.asm.Operand;
import sun.jvm.hotspot.asm.SymbolFinder;

public class X86ArithmeticInstruction
  extends X86Instruction
  implements ArithmeticInstruction
{
  private final int operation;
  private final Operand operand1;
  private final Operand operand2;
  private final Operand operand3;
  private final String description;
  
  public X86ArithmeticInstruction(String name, int operation, Operand op1, Operand op2, int size, int prefixes)
  {
    super(name, size, prefixes);
    this.operation = operation;
    operand1 = op1;
    operand2 = op2;
    operand3 = null;
    description = initDescription();
  }
  
  public X86ArithmeticInstruction(String name, int operation, Operand op1, Operand op2, Operand op3, int size, int prefixes)
  {
    super(name, size, prefixes);
    this.operation = operation;
    operand1 = op1;
    operand2 = op2;
    operand3 = op3;
    description = initDescription();
  }
  
  protected String initDescription()
  {
    StringBuffer buf = new StringBuffer();
    buf.append(getPrefixString());
    buf.append(getName());
    buf.append(spaces);
    if (operand1 != null) {
      buf.append(getOperandAsString(operand1));
    }
    if (operand2 != null)
    {
      buf.append(comma);
      buf.append(getOperandAsString(operand2));
    }
    if (operand3 != null)
    {
      buf.append(comma);
      buf.append(getOperandAsString(operand3));
    }
    return buf.toString();
  }
  
  public String asString(long currentPc, SymbolFinder symFinder)
  {
    return description;
  }
  
  public Operand getArithmeticDestination()
  {
    return operand1;
  }
  
  public Operand getOperand1()
  {
    return operand1;
  }
  
  public Operand getOperand2()
  {
    return operand2;
  }
  
  public Operand getOperand3()
  {
    return operand3;
  }
  
  public Operand[] getArithmeticSources()
  {
    return new Operand[] { operand1, operand2, operand3 };
  }
  
  public int getOperation()
  {
    return operation;
  }
  
  public boolean isArithmetic()
  {
    return true;
  }
}

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

import sun.jvm.hotspot.asm.Address;
import sun.jvm.hotspot.asm.BranchInstruction;
import sun.jvm.hotspot.asm.SymbolFinder;

public class X86BranchInstruction
  extends X86Instruction
  implements BranchInstruction
{
  private final X86PCRelativeAddress addr;
  
  public X86BranchInstruction(String name, X86PCRelativeAddress addr, int size, int prefixes)
  {
    super(name, size, prefixes);
    this.addr = addr;
    if ((addr instanceof X86PCRelativeAddress)) {
      addr.setInstructionSize(getSize());
    }
  }
  
  public String asString(long currentPc, SymbolFinder symFinder)
  {
    StringBuffer buf = new StringBuffer();
    buf.append(getPrefixString());
    buf.append(getName());
    if (addr != null)
    {
      buf.append(spaces);
      if ((addr instanceof X86PCRelativeAddress))
      {
        long disp = addr.getDisplacement();
        long address = disp + currentPc;
        buf.append(symFinder.getSymbolFor(address));
      }
    }
    return buf.toString();
  }
  
  public Address getBranchDestination()
  {
    return addr;
  }
  
  public boolean isBranch()
  {
    return true;
  }
  
  public boolean isConditional()
  {
    return false;
  }
}

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

import sun.jvm.hotspot.asm.Address;
import sun.jvm.hotspot.asm.CallInstruction;
import sun.jvm.hotspot.asm.SymbolFinder;

public class X86CallInstruction
  extends X86Instruction
  implements CallInstruction
{
  private final Address addr;
  
  public X86CallInstruction(String name, Address addr, int size, int prefixes)
  {
    super(name, size, prefixes);
    this.addr = addr;
    if ((addr instanceof X86PCRelativeAddress)) {
      ((X86PCRelativeAddress)addr).setInstructionSize(getSize());
    }
  }
  
  public String asString(long currentPc, SymbolFinder symFinder)
  {
    StringBuffer buf = new StringBuffer();
    buf.append(getPrefixString());
    buf.append(getName());
    buf.append(spaces);
    if ((addr instanceof X86PCRelativeAddress))
    {
      long disp = ((X86PCRelativeAddress)addr).getDisplacement();
      long address = disp + currentPc;
      buf.append(symFinder.getSymbolFor(address));
    }
    else
    {
      buf.append(addr.toString());
    }
    return buf.toString();
  }
  
  public Address getBranchDestination()
  {
    return addr;
  }
  
  public boolean isCall()
  {
    return true;
  }
  
  public boolean isConditional()
  {
    return false;
  }
}

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

import sun.jvm.hotspot.asm.Address;
import sun.jvm.hotspot.asm.BranchInstruction;
import sun.jvm.hotspot.asm.SymbolFinder;

public class X86CondJmpInstruction
  extends X86Instruction
  implements BranchInstruction
{
  private final X86PCRelativeAddress addr;
  
  public X86CondJmpInstruction(String name, X86PCRelativeAddress addr, int size, int prefixes)
  {
    super(name, size, prefixes);
    this.addr = addr;
    if ((addr instanceof X86PCRelativeAddress)) {
      addr.setInstructionSize(getSize());
    }
  }
  
  public String asString(long currentPc, SymbolFinder symFinder)
  {
    StringBuffer buf = new StringBuffer();
    buf.append(getPrefixString());
    buf.append(getName());
    buf.append(spaces);
    if ((addr instanceof X86PCRelativeAddress))
    {
      long disp = addr.getDisplacement();
      long address = disp + currentPc;
      buf.append(symFinder.getSymbolFor(address));
    }
    return buf.toString();
  }
  
  public Address getBranchDestination()
  {
    return addr;
  }
  
  public boolean isBranch()
  {
    return true;
  }
  
  public boolean isConditional()
  {
    return true;
  }
}

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

import sun.jvm.hotspot.asm.DirectAddress;

public class X86DirectAddress
  extends DirectAddress
{
  private long segment;
  
  public X86DirectAddress(long segment, long disp)
  {
    super(disp);
    this.segment = segment;
  }
  
  public X86DirectAddress(long disp)
  {
    super(disp);
    segment = 0L;
  }
  
  public String toString()
  {
    StringBuffer buf = new StringBuffer();
    if (getSegment() != 0L)
    {
      buf.append("0x");
      buf.append(Long.toHexString(getSegment()));
      buf.append(":");
    }
    buf.append("[");
    buf.append("0x");
    buf.append(Long.toHexString(getValue()));
    buf.append("]");
    
    return buf.toString();
  }
  
  long getSegment()
  {
    return segment;
  }
}

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

import sun.jvm.hotspot.asm.Disassembler;
import sun.jvm.hotspot.asm.Instruction;
import sun.jvm.hotspot.asm.InstructionVisitor;

public class X86Disassembler
  extends Disassembler
  implements X86Opcodes
{
  private int byteIndex;
  protected final X86InstructionFactory factory;
  
  public X86Disassembler(long startPc, byte[] code, X86InstructionFactory factory)
  {
    super(startPc, code);
    this.factory = factory;
  }
  
  public X86Disassembler(long startPc, byte[] code)
  {
    this(startPc, code, new X86InstructionFactoryImpl());
  }
  
  private static final InstructionDecoder[] oneByteTable = { new ArithmeticDecoder("addb", 1, 1, 5, 1, 0), new ArithmeticDecoder("addS", 1, 2, 5, 2, 0), new ArithmeticDecoder("addb", 5, 1, 1, 1, 0), new ArithmeticDecoder("addS", 5, 2, 1, 2, 0), new ArithmeticDecoder("addb", 6, 16, 2, 1, 0), new ArithmeticDecoder("addS", 6, 0, 2, 2, 0), new InstructionDecoder("pushl", 6, 24), new InstructionDecoder("popl", 6, 24), new LogicalDecoder("orb", 1, 1, 5, 1, 9), new LogicalDecoder("orS", 1, 2, 5, 2, 9), new LogicalDecoder("orb", 5, 1, 1, 1, 9), new LogicalDecoder("orS", 5, 2, 1, 2, 9), new LogicalDecoder("orb", 6, 16, 2, 1, 9), new LogicalDecoder("orS", 6, 0, 2, 2, 9), new InstructionDecoder("pushl", 6, 25), null, new ArithmeticDecoder("adcb", 1, 1, 5, 1, 1), new ArithmeticDecoder("adcS", 1, 2, 5, 2, 1), new ArithmeticDecoder("adcb", 5, 1, 1, 1, 1), new ArithmeticDecoder("adcS", 5, 2, 1, 2, 1), new ArithmeticDecoder("adcb", 6, 16, 2, 1, 1), new ArithmeticDecoder("adcS", 6, 0, 2, 2, 1), new InstructionDecoder("pushl", 6, 26), new InstructionDecoder("popl", 6, 26), new ArithmeticDecoder("sbbb", 1, 1, 5, 1, 3), new ArithmeticDecoder("sbbS", 1, 2, 5, 2, 3), new ArithmeticDecoder("sbbb", 5, 1, 1, 1, 3), new ArithmeticDecoder("sbbS", 5, 2, 1, 2, 3), new ArithmeticDecoder("sbbb", 6, 16, 2, 1, 3), new ArithmeticDecoder("sbbS", 6, 0, 2, 2, 3), new InstructionDecoder("pushl", 6, 27), new InstructionDecoder("popl", 6, 27), new LogicalDecoder("andb", 1, 1, 5, 1, 8), new LogicalDecoder("andS", 1, 2, 5, 2, 8), new LogicalDecoder("andb", 5, 1, 1, 1, 8), new LogicalDecoder("andS", 5, 2, 1, 2, 8), new LogicalDecoder("andb", 6, 16, 2, 1, 8), new LogicalDecoder("andS", 6, 0, 2, 2, 8), null, new InstructionDecoder("daa"), new ArithmeticDecoder("subb", 1, 1, 5, 1, 2), new ArithmeticDecoder("subS", 1, 2, 5, 2, 2), new ArithmeticDecoder("subb", 5, 1, 1, 1, 2), new ArithmeticDecoder("subS", 5, 2, 1, 2, 2), new ArithmeticDecoder("subb", 6, 16, 2, 1, 2), new ArithmeticDecoder("subS", 6, 0, 2, 2, 2), null, new InstructionDecoder("das"), new LogicalDecoder("xorb", 1, 1, 5, 1, 13), new LogicalDecoder("xorS", 1, 2, 5, 2, 13), new LogicalDecoder("xorb", 5, 1, 1, 1, 13), new LogicalDecoder("xorS", 5, 2, 1, 2, 13), new LogicalDecoder("xorb", 6, 16, 2, 1, 13), new LogicalDecoder("xorS", 6, 0, 2, 2, 13), null, new InstructionDecoder("aaa"), new InstructionDecoder("cmpb", 1, 1, 5, 1), new InstructionDecoder("cmpS", 1, 2, 5, 2), new InstructionDecoder("cmpb", 5, 1, 1, 1), new InstructionDecoder("cmpS", 5, 2, 1, 2), new InstructionDecoder("cmpb", 6, 16, 2, 1), new InstructionDecoder("cmpS", 6, 0, 2, 2), null, new InstructionDecoder("aas"), new ArithmeticDecoder("incS", 6, 0, 0), new ArithmeticDecoder("incS", 6, 1, 0), new ArithmeticDecoder("incS", 6, 2, 0), new ArithmeticDecoder("incS", 6, 3, 0), new ArithmeticDecoder("incS", 6, 4, 0), new ArithmeticDecoder("incS", 6, 5, 0), new ArithmeticDecoder("incS", 6, 6, 0), new ArithmeticDecoder("incS", 6, 7, 0), new ArithmeticDecoder("decS", 6, 0, 2), new ArithmeticDecoder("decS", 6, 1, 2), new ArithmeticDecoder("decS", 6, 2, 2), new ArithmeticDecoder("decS", 6, 3, 2), new ArithmeticDecoder("decS", 6, 4, 2), new ArithmeticDecoder("decS", 6, 5, 2), new ArithmeticDecoder("decS", 6, 6, 2), new ArithmeticDecoder("decS", 6, 7, 2), new InstructionDecoder("pushS", 6, 0), new InstructionDecoder("pushS", 6, 1), new InstructionDecoder("pushS", 6, 2), new InstructionDecoder("pushS", 6, 3), new InstructionDecoder("pushS", 6, 4), new InstructionDecoder("pushS", 6, 5), new InstructionDecoder("pushS", 6, 6), new InstructionDecoder("pushS", 6, 7), new InstructionDecoder("popS", 6, 0), new InstructionDecoder("popS", 6, 1), new InstructionDecoder("popS", 6, 2), new InstructionDecoder("popS", 6, 3), new InstructionDecoder("popS", 6, 4), new InstructionDecoder("popS", 6, 5), new InstructionDecoder("popS", 6, 6), new InstructionDecoder("popS", 6, 7), new InstructionDecoder("pusha"), new InstructionDecoder("popa"), new InstructionDecoder("boundS", 5, 2, 1, 2), new InstructionDecoder("arpl", 1, 3, 5, 3), null, null, null, null, new InstructionDecoder("pushS", 2, 2), new ArithmeticDecoder("imulS", 5, 2, 1, 2, 2, 2, 4), new InstructionDecoder("pushl", 2, 1), new ArithmeticDecoder("imulS", 5, 2, 1, 2, 2, 1, 4), new InstructionDecoder("insb", 7, 1, 11, 10), new InstructionDecoder("insS", 7, 2, 11, 10), new InstructionDecoder("outsb", 11, 10, 8, 1), new InstructionDecoder("outsS", 11, 10, 8, 2), new ConditionalJmpDecoder("jo", 4, 1), new ConditionalJmpDecoder("jno", 4, 1), new ConditionalJmpDecoder("jb", 4, 1), new ConditionalJmpDecoder("jae", 4, 1), new ConditionalJmpDecoder("je", 4, 1), new ConditionalJmpDecoder("jne", 4, 1), new ConditionalJmpDecoder("jbe", 4, 1), new ConditionalJmpDecoder("ja", 4, 1), new ConditionalJmpDecoder("js", 4, 1), new ConditionalJmpDecoder("jns", 4, 1), new ConditionalJmpDecoder("jp", 4, 1), new ConditionalJmpDecoder("jnp", 4, 1), new ConditionalJmpDecoder("jl", 4, 1), new ConditionalJmpDecoder("jnl", 4, 1), new ConditionalJmpDecoder("jle", 4, 1), new ConditionalJmpDecoder("jg", 4, 1), new GRPDecoder(null, 0), new GRPDecoder(null, 1), null, new GRPDecoder(null, 2), new InstructionDecoder("testb", 1, 1, 5, 1), new InstructionDecoder("testS", 1, 2, 5, 2), new MoveDecoder("xchgb", 1, 1, 5, 1), new MoveDecoder("xchgS", 1, 2, 5, 2), new MoveDecoder("movb", 1, 1, 5, 1), new MoveDecoder("movS", 1, 2, 5, 2), new MoveDecoder("movb", 5, 1, 1, 1), new MoveDecoder("movS", 5, 2, 1, 2), new MoveDecoder("movw", 1, 3, 9, 3), new InstructionDecoder("leaS", 5, 2, 1, 0), new MoveDecoder("movw", 9, 3, 1, 3), new InstructionDecoder("popS", 1, 2), new InstructionDecoder("nop"), new MoveDecoder("xchgS", 6, 1, 6, 0), new MoveDecoder("xchgS", 6, 2, 6, 0), new MoveDecoder("xchgS", 6, 3, 6, 0), new MoveDecoder("xchgS", 6, 4, 6, 0), new MoveDecoder("xchgS", 6, 5, 6, 0), new MoveDecoder("xchgS", 6, 6, 6, 0), new MoveDecoder("xchgS", 6, 7, 6, 0), new InstructionDecoder("cwtl"), new InstructionDecoder("cltd"), new CallDecoder("lcall", 3, 5), null, new InstructionDecoder("pushf"), new InstructionDecoder("popf"), new InstructionDecoder("sahf"), new InstructionDecoder("lahf"), new MoveDecoder("movb", 6, 16, 10, 1), new MoveDecoder("movS", 6, 0, 10, 2), new MoveDecoder("movb", 10, 1, 6, 16), new MoveDecoder("movS", 10, 2, 6, 0), new MoveDecoder("movsb", 7, 1, 8, 1), new MoveDecoder("movsS", 7, 2, 8, 2), new InstructionDecoder("cmpsb", 7, 1, 8, 1), new InstructionDecoder("cmpsS", 7, 2, 8, 2), new InstructionDecoder("testb", 6, 16, 2, 1), new InstructionDecoder("testS", 6, 0, 2, 2), new InstructionDecoder("stosb", 7, 1, 6, 16), new InstructionDecoder("stosS", 7, 2, 6, 0), new InstructionDecoder("lodsb", 6, 16, 8, 1), new InstructionDecoder("lodsS", 6, 0, 8, 2), new InstructionDecoder("scasb", 6, 16, 7, 1), new InstructionDecoder("scasS", 6, 0, 7, 2), new MoveDecoder("movb", 6, 16, 2, 1), new MoveDecoder("movb", 6, 17, 2, 1), new MoveDecoder("movb", 6, 18, 2, 1), new MoveDecoder("movb", 6, 19, 2, 1), new MoveDecoder("movb", 6, 20, 2, 1), new MoveDecoder("movb", 6, 21, 2, 1), new MoveDecoder("movb", 6, 22, 2, 1), new MoveDecoder("movb", 6, 23, 2, 1), new MoveDecoder("movS", 6, 0, 2, 2), new MoveDecoder("movS", 6, 1, 2, 2), new MoveDecoder("movS", 6, 2, 2, 2), new MoveDecoder("movS", 6, 3, 2, 2), new MoveDecoder("movS", 6, 4, 2, 2), new MoveDecoder("movS", 6, 5, 2, 2), new MoveDecoder("movS", 6, 6, 2, 2), new MoveDecoder("movS", 6, 7, 2, 2), new GRPDecoder(null, 3), new GRPDecoder(null, 4), new BranchDecoder("ret", 2, 3), new BranchDecoder("ret"), new InstructionDecoder("lesS", 5, 2, 1, 0), new InstructionDecoder("ldsS", 5, 2, 1, 0), new MoveDecoder("movb", 1, 1, 2, 1), new MoveDecoder("movS", 1, 2, 2, 2), new InstructionDecoder("enter", 2, 3, 2, 1), new InstructionDecoder("leave"), new InstructionDecoder("lret", 2, 3), new InstructionDecoder("lret"), new InstructionDecoder("int3"), new InstructionDecoder("int", 2, 1), new InstructionDecoder("into"), new InstructionDecoder("iret"), new GRPDecoder(null, 5), new GRPDecoder(null, 6), new GRPDecoder(null, 7), new GRPDecoder(null, 8), new InstructionDecoder("aam", 2, 1), new InstructionDecoder("aad", 2, 1), null, new InstructionDecoder("xlat"), new FloatDecoder(), new FloatDecoder(), new FloatDecoder(), new FloatDecoder(), new FloatDecoder(), new FloatDecoder(), new FloatDecoder(), new FloatDecoder(), new BranchDecoder("loopne", 4, 1), new BranchDecoder("loope", 4, 1), new BranchDecoder("loop", 4, 1), new ConditionalJmpDecoder("jCcxz", 4, 1), new InstructionDecoder("inb", 6, 16, 2, 1), new InstructionDecoder("inS", 6, 0, 2, 1), new InstructionDecoder("outb", 2, 1, 6, 16), new InstructionDecoder("outS", 2, 1, 6, 0), new CallDecoder("call", 4, 2), new JmpDecoder("jmp", 4, 2), new JmpDecoder("ljmp", 3, 5), new JmpDecoder("jmp", 4, 1), new InstructionDecoder("inb", 6, 16, 11, 10), new InstructionDecoder("inS", 6, 0, 11, 10), new InstructionDecoder("outb", 11, 10, 6, 16), new InstructionDecoder("outS", 11, 10, 6, 0), new InstructionDecoder("lock"), null, new InstructionDecoder("repne"), new InstructionDecoder("rep"), new InstructionDecoder("hlt"), new InstructionDecoder("cmc"), new GRPDecoder(null, 9), new GRPDecoder(null, 10), new InstructionDecoder("clc"), new InstructionDecoder("stc"), new InstructionDecoder("cli"), new InstructionDecoder("sti"), new InstructionDecoder("cld"), new InstructionDecoder("std"), new GRPDecoder(null, 11), new GRPDecoder(null, 12) };
  private static final InstructionDecoder[] twoByteTable = { new GRPDecoder(null, 13), new GRPDecoder(null, 
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