sa-jdi

arc;

public class SPARCV9SavedInstruction
  extends SPARCInstruction
  implements SPARCV9Instruction
{
  public SPARCV9SavedInstruction()
  {
    super("saved");
  }
}

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

public class SPARCV9SirInstruction
  extends SPARCInstruction
  implements SPARCV9Instruction
{
  public SPARCV9SirInstruction()
  {
    super("sir");
  }
}

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

import sun.jvm.hotspot.asm.SymbolFinder;

public abstract class SPARCV9SpecialRegisterInstruction
  extends SPARCInstruction
  implements SPARCV9SpecialRegisters, SPARCV9Instruction
{
  protected SPARCV9SpecialRegisterInstruction(String name)
  {
    super(name);
  }
  
  protected abstract String getDescription();
  
  public String asString(long currentPc, SymbolFinder symFinder)
  {
    return getDescription();
  }
  
  protected static String[] specialRegNames = { "%y", null, "%ccr", "%asi", "%tick", "%pc", "%fprs", "%asr" };
  
  protected static String getSpecialRegisterName(int index)
  {
    return specialRegNames[index];
  }
}

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

public abstract interface SPARCV9SpecialRegisters
{
  public static final int Y = 0;
  public static final int CCR = 2;
  public static final int ASI = 3;
  public static final int TICK = 4;
  public static final int PC = 5;
  public static final int FPRS = 6;
  public static final int ASR = 7;
}

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

public class SPARCV9WriteInstruction
  extends SPARCV9SpecialRegisterInstruction
{
  private final int specialReg;
  private final int asrRegNum;
  private final SPARCRegister rs1;
  private final ImmediateOrRegister operand2;
  
  public SPARCV9WriteInstruction(int specialReg, int asrRegNum, SPARCRegister rs1, ImmediateOrRegister operand2)
  {
    super("wr");
    this.specialReg = specialReg;
    this.asrRegNum = asrRegNum;
    this.rs1 = rs1;
    this.operand2 = operand2;
  }
  
  public int getSpecialRegister()
  {
    return specialReg;
  }
  
  public int getAncillaryRegister()
  {
    if (Assert.ASSERTS_ENABLED) {
      Assert.that(specialReg == 7, "not an ancillary register");
    }
    return asrRegNum;
  }
  
  protected String getDescription()
  {
    StringBuffer buf = new StringBuffer();
    buf.append(getName());
    buf.append(spaces);
    buf.append(rs1.toString());
    buf.append(comma);
    if (operand2.isRegister())
    {
      buf.append(operand2.toString());
    }
    else
    {
      Number number = ((Immediate)operand2).getNumber();
      buf.append("0x");
      buf.append(Integer.toHexString(number.intValue()));
    }
    buf.append(comma);
    if (specialReg == 7) {
      buf.append("%asr" + asrRegNum);
    } else {
      buf.append(getSpecialRegisterName(specialReg));
    }
    return buf.toString();
  }
}

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

public class SPARCV9WrprInstruction
  extends SPARCV9PrivilegedRegisterInstruction
{
  private final SPARCRegister rs1;
  private final ImmediateOrRegister operand2;
  
  public SPARCV9WrprInstruction(SPARCRegister rs1, ImmediateOrRegister operand2, int regNum)
  {
    super("wrpr", regNum);
    this.rs1 = rs1;
    this.operand2 = operand2;
  }
  
  protected String getDescription()
  {
    StringBuffer buf = new StringBuffer();
    buf.append(getName());
    buf.append(spaces);
    buf.append(rs1.toString());
    buf.append(comma);
    if (operand2.isRegister())
    {
      buf.append(operand2.toString());
    }
    else
    {
      int value = ((Immediate)operand2).getNumber().intValue();
      buf.append(Integer.toHexString(value));
    }
    buf.append(comma);
    buf.append(getPrivilegedRegisterName(regNum));
    return buf.toString();
  }
  
  public SPARCRegister getSourceRegister1()
  {
    return rs1;
  }
  
  public ImmediateOrRegister getOperand2()
  {
    return operand2;
  }
}

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

public class SPARCWriteInstruction
  extends SPARCSpecialRegisterInstruction
{
  private final int specialReg;
  private final int asrRegNum;
  private final SPARCRegister rs1;
  private final ImmediateOrRegister operand2;
  
  public SPARCWriteInstruction(int specialReg, int asrRegNum, SPARCRegister rs1, ImmediateOrRegister operand2)
  {
    super("wr");
    this.specialReg = specialReg;
    this.asrRegNum = asrRegNum;
    this.rs1 = rs1;
    this.operand2 = operand2;
  }
  
  public int getSpecialRegister()
  {
    return specialReg;
  }
  
  public int getAncillaryRegister()
  {
    if (Assert.ASSERTS_ENABLED) {
      Assert.that(specialReg == 4, "not an ancillary register");
    }
    return asrRegNum;
  }
  
  protected String getDescription()
  {
    StringBuffer buf = new StringBuffer();
    buf.append(getName());
    buf.append(spaces);
    buf.append(rs1.toString());
    buf.append(comma);
    if (operand2.isRegister())
    {
      buf.append(operand2.toString());
    }
    else
    {
      Number number = ((Immediate)operand2).getNumber();
      buf.append("0x");
      buf.append(Integer.toHexString(number.intValue()));
    }
    buf.append(comma);
    if (specialReg == 4) {
      buf.append("%asr" + asrRegNum);
    } else {
      buf.append(getSpecialRegisterName(specialReg));
    }
    return buf.toString();
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.asm.sparc.SPARCWriteInstruction
 * 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 SpecialLoadDecoder
  extends SpecialLoadStoreDecoder
{
  SpecialLoadDecoder(int op3, String name, int specialRegNum)
  {
    super(op3, name, specialRegNum);
  }
  
  Instruction decodeSpecialLoadStoreInstruction(int cregNum, SPARCRegisterIndirectAddress addr, SPARCInstructionFactory factory)
  {
    return factory.newSpecialLoadInstruction(name, specialRegNum, cregNum, addr);
  }
}

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

abstract class SpecialLoadStoreDecoder
  extends MemoryInstructionDecoder
{
  final int specialRegNum;
  
  SpecialLoadStoreDecoder(int op3, String name, int specialRegNum)
  {
    super(op3, name, Integer.MAX_VALUE);
    this.specialRegNum = specialRegNum;
  }
  
  final Instruction decodeMemoryInstruction(int instruction, SPARCRegisterIndirectAddress addr, SPARCRegister rd, SPARCInstructionFactory factory)
  {
    int cregNum = getSourceRegister1(instruction);
    return decodeSpecialLoadStoreInstruction(cregNum, addr, factory);
  }
  
  abstract Instruction decodeSpecialLoadStoreInstruction(int paramInt, SPARCRegisterIndirectAddress paramSPARCRegisterIndirectAddress, SPARCInstructionFactory paramSPARCInstructionFactory);
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.asm.sparc.SpecialLoadStoreDecoder
 * 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 SpecialStoreDecoder
  extends SpecialLoadStoreDecoder
{
  SpecialStoreDecoder(int op3, String name, int specialRegNum)
  {
    super(op3, name, specialRegNum);
  }
  
  Instruction decodeSpecialLoadStoreInstruction(int cregNum, SPARCRegisterIndirectAddress addr, SPARCInstructionFactory factory)
  {
    return factory.newSpecialStoreInstruction(name, specialRegNum, cregNum, addr);
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.asm.sparc.SpecialStoreDecoder
 * 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 StoreDecoder
  extends MemoryInstructionDecoder
{
  StoreDecoder(int op3, String name, int dataType)
  {
    super(op3, name, dataType);
  }
  
  Instruction decodeMemoryInstruction(int instruction, SPARCRegisterIndirectAddress addr, SPARCRegister rd, SPARCInstructionFactory factory)
  {
    return factory.newStoreInstruction(name, op3, addr, rd, dataType);
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.asm.sparc.StoreDecoder
 * 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 SwapDecoder
  extends MemoryInstructionDecoder
{
  SwapDecoder(int op3, String name, int dataType)
  {
    super(op3, name, dataType);
  }
  
  Instruction decodeMemoryInstruction(int instruction, SPARCRegisterIndirectAddress addr, SPARCRegister rd, SPARCInstructionFactory factory)
  {
    return factory.newSwapInstruction(name, addr, rd);
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.asm.sparc.SwapDecoder
 * 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 TrapDecoder
  extends InstructionDecoder
{
  private static final String[] trapConditionNames = { "tn", "te", "tle", "tl", "tleu", "tcs", "tneg", "tvs", "ta", "tne", "tg", "tge", "tgu", "tcc", "tpos", "tvc" };
  
  static String getTrapConditionName(int index)
  {
    return trapConditionNames[index];
  }
  
  Instruction decode(int instruction, SPARCInstructionFactory factory)
  {
    int conditionCode = getConditionCode(instruction);
    return factory.newTrapInstruction(getTrapConditionName(conditionCode), conditionCode);
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.asm.sparc.TrapDecoder
 * 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 UnimpDecoder
  extends InstructionDecoder
{
  Instruction decode(int instruction, SPARCInstructionFactory factory)
  {
    return factory.newUnimpInstruction(instruction & 0x3FFFFF);
  }
}

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

import java.util.HashMap;
import java.util.Map;

class V8FPop1Decoder
  extends FPopDecoder
{
  static Map opfDecoders = new HashMap();
  
  static void addOpfDecoder(int fpOpcode, InstructionDecoder decoder)
  {
    opfDecoders.put(new Integer(fpOpcode), decoder);
  }
  
  static
  {
    addOpfDecoder(1, new FPMoveDecoder(1, "fmovs", 10, 10));
    addOpfDecoder(5, new FP2RegisterDecoder(5, "fnegs", 10, 10));
    addOpfDecoder(9, new FP2RegisterDecoder(9, "fabss", 10, 10));
    addOpfDecoder(41, new FP2RegisterDecoder(41, "fsqrts", 10, 10));
    addOpfDecoder(42, new FP2RegisterDecoder(42, "fsqrtd", 11, 11));
    addOpfDecoder(43, new FP2RegisterDecoder(43, "fsqrtq", 13, 13));
    addOpfDecoder(65, new FPArithmeticDecoder(65, "fadds", 0, 10, 10, 10));
    addOpfDecoder(66, new FPArithmeticDecoder(66, "faddd", 0, 11, 11, 11));
    addOpfDecoder(67, new FPArithmeticDecoder(67, "faddq", 0, 13, 13, 13));
    addOpfDecoder(69, new FPArithmeticDecoder(69, "fsubs", 2, 10, 10, 10));
    addOpfDecoder(70, new FPArithmeticDecoder(70, "fsubd", 2, 11, 11, 11));
    addOpfDecoder(71, new FPArithmeticDecoder(71, "fsubq", 2, 13, 13, 13));
    addOpfDecoder(73, new FPArithmeticDecoder(73, "fmuls", 4, 10, 10, 10));
    addOpfDecoder(74, new FPArithmeticDecoder(74, "fmuld", 4, 11, 11, 11));
    addOpfDecoder(75, new FPArithmeticDecoder(75, "fmulq", 4, 13, 13, 13));
    addOpfDecoder(105, new FPArithmeticDecoder(105, "fsmuld", 4, 10, 10, 11));
    addOpfDecoder(110, new FPArithmeticDecoder(110, "fdmulq", 4, 11, 11, 13));
    addOpfDecoder(77, new FPArithmeticDecoder(77, "fdivs", 6, 10, 10, 10));
    addOpfDecoder(78, new FPArithmeticDecoder(78, "fdivd", 6, 11, 11, 11));
    addOpfDecoder(79, new FPArithmeticDecoder(79, "fdivq", 6, 13, 13, 13));
    addOpfDecoder(196, new FP2RegisterDecoder(196, "fitos", 10, 10));
    addOpfDecoder(200, new FP2RegisterDecoder(200, "fitod", 10, 11));
    addOpfDecoder(204, new FP2RegisterDecoder(204, "fitoq", 10, 13));
    addOpfDecoder(209, new FP2RegisterDecoder(209, "fstoi", 10, 10));
    addOpfDecoder(210, new FP2RegisterDecoder(210, "fdtoi", 11, 10));
    addOpfDecoder(211, new FP2RegisterDecoder(211, "fqtoi", 13, 10));
    addOpfDecoder(201, new FP2RegisterDecoder(201, "fstod", 10, 11));
    addOpfDecoder(205, new FP2RegisterDecoder(205, "fstoq", 10, 13));
    addOpfDecoder(198, new FP2RegisterDecoder(198, "fdtos", 11, 10));
    addOpfDecoder(206, new FP2RegisterDecoder(206, "fdtoq", 11, 13));
    addOpfDecoder(199, new FP2RegisterDecoder(199, "fqtos", 13, 10));
    addOpfDecoder(203, new FP2RegisterDecoder(203, "fqtod", 13, 11));
  }
  
  InstructionDecoder getOpfDecoder(int opf)
  {
    return (InstructionDecoder)opfDecoders.get(new Integer(opf));
  }
}

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

import java.util.HashMap;
import java.util.Map;

class V8FPop2Decoder
  extends FPopDecoder
{
  static Map fpop2Decoders = new HashMap();
  
  static void addFPop2Decoder(int fpOpcode, InstructionDecoder decoder)
  {
    fpop2Decoders.put(new Integer(fpOpcode), decoder);
  }
  
  static
  {
    addFPop2Decoder(81, new FP2RegisterDecoder(81, "fcmps", 10, 10));
    addFPop2Decoder(82, new FP2RegisterDecoder(82, "fcmpd", 11, 11));
    addFPop2Decoder(83, new FP2RegisterDecoder(83, "fcmpq", 13, 13));
    addFPop2Decoder(85, new FP2RegisterDecoder(85, "fcmpes", 10, 10));
    addFPop2Decoder(86, new FP2RegisterDecoder(86, "fcmped", 11, 11));
    addFPop2Decoder(87, new FP2RegisterDecoder(87, "fcmpeq", 13, 13));
  }
  
  InstructionDecoder getOpfDecoder(int opf)
  {
    return (InstructionDecoder)fpop2Decoders.get(new Integer(opf));
  }
}

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

abstract class V9AlternateSpaceDecoder
  extends MemoryInstructionDecoder
  implements V9InstructionDecoder
{
  V9AlternateSpaceDecoder(int op3, String name, int dataType)
  {
    super(op3, name, dataType);
  }
  
  SPARCRegisterIndirectAddress newRegisterIndirectAddress(SPARCRegister rs1, SPARCRegister rs2)
  {
    return new SPARCV9RegisterIndirectAddress(rs1, rs2);
  }
  
  SPARCRegisterIndirectAddress newRegisterIndirectAddress(SPARCRegister rs1, int offset)
  {
    return new SPARCV9RegisterIndirectAddress(rs1, offset);
  }
  
  abstract Instruction decodeV9AsiLoadStore(int paramInt, SPARCV9RegisterIndirectAddress paramSPARCV9RegisterIndirectAddress, SPARCRegister paramSPARCRegister, SPARCV9InstructionFactory paramSPARCV9InstructionFactory);
  
  Instruction decodeMemoryInstruction(int instruction, SPARCRegisterIndirectAddress addr, SPARCRegister rd, SPARCInstructionFactory factory)
  {
    SPARCV9RegisterIndirectAddress v9addr = (SPARCV9RegisterIndirectAddress)addr;
    if (isIBitSet(instruction))
    {
      v9addr.setIndirectAsi(true);
    }
    else
    {
      int asi = (instruction & 0x1FE0) >>> 5;
      v9addr.setAddressSpace(asi);
    }
    return decodeV9AsiLoadStore(instruction, v9addr, rd, (SPARCV9InstructionFactory)factory);
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.asm.sparc.V9AlternateSpaceDecoder
 * 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 V9AlternateSpaceLdstubDecoder
  extends V9AlternateSpaceDecoder
{
  V9AlternateSpaceLdstubDecoder(int op3, String name, int dataType)
  {
    super(op3, name, dataType);
  }
  
  Instruction decodeV9AsiLoadStore(int instruction, SPARCV9RegisterIndirectAddress addr, SPARCRegister rd, SPARCV9InstructionFactory factory)
  {
    return factory.newLdstubInstruction(name, addr, rd);
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.asm.sparc.V9AlternateSpaceLdstubDecoder
 * 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 V9AlternateSpaceLoadDecoder
  extends V9AlternateSpaceDecoder
{
  V9AlternateSpaceLoadDecoder(int op3, String name, int dataType)
  {
    super(op3, name, dataType);
  }
  
  Instruction decodeV9AsiLoadStore(int instruction, SPARCV9RegisterIndirectAddress addr, SPARCRegister rd, SPARCV9InstructionFactory factory)
  {
    return factory.newLoadInstruction(name, op3, addr, rd, dataType);
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.asm.sparc.V9AlternateSpaceLoadDecoder
 * 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 V9AlternateSpacePrefetchDecoder
  extends V9AlternateSpaceDecoder
{
  V9AlternateSpacePrefetchDecoder()
  {
    super(61, "prefetcha", 4);
  }
  
  Instruction decodeV9AsiLoadStore(int instruction, SPARCV9RegisterIndirectAddress addr, SPARCRegister rd, SPARCV9InstructionFactory factory)
  {
    SPARCV9InstructionFactory v9factory = factory;
    return v9factory.newV9PrefetchInstruction(name, addr, rd.getNumber());
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.asm.sparc.V9AlternateSpacePrefetchDecoder
 * 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 V9AlternateSpaceStoreDecoder
  extends V9AlternateSpaceDecoder
{
  V9AlternateSpaceStoreDecoder(int op3, String name, int dataType)
  {
    super(op3, name, dataType);
  }
  
  Instruction decodeV9AsiLoadStore(int instruction, SPARCV9RegisterIndirectAddress addr, SPARCRegister rd, SPARCV9InstructionFactory factory)
  {
    return factory.newStoreInstruction(name, op3, addr, rd, dataType);
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.asm.sparc.V9AlternateSpaceStoreDecoder
 * 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 V9AlternateSpaceSwapDecoder
  extends V9AlternateSpaceDecoder
{
  V9AlternateSpaceSwapDecoder(int op3, String name, int dataType)
  {
    super(op3, name, dataType);
  }
  
  Instruction decodeV9AsiLoadStore(int instruction, SPARCV9RegisterIndirectAddress addr, SPARCRegister rd, SPARCV9InstructionFactory factory)
  {
    return factory.newSwapInstruction(name, addr, rd);
  }
}

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

abstract class V9BranchDecoder
  extends BranchDecoder
  implements V9InstructionDecoder
{
  static boolean getPredictTaken(int instruction)
  {
    return (0x80000 & instruction) != 0;
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.asm.sparc.V9BranchDecoder
 * 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 V9CasDecoder
  extends V9AlternateSpaceDecoder
{
  V9CasDecoder(int op3, String name, int dataType)
  {
    super(op3, name, dataType);
  }
  
  Instruction decodeV9AsiLoadStore(int instruction, SPARCV9RegisterIndirectAddress addr, SPARCRegister rd, SPARCV9InstructionFactory factory)
  {
    SPARCV9InstructionFactory v9factory = factory;
    SPARCRegister rs2 = SPARCRegisters.getRegister(getSourceRegister2(instruction));
    return v9factory.newV9CasInstruction(name, addr, rs2, rd, dataType);
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.asm.sparc.V9CasDecoder
 * 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 V9CCBranchDecoder
  extends V9BranchDecoder
{
  abstract int getConditionFlag(int paramInt);
  
  Instruction decode(int instruction, SPARCInstructionFactory factory)
  {
    SPARCV9InstructionFactory v9factory = (SPARCV9InstructionFactory)factory;
    int conditionFlag = getConditionFlag(instruction);
    boolean predictTaken = getPredictTaken(instruction);
    int conditionCode = getConditionCode(instruction);
    boolean annuled = getAnnuledBit(instruction);
    String name = getConditionName(conditionCode, annuled);
    
    PCRelativeAddress addr = new PCRelativeAddress(extractSignedIntFromNBits(instruction, 19) << 2);
    return v9factory.newV9BranchInstruction(name, addr, annuled, conditionCode, predictTaken, conditionFlag);
  }
}

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

abstract class V9CMoveDecoder
  extends InstructionDecoder
  implements V9InstructionDecoder
{
  private static final String[] iccConditionNames = { "n", "e", "le", "l", "leu", "cs", "neg", "vs", "a", "ne", "g", "ge", "gu", "cc", "pos", "vc" };
  private static final String[] fccConditionNames = { "fn", "fne", "flg", "ful", "fl", "fug", "fg", "fu", "fa", "fe", "fue", "fge", "fuge", "fle", "fule", "fo" };
  
  static String getConditionName(int conditionCode, int conditionFlag)
  {
    return (conditionFlag == 4) || (conditionFlag == 6) ? iccConditionNames[conditionCode] : fccConditionNames[conditionCode];
  }
  
  static int getMoveConditionCode(int instruction)
  {
    return (instruction & 0x3C000) >>> 14;
  }
  
  static int getRegisterConditionCode(int instruction)
  {
    return (instruction & 0x1C00) >>> 10;
  }
  
  static ImmediateOrRegister getCMoveSource(int instruction, int numBits)
  {
    ImmediateOrRegister source = null;
    if (isIBitSet(instruction)) {
      source = new Immediate(new Short((short)extractSignedIntFromNBits(instruction, numBits)));
    } else {
      source = SPARCRegisters.getRegister(getSourceRegister2(instruction));
    }
    return source;
  }
  
  static String getFloatTypeCode(int dataType)
  {
    String result = null;
    switch (dataType)
    {
    case 10: 
      result = "s";
      break;
    case 11: 
      result = "d";
      break;
    case 13: 
      result = "q";
      break;
    case 12: 
    default: 
      if (Assert.ASSERTS_ENABLED) {
        Assert.that(false, "should not reach here");
      }
      break;
    }
    return result;
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.asm.sparc.V9CMoveDecoder
 * 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 V9DoneRetryDecoder
  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.newV9DoneInstruction();
      break;
    case 1: 
      instr = v9factory.newV9RetryInstruction();
      break;
    default: 
      instr = v9factory.newIllegalInstruction(instruction);
    }
    return instr;
  }
}

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

class V9FloatBranchDecoder
  extends V9CCBranchDecoder
{
  String getConditionName(int conditionCode, boolean isAnnuled)
  {
    return isAnnuled ? floatAnnuledConditionNames[conditionCode] : floatConditionNames[conditionCode];
  }
  
  int getConditionFlag(int instruction)
  {
    return (0x300000 & instruction) >>> 20;
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.asm.sparc.V9FloatBranchDecoder
 * 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 V9FlushwDecoder
  extends InstructionDecoder
  implements V9InstructionDecoder
{
  Instruction decode(int instruction, SPARCInstructionFactory factory)
  {
    SPARCV9InstructionFactory v9factory = (SPARCV9InstructionFactory)factory;
    Instruction instr = null;
    if (isIBitSet(instruction)) {
      instr = v9factory.newIllegalInstruction(instruction);
    } else {
      instr = v9factory.newV9FlushwInstruction();
    }
    return instr;
  }
}

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

class V9FMOVccDecoder
  extends V9CMoveDecoder
  implements RTLDataTypes
{
  private final int opf;
  private final int dataType;
  
  V9FMOVccDecoder(int opf, int dataType)
  {
    this.opf = opf;
    this.dataType = dataType;
  }
  
  private static String getFMoveCCName(int conditionCode, int conditionFlag, int dataType)
  {
    StringBuffer buf = new StringBuffer("fmov");
    buf.append(getFloatTypeCode(dataType));
    buf.append(getConditionName(conditionCode, conditionFlag));
    return buf.toString();
  }
  
  private static int getFMoveConditionFlag(int instruction)
  {
    return (instruction & 0x3800) >>> 11;
  }
  
  Instruction decode(int instruction, SPARCInstructionFactory factory)
  {
    SPARCV9InstructionFactory v9factory = (SPARCV9InstructionFactory)factory;
    Instruction instr = null;
    int conditionFlag = getFMoveConditionFlag(instruction);
    if ((conditionFlag == 5) || (conditionFlag == 7))
    {
      instr = v9factory.newIllegalInstruction(instruction);
    }
    else
    {
      int rdNum = getDestinationRegister(instruction);
      int rs1Num = getSourceRegister1(instruction);
      SPARCRegister rd = RegisterDecoder.decode(dataType, rdNum);
      int conditionCode = getMoveConditionCode(instruction);
      SPARCRegister rs = RegisterDecoder.decode(dataType, rs1Num);
      String name = getFMoveCCName(conditionCode, conditionFlag, dataType);
      instr = v9factory.newV9FMOVccInstruction(name, opf, conditionCode, conditionFlag, (SPARCFloatRegister)rs, (SPARCFloatRegister)rd);
    }
    return instr;
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.asm.sparc.V9FMOVccDecoder
 * 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 V9FMOVrDecoder
  extends V9CMoveDecoder
{
  private final int opf;
  private final String name;
  private final int dataType;
  
  V9FMOVrDecoder(int opf, String name, int dataType)
  {
    this.opf = opf;
    this.name = name;
    this.dataType = dataType;
  }
  
  Instruction decode(int instruction, SPARCInstructionFactory factory)
  {
    SPARCV9InstructionFactory v9factory = (SPARCV9InstructionFactory)factory;
    int regConditionCode = getRegisterConditionCode(instruction);
    int rdNum = getDestinationRegister(instruction);
    int rs1Num = getSourceRegister1(instruction);
    int rs2Num = getSourceRegister2(instruction);
    SPARCRegister rd = RegisterDecoder.decode(dataType, rdNum);
    SPARCRegister rs2 = RegisterDecoder.decode(dataType, rs2Num);
    SPARCRegister rs1 = SPARCRegisters.getRegister(rs1Num);
    return v9factory.newV9FMOVrInstruction(name, opf, rs1, (SPARCFloatRegister)rs2, (SPARCFloatRegister)rd, regConditionCode);
  }
}

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

import java.util.HashMap;
import java.util.Map;

class V9FPop1Decoder
  extends FPopDecoder
  implements V9InstructionDecoder
{
  static Map v9opfDecoders = new HashMap();
  
  static void addV9OpfDecoder(int fpOpcode, InstructionDecoder decoder)
  {
    v9opfDecoders.put(new Integer(fpOpcode), decoder);
  }
  
  static
  {
    addV9OpfDecoder(2, new FPMoveDecoder(2, "fmovd", 11, 11));
    addV9OpfDecoder(3, new FPMoveDecoder(3, "fmovq", 13, 13));
    addV9OpfDecoder(6, new FP2RegisterDecoder(6, "fnegd", 11, 11));
    addV9OpfDecoder(7, new FP2RegisterDecoder(7, "fnegq", 13, 13));
    addV9OpfDecoder(10, new FP2RegisterDecoder(10, "fabsd", 11, 11));
    addV9OpfDecoder(11, new FP2RegisterDecoder(11, "fabsq", 13, 13));
    addV9OpfDecoder(129, new FP2RegisterDecoder(129, "fstox", 10, 13));
    addV9OpfDecoder(130, new FP2RegisterDecoder(130, "fdtox", 11, 13));
    addV9OpfDecoder(131, new FP2RegisterDecoder(131, "fqtox", 13, 13));
    addV9OpfDecoder(132, new FP2RegisterDecoder(132, "fxtos", 13, 10));
    addV9OpfDecoder(136, new FP2RegisterDecoder(136, "fxtod", 13, 10));
    addV9OpfDecoder(140, new FP2RegisterDecoder(140, "fxtoq", 13, 13));
  }
  
  InstructionDecoder getOpfDecoder(int opf)
  {
    InstructionDecoder decoder = (InstructionDecoder)V8FPop1Decoder.opfDecoders.get(new Integer(opf));
    return decoder != null ? decoder : (InstructionDecoder)v9opfDecoders.get(new Integer(opf));
  }
}

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

import java.util.HashMap;
import java.util.Map;

class V9FPop2Decoder
  extends FPopDecoder
  implements V9InstructionDecoder
{
  static Map v9fpop2Decoders = new HashMap();
  
  static void addV9FPop2Decoder(int fpOpcode, InstructionDecoder decoder)
  {
    v9fpop2Decoders.put(new Integer(fpOpcode), decoder);
  }
  
  static
  {
    addV9FPop2Decoder(1, new V9FMOVccDecoder(1, 10));
    addV9FPop2Decoder(65, new V9FMOVccDecoder(65, 10));
    addV9FPop2Decoder(129, new V9FMOVccDecoder(129, 10));
    addV9FPop2Decoder(193, new V9FMOVccDecoder(193, 10));
    addV9FPop2Decoder(257, new V9FMOVccDecoder(257, 10));
    addV9FPop2Decoder(385, new V9FMOVccDecoder(385, 10));
    addV9FPop2Decoder(2, new V9FMOVccDecoder(2, 11));
    addV9FPop2Decoder(66, new V9FMOVccDecoder(66, 11));
    addV9FPop2Decoder(130, new V9FMOVccDecoder(130, 11));
    addV9FPop2Decoder(194, new V9FMOVccDecoder(194, 11));
    addV9FPop2Decoder(258, new V9FMOVccDecoder(258, 11));
    addV9FPop2Decoder(386, new V9FMOVccDecoder(386, 11));
    addV9FPop2Decoder(3, new V9FMOVccDecoder(3, 13));
    addV9FPop2Decoder(67, new V9FMOVccDecoder(67, 13));
    addV9FPop2Decoder(131, new V9FMOVccDecoder(131, 13));
    addV9FPop2Decoder(195, new V9FMOVccDecoder(195, 13));
    addV9FPop2Decoder(259, new V9FMOVccDecoder(259, 13));
    addV9FPop2Decoder(387, new V9FMOVccDecoder(387, 13));
    
    addV9FPop2Decoder(37, new V9FMOVrDecoder(37, "fmovrsz", 10));
    addV9FPop2Decoder(69, new V9FMOVrDecoder(69, "fmovrslez", 10));
    addV9FPop2Decoder(101, new V9FMOVrDecoder(101, "fmovrslz", 10));
    addV9FPop2Decoder(165, new V9FMOVrDecoder(165, "fmovrsnz", 10));
    addV9FPop2Decoder(197, new V9FMOVrDecoder(197, "fmovrsgz", 10));
    addV9FPop2Decoder(229, new V9FMOVrDecoder(229, "fmovrsgez", 10));
    
    addV9FPop2Decoder(38, new V9FMOVrDecoder(38, "fmovrdz", 11));
    addV9FPop2Decoder(70, new V9FMOVrDecoder(70, "fmovrdlez", 11));
    addV9FPop2Decoder(102, new V9FMOVrDecoder(102, "fmovrdlz", 11));
    addV9FPop2Decoder(166, new V9FMOVrDecoder(166, "fmovrdnz", 11));
    addV9FPop2Decoder(198, new V9FMOVrDecoder(198, "fmovrdgz", 11));
    addV9FPop2Decoder(230, new V9FMOVrDecoder(230, "fmovrdgez", 11));
    
    addV9FPop2Decoder(39, new V9FMOVrDecoder(39, "fmovrqz", 13));
    addV9FPop2Decoder(71, new V9FMOVrDecoder(71, "fmovrqlez", 13));
    addV9FPop2Decoder(103, new V9FMOVrDecoder(103, "fmovrqlz", 13));
    addV9FPop2Decoder(167, new V9FMOVrDecoder(167, "fmovrqnz", 13));
    addV9FPop2Decoder(199, new V9FMOVrDecoder(199, "fmovrqgz", 13));
    addV9FPop2Decoder(231, new V9FMOVrDecoder(231, "fmovrqgez", 13));
  }
  
  InstructionDecoder getOpfDecoder(int opf)
  {
    InstructionDecoder decoder = (InstructionDecoder)V8FPop2Decoder.fpop2Decoders.get(new Integer(opf));
    return decoder != null ? decoder : (InstructionDecoder)v9fpop2Decoders.get(new Integer(opf));
  }
}

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

abstract interface V9InstructionDecoder
  extends SPARCV9Opcodes
{}

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

class V9IntegerBranchDecoder
  extends V9CCBranchDecoder
{
  String getConditionName(int conditionCode, boolean isAnnuled)
  {
    return isAnnuled ? integerAnnuledConditionNames[conditionCode] : integerConditionNames[conditionCode];
  }
  
  int getConditionFlag(int instruction)
  {
    return ((0x300000 & instruction) >>> 20) + 4;
  }
}

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

class V9IntRegisterBranchDecoder
  extends V9RegisterBranchDecoder
{
  static final String[] integerRegisterConditionNames = { null, "brz", "brlez", "brlz", null, "brnz", "brgz", "brgez" };
  
  String getRegisterConditionName(int index)
  {
    return integerRegisterConditionNames[index];
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.asm.sparc.V9IntRegisterBranchDecoder
 * 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 V9MOVccDecoder
  extends V9CMoveDecoder
{
  private static String getMoveCCName(int conditionCode, int conditionFlag)
  {
    return "mov" + getConditionName(conditionCode, conditionFlag);
  }
  
  private static int getMoveConditionFlag(int instruction)
  {
    boolean cc2Bit = (instruction & 0x40000) != 0;
    int conditionFlag = (instruction & 0x1800) >>> 11;
    if (cc2Bit) {
      conditionFlag |= 0x4;
    }
    return conditionFlag;
  }
  
  Instruction decode(int instruction, SPARCInstructionFactory factory)
  {
    SPARCV9InstructionFactory v9factory = (SPARCV9InstructionFactory)factory;
    Instruction instr = null;
    int conditionFlag = getMoveConditionFlag(instruction);
    if ((conditionFlag == 5) || (conditionFlag == 7))
    {
      instr = v9factory.newIllegalInstruction(instruction);
    }
    else
    {
      int rdNum = getDestinationRegister(instruction);
      SPARCRegister rd = SPARCRegisters.getRegister(rdNum);
      int conditionCode = getMoveConditionCode(instruction);
      ImmediateOrRegister source = getCMoveSource(instruction, 11);
      String name = getMoveCCName(conditionCode, conditionFlag);
      instr = v9factory.newV9MOVccInstruction(name, conditionCode, conditionFlag, source, rd);
    }
    return instr;
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.asm.sparc.V9MOVccDecoder
 * 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 V9MOVrDecoder
  extends V9CMoveDecoder
{
  private static final String[] regConditionNames = { null, "movrz", "movrlez", "movrlz", null, "movrnz", "movrgz", "movrgez" };
  
  private static String getMOVrName(int conditionCode)
  {
    return regConditionNames[conditionCode];
  }
  
  Instruction decode(int instruction, SPARCInstructionFactory factory)
  {
    SPARCV9InstructionFactory v9factory = (SPARCV9InstructionFactory)factory;
    Instruction instr = null;
    int regConditionCode = getRegisterConditionCode(instruction);
    String name = getMOVrName(regConditionCode);
    if (name == null)
    {
      instr = v9factory.newIllegalInstruction(instruction);
    }
    else
    {
      int rdNum = getDestinationRegister(instruction);
      SPARCRegister rd = SPARCRegisters.getRegister(rdNum);
      SPARCRegister rs1 = SPARCRegisters.getRegister(getSourceRegister1(instruction));
      ImmediateOrRegister operand2 = getCMoveSource(instruction, 10);
      instr = v9factory.newV9MOVrInstruction(name, rs1, operand2, rd, regConditionCode);
    }
    return instr;
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.asm.sparc.V9MOVrDecoder
 * 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 V9PopcDecoder
  extends InstructionDecoder
  implements V9InstructionDecoder
{
  Instruction decode(int instruction, SPARCInstructionFactory factory)
  {
    SPARCV9InstructionFactory v9factory = (SPARCV9InstructionFactory)factory;
    int rs1Num = getSourceRegister1(instruction);
    Instruction instr = null;
    if (rs1Num != 0)
    {
      instr = v9factory.newIllegalInstruction(instruction);
    }
    else
    {
      SPARCRegister rd = SPARCRegisters.getRegister(getDestinationRegister(instruction));
      instr = v9factory.newV9PopcInstruction(getOperand2(instruction), rd);
    }
    return instr;
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.asm.sparc.V9PopcDecoder
 * 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 V9PrefetchDecoder
  extends MemoryInstructionDecoder
  implements V9InstructionDecoder
{
  V9PrefetchDecoder()
  {
    super(45, "prefetch", 4);
  }
  
  Instruction decodeMemoryInstruction(int instruction, SPARCRegisterIndirectAddress addr, SPARCRegister rd, SPARCInstructionFactory factory)
  {
    SPARCV9InstructionFactory v9factory = (SPARCV9InstructionFactory)factory;
    return v9factory.newV9PrefetchInstruction(name, addr, rd.getNumber());
  }
}

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

abstract class V9PrivilegedReadWriteDecoder
  extends InstructionDecoder
  implements V9InstructionDecoder
{
  static boolean isLegalPrivilegedRegister(int reg)
  {
    return ((reg > -1) && (reg < 16)) || (reg == 31);
  }
}

/* Location:
 * Qualified Name:     sun.jvm.hotspot.asm.sparc.V9PrivilegedReadWriteDecoder
 * 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 V9RdprDecoder
  extends V9PrivilegedReadWriteDecoder
{
  Instruction decode(int instruction, SPARCInstructionFactory factory)
  {
    SPARCV9InstructionFactory v9factory = (SPARCV9InstructionFactory)factor
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