sa-jdi

y;
    Instruction instr = null;
    int prNum = getSourceRegister1(instruction);
    if (isLegalPrivilegedRegister(prNum))
    {
      SPARCRegister rd = SPARCRegisters.getRegister(getDestinationRegister(instruction));
      instr = v9factory.newV9RdprInstruction(prNum, rd);
    }
    else
    {
      instr = v9factory.newIllegalInstruction(instruction);
    }
    return instr;
  }
}

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

import sun.jvm.hotspot.asm.Instruction;

class V9ReadDecoder
  extends InstructionDecoder
  implements V9InstructionDecoder
{
  Instruction decode(int instruction, SPARCInstructionFactory factory)
  {
    SPARCV9InstructionFactory v9factory = (SPARCV9InstructionFactory)factory;
    Instruction instr = null;
    int specialRegNum = getSourceRegister1(instruction);
    if ((specialRegNum == 1) || ((specialRegNum > 6) && (specialRegNum < 15)))
    {
      instr = v9factory.newIllegalInstruction(instruction);
    }
    else
    {
      int rdNum = getDestinationRegister(instruction);
      if (specialRegNum == 15)
      {
        if (rdNum == 0)
        {
          boolean iBit = isIBitSet(instruction);
          if (iBit) {
            instr = v9factory.newV9MembarInstruction((instruction & 0xF) >>> 0, (instruction & 0x70) >>> 4);
          } else {
            instr = v9factory.newStbarInstruction();
          }
        }
        else
        {
          instr = v9factory.newIllegalInstruction(instruction);
        }
      }
      else
      {
        int asrRegNum = -1;
        if (specialRegNum > 15)
        {
          asrRegNum = specialRegNum;
          specialRegNum = 7;
        }
        SPARCRegister rd = SPARCRegisters.getRegister(rdNum);
        instr = v9factory.newV9ReadInstruction(specialRegNum, asrRegNum, rd);
      }
    }
    return instr;
  }
}

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

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

abstract class V9RegisterBranchDecoder
  extends V9BranchDecoder
{
  static int getDisp16(int instruction)
  {
    int offset = 0x3FFF & instruction | (0x300000 & instruction) >>> 6;
    
    offset = extractSignedIntFromNBits(offset, 16);
    offset <<= 2;
    
    return offset;
  }
  
  String getConditionName(int conditionCode, boolean isAnnuled)
  {
    return null;
  }
  
  abstract String getRegisterConditionName(int paramInt);
  
  public Instruction decode(int instruction, SPARCInstructionFactory factory)
  {
    SPARCV9InstructionFactory v9factory = (SPARCV9InstructionFactory)factory;
    int rcond = (0xE000000 & instruction) >>> 25;
    if ((rcond == 0) || (rcond == 4)) {
      return factory.newIllegalInstruction(instruction);
    }
    SPARCRegister rs1 = SPARCRegisters.getRegister(getSourceRegister1(instruction));
    boolean predictTaken = getPredictTaken(instruction);
    boolean annuled = getAnnuledBit(instruction);
    PCRelativeAddress addr = new PCRelativeAddress(getDisp16(instruction));
    String name = getRegisterConditionName(rcond);
    return v9factory.newV9RegisterBranchInstruction(name, addr, annuled, rcond, rs1, predictTaken);
  }
}

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

import sun.jvm.hotspot.asm.Instruction;

class V9SavedRestoredDecoder
  extends InstructionDecoder
  implements V9InstructionDecoder
{
  Instruction decode(int instruction, SPARCInstructionFactory factory)
  {
    SPARCV9InstructionFactory v9factory = (SPARCV9InstructionFactory)factory;
    Instruction instr = null;
    int rdNum = getDestinationRegister(instruction);
    switch (rdNum)
    {
    case 0: 
      instr = v9factory.newV9SavedInstruction();
      break;
    case 1: 
      instr = v9factory.newV9RestoredInstruction();
      break;
    default: 
      instr = v9factory.newIllegalInstruction(instruction);
    }
    return instr;
  }
}

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

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

class V9ShiftDecoder
  extends InstructionDecoder
  implements V9InstructionDecoder
{
  final int op3;
  final String name;
  final int rtlOperation;
  
  V9ShiftDecoder(int op3, String name, int rtlOperation)
  {
    this.op3 = op3;
    this.name = name;
    this.rtlOperation = rtlOperation;
  }
  
  static boolean isXBitSet(int instruction)
  {
    return (instruction & 0x1000) != 0;
  }
  
  Instruction decode(int instruction, SPARCInstructionFactory factory)
  {
    SPARCRegister rs1 = SPARCRegisters.getRegister(getSourceRegister1(instruction));
    SPARCRegister rd = SPARCRegisters.getRegister(getDestinationRegister(instruction));
    boolean xBit = isXBitSet(instruction);
    ImmediateOrRegister operand2 = null;
    if (isIBitSet(instruction))
    {
      int value = instruction & (xBit ? 63 : 31);
      operand2 = new Immediate(new Short((short)value));
    }
    else
    {
      operand2 = SPARCRegisters.getRegister(getSourceRegister2(instruction));
    }
    return factory.newShiftInstruction(xBit ? name + "x" : name, op3, rtlOperation, rs1, operand2, rd);
  }
}

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

import sun.jvm.hotspot.asm.Instruction;

class V9SpecialLoadDecoder
  extends MemoryInstructionDecoder
  implements V9InstructionDecoder
{
  V9SpecialLoadDecoder(int op3)
  {
    super(op3, "ld[x]fsr", Integer.MAX_VALUE);
  }
  
  Instruction decodeMemoryInstruction(int instruction, SPARCRegisterIndirectAddress addr, SPARCRegister rd, SPARCInstructionFactory factory)
  {
    return factory.newSpecialLoadInstruction(rd == SPARCRegisters.G0 ? "ld" : "ldx", 5, -1, addr);
  }
}

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

import sun.jvm.hotspot.asm.Instruction;

class V9SpecialStoreDecoder
  extends MemoryInstructionDecoder
  implements V9InstructionDecoder
{
  V9SpecialStoreDecoder(int op3)
  {
    super(op3, "st[x]fsr", Integer.MAX_VALUE);
  }
  
  Instruction decodeMemoryInstruction(int instruction, SPARCRegisterIndirectAddress addr, SPARCRegister rd, SPARCInstructionFactory factory)
  {
    return factory.newSpecialStoreInstruction(rd == SPARCRegisters.G0 ? "st" : "stx", 5, -1, addr);
  }
}

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

import sun.jvm.hotspot.asm.Instruction;

class V9WriteDecoder
  extends InstructionDecoder
  implements V9InstructionDecoder
{
  Instruction decode(int instruction, SPARCInstructionFactory factory)
  {
    SPARCV9InstructionFactory v9factory = (SPARCV9InstructionFactory)factory;
    Instruction instr = null;
    int specialRegNum = getDestinationRegister(instruction);
    if ((specialRegNum == 1) || (specialRegNum == 4) || (specialRegNum == 5) || ((specialRegNum > 6) && (specialRegNum < 15)))
    {
      instr = v9factory.newIllegalInstruction(instruction);
    }
    else
    {
      int rs1Num = getSourceRegister1(instruction);
      if (specialRegNum == 15)
      {
        if ((isIBitSet(instruction)) && (rs1Num == 0)) {
          instr = v9factory.newV9SirInstruction();
        } else {
          instr = v9factory.newIllegalInstruction(instruction);
        }
      }
      else
      {
        int asrRegNum = -1;
        if (specialRegNum > 15)
        {
          asrRegNum = specialRegNum;
          specialRegNum = 7;
        }
        SPARCRegister rs1 = SPARCRegisters.getRegister(rs1Num);
        instr = v9factory.newV9WriteInstruction(specialRegNum, asrRegNum, rs1, getOperand2(instruction));
      }
    }
    return instr;
  }
}

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

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

class V9WrprDecoder
  extends V9PrivilegedReadWriteDecoder
{
  Instruction decode(int instruction, SPARCInstructionFactory factory)
  {
    SPARCV9InstructionFactory v9factory = (SPARCV9InstructionFactory)factory;
    Instruction instr = null;
    int prNum = getDestinationRegister(instruction);
    if (isLegalPrivilegedRegister(prNum))
    {
      SPARCRegister rs1 = SPARCRegisters.getRegister(getSourceRegister1(instruction));
      ImmediateOrRegister operand2 = getOperand2(instruction);
      instr = v9factory.newV9WrprInstruction(rs1, operand2, prNum);
    }
    else
    {
      instr = v9factory.newIllegalInstruction(instruction);
    }
    return instr;
  }
}

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

import sun.jvm.hotspot.asm.Instruction;

class WriteDecoder
  extends ReadWriteDecoder
{
  WriteDecoder(int specialRegNum)
  {
    super(specialRegNum);
  }
  
  Instruction decodeReadWrite(int instruction, SPARCInstructionFactory factory, int rs1Num, int rdNum)
  {
    Instruction instr = null;
    int specialReg = specialRegNum;
    if (rdNum == 0) {
      specialReg = 0;
    }
    return factory.newWriteInstruction(specialReg, rdNum, SPARCRegisters.getRegister(rs1Num), getOperand2(instruction));
  }
}

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

public abstract interface StoreInstruction
  extends MemoryInstruction
{
  public abstract Register[] getStoreSources();
  
  public abstract Address getStoreDestination();
}

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

public abstract interface SymbolFinder
{
  public abstract String getSymbolFor(long paramLong);
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.asm.SymbolFinder
 * 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 ArithmeticDecoder
  extends InstructionDecoder
{
  private int rtlOperation;
  
  public ArithmeticDecoder(String name, int addrMode1, int operandType1, int rtlOperation)
  {
    super(name, addrMode1, operandType1);
    this.rtlOperation = rtlOperation;
  }
  
  public ArithmeticDecoder(String name, int addrMode1, int operandType1, int addrMode2, int operandType2, int rtlOperation)
  {
    super(name, addrMode1, operandType1, addrMode2, operandType2);
    this.rtlOperation = rtlOperation;
  }
  
  public ArithmeticDecoder(String name, int addrMode1, int operandType1, int addrMode2, int operandType2, int addrMode3, int operandType3, int rtlOperation)
  {
    super(name, addrMode1, operandType1, addrMode2, operandType2, addrMode3, operandType3);
    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);
    Operand op3 = getOperand3(bytesArray, operandSize, addrSize);
    int size = byteIndex - instrStartIndex;
    return factory.newArithmeticInstruction(name, rtlOperation, op1, op2, op3, size, prefixes);
  }
}

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

public class BranchDecoder
  extends InstructionDecoder
{
  public BranchDecoder(String name)
  {
    super(name);
  }
  
  public BranchDecoder(String name, int addrMode1, int operandType1)
  {
    super(name, addrMode1, operandType1);
  }
  
  protected Instruction decodeInstruction(byte[] bytesArray, boolean operandSize, boolean addrSize, X86InstructionFactory factory)
  {
    Operand addr = getOperand1(bytesArray, operandSize, addrSize);
    if (Assert.ASSERTS_ENABLED) {
      Assert.that((addr == null) || ((addr instanceof X86PCRelativeAddress)), "Address should be PC Relative!");
    }
    int size = byteIndex - instrStartIndex;
    return factory.newBranchInstruction(name, (X86PCRelativeAddress)addr, size, prefixes);
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.asm.x86.BranchDecoder
 * 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 CallDecoder
  extends InstructionDecoder
{
  public CallDecoder(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.newCallInstruction(name, address, size, prefixes);
  }
}

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

public class ConditionalJmpDecoder
  extends InstructionDecoder
{
  public ConditionalJmpDecoder(String name, int addrMode1, int operandType1)
  {
    super(name, addrMode1, operandType1);
  }
  
  protected Instruction decodeInstruction(byte[] bytesArray, boolean operandSize, boolean addrSize, X86InstructionFactory factory)
  {
    Operand addr = getOperand1(bytesArray, operandSize, addrSize);
    if (Assert.ASSERTS_ENABLED) {
      Assert.that(addr instanceof X86PCRelativeAddress, "Address should be PC Relative!");
    }
    return factory.newCondJmpInstruction(name, (X86PCRelativeAddress)addr, byteIndex - instrStartIndex, prefixes);
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.asm.x86.ConditionalJmpDecoder
 * 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;

public class FloatDecoder
  extends FPInstructionDecoder
{
  public FloatDecoder()
  {
    super(null);
  }
  
  private static final FPInstructionDecoder[][] floatMapOne = { { new FPArithmeticDecoder("fadds", 1, 2, 0), new FPArithmeticDecoder("fmuls", 1, 2, 4), new FPInstructionDecoder("fcoms", 1, 2), new FPInstructionDecoder("fcomps", 1, 2), new FPArithmeticDecoder("fsubs", 1, 2, 2), new FPArithmeticDecoder("fsubrs", 1, 2, 2), new FPArithmeticDecoder("fdivs", 1, 2, 6), new FPArithmeticDecoder("fdivrs", 1, 2, 6) }, { new FPLoadDecoder("flds", 1, 2), null, new FPStoreDecoder("fsts", 1, 2), new FPStoreDecoder("fstps", 1, 2), new FPStoreDecoder("fldenv", 1, 2), new FPStoreDecoder("fldcw", 1, 2), new FPStoreDecoder("fNstenv", 1, 2), new FPStoreDecoder("fNstcw", 1, 2) }, { new FPArithmeticDecoder("fiaddl", 1, 2, 0), new FPArithmeticDecoder("fimull", 1, 2, 4), new FPInstructionDecoder("ficoml", 1, 2), new FPInstructionDecoder("ficompl", 1, 2), new FPArithmeticDecoder("fisubl", 1, 2, 2), new FPArithmeticDecoder("fisubrl", 1, 2, 2), new FPArithmeticDecoder("fidivl", 1, 2, 6), new FPArithmeticDecoder("fidivrl", 1, 2, 6) }, { new FPLoadDecoder("fildl", 1, 2), null, new FPStoreDecoder("fistl", 1, 2), new FPStoreDecoder("fistpl", 1, 2), null, new FPLoadDecoder("fldt", 1, 2), null, new FPStoreDecoder("fstpt", 1, 2) }, { new FPArithmeticDecoder("faddl", 1, 2, 0), new FPArithmeticDecoder("fmull", 1, 2, 4), new FPInstructionDecoder("fcoml", 1, 2), new FPInstructionDecoder("fcompl", 1, 2), new FPArithmeticDecoder("fsubl", 1, 2, 2), new FPArithmeticDecoder("fsubrl", 1, 2, 2), new FPArithmeticDecoder("fdivl", 1, 2, 6), new FPArithmeticDecoder("fdivrl", 1, 2, 6) }, { new FPLoadDecoder("fldl", 1, 2), null, new FPStoreDecoder("fstl", 1, 2), new FPStoreDecoder("fstpl", 1, 2), new FPStoreDecoder("frstor", 1, 2), null, new FPStoreDecoder("fNsave", 1, 2), new FPStoreDecoder("fNstsw", 1, 2) }, { new FPArithmeticDecoder("fiadd", 1, 2, 0), new FPArithmeticDecoder("fimul", 1, 2, 4), new FPInstructionDecoder("ficom", 1, 2), new FPInstructionDecoder("ficomp", 1, 2), new FPArithmeticDecoder("fisub", 1, 2, 2), new FPArithmeticDecoder("fisubr", 1, 2, 2), new FPArithmeticDecoder("fidiv", 1, 2, 6), new FPArithmeticDecoder("fidivr", 1, 2, 6) }, { new FPLoadDecoder("fild", 1, 2), null, new FPStoreDecoder("fist", 1, 2), new FPStoreDecoder("fistp", 1, 2), new FPLoadDecoder("fbld", 1, 2), new FPLoadDecoder("fildll", 1, 2), new FPStoreDecoder("fbstp", 1, 2), new FPStoreDecoder("fistpll", 1, 2) } };
  private static final FPInstructionDecoder[][] floatMapTwo = { { new FPArithmeticDecoder("fadd", 18, 0, 18, 1, 0), new FPArithmeticDecoder("fmul", 18, 0, 18, 1, 4), new FPInstructionDecoder("fcom", 18, 1), new FPInstructionDecoder("fcomp", 18, 1), new FPArithmeticDecoder("fsub", 18, 0, 18, 1, 2), new FPArithmeticDecoder("fsubr", 18, 0, 18, 1, 2), new FPArithmeticDecoder("fdiv", 18, 0, 18, 1, 6), new FPArithmeticDecoder("fdivr", 18, 0, 18, 1, 6) }, { new FPLoadDecoder("fld", 18, 1), new FPInstructionDecoder("fxch", 18, 1), new FloatGRPDecoder(null, 0), null, new FloatGRPDecoder(null, 1), new FloatGRPDecoder(null, 2), new FloatGRPDecoder(null, 3), new FloatGRPDecoder(null, 4) }, { null, null, null, null, null, new FloatGRPDecoder(null, 5), null, null }, { null, null, null, null, new FloatGRPDecoder(null, 6), null, null, null }, { new FPArithmeticDecoder("fadd", 18, 1, 18, 0, 0), new FPArithmeticDecoder("fmul", 18, 1, 18, 0, 4), null, null, new FPArithmeticDecoder("fsub", 18, 1, 18, 0, 2), new FPArithmeticDecoder("fsubr", 18, 1, 18, 0, 2), new FPArithmeticDecoder("fdiv", 18, 1, 18, 0, 6), new FPArithmeticDecoder("fdivr", 18, 1, 18, 0, 6) }, { new FPInstructionDecoder("ffree", 18, 1), null, new FPStoreDecoder("fst", 18, 1), new FPStoreDecoder("fstp", 18, 1), new FPInstructionDecoder("fucom", 18, 1), new FPInstructionDecoder("fucomp", 18, 1), null, null }, { new FPArithmeticDecoder("faddp", 18, 1, 18, 0, 0), new FPArithmeticDecoder("fmulp", 18, 1, 18, 0, 4), null, new FloatGRPDecoder(null, 7), new FPArithmeticDecoder("fsubrp", 18, 1, 18, 0, 2), new FPArithmeticDecoder("fsubp", 18, 1, 18, 0, 2), new FPArithmeticDecoder("fdivrp", 18, 1, 18, 0, 6), new FPArithmeticDecoder("fdivp", 18, 1, 18, 0, 6) }, { null, null, null, null, new FloatGRPDecoder(null, 7), null, null, null } };
  
  public Instruction decode(byte[] bytesArray, int index, int instrStartIndex, int segmentOverride, int prefixes, X86InstructionFactory factory)
  {
    byteIndex = index;
    this.instrStartIndex = instrStartIndex;
    this.prefixes = prefixes;
    
    int ModRM = readByte(bytesArray, byteIndex);
    int reg = ModRM >> 3 & 0x7;
    int regOrOpcode = ModRM >> 3 & 0x7;
    int rm = ModRM & 0x7;
    
    int floatOpcode = InstructionDecoder.readByte(bytesArray, instrStartIndex);
    FPInstructionDecoder instrDecoder = null;
    if (ModRM < 191) {
      instrDecoder = floatMapOne[(floatOpcode - 216)][reg];
    } else {
      instrDecoder = floatMapTwo[(floatOpcode - 216)][reg];
    }
    Instruction instr = null;
    if (instrDecoder != null)
    {
      instr = instrDecoder.decode(bytesArray, byteIndex, instrStartIndex, segmentOverride, prefixes, factory);
      byteIndex = instrDecoder.getCurrentIndex();
    }
    else
    {
      instr = factory.newIllegalInstruction();
    }
    return instr;
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.asm.x86.FloatDecoder
 * 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;

public class FloatGRPDecoder
  extends FPInstructionDecoder
{
  private final int number;
  private static final FPInstructionDecoder[][] floatGRPMap = { { new FPInstructionDecoder("fnop"), null, null, null, null, null, null, null }, { new FPInstructionDecoder("fchs"), new FPInstructionDecoder("fabs"), null, null, new FPInstructionDecoder("ftst"), new FPInstructionDecoder("fxam"), null, null }, { new FPInstructionDecoder("fld1"), new FPInstructionDecoder("fldl2t"), new FPInstructionDecoder("fldl2e"), new FPInstructionDecoder("fldpi"), new FPInstructionDecoder("fldlg2"), new FPInstructionDecoder("fldln2"), new FPInstructionDecoder("fldz"), null }, { new FPInstructionDecoder("f2xm1"), new FPInstructionDecoder("fyl2x"), new FPInstructionDecoder("fptan"), new FPInstructionDecoder("fpatan"), new FPInstructionDecoder("fxtract"), new FPInstructionDecoder("fprem1"), new FPInstructionDecoder("fdecstp"), new FPInstructionDecoder("fincstp") }, { new FPInstructionDecoder("fprem"), new FPInstructionDecoder("fyl2xp1"), new FPInstructionDecoder("fsqrt"), new FPInstructionDecoder("fsincos"), new FPInstructionDecoder("frndint"), new FPInstructionDecoder("fscale"), new FPInstructionDecoder("fsin"), new FPInstructionDecoder("fcos") }, { null, new FPInstructionDecoder("fucompp"), null, null, null, null, null, null }, { new FPInstructionDecoder("feni(287 only)"), new FPInstructionDecoder("fdisi(287 only)"), new FPInstructionDecoder("fNclex"), new FPInstructionDecoder("fNinit"), new FPInstructionDecoder("fNsetpm(287 only)"), null, null, null }, { null, new FPInstructionDecoder("fcompp"), null, null, null, null, null, null }, { new FPInstructionDecoder("fNstsw"), null, null, null, null, null, null, null } };
  
  public FloatGRPDecoder(String name, int number)
  {
    super(name);
    this.number = number;
  }
  
  public Instruction decode(byte[] bytesArray, int index, int instrStartIndex, int segmentOverride, int prefixes, X86InstructionFactory factory)
  {
    byteIndex = index;
    this.instrStartIndex = instrStartIndex;
    this.prefixes = prefixes;
    
    int ModRM = readByte(bytesArray, byteIndex);
    int rm = ModRM & 0x7;
    
    FPInstructionDecoder instrDecoder = null;
    instrDecoder = floatGRPMap[number][rm];
    
    Instruction instr = null;
    if (instrDecoder != null)
    {
      instr = instrDecoder.decode(bytesArray, byteIndex, instrStartIndex, segmentOverride, prefixes, factory);
      byteIndex = instrDecoder.getCurrentIndex();
    }
    else
    {
      instr = factory.newIllegalInstruction();
    }
    return instr;
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.asm.x86.FloatGRPDecoder
 * 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 FPArithmeticDecoder
  extends FPInstructionDecoder
{
  private int rtlOperation;
  
  public FPArithmeticDecoder(String name, int addrMode1, int operandType1, int rtlOperation)
  {
    super(name, addrMode1, operandType1);
    this.rtlOperation = rtlOperation;
  }
  
  public FPArithmeticDecoder(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.newFPArithmeticInstruction(name, rtlOperation, op1, op2, size, prefixes);
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.asm.x86.FPArithmeticDecoder
 * 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 FPInstructionDecoder
  extends InstructionDecoder
{
  public FPInstructionDecoder(String name)
  {
    super(name);
  }
  
  public FPInstructionDecoder(String name, int addrMode1, int operandType1)
  {
    super(name, addrMode1, operandType1);
  }
  
  public FPInstructionDecoder(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);
    int size = byteIndex - instrStartIndex;
    return new X86FPInstruction(name, op1, size, prefixes);
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.asm.x86.FPInstructionDecoder
 * 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;

class FPLoadDecoder
  extends FPInstructionDecoder
{
  FPLoadDecoder(String name, int addrMode1, int operandType1)
  {
    super(name, addrMode1, operandType1);
  }
  
  protected Instruction decodeInstruction(byte[] bytesArray, boolean operandSize, boolean addrSize, X86InstructionFactory factory)
  {
    Operand op = getOperand1(bytesArray, operandSize, addrSize);
    int size = byteIndex - instrStartIndex;
    return factory.newFPLoadInstruction(name, op, size, prefixes);
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.asm.x86.FPLoadDecoder
 * 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;

class FPStoreDecoder
  extends FPInstructionDecoder
{
  FPStoreDecoder(String name, int addrMode1, int operandType1)
  {
    super(name, addrMode1, operandType1);
  }
  
  protected Instruction decodeInstruction(byte[] bytesArray, boolean operandSize, boolean addrSize, X86InstructionFactory factory)
  {
    Operand op = getOperand1(bytesArray, operandSize, addrSize);
    int size = byteIndex - instrStartIndex;
    return factory.newFPStoreInstruction(name, op, size, prefixes);
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.asm.x86.FPStoreDecoder
 * 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;

public class GRPDecoder
  extends InstructionDecoder
{
  private final int number;
  private static final InstructionDecoder[][] grpTable = { { new ArithmeticDecoder("addb", 1, 1, 2, 1, 0), new LogicalDecoder("orb", 1, 1, 2, 1, 9), new ArithmeticDecoder("adcb", 1, 1, 2, 1, 1), new ArithmeticDecoder("sbbb", 1, 1, 2, 1, 3), new LogicalDecoder("andb", 1, 1, 2, 1, 8), new ArithmeticDecoder("subb", 1, 1, 2, 1, 2), new LogicalDecoder("xorb", 1, 1, 2, 1, 13), new InstructionDecoder("cmpb", 1, 1, 2, 1) }, { new ArithmeticDecoder("addS", 1, 2, 2, 2, 0), new LogicalDecoder("orS", 1, 2, 2, 2, 9), new ArithmeticDecoder("adcS", 1, 2, 2, 2, 1), new ArithmeticDecoder("sbbS", 1, 2, 2, 2, 3), new LogicalDecoder("andS", 1, 2, 2, 2, 8), new ArithmeticDecoder("subS", 1, 2, 2, 2, 2), new LogicalDecoder("xorS", 1, 2, 2, 2, 13), new InstructionDecoder("cmpS", 1, 2, 2, 2) }, { new ArithmeticDecoder("addS", 1, 2, 2, 1, 0), new LogicalDecoder("orS", 1, 2, 2, 1, 9), new ArithmeticDecoder("adcS", 1, 2, 2, 1, 1), new ArithmeticDecoder("sbbS", 1, 2, 2, 1, 3), new LogicalDecoder("andS", 1, 2, 2, 1, 8), new ArithmeticDecoder("subS", 1, 2, 2, 1, 2), new LogicalDecoder("xorS", 1, 2, 2, 1, 13), new InstructionDecoder("cmpS", 1, 2, 2, 1) }, { new RotateDecoder("rolb", 1, 1, 2, 1), new RotateDecoder("rorb", 1, 1, 2, 1), new RotateDecoder("rclb", 1, 1, 2, 1), new RotateDecoder("rcrb", 1, 1, 2, 1), new ShiftDecoder("shlb", 1, 1, 2, 1, 17), new ShiftDecoder("shrb", 1, 1, 2, 1, 15), null, new ShiftDecoder("sarb", 1, 1, 2, 1, 16) }, { new RotateDecoder("rolS", 1, 2, 2, 1), new RotateDecoder("rorS", 1, 2, 2, 1), new RotateDecoder("rclS", 1, 2, 2, 1), new RotateDecoder("rcrS", 1, 2, 2, 1), new ShiftDecoder("shlS", 1, 2, 2, 1, 17), new ShiftDecoder("shrS", 1, 2, 2, 1, 15), null, new ShiftDecoder("sarS", 1, 2, 2, 1, 16) }, { new RotateDecoder("rolb", 1, 1), new RotateDecoder("rorb", 1, 1), new RotateDecoder("rclb", 1, 1), new RotateDecoder("rcrb", 1, 1), new ShiftDecoder("shlb", 1, 1, 17), new ShiftDecoder("shrb", 1, 1, 15), null, new ShiftDecoder("sarb", 1, 1, 16) }, { new RotateDecoder("rolS", 1, 2), new RotateDecoder("rorS", 1, 2), new RotateDecoder("rclS", 1, 2), new RotateDecoder("rcrS", 1, 2), new ShiftDecoder("shlS", 1, 2, 17), new ShiftDecoder("shrS", 1, 2, 15), null, new ShiftDecoder("sarS", 1, 2, 16) }, { new RotateDecoder("rolb", 1, 1, 6, 17), new RotateDecoder("rorb", 1, 1, 6, 17), new RotateDecoder("rclb", 1, 1, 6, 17), new RotateDecoder("rcrb", 1, 1, 6, 17), new ShiftDecoder("shlb", 1, 1, 6, 17, 17), new ShiftDecoder("shrb", 1, 1, 6, 17, 15), null, new ShiftDecoder("sarb", 1, 1, 6, 17, 16) }, { new RotateDecoder("rolS", 1, 2, 6, 17), new RotateDecoder("rorS", 1, 2, 6, 17), new RotateDecoder("rclS", 1, 2, 6, 17), new RotateDecoder("rcrS", 1, 2, 6, 17), new ShiftDecoder("shlS", 1, 2, 6, 17, 17), new ShiftDecoder("shrS", 1, 2, 6, 17, 15), null, new ShiftDecoder("sarS", 1, 2, 6, 17, 16) }, { new InstructionDecoder("testb", 1, 1, 2, 1), null, new LogicalDecoder("notb", 1, 1, 10), new InstructionDecoder("negb", 1, 1), new ArithmeticDecoder("mulb", 6, 16, 1, 1, 5), new ArithmeticDecoder("imulb", 6, 16, 1, 1, 4), new ArithmeticDecoder("divb", 6, 16, 1, 1, 7), new ArithmeticDecoder("idivb", 6, 16, 1, 1, 6) }, { new InstructionDecoder("testS", 1, 2, 2, 2), null, new LogicalDecoder("notS", 1, 2, 10), new InstructionDecoder("negS", 1, 2), new ArithmeticDecoder("mulS", 6, 0, 1, 2, 5), new ArithmeticDecoder("imulS", 6, 0, 1, 2, 4), new ArithmeticDecoder("divS", 6, 0, 1, 2, 6), new ArithmeticDecoder("idivS", 6, 0, 1, 2, 6) }, { new ArithmeticDecoder("incb", 1, 1, 0), new ArithmeticDecoder("decb", 1, 1, 2), null, null, null, null, null, null }, { new ArithmeticDecoder("incS", 1, 2, 0), new ArithmeticDecoder("decS", 1, 2, 2), new CallDecoder("call", 1, 2), new CallDecoder("lcall", 1, 5), new JmpDecoder("jmp", 1, 2), new JmpDecoder("ljmp", 1, 5), new InstructionDecoder("pushS", 1, 2), null }, { new InstructionDecoder("sldt", 1, 3), new InstructionDecoder("str", 1, 3), new InstructionDecoder("lldt", 1, 3), new InstructionDecoder("ltr", 1, 3), new InstructionDecoder("verr", 1, 3), new InstructionDecoder("verw", 1, 3), null, null }, { new InstructionDecoder("sgdt", 1, 3), new InstructionDecoder("sidt", 1, 3), new InstructionDecoder("lgdt", 1, 3), new InstructionDecoder("lidt", 1, 3), new InstructionDecoder("smsw", 1, 3), null, new InstructionDecoder("lmsw", 1, 3), new InstructionDecoder("invlpg", 1, 3) }, { null, null, null, null, new InstructionDecoder("btS", 1, 2, 2, 1), new InstructionDecoder("btsS", 1, 2, 2, 1), new InstructionDecoder("btrS", 1, 2, 2, 1), new InstructionDecoder("btcS", 1, 2, 2, 1) }, { null, new SSEInstructionDecoder("cmpxch8b", 19, 11), null, null, null, null, null, null }, { null, null, new SSEShiftDecoder("psrlw", 22, 11, 2, 1, 15), null, new SSEShiftDecoder("psraw", 22, 11, 2, 1, 16), null, new SSEShiftDecoder("psllw", 22, 11, 2, 1, 17), null }, { null, null, new SSEShiftDecoder("psrld", 22, 11, 2, 1, 15), null, new SSEShiftDecoder("psrad", 22, 11, 2, 1, 16), null, new SSEShiftDecoder("pslld", 22, 11, 2, 1, 17), null }, { null, null, new SSEShiftDecoder("psrlq", 22, 11, 2, 1, 15), null, null, null, new SSEShiftDecoder("psllq", 22, 11, 2, 1, 17), null }, { new SSEInstructionDecoder("fxsave"), new SSEInstructionDecoder("fxrstor"), new SSEInstructionDecoder("ldmxcsr"), new SSEInstructionDecoder("stmxcsr"), null, null, null, new SSEInstructionDecoder("clflush") }, { new SSEInstructionDecoder("prefetchnta"), new SSEInstructionDecoder("prefetcht0"), new SSEInstructionDecoder("prefetcht1"), new SSEInstructionDecoder("prefetcht2"), null, null, null, null }, { null, null, new SSEShiftDecoder("psrlw", 22, 6, 2, 1, 15), null, new SSEShiftDecoder("psraw", 22, 6, 2, 1, 16), null, new SSEShiftDecoder("psllw", 22, 6, 2, 1, 17), null }, { null, null, new SSEShiftDecoder("psrld", 19, 6, 2, 1, 15), null, new SSEShiftDecoder("psrad", 19, 6, 2, 1, 16), null, new SSEShiftDecoder("pslld", 19, 6, 2, 1, 17), null }, { null, null, new SSEShiftDecoder("psrlq", 19, 6, 2, 1, 15), new SSEShiftDecoder("psrldq", 19, 6, 2, 1, 15), null, null, new SSEShiftDecoder("psllq", 19, 6, 2, 1, 17), new SSEShiftDecoder("psllq", 19, 6, 2, 1, 17) } };
  
  public GRPDecoder(String name, int number)
  {
    super(name);
    this.number = number;
  }
  
  public Instruction decode(byte[] bytesArray, int index, int instrStartIndex, int segmentOverride, int prefixes, X86InstructionFactory factory)
  {
    byteIndex = index;
    this.instrStartIndex = instrStartIndex;
    this.prefixes = prefixes;
    
    int ModRM = readByte(bytesArray, byteIndex);
    int reg = ModRM >> 3 & 0x7;
    
    InstructionDecoder instrDecoder = grpTable[number][reg];
    Instruction instr = null;
    if (instrDecoder != null)
    {
      instr = instrDecoder.decode(bytesArray, byteIndex, instrStartIndex, segmentOverride, prefixes, factory);
      byteIndex = instrDecoder.getCurrentIndex();
    }
    else
    {
      instr = factory.newIllegalInstruction();
    }
    return instr;
  }
}

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

import sun.jvm.hotspot.asm.Immediate;
import sun.jvm.hotspot.asm.Instruction;
import sun.jvm.hotspot.asm.Operand;
import sun.jvm.hotspot.asm.RTLDataTypes;
import sun.jvm.hotspot.asm.RTLOperations;

public class InstructionDecoder
  implements X86Opcodes, RTLDataTypes, RTLOperations
{
  protected String name;
  protected int addrMode1;
  protected int operandType1;
  protected int addrMode2;
  protected int operandType2;
  protected int addrMode3;
  protected int operandType3;
  private int mod;
  private int regOrOpcode;
  private int rm;
  protected int prefixes;
  protected int byteIndex;
  protected int instrStartIndex;
  
  public InstructionDecoder(String name)
  {
    this.name = name;
    operandType1 = -1;
    operandType2 = -1;
    operandType3 = -1;
    addrMode1 = -1;
    addrMode2 = -1;
    addrMode3 = -1;
  }
  
  public InstructionDecoder(String name, int addrMode1, int operandType1)
  {
    this(name);
    this.addrMode1 = addrMode1;
    this.operandType1 = operandType1;
  }
  
  public InstructionDecoder(String name, int addrMode1, int operandType1, int addrMode2, int operandType2)
  {
    this(name, addrMode1, operandType1);
    this.addrMode2 = addrMode2;
    this.operandType2 = operandType2;
  }
  
  public InstructionDecoder(String name, int addrMode1, int operandType1, int addrMode2, int operandType2, int addrMode3, int operandType3)
  {
    this(name, addrMode1, operandType1, addrMode2, operandType2);
    this.addrMode3 = addrMode3;
    this.operandType3 = operandType3;
  }
  
  protected Operand getOperand1(byte[] bytesArray, boolean operandSize, boolean addrSize)
  {
    if ((addrMode1 != -1) && (operandType1 != -1)) {
      return getOperand(bytesArray, addrMode1, operandType1, operandSize, addrSize);
    }
    return null;
  }
  
  protected Operand getOperand2(byte[] bytesArray, boolean operandSize, boolean addrSize)
  {
    if ((addrMode2 != -1) && (operandType2 != -1)) {
      return getOperand(bytesArray, addrMode2, operandType2, operandSize, addrSize);
    }
    return null;
  }
  
  protected Operand getOperand3(byte[] bytesArray, boolean operandSize, boolean addrSize)
  {
    if ((addrMode3 != -1) && (operandType3 != -1)) {
      return getOperand(bytesArray, addrMode3, operandType3, operandSize, addrSize);
    }
    return null;
  }
  
  static int readInt32(byte[] bytesArray, int index)
  {
    int ret = 0;
    ret = readByte(bytesArray, index);
    ret |= readByte(bytesArray, index + 1) << 8;
    ret |= readByte(bytesArray, index + 2) << 16;
    ret |= readByte(bytesArray, index + 3) << 24;
    return ret;
  }
  
  static int readInt16(byte[] bytesArray, int index)
  {
    int ret = 0;
    ret = readByte(bytesArray, index);
    ret |= readByte(bytesArray, index + 1) << 8;
    return ret;
  }
  
  static int readByte(byte[] bytesArray, int index)
  {
    int ret = 0;
    if (index < bytesArray.length)
    {
      ret = bytesArray[index];
      ret &= 0xFF;
    }
    return ret;
  }
  
  private boolean isModRMPresent(int addrMode)
  {
    if ((addrMode == 1) || (addrMode == 5) || (addrMode == 18) || (addrMode == 20) || (addrMode == 19)) {
      return true;
    }
    return false;
  }
  
  public int getCurrentIndex()
  {
    return byteIndex;
  }
  
  public Instruction decode(byte[] bytesArray, int index, int instrStartIndex, int segmentOverride, int prefixes, X86InstructionFactory factory)
  {
    byteIndex = index;
    this.instrStartIndex = instrStartIndex;
    this.prefixes = prefixes;
    boolean operandSize;
    boolean operandSize;
    if ((prefixes & 0x200 ^ segmentOverride) == 1) {
      operandSize = true;
    } else {
      operandSize = false;
    }
    boolean addrSize;
    boolean addrSize;
    if ((prefixes & 0x400 ^ segmentOverride) == 1) {
      addrSize = true;
    } else {
      addrSize = false;
    }
    name = getCorrectOpcodeName(name, prefixes, operandSize, addrSize);
    if ((isModRMPresent(addrMode1)) || (isModRMPresent(addrMode2)) || (isModRMPresent(addrMode3)))
    {
      int ModRM = readByte(bytesArray, byteIndex);
      byteIndex += 1;
      mod = (ModRM >> 6 & 0x3);
      regOrOpcode = (ModRM >> 3 & 0x7);
      rm = (ModRM & 0x7);
    }
    return decodeInstruction(bytesArray, operandSize, addrSize, factory);
  }
  
  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, prefixes);
  }
  
  private String getCorrectOpcodeName(String oldName, int prefixes, boolean operandSize, boolean addrSize)
  {
    StringBuffer newName = new StringBuffer(oldName);
    int index = 0;
    for (index = 0; index < oldName.length(); index++) {
      switch (oldName.charAt(index))
      {
      case 'C': 
        if (addrSize) {
          newName.setCharAt(index, 'e');
        }
        index++;
        break;
      case 'N': 
        if ((prefixes & 0x800) == 0) {
          newName.setCharAt(index, 'n');
        }
        index++;
        break;
      case 'S': 
        if (operandSize == true) {
          newName.se
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