Mercurial > hg > graal-jvmci-8

changeset 17030:2110fe2b7284

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Merge
author Stefan Anzinger <stefan.anzinger@oracle.com>
date Tue, 02 Sep 2014 19:23:43 -0700
parents 790e5e5072a2 (diff) 66bf28082a14 (current diff)
children 4f8c81b1d1cb
files graal/com.oracle.graal.graph/src/com/oracle/graal/graph/NodeRefIterable.java
diffstat 18 files changed, 574 insertions(+), 640 deletions(-) [+]
line wrap: on
line diff
--- a/graal/com.oracle.graal.asm.sparc/src/com/oracle/graal/asm/sparc/SPARCAssembler.java	Tue Sep 02 15:44:33 2014 -0700
+++ b/graal/com.oracle.graal.asm.sparc/src/com/oracle/graal/asm/sparc/SPARCAssembler.java	Tue Sep 02 19:23:43 2014 -0700
@@ -1998,6 +1998,7 @@
         public Movwtos(Register src, Register dst) {
             /* VIS3 only */
             super(Ops.ArithOp, Op3s.Impdep1, Opfs.Movwtos, g0, src, dst);
+            assert isSingleFloatRegister(dst);
         }
     }
 
@@ -2012,6 +2013,7 @@
         public Movxtod(Register src, Register dst) {
             /* VIS3 only */
             super(Ops.ArithOp, Op3s.Impdep1, Opfs.Movxtod, g0, src, dst);
+            assert isDoubleFloatRegister(dst);
         }
     }
 
@@ -2019,6 +2021,7 @@
         public Movdtox(Register src, Register dst) {
             /* VIS3 only */
             super(Ops.ArithOp, Op3s.Impdep1, Opfs.Movdtox, g0, src, dst);
+            assert isDoubleFloatRegister(src);
         }
     }
 
@@ -2026,6 +2029,7 @@
         public Movstosw(Register src, Register dst) {
             /* VIS3 only */
             super(Ops.ArithOp, Op3s.Impdep1, Opfs.Movstosw, g0, src, dst);
+            assert isSingleFloatRegister(src);
         }
     }
 
@@ -2033,6 +2037,7 @@
         public Movstouw(Register src, Register dst) {
             /* VIS3 only */
             super(Ops.ArithOp, Op3s.Impdep1, Opfs.Movstouw, g0, src, dst);
+            assert isSingleFloatRegister(src);
         }
     }
 
@@ -2040,6 +2045,8 @@
         public Fdtos(Register src, Register dst) {
             /* VIS3 only */
             super(Ops.ArithOp, Op3s.Fpop1, Opfs.Fdtos, g0, src, dst);
+            assert isSingleFloatRegister(dst);
+            assert isDoubleFloatRegister(src);
         }
     }
 
@@ -2804,6 +2811,10 @@
 
         public Fmsubs(SPARCAssembler asm, Register src1, Register src2, Register src3, Register dst) {
             super(asm, Ops.ArithOp.getValue(), Op3s.Impdep2.getValue(), Op5s.Fmsubs.getValue(), src1.encoding(), src2.encoding(), src3.encoding(), dst.encoding());
+            assert isSingleFloatRegister(src1);
+            assert isSingleFloatRegister(src2);
+            assert isSingleFloatRegister(src3);
+            assert isSingleFloatRegister(dst);
         }
     }
 
@@ -2811,6 +2822,10 @@
 
         public Fmsubd(SPARCAssembler asm, Register src1, Register src2, Register src3, Register dst) {
             super(asm, Ops.ArithOp.getValue(), Op3s.Impdep2.getValue(), Op5s.Fmsubd.getValue(), src1.encoding(), src2.encoding(), src3.encoding(), dst.encoding());
+            assert isDoubleFloatRegister(src1);
+            assert isDoubleFloatRegister(src2);
+            assert isDoubleFloatRegister(src3);
+            assert isDoubleFloatRegister(dst);
         }
     }
 
@@ -2818,6 +2833,8 @@
 
         public Fmovs(Register src, Register dst) {
             super(Ops.ArithOp, Op3s.Fpop1, Opfs.Fmovs, g0, src, dst);
+            assert isSingleFloatRegister(src);
+            assert isSingleFloatRegister(dst);
         }
     }
 
@@ -2832,6 +2849,9 @@
 
         public Fmuls(Register src1, Register src2, Register dst) {
             super(Ops.ArithOp, Op3s.Fpop1, Opfs.Fmuls, src1, src2, dst);
+            assert isSingleFloatRegister(src1);
+            assert isSingleFloatRegister(src2);
+            assert isSingleFloatRegister(dst);
         }
     }
 
@@ -2839,6 +2859,9 @@
 
         public Fmuld(Register src1, Register src2, Register dst) {
             super(Ops.ArithOp, Op3s.Fpop1, Opfs.Fmuld, src1, src2, dst);
+            assert isDoubleFloatRegister(src1);
+            assert isDoubleFloatRegister(src2);
+            assert isDoubleFloatRegister(dst);
         }
     }
 
@@ -2846,6 +2869,9 @@
 
         public Fsmuld(Register src1, Register src2, Register dst) {
             super(Ops.ArithOp, Op3s.Fpop1, Opfs.Fsmuld, src1, src2, dst);
+            assert isSingleFloatRegister(src1);
+            assert isSingleFloatRegister(src2);
+            assert isDoubleFloatRegister(dst);
         }
     }
 
@@ -2910,6 +2936,9 @@
         public Fnadds(Register src1, Register src2, Register dst) {
             /* VIS3 only */
             super(Ops.ArithOp, Op3s.Fpop1, Opfs.Fnadds, src1, src2, dst);
+            assert isSingleFloatRegister(src1);
+            assert isSingleFloatRegister(src2);
+            assert isSingleFloatRegister(dst);
         }
     }
 
@@ -2918,6 +2947,9 @@
         public Fnaddd(Register src1, Register src2, Register dst) {
             /* VIS3 only */
             super(Ops.ArithOp, Op3s.Fpop1, Opfs.Fnaddd, src1, src2, dst);
+            assert isDoubleFloatRegister(src1);
+            assert isDoubleFloatRegister(src2);
+            assert isDoubleFloatRegister(dst);
         }
     }
 
@@ -2925,6 +2957,8 @@
 
         public Fnegs(Register src2, Register dst) {
             super(Ops.ArithOp.getValue(), Op3s.Fpop1.getValue(), Opfs.Fnegs.getValue(), src2.encoding(), dst.encoding());
+            assert isSingleFloatRegister(src2);
+            assert isSingleFloatRegister(dst);
         }
     }
 
@@ -2932,6 +2966,8 @@
 
         public Fnegd(Register src2, Register dst) {
             super(Ops.ArithOp.getValue(), Op3s.Fpop1.getValue(), Opfs.Fnegd.getValue(), src2.encoding(), dst.encoding());
+            assert isDoubleFloatRegister(src2);
+            assert isDoubleFloatRegister(dst);
         }
     }
 
@@ -2940,6 +2976,9 @@
         public Fnhadds(Register src1, Register src2, Register dst) {
             /* VIS3 only */
             super(Ops.ArithOp, Op3s.Fpop1, Opfs.Fnhadds, src1, src2, dst);
+            assert isSingleFloatRegister(src1);
+            assert isSingleFloatRegister(src2);
+            assert isSingleFloatRegister(dst);
         }
     }
 
@@ -2948,6 +2987,9 @@
         public Fnhaddd(Register src1, Register src2, Register dst) {
             /* VIS3 only */
             super(Ops.ArithOp, Op3s.Fpop1, Opfs.Fnhaddd, src1, src2, dst);
+            assert isDoubleFloatRegister(src1);
+            assert isDoubleFloatRegister(src2);
+            assert isDoubleFloatRegister(dst);
         }
     }
 
@@ -2955,6 +2997,10 @@
 
         public Fnmadds(SPARCAssembler asm, Register src1, Register src2, Register src3, Register dst) {
             super(asm, Ops.ArithOp.getValue(), Op3s.Impdep2.getValue(), Op5s.Fnmadds.getValue(), src1.encoding(), src2.encoding(), src3.encoding(), dst.encoding());
+            assert isSingleFloatRegister(src1);
+            assert isSingleFloatRegister(src2);
+            assert isSingleFloatRegister(src3);
+            assert isSingleFloatRegister(dst);
         }
     }
 
@@ -2962,6 +3008,10 @@
 
         public Fnmaddd(SPARCAssembler asm, Register src1, Register src2, Register src3, Register dst) {
             super(asm, Ops.ArithOp.getValue(), Op3s.Impdep2.getValue(), Op5s.Fnmaddd.getValue(), src1.encoding(), src2.encoding(), src3.encoding(), dst.encoding());
+            assert isDoubleFloatRegister(src1);
+            assert isDoubleFloatRegister(src2);
+            assert isDoubleFloatRegister(src3);
+            assert isDoubleFloatRegister(dst);
         }
     }
 
@@ -2969,6 +3019,10 @@
 
         public Fnmsubs(SPARCAssembler masm, Register src1, Register src2, Register src3, Register dst) {
             super(masm, Ops.ArithOp.getValue(), Op3s.Impdep2.getValue(), Op5s.Fnmsubs.getValue(), src1.encoding(), src2.encoding(), src3.encoding(), dst.encoding());
+            assert isSingleFloatRegister(src1);
+            assert isSingleFloatRegister(src2);
+            assert isSingleFloatRegister(src3);
+            assert isSingleFloatRegister(dst);
         }
     }
 
@@ -2976,6 +3030,10 @@
 
         public Fnmsubd(SPARCAssembler masm, Register src1, Register src2, Register src3, Register dst) {
             super(masm, Ops.ArithOp.getValue(), Op3s.Impdep2.getValue(), Op5s.Fnmsubd.getValue(), src1.encoding(), src2.encoding(), src3.encoding(), dst.encoding());
+            assert isDoubleFloatRegister(src1);
+            assert isDoubleFloatRegister(src2);
+            assert isDoubleFloatRegister(src3);
+            assert isDoubleFloatRegister(dst);
         }
     }
 
@@ -2984,6 +3042,9 @@
         public Fnmuls(Register src1, Register src2, Register dst) {
             /* VIS3 only */
             super(Ops.ArithOp, Op3s.Fpop1, Opfs.Fnmuls, src1, src2, dst);
+            assert isSingleFloatRegister(src1);
+            assert isSingleFloatRegister(src2);
+            assert isSingleFloatRegister(dst);
         }
     }
 
@@ -2992,6 +3053,9 @@
         public Fnmuld(Register src1, Register src2, Register dst) {
             /* VIS3 only */
             super(Ops.ArithOp, Op3s.Fpop1, Opfs.Fnmuld, src1, src2, dst);
+            assert isDoubleFloatRegister(src1);
+            assert isDoubleFloatRegister(src2);
+            assert isDoubleFloatRegister(dst);
         }
     }
 
@@ -3000,6 +3064,9 @@
         public Fnsmuld(Register src1, Register src2, Register dst) {
             /* VIS3 only */
             super(Ops.ArithOp, Op3s.Fpop1, Opfs.Fnsmuld, src1, src2, dst);
+            assert isDoubleFloatRegister(src1);
+            assert isDoubleFloatRegister(src2);
+            assert isDoubleFloatRegister(dst);
         }
     }
 
@@ -3007,6 +3074,8 @@
 
         public Fstoi(Register src2, Register dst) {
             super(Ops.ArithOp.getValue(), Op3s.Fpop1.getValue(), Opfs.Fstoi.getValue(), src2.encoding(), dst.encoding());
+            assert isSingleFloatRegister(dst);
+            assert isSingleFloatRegister(src2);
         }
     }
 
@@ -3014,6 +3083,8 @@
 
         public Fstox(Register src2, Register dst) {
             super(Ops.ArithOp.getValue(), Op3s.Fpop1.getValue(), Opfs.Fstox.getValue(), src2.encoding(), dst.encoding());
+            assert isDoubleFloatRegister(dst);
+            assert isSingleFloatRegister(src2);
         }
     }
 
@@ -3021,6 +3092,8 @@
 
         public Fdtox(Register src2, Register dst) {
             super(Ops.ArithOp.getValue(), Op3s.Fpop1.getValue(), Opfs.Fdtox.getValue(), src2.encoding(), dst.encoding());
+            assert isDoubleFloatRegister(src2);
+            assert isDoubleFloatRegister(dst);
         }
     }
 
@@ -3028,6 +3101,8 @@
 
         public Fstod(Register src2, Register dst) {
             super(Ops.ArithOp.getValue(), Op3s.Fpop1.getValue(), Opfs.Fstod.getValue(), src2.encoding(), dst.encoding());
+            assert isDoubleFloatRegister(dst);
+            assert isSingleFloatRegister(src2);
         }
     }
 
@@ -3038,6 +3113,8 @@
 
         public Fdtoi(Register src2, Register dst) {
             super(Ops.ArithOp.getValue(), Op3s.Fpop1.getValue(), Opfs.Fdtoi.getValue(), src2.encoding(), dst.encoding());
+            assert isDoubleFloatRegister(src2);
+            assert isSingleFloatRegister(dst);
         }
     }
 
@@ -3045,6 +3122,8 @@
 
         public Fitos(Register src2, Register dst) {
             super(Ops.ArithOp.getValue(), Op3s.Fpop1.getValue(), Opfs.Fitos.getValue(), src2.encoding(), dst.encoding());
+            assert isSingleFloatRegister(src2);
+            assert isSingleFloatRegister(dst);
         }
     }
 
@@ -3052,6 +3131,8 @@
 
         public Fitod(Register src2, Register dst) {
             super(Ops.ArithOp.getValue(), Op3s.Fpop1.getValue(), Opfs.Fitod.getValue(), src2.encoding(), dst.encoding());
+            assert isSingleFloatRegister(src2);
+            assert isDoubleFloatRegister(dst);
         }
     }
 
@@ -3059,6 +3140,8 @@
 
         public Fxtod(Register src2, Register dst) {
             super(Ops.ArithOp.getValue(), Op3s.Fpop1.getValue(), Opfs.Fxtod.getValue(), src2.encoding(), dst.encoding());
+            assert isDoubleFloatRegister(src2);
+            assert isDoubleFloatRegister(dst);
         }
     }
 
@@ -3097,6 +3180,10 @@
 
         public Fpmaddx(SPARCAssembler asm, Register src1, Register src2, Register src3, Register dst) {
             super(asm, Ops.ArithOp.getValue(), Op3s.Impdep2.getValue(), 0, src1.encoding(), src2.encoding(), src3.encoding(), dst.encoding());
+            assert isDoubleFloatRegister(src1);
+            assert isDoubleFloatRegister(src2);
+            assert isDoubleFloatRegister(src3);
+            assert isDoubleFloatRegister(dst);
         }
     }
 
@@ -3104,6 +3191,10 @@
 
         public Fpmaddxhi(SPARCAssembler asm, Register src1, Register src2, Register src3, Register dst) {
             super(asm, Ops.ArithOp.getValue(), Op3s.Impdep2.getValue(), 4, src1.encoding(), src2.encoding(), src3.encoding(), dst.encoding());
+            assert isDoubleFloatRegister(src1);
+            assert isDoubleFloatRegister(src2);
+            assert isDoubleFloatRegister(src3);
+            assert isDoubleFloatRegister(dst);
         }
     }
 
@@ -3112,6 +3203,9 @@
         public Fpmerge(Register src1, Register src2, Register dst) {
             /* VIS1 only */
             super(Ops.ArithOp, Op3s.Impdep1, Opfs.Fpmerge, src1, src2, dst);
+            assert isSingleFloatRegister(src1);
+            assert isSingleFloatRegister(src2);
+            assert isDoubleFloatRegister(dst);
         }
     }
 
@@ -3230,6 +3324,9 @@
 
         public Fsubs(Register src1, Register src2, Register dst) {
             super(Ops.ArithOp, Op3s.Fpop1, Opfs.Fsubs, src1, src2, dst);
+            assert isSingleFloatRegister(src1);
+            assert isSingleFloatRegister(src2);
+            assert isSingleFloatRegister(dst);
         }
     }
 
@@ -3237,6 +3334,9 @@
 
         public Fsubd(Register src1, Register src2, Register dst) {
             super(Ops.ArithOp, Op3s.Fpop1, Opfs.Fsubd, src1, src2, dst);
+            assert isDoubleFloatRegister(src1);
+            assert isDoubleFloatRegister(src2);
+            assert isDoubleFloatRegister(dst);
         }
     }
 
@@ -3252,6 +3352,7 @@
         public Fzeros(Register dst) {
             /* VIS1 only */
             super(Ops.ArithOp.getValue(), Op3s.Fpop1.getValue(), Opfs.Fzeros.getValue(), 0, dst.encoding());
+            assert isSingleFloatRegister(dst);
         }
     }
 
@@ -3260,6 +3361,7 @@
         public Fzerod(Register dst) {
             /* VIS1 only */
             super(Ops.ArithOp.getValue(), Op3s.Fpop1.getValue(), Opfs.Fzerod.getValue(), 0, dst.encoding());
+            assert isDoubleFloatRegister(dst);
         }
     }
 
@@ -3267,6 +3369,8 @@
 
         public Fcmp(CC cc, Opfs opf, Register r1, Register r2) {
             super(Ops.ArithOp, cc, 0b110101, opf, r1, r2);
+            assert opf != Opfs.Fcmpd || (isDoubleFloatRegister(r1) && isDoubleFloatRegister(r2));
+            assert opf != Opfs.Fcmps || (isSingleFloatRegister(r1) && isSingleFloatRegister(r2));
         }
     }
 
@@ -3452,10 +3556,12 @@
 
         public Lddf(SPARCAddress src, Register dst) {
             super(Op3s.Lddf, src, dst);
+            assert dst == f0 || dst == f2 || dst == f4 || dst == f6 || isDoubleFloatRegister(dst);
         }
 
         public Lddf(Register src, Register dst) {
             super(Op3s.Lddf, src, dst);
+            assert dst == f0 || dst == f2 || dst == f4 || dst == f6 || isDoubleFloatRegister(dst);
         }
     }
 
@@ -3463,10 +3569,12 @@
 
         public Ldf(SPARCAddress src, Register dst) {
             super(Op3s.Ldf, src, dst);
+            assert isSingleFloatRegister(dst);
         }
 
         public Ldf(Register src, Register dst) {
             super(Op3s.Ldf, src, dst);
+            assert isSingleFloatRegister(dst);
         }
     }
 
--- a/graal/com.oracle.graal.compiler.common/src/com/oracle/graal/compiler/common/cfg/AbstractControlFlowGraph.java	Tue Sep 02 15:44:33 2014 -0700
+++ b/graal/com.oracle.graal.compiler.common/src/com/oracle/graal/compiler/common/cfg/AbstractControlFlowGraph.java	Tue Sep 02 19:23:43 2014 -0700
@@ -24,6 +24,8 @@
 
 import java.util.*;
 
+import com.oracle.graal.compiler.common.*;
+
 public interface AbstractControlFlowGraph<T extends AbstractBlock<T>> {
 
     static final int BLOCK_ID_INITIAL = -1;
@@ -72,13 +74,18 @@
      */
     static boolean isDominatedBy(AbstractBlock<?> a, AbstractBlock<?> b) {
         assert a != null;
-        if (a == b) {
-            return true;
+        AbstractBlock<?> dominator = a;
+        int i = 0;
+        while (dominator != null) {
+            if (i++ == Integer.MAX_VALUE) { // For safety
+                throw GraalInternalError.shouldNotReachHere();
+            }
+            if (dominator == b) {
+                return true;
+            }
+            dominator = dominator.getDominator();
         }
-        if (a.getDominator() == null) {
-            return false;
-        }
-        return isDominatedBy(a.getDominator(), b);
+        return false;
     }
 
     /**
--- a/graal/com.oracle.graal.compiler.sparc/src/com/oracle/graal/compiler/sparc/SPARCLIRGenerator.java	Tue Sep 02 15:44:33 2014 -0700
+++ b/graal/com.oracle.graal.compiler.sparc/src/com/oracle/graal/compiler/sparc/SPARCLIRGenerator.java	Tue Sep 02 19:23:43 2014 -0700
@@ -224,7 +224,6 @@
                     double trueDestinationProbability) {
         boolean mirrored = emitCompare(cmpKind, left, right);
         Condition finalCondition = mirrored ? cond.mirror() : cond;
-        boolean finalUnorderedIsTrue = mirrored ? !unorderedIsTrue : unorderedIsTrue;
 
         Kind kind = left.getKind().getStackKind();
         switch (kind) {
@@ -235,7 +234,7 @@
                 break;
             case Float:
             case Double:
-                append(new BranchOp(finalCondition, trueDestination, falseDestination, kind, finalUnorderedIsTrue));
+                append(new BranchOp(finalCondition, trueDestination, falseDestination, kind, unorderedIsTrue));
                 break;
             default:
                 throw GraalInternalError.shouldNotReachHere("" + left.getKind());
@@ -705,7 +704,7 @@
         Value actualB = b;
         switch (a.getKind().getStackKind()) {
             case Int:
-                op = IUDIV;
+                op = LUDIV;
                 actualA = emitZeroExtend(actualA, 32, 64);
                 actualB = emitZeroExtend(actualB, 32, 64);
                 break;
@@ -756,10 +755,10 @@
         Variable result = newVariable(LIRKind.derive(a, b));
         switch (a.getKind().getStackKind()) {
             case Int:
-                append(new Op2Stack(IXOR, result, a, loadNonConst(b)));
+                append(new Op2Stack(IXOR, result, load(a), loadNonConst(b)));
                 break;
             case Long:
-                append(new Op2Stack(LXOR, result, a, loadNonConst(b)));
+                append(new Op2Stack(LXOR, result, load(a), loadNonConst(b)));
                 break;
             default:
                 throw GraalInternalError.shouldNotReachHere();
@@ -829,45 +828,43 @@
     @Override
     public Value emitFloatConvert(FloatConvert op, Value inputVal) {
         AllocatableValue input = asAllocatable(inputVal);
-        Kind fromRegisterKind = null;
-        Kind toRegisterKind = null;
-        SPARCArithmetic conversionInstruction = null;
         switch (op) {
             case D2F:
                 return emitConvert2Op(LIRKind.derive(inputVal).changeType(Kind.Float), D2F, input);
-            case D2I:
-                fromRegisterKind = Kind.Double;
-                toRegisterKind = Kind.Int;
-                conversionInstruction = D2I;
-                break;
-            case F2L:
-                Variable v = newVariable(LIRKind.derive(inputVal).changeType(Kind.Double));
-                emitMove(v, input);
-                input = v;
-            case D2L:
-                fromRegisterKind = Kind.Double;
-                toRegisterKind = Kind.Long;
-                conversionInstruction = D2L;
-                break;
             case F2D:
                 return emitConvert2Op(LIRKind.derive(inputVal).changeType(Kind.Double), F2D, input);
-            case F2I:
-                fromRegisterKind = Kind.Float;
-                toRegisterKind = Kind.Int;
-                conversionInstruction = F2I;
-                break;
-            case I2D:
-            // Implemented in two steps, as this consists of sign extension and then move the
-            // bits over to the double register and then convert to double, in fact this does
-            // not generate any overhead in generated code
-            {
-                AllocatableValue tmp = emitConvert2Op(LIRKind.derive(inputVal).changeType(Kind.Long), I2L, input);
-                return emitConvert2Op(LIRKind.derive(inputVal).changeType(Kind.Double), L2D, tmp);
-            }
             case I2F:
                 return emitConvert2Op(LIRKind.derive(inputVal).changeType(Kind.Float), I2F, input);
             case L2D:
                 return emitConvert2Op(LIRKind.derive(inputVal).changeType(Kind.Double), L2D, input);
+            case D2I: {
+                AllocatableValue convertedFloatReg = emitConvert2Op(LIRKind.derive(input).changeType(Kind.Float), D2I, input);
+                AllocatableValue convertedIntReg = newVariable(LIRKind.derive(convertedFloatReg).changeType(Kind.Int));
+                emitMove(convertedIntReg, convertedFloatReg);
+                return convertedIntReg;
+            }
+            case F2L: {
+                AllocatableValue convertedDoubleReg = emitConvert2Op(LIRKind.derive(input).changeType(Kind.Double), F2L, input);
+                AllocatableValue convertedLongReg = newVariable(LIRKind.derive(convertedDoubleReg).changeType(Kind.Long));
+                emitMove(convertedLongReg, convertedDoubleReg);
+                return convertedLongReg;
+            }
+            case F2I: {
+                AllocatableValue convertedFloatReg = emitConvert2Op(LIRKind.derive(input).changeType(Kind.Float), F2I, input);
+                AllocatableValue convertedIntReg = newVariable(LIRKind.derive(convertedFloatReg).changeType(Kind.Int));
+                emitMove(convertedIntReg, convertedFloatReg);
+                return convertedIntReg;
+            }
+            case D2L: {
+                AllocatableValue convertedDoubleReg = emitConvert2Op(LIRKind.derive(input).changeType(Kind.Double), D2L, input);
+                AllocatableValue convertedLongReg = newVariable(LIRKind.derive(convertedDoubleReg).changeType(Kind.Long));
+                emitMove(convertedLongReg, convertedDoubleReg);
+                return convertedLongReg;
+            }
+            case I2D: {
+                AllocatableValue tmp = emitConvert2Op(LIRKind.derive(inputVal).changeType(Kind.Long), I2L, input);
+                return emitConvert2Op(LIRKind.derive(inputVal).changeType(Kind.Double), L2D, tmp);
+            }
             case L2F: {
                 AllocatableValue tmp = emitConvert2Op(LIRKind.derive(inputVal).changeType(Kind.Double), L2D, input);
                 return emitConvert2Op(LIRKind.derive(inputVal).changeType(Kind.Float), D2F, tmp);
@@ -875,13 +872,6 @@
             default:
                 throw GraalInternalError.shouldNotReachHere();
         }
-        if (fromRegisterKind != null) {
-            AllocatableValue var = newVariable(LIRKind.derive(inputVal).changeType(toRegisterKind));
-            emitMove(var, emitConvert2Op(LIRKind.derive(inputVal).changeType(fromRegisterKind), conversionInstruction, input));
-            return var;
-        } else {
-            throw GraalInternalError.shouldNotReachHere();
-        }
     }
 
     @Override
--- a/graal/com.oracle.graal.hotspot.sparc/src/com/oracle/graal/hotspot/sparc/SPARCHotSpotBackend.java	Tue Sep 02 15:44:33 2014 -0700
+++ b/graal/com.oracle.graal.hotspot.sparc/src/com/oracle/graal/hotspot/sparc/SPARCHotSpotBackend.java	Tue Sep 02 19:23:43 2014 -0700
@@ -54,6 +54,7 @@
 import com.oracle.graal.lir.sparc.*;
 import com.oracle.graal.nodes.*;
 import com.oracle.graal.nodes.spi.*;
+import com.oracle.graal.sparc.*;
 
 /**
  * HotSpot SPARC specific backend.
@@ -113,8 +114,11 @@
                     if (SPARCAssembler.isSimm13(address.getDisplacement())) {
                         new Stx(g0, address).emit(masm);
                     } else {
-                        new Setx(address.getDisplacement(), g3).emit(masm);
-                        new Stx(g0, new SPARCAddress(sp, g3)).emit(masm);
+                        try (SPARCScratchRegister sc = SPARCScratchRegister.get()) {
+                            Register scratch = sc.getRegister();
+                            new Setx(address.getDisplacement(), scratch).emit(masm);
+                            new Stx(g0, new SPARCAddress(sp, scratch)).emit(masm);
+                        }
                     }
                 }
             }
@@ -145,8 +149,11 @@
             if (SPARCAssembler.isSimm13(stackpoinerChange)) {
                 new Save(sp, stackpoinerChange, sp).emit(masm);
             } else {
-                new Setx(stackpoinerChange, g3).emit(masm);
-                new Save(sp, g3, sp).emit(masm);
+                try (SPARCScratchRegister sc = SPARCScratchRegister.get()) {
+                    Register scratch = sc.getRegister();
+                    new Setx(stackpoinerChange, scratch).emit(masm);
+                    new Save(sp, scratch, sp).emit(masm);
+                }
             }
 
             if (ZapStackOnMethodEntry.getValue()) {
@@ -213,12 +220,15 @@
             // We need to use JavaCall here because we haven't entered the frame yet.
             CallingConvention cc = regConfig.getCallingConvention(JavaCall, null, new JavaType[]{getProviders().getMetaAccess().lookupJavaType(Object.class)}, getTarget(), false);
             Register inlineCacheKlass = g5; // see MacroAssembler::ic_call
-            Register scratch = g3;
-            Register receiver = asRegister(cc.getArgument(0));
-            SPARCAddress src = new SPARCAddress(receiver, config.hubOffset);
 
-            new Ldx(src, scratch).emit(masm);
-            new Cmp(scratch, inlineCacheKlass).emit(masm);
+            try (SPARCScratchRegister sc = SPARCScratchRegister.get()) {
+                Register scratch = sc.getRegister();
+                Register receiver = asRegister(cc.getArgument(0));
+                SPARCAddress src = new SPARCAddress(receiver, config.hubOffset);
+
+                new Ldx(src, scratch).emit(masm);
+                new Cmp(scratch, inlineCacheKlass).emit(masm);
+            }
             new Bpne(CC.Xcc, unverifiedStub).emit(masm);
             new Nop().emit(masm);  // delay slot
         }
@@ -244,8 +254,10 @@
 
         if (unverifiedStub != null) {
             masm.bind(unverifiedStub);
-            Register scratch = g3;
-            SPARCCall.indirectJmp(crb, masm, scratch, foreignCalls.lookupForeignCall(IC_MISS_HANDLER));
+            try (SPARCScratchRegister sc = SPARCScratchRegister.get()) {
+                Register scratch = sc.getRegister();
+                SPARCCall.indirectJmp(crb, masm, scratch, foreignCalls.lookupForeignCall(IC_MISS_HANDLER));
+            }
         }
     }
 
--- a/graal/com.oracle.graal.hotspot.sparc/src/com/oracle/graal/hotspot/sparc/SPARCHotSpotDeoptimizeCallerOp.java	Tue Sep 02 15:44:33 2014 -0700
+++ b/graal/com.oracle.graal.hotspot.sparc/src/com/oracle/graal/hotspot/sparc/SPARCHotSpotDeoptimizeCallerOp.java	Tue Sep 02 19:23:43 2014 -0700
@@ -23,13 +23,13 @@
 package com.oracle.graal.hotspot.sparc;
 
 import static com.oracle.graal.hotspot.HotSpotHostBackend.*;
-import static com.oracle.graal.sparc.SPARC.*;
 
 import com.oracle.graal.api.code.*;
 import com.oracle.graal.asm.sparc.*;
 import com.oracle.graal.lir.*;
 import com.oracle.graal.lir.asm.*;
 import com.oracle.graal.lir.sparc.*;
+import com.oracle.graal.sparc.*;
 
 /**
  * Removes the current frame and tail calls the uncommon trap routine.
@@ -46,8 +46,11 @@
         // final boolean isStub = true;
         // HotSpotFrameContext frameContext = backend.new HotSpotFrameContext(isStub);
         // frameContext.enter(crb);
-        Register scratch = g3;
-        SPARCCall.indirectJmp(crb, masm, scratch, crb.foreignCalls.lookupForeignCall(UNCOMMON_TRAP_HANDLER));
+
+        try (SPARCScratchRegister sc = SPARCScratchRegister.get()) {
+            Register scratch = sc.getRegister();
+            SPARCCall.indirectJmp(crb, masm, scratch, crb.foreignCalls.lookupForeignCall(UNCOMMON_TRAP_HANDLER));
+        }
 
         // frameContext.leave(crb);
     }
--- a/graal/com.oracle.graal.hotspot.sparc/src/com/oracle/graal/hotspot/sparc/SPARCHotSpotLeaveUnpackFramesStackFrameOp.java	Tue Sep 02 15:44:33 2014 -0700
+++ b/graal/com.oracle.graal.hotspot.sparc/src/com/oracle/graal/hotspot/sparc/SPARCHotSpotLeaveUnpackFramesStackFrameOp.java	Tue Sep 02 19:23:43 2014 -0700
@@ -64,6 +64,6 @@
         new Stx(g0, new SPARCAddress(thread, threadLastJavaPcOffset)).emit(masm);
         new Stw(g0, new SPARCAddress(thread, threadJavaFrameAnchorFlagsOffset)).emit(masm);
 
-        new Movdtox(f31, i0).emit(masm);
+        new Movdtox(SPARCSaveRegistersOp.RETURN_REGISTER_STORAGE, i0).emit(masm);
     }
 }
--- a/graal/com.oracle.graal.hotspot.sparc/src/com/oracle/graal/hotspot/sparc/SPARCHotSpotNodeLIRBuilder.java	Tue Sep 02 15:44:33 2014 -0700
+++ b/graal/com.oracle.graal.hotspot.sparc/src/com/oracle/graal/hotspot/sparc/SPARCHotSpotNodeLIRBuilder.java	Tue Sep 02 19:23:43 2014 -0700
@@ -110,7 +110,8 @@
     protected void emitIndirectCall(IndirectCallTargetNode callTarget, Value result, Value[] parameters, Value[] temps, LIRFrameState callState) {
         AllocatableValue metaspaceMethod = g5.asValue();
         gen.emitMove(metaspaceMethod, operand(((HotSpotIndirectCallTargetNode) callTarget).metaspaceMethod()));
-        AllocatableValue targetAddress = g3.asValue();
+
+        AllocatableValue targetAddress = o7.asValue();
         gen.emitMove(targetAddress, operand(callTarget.computedAddress()));
         append(new SPARCIndirectCallOp(callTarget.targetMethod(), result, parameters, temps, metaspaceMethod, targetAddress, callState));
     }
--- a/graal/com.oracle.graal.lir.sparc/src/com/oracle/graal/lir/sparc/SPARCArithmetic.java	Tue Sep 02 15:44:33 2014 -0700
+++ b/graal/com.oracle.graal.lir.sparc/src/com/oracle/graal/lir/sparc/SPARCArithmetic.java	Tue Sep 02 19:23:43 2014 -0700
@@ -26,6 +26,7 @@
 import static com.oracle.graal.asm.sparc.SPARCAssembler.*;
 import static com.oracle.graal.lir.LIRInstruction.OperandFlag.*;
 
+import com.oracle.graal.api.code.*;
 import com.oracle.graal.api.meta.*;
 import com.oracle.graal.asm.*;
 import com.oracle.graal.asm.sparc.*;
@@ -67,7 +68,7 @@
 
         @Override
         public void emitCode(CompilationResultBuilder crb, SPARCMacroAssembler masm) {
-            emit(crb, masm, opcode, result, x, null);
+            emitUnary(crb, masm, opcode, result, x, null);
         }
     }
 
@@ -85,7 +86,7 @@
 
         @Override
         public void emitCode(CompilationResultBuilder crb, SPARCMacroAssembler masm) {
-            emit(crb, masm, opcode, result, x, null);
+            emitUnary(crb, masm, opcode, result, x, null);
         }
     }
 
@@ -423,8 +424,11 @@
                     break;
                 case DAND:
                     SPARCAddress addr = (SPARCAddress) crb.recordDataReferenceInCode(asConstant(src2), 4);
-                    addr = SPARCMove.guaranueeLoadable(addr, masm);
-                    new Lddf(addr, asDoubleReg(dst)).emit(masm);
+                    try (SPARCScratchRegister sc = SPARCScratchRegister.get()) {
+                        Register scratch = sc.getRegister();
+                        addr = SPARCMove.guaranueeLoadable(addr, masm, scratch);
+                        new Lddf(addr, asDoubleReg(dst)).emit(masm);
+                    }
                     new Fandd(asDoubleReg(src1), asDoubleReg(dst), asDoubleReg(dst)).emit(masm);
                     break;
                 case FADD:
@@ -685,7 +689,7 @@
         }
     }
 
-    public static void emit(CompilationResultBuilder crb, SPARCAssembler masm, SPARCArithmetic opcode, Value dst, Value src, LIRFrameState info) {
+    public static void emitUnary(CompilationResultBuilder crb, SPARCAssembler masm, SPARCArithmetic opcode, Value dst, Value src, LIRFrameState info) {
         int exceptionOffset = -1;
         Label notOrdered = new Label();
         if (isRegister(src)) {
@@ -738,7 +742,7 @@
                     new Sra(asIntReg(dst), 16, asIntReg(dst)).emit(masm);
                     break;
                 case I2F:
-                    if (src.getPlatformKind() == Kind.Int) {
+                    if (src.getPlatformKind() == Kind.Int || src.getPlatformKind() == Kind.Char || src.getPlatformKind() == Kind.Short || src.getPlatformKind() == Kind.Byte) {
                         new Movwtos(asIntReg(src), asFloatReg(dst)).emit(masm);
                         new Fitos(asFloatReg(dst), asFloatReg(dst)).emit(masm);
                     } else if (src.getPlatformKind() == Kind.Float) {
@@ -752,15 +756,14 @@
                     break;
                 case F2L:
                     new Fcmp(CC.Fcc0, Opfs.Fcmps, asFloatReg(src), asFloatReg(src)).emit(masm);
-                    new Fbo(false, notOrdered).emit(masm);
-                    new Fstox(asFloatReg(src), asFloatReg(dst)).emit(masm);
-                    new Fitos(asFloatReg(dst), asFloatReg(dst)).emit(masm);
-                    new Fsubs(asFloatReg(dst), asFloatReg(dst), asFloatReg(dst)).emit(masm);
+                    new Fbo(true, notOrdered).emit(masm);
+                    new Fstox(asFloatReg(src), asDoubleReg(dst)).emit(masm);
+                    new Fsubd(asDoubleReg(dst), asDoubleReg(dst), asDoubleReg(dst)).emit(masm);
                     masm.bind(notOrdered);
                     break;
                 case F2I:
                     new Fcmp(CC.Fcc0, Opfs.Fcmps, asFloatReg(src), asFloatReg(src)).emit(masm);
-                    new Fbo(false, notOrdered).emit(masm);
+                    new Fbo(true, notOrdered).emit(masm);
                     new Fstoi(asFloatReg(src), asFloatReg(dst)).emit(masm);
                     new Fitos(asFloatReg(dst), asFloatReg(dst)).emit(masm);
                     new Fsubs(asFloatReg(dst), asFloatReg(dst), asFloatReg(dst)).emit(masm);
@@ -788,10 +791,10 @@
                     break;
                 case D2I:
                     new Fcmp(CC.Fcc0, Opfs.Fcmpd, asDoubleReg(src), asDoubleReg(src)).emit(masm);
-                    new Fbo(false, notOrdered).emit(masm);
-                    new Fdtoi(asDoubleReg(src), asDoubleReg(dst)).emit(masm);
-                    new Fitod(asDoubleReg(dst), asDoubleReg(dst)).emit(masm);
-                    new Fsubd(asDoubleReg(dst), asDoubleReg(dst), asDoubleReg(dst)).emit(masm);
+                    new Fbo(true, notOrdered).emit(masm);
+                    new Fdtoi(asDoubleReg(src), asFloatReg(dst)).emit(masm);
+                    new Fsubs(asFloatReg(dst), asFloatReg(dst), asFloatReg(dst)).emit(masm);
+                    new Fstoi(asFloatReg(dst), asFloatReg(dst)).emit(masm);
                     masm.bind(notOrdered);
                     break;
                 case FNEG:
--- a/graal/com.oracle.graal.lir.sparc/src/com/oracle/graal/lir/sparc/SPARCControlFlow.java	Tue Sep 02 15:44:33 2014 -0700
+++ b/graal/com.oracle.graal.lir.sparc/src/com/oracle/graal/lir/sparc/SPARCControlFlow.java	Tue Sep 02 19:23:43 2014 -0700
@@ -38,6 +38,7 @@
 import com.oracle.graal.lir.StandardOp.BlockEndOp;
 import com.oracle.graal.lir.SwitchStrategy.BaseSwitchClosure;
 import com.oracle.graal.lir.asm.*;
+import com.oracle.graal.sparc.*;
 
 public class SPARCControlFlow {
 
@@ -139,28 +140,44 @@
     }
 
     private static void emitFloatCompare(SPARCMacroAssembler masm, Label target, Condition actualCondition, boolean branchOnUnordered) {
-        if (branchOnUnordered) {
-            // new Fbu(false, target).emit(masm);
-            // new Nop().emit(masm);
-        }
         switch (actualCondition) {
             case EQ:
-                new Fbe(false, target).emit(masm);
+                if (branchOnUnordered) {
+                    new Fbue(false, target).emit(masm);
+                } else {
+                    new Fbe(false, target).emit(masm);
+                }
                 break;
             case NE:
-                new Fbne(false, target).emit(masm);
+                new Fbne(false, target).emit(masm); // Is also unordered
                 break;
             case LT:
-                new Fbl(false, target).emit(masm);
+                if (branchOnUnordered) {
+                    new Fbul(false, target).emit(masm);
+                } else {
+                    new Fbl(false, target).emit(masm);
+                }
                 break;
             case LE:
-                new Fble(false, target).emit(masm);
+                if (branchOnUnordered) {
+                    new Fbule(false, target).emit(masm);
+                } else {
+                    new Fble(false, target).emit(masm);
+                }
                 break;
             case GT:
-                new Fbg(false, target).emit(masm);
+                if (branchOnUnordered) {
+                    new Fbug(false, target).emit(masm);
+                } else {
+                    new Fbg(false, target).emit(masm);
+                }
                 break;
             case GE:
-                new Fbge(false, target).emit(masm);
+                if (branchOnUnordered) {
+                    new Fbuge(false, target).emit(masm);
+                } else {
+                    new Fbge(false, target).emit(masm);
+                }
                 break;
             case AE:
             case AT:
@@ -305,32 +322,38 @@
             if (isSimm13(lowKey)) {
                 new Sub(value, lowKey, scratchReg).emit(masm);
             } else {
-                new Setx(lowKey, g3).emit(masm);
-                new Sub(value, g3, scratchReg).emit(masm);
+                try (SPARCScratchRegister sc = SPARCScratchRegister.get()) {
+                    Register scratch2 = sc.getRegister();
+                    new Setx(lowKey, scratch2).emit(masm);
+                    new Sub(value, scratch2, scratchReg).emit(masm);
+                }
             }
             int upperLimit = highKey - lowKey;
-            if (isSimm13(upperLimit)) {
-                new Cmp(scratchReg, upperLimit).emit(masm);
-            } else {
-                new Setx(upperLimit, g3).emit(masm);
-                new Cmp(scratchReg, upperLimit).emit(masm);
-            }
+            try (SPARCScratchRegister sc = SPARCScratchRegister.get()) {
+                Register scratch2 = sc.getRegister();
+                if (isSimm13(upperLimit)) {
+                    new Cmp(scratchReg, upperLimit).emit(masm);
+                } else {
+                    new Setx(upperLimit, scratch2).emit(masm);
+                    new Cmp(scratchReg, upperLimit).emit(masm);
+                }
 
-            // Jump to default target if index is not within the jump table
-            if (defaultTarget != null) {
-                new Bpgu(CC.Icc, defaultTarget.label()).emit(masm);
-                new Nop().emit(masm);  // delay slot
-            }
+                // Jump to default target if index is not within the jump table
+                if (defaultTarget != null) {
+                    new Bpgu(CC.Icc, defaultTarget.label()).emit(masm);
+                    new Nop().emit(masm);  // delay slot
+                }
 
-            // Load jump table entry into scratch and jump to it
-            new Sll(scratchReg, 3, scratchReg).emit(masm); // Multiply by 8
-            // Zero the left bits sll with shcnt>0 does not mask upper 32 bits
-            new Srl(scratchReg, 0, scratchReg).emit(masm);
-            new Rdpc(g3).emit(masm);
+                // Load jump table entry into scratch and jump to it
+                new Sll(scratchReg, 3, scratchReg).emit(masm); // Multiply by 8
+                // Zero the left bits sll with shcnt>0 does not mask upper 32 bits
+                new Srl(scratchReg, 0, scratchReg).emit(masm);
+                new Rdpc(scratch2).emit(masm);
 
-            // The jump table follows four instructions after rdpc
-            new Add(scratchReg, 4 * 4, scratchReg).emit(masm);
-            new Jmpl(g3, scratchReg, g0).emit(masm);
+                // The jump table follows four instructions after rdpc
+                new Add(scratchReg, 4 * 4, scratchReg).emit(masm);
+                new Jmpl(scratch2, scratchReg, g0).emit(masm);
+            }
             new Nop().emit(masm);
             // new Sra(value, 3, value).emit(masm); // delay slot, correct the value (division by 8)
 
--- a/graal/com.oracle.graal.lir.sparc/src/com/oracle/graal/lir/sparc/SPARCMove.java	Tue Sep 02 15:44:33 2014 -0700
+++ b/graal/com.oracle.graal.lir.sparc/src/com/oracle/graal/lir/sparc/SPARCMove.java	Tue Sep 02 19:23:43 2014 -0700
@@ -38,6 +38,7 @@
 import com.oracle.graal.lir.StandardOp.MoveOp;
 import com.oracle.graal.lir.StandardOp.NullCheck;
 import com.oracle.graal.lir.asm.*;
+import com.oracle.graal.sparc.*;
 
 public class SPARCMove {
 
@@ -137,36 +138,39 @@
 
         @Override
         public void emitMemAccess(SPARCMacroAssembler masm) {
-            final SPARCAddress addr = guaranueeLoadable(address.toAddress(), masm);
-            final Register dst = asRegister(result);
-            switch (kind) {
-                case Boolean:
-                case Byte:
-                    new Ldsb(addr, dst).emit(masm);
-                    break;
-                case Short:
-                    new Ldsh(addr, dst).emit(masm);
-                    break;
-                case Char:
-                    new Lduh(addr, dst).emit(masm);
-                    break;
-                case Int:
-                    new Ldsw(addr, dst).emit(masm);
-                    break;
-                case Long:
-                    new Ldx(addr, dst).emit(masm);
-                    break;
-                case Float:
-                    new Ldf(addr, dst).emit(masm);
-                    break;
-                case Double:
-                    new Lddf(addr, dst).emit(masm);
-                    break;
-                case Object:
-                    new Ldx(addr, dst).emit(masm);
-                    break;
-                default:
-                    throw GraalInternalError.shouldNotReachHere();
+            try (SPARCScratchRegister sc = SPARCScratchRegister.get()) {
+                Register scratch = sc.getRegister();
+                final SPARCAddress addr = guaranueeLoadable(address.toAddress(), masm, scratch);
+                final Register dst = asRegister(result);
+                switch (kind) {
+                    case Boolean:
+                    case Byte:
+                        new Ldsb(addr, dst).emit(masm);
+                        break;
+                    case Short:
+                        new Ldsh(addr, dst).emit(masm);
+                        break;
+                    case Char:
+                        new Lduh(addr, dst).emit(masm);
+                        break;
+                    case Int:
+                        new Ldsw(addr, dst).emit(masm);
+                        break;
+                    case Long:
+                        new Ldx(addr, dst).emit(masm);
+                        break;
+                    case Float:
+                        new Ldf(addr, dst).emit(masm);
+                        break;
+                    case Double:
+                        new Lddf(addr, dst).emit(masm);
+                        break;
+                    case Object:
+                        new Ldx(addr, dst).emit(masm);
+                        break;
+                    default:
+                        throw GraalInternalError.shouldNotReachHere();
+                }
             }
         }
     }
@@ -311,33 +315,36 @@
         @Override
         public void emitMemAccess(SPARCMacroAssembler masm) {
             assert isRegister(input);
-            SPARCAddress addr = guaranueeLoadable(address.toAddress(), masm);
-            switch (kind) {
-                case Boolean:
-                case Byte:
-                    new Stb(asRegister(input), addr).emit(masm);
-                    break;
-                case Short:
-                case Char:
-                    new Sth(asRegister(input), addr).emit(masm);
-                    break;
-                case Int:
-                    new Stw(asRegister(input), addr).emit(masm);
-                    break;
-                case Long:
-                    new Stx(asRegister(input), addr).emit(masm);
-                    break;
-                case Object:
-                    new Stx(asRegister(input), addr).emit(masm);
-                    break;
-                case Float:
-                    new Stf(asRegister(input), addr).emit(masm);
-                    break;
-                case Double:
-                    new Stdf(asRegister(input), addr).emit(masm);
-                    break;
-                default:
-                    throw GraalInternalError.shouldNotReachHere("missing: " + kind);
+            try (SPARCScratchRegister sc = SPARCScratchRegister.get()) {
+                Register scratch = sc.getRegister();
+                SPARCAddress addr = guaranueeLoadable(address.toAddress(), masm, scratch);
+                switch (kind) {
+                    case Boolean:
+                    case Byte:
+                        new Stb(asRegister(input), addr).emit(masm);
+                        break;
+                    case Short:
+                    case Char:
+                        new Sth(asRegister(input), addr).emit(masm);
+                        break;
+                    case Int:
+                        new Stw(asRegister(input), addr).emit(masm);
+                        break;
+                    case Long:
+                        new Stx(asRegister(input), addr).emit(masm);
+                        break;
+                    case Object:
+                        new Stx(asRegister(input), addr).emit(masm);
+                        break;
+                    case Float:
+                        new Stf(asRegister(input), addr).emit(masm);
+                        break;
+                    case Double:
+                        new Stdf(asRegister(input), addr).emit(masm);
+                        break;
+                    default:
+                        throw GraalInternalError.shouldNotReachHere("missing: " + kind);
+                }
             }
         }
     }
@@ -356,28 +363,31 @@
 
         @Override
         public void emitMemAccess(SPARCMacroAssembler masm) {
-            SPARCAddress addr = guaranueeLoadable(address.toAddress(), masm);
-            switch (kind) {
-                case Boolean:
-                case Byte:
-                    new Stb(g0, addr).emit(masm);
-                    break;
-                case Short:
-                case Char:
-                    new Sth(g0, addr).emit(masm);
-                    break;
-                case Int:
-                    new Stw(g0, addr).emit(masm);
-                    break;
-                case Long:
-                case Object:
-                    new Stx(g0, addr).emit(masm);
-                    break;
-                case Float:
-                case Double:
-                    throw GraalInternalError.shouldNotReachHere("Cannot store float constants to memory");
-                default:
-                    throw GraalInternalError.shouldNotReachHere();
+            try (SPARCScratchRegister sc = SPARCScratchRegister.get()) {
+                Register scratch = sc.getRegister();
+                SPARCAddress addr = guaranueeLoadable(address.toAddress(), masm, scratch);
+                switch (kind) {
+                    case Boolean:
+                    case Byte:
+                        new Stb(g0, addr).emit(masm);
+                        break;
+                    case Short:
+                    case Char:
+                        new Sth(g0, addr).emit(masm);
+                        break;
+                    case Int:
+                        new Stw(g0, addr).emit(masm);
+                        break;
+                    case Long:
+                    case Object:
+                        new Stx(g0, addr).emit(masm);
+                        break;
+                    case Float:
+                    case Double:
+                        throw GraalInternalError.shouldNotReachHere("Cannot store float constants to memory");
+                    default:
+                        throw GraalInternalError.shouldNotReachHere();
+                }
             }
         }
     }
@@ -401,10 +411,16 @@
             if (isRegister(result)) {
                 const2reg(crb, masm, result, (Constant) input);
             } else if (isStackSlot(result)) {
-                // Move a Constant to a stack slot (Probably a 7th output parameter)
-                Value scratch = input.getKind() == Kind.Float || input.getKind() == Kind.Double ? f30.asValue(input.getLIRKind()) : g5.asValue(input.getLIRKind());
-                const2reg(crb, masm, scratch, (Constant) input);
-                reg2stack(crb, masm, result, scratch);
+                try (SPARCScratchRegister sc = SPARCScratchRegister.get()) {
+                    Register scratch = sc.getRegister();
+                    Constant constant = asConstant(input);
+                    if (constant.isNull()) {
+                        new Clr(scratch).emit(masm);
+                    } else {
+                        new Setx(constant.asLong(), scratch).emit(masm);
+                    }
+                    reg2stack(crb, masm, result, scratch.asValue(LIRKind.derive(input)));
+                }
             } else {
                 throw GraalInternalError.shouldNotReachHere("Result is a: " + result);
             }
@@ -473,10 +489,9 @@
      * @param masm assembler to output the prior stx command
      * @return a loadable SPARCAddress
      */
-    public static SPARCAddress guaranueeLoadable(SPARCAddress addr, SPARCMacroAssembler masm) {
+    public static SPARCAddress guaranueeLoadable(SPARCAddress addr, SPARCMacroAssembler masm, Register scratch) {
         boolean displacementOutOfBound = addr.getIndex().equals(Register.None) && !SPARCAssembler.isSimm13(addr.getDisplacement());
         if (displacementOutOfBound) {
-            Register scratch = g3;
             new Setx(addr.getDisplacement(), scratch, false).emit(masm);
             return new SPARCAddress(addr.getBase(), scratch);
         } else {
@@ -486,109 +501,117 @@
 
     private static void reg2stack(CompilationResultBuilder crb, SPARCMacroAssembler masm, Value result, Value input) {
         SPARCAddress dst = (SPARCAddress) crb.asAddress(result);
-        dst = guaranueeLoadable(dst, masm);
-        Register src = asRegister(input);
-        switch (input.getKind()) {
-            case Byte:
-            case Boolean:
-                new Stb(src, dst).emit(masm);
-                break;
-            case Char:
-            case Short:
-                new Sth(src, dst).emit(masm);
-                break;
-            case Int:
-                new Stw(src, dst).emit(masm);
-                break;
-            case Long:
-            case Object:
-                new Stx(src, dst).emit(masm);
-                break;
-            case Float:
-                new Stf(src, dst).emit(masm);
-                break;
-            case Double:
-                new Stdf(src, dst).emit(masm);
-                break;
-            default:
-                throw GraalInternalError.shouldNotReachHere("Input is a: " + input.getKind() + "(" + input + ")");
+        try (SPARCScratchRegister sc = SPARCScratchRegister.get()) {
+            Register scratch = sc.getRegister();
+            dst = guaranueeLoadable(dst, masm, scratch);
+            Register src = asRegister(input);
+            switch (input.getKind()) {
+                case Byte:
+                case Boolean:
+                    new Stb(src, dst).emit(masm);
+                    break;
+                case Char:
+                case Short:
+                    new Sth(src, dst).emit(masm);
+                    break;
+                case Int:
+                    new Stw(src, dst).emit(masm);
+                    break;
+                case Long:
+                case Object:
+                    new Stx(src, dst).emit(masm);
+                    break;
+                case Float:
+                    new Stf(src, dst).emit(masm);
+                    break;
+                case Double:
+                    new Stdf(src, dst).emit(masm);
+                    break;
+                default:
+                    throw GraalInternalError.shouldNotReachHere("Input is a: " + input.getKind() + "(" + input + ")");
+            }
         }
     }
 
     private static void stack2reg(CompilationResultBuilder crb, SPARCMacroAssembler masm, Value result, Value input) {
         SPARCAddress src = (SPARCAddress) crb.asAddress(input);
-        src = guaranueeLoadable(src, masm);
-        Register dst = asRegister(result);
-        switch (input.getKind()) {
-            case Boolean:
-            case Byte:
-                new Ldsb(src, dst).emit(masm);
-                break;
-            case Short:
-                new Ldsh(src, dst).emit(masm);
-                break;
-            case Char:
-                new Lduh(src, dst).emit(masm);
-                break;
-            case Int:
-                new Ldsw(src, dst).emit(masm);
-                break;
-            case Long:
-            case Object:
-                new Ldx(src, dst).emit(masm);
-                break;
-            case Float:
-                new Ldf(src, dst).emit(masm);
-                break;
-            case Double:
-                new Lddf(src, dst).emit(masm);
-                break;
-            default:
-                throw GraalInternalError.shouldNotReachHere("Input is a: " + input.getKind());
+        try (SPARCScratchRegister sc = SPARCScratchRegister.get()) {
+            Register scratch = sc.getRegister();
+            src = guaranueeLoadable(src, masm, scratch);
+            Register dst = asRegister(result);
+            switch (input.getKind()) {
+                case Boolean:
+                case Byte:
+                    new Ldsb(src, dst).emit(masm);
+                    break;
+                case Short:
+                    new Ldsh(src, dst).emit(masm);
+                    break;
+                case Char:
+                    new Lduh(src, dst).emit(masm);
+                    break;
+                case Int:
+                    new Ldsw(src, dst).emit(masm);
+                    break;
+                case Long:
+                case Object:
+                    new Ldx(src, dst).emit(masm);
+                    break;
+                case Float:
+                    new Ldf(src, dst).emit(masm);
+                    break;
+                case Double:
+                    new Lddf(src, dst).emit(masm);
+                    break;
+                default:
+                    throw GraalInternalError.shouldNotReachHere("Input is a: " + input.getKind());
+            }
         }
     }
 
     private static void const2reg(CompilationResultBuilder crb, SPARCMacroAssembler masm, Value result, Constant input) {
-        Register scratch = g5;
-        switch (input.getKind().getStackKind()) {
-            case Int:
-                new Setx(input.asLong(), asIntReg(result)).emit(masm);
-                break;
-            case Long:
-                new Setx(input.asLong(), asLongReg(result)).emit(masm);
-                break;
-            case Float:
-                // TODO: Handle it the same way, as in the double case with Movwtos
-                crb.asFloatConstRef(input);
-                // First load the address into the scratch register
-                new Setx(0, scratch, true).emit(masm);
-                // Now load the float value
-                new Ldf(scratch, asFloatReg(result)).emit(masm);
-                break;
-            case Double:
-                // instead loading this from memory and do the complicated lookup,
-                // just load it directly into a scratch register
-                // First load the address into the scratch register
-                new Setx(Double.doubleToLongBits(input.asDouble()), scratch, true).emit(masm);
-                // Now load the float value
-                new Movxtod(scratch, asDoubleReg(result)).emit(masm);
-                break;
-            case Object:
-                if (input.isNull()) {
-                    new Clr(asRegister(result)).emit(masm);
-                } else if (crb.target.inlineObjects) {
-                    crb.recordInlineDataInCode(input);
-                    new Setx(0xDEADDEADDEADDEADL, asRegister(result), true).emit(masm);
-                } else {
-                    Register dst = asRegister(result);
-                    new Rdpc(dst).emit(masm);
-                    crb.asObjectConstRef(input);
-                    new Ldx(new SPARCAddress(dst, 0), dst).emit(masm);
-                    throw GraalInternalError.shouldNotReachHere("the patched offset might be too big for the load");
-                }
-                break;
-            default:
-                throw GraalInternalError.shouldNotReachHere("missing: " + input.getKind());
+        try (SPARCScratchRegister sc = SPARCScratchRegister.get()) {
+            Register scratch = sc.getRegister();
+            switch (input.getKind().getStackKind()) {
+                case Int:
+                    new Setx(input.asLong(), asIntReg(result)).emit(masm);
+                    break;
+                case Long:
+                    new Setx(input.asLong(), asLongReg(result)).emit(masm);
+                    break;
+                case Float:
+                    // TODO: Handle it the same way, as in the double case with Movwtos
+                    crb.asFloatConstRef(input);
+                    // First load the address into the scratch register
+                    new Setx(0, scratch, true).emit(masm);
+                    // Now load the float value
+                    new Ldf(scratch, asFloatReg(result)).emit(masm);
+                    break;
+                case Double:
+                    // instead loading this from memory and do the complicated lookup,
+                    // just load it directly into a scratch register
+                    // First load the address into the scratch register
+                    new Setx(Double.doubleToLongBits(input.asDouble()), scratch, true).emit(masm);
+                    // Now load the float value
+                    new Movxtod(scratch, asDoubleReg(result)).emit(masm);
+                    break;
+                case Object:
+                    if (input.isNull()) {
+                        new Clr(asRegister(result)).emit(masm);
+                    } else if (crb.target.inlineObjects) {
+                        crb.recordInlineDataInCode(input);
+                        new Setx(0xDEADDEADDEADDEADL, asRegister(result), true).emit(masm);
+                    } else {
+                        Register dst = asRegister(result);
+                        new Rdpc(dst).emit(masm);
+                        crb.asObjectConstRef(input);
+                        new Ldx(new SPARCAddress(dst, 0), dst).emit(masm);
+                        throw GraalInternalError.shouldNotReachHere("the patched offset might be too big for the load");
+                    }
+                    break;
+                default:
+                    throw GraalInternalError.shouldNotReachHere("missing: " + input.getKind());
+            }
         }
     }
 
--- a/graal/com.oracle.graal.lir.sparc/src/com/oracle/graal/lir/sparc/SPARCSaveRegistersOp.java	Tue Sep 02 15:44:33 2014 -0700
+++ b/graal/com.oracle.graal.lir.sparc/src/com/oracle/graal/lir/sparc/SPARCSaveRegistersOp.java	Tue Sep 02 19:23:43 2014 -0700
@@ -39,7 +39,7 @@
  */
 @Opcode("SAVE_REGISTER")
 public class SPARCSaveRegistersOp extends SPARCLIRInstruction implements SaveRegistersOp {
-
+    public static Register RETURN_REGISTER_STORAGE = SPARC.d62;
     /**
      * The registers (potentially) saved by this operation.
      */
@@ -80,7 +80,7 @@
                 saveRegister(crb, masm, slots[i], savedRegisters[i]);
             }
         }
-        new Movxtod(SPARC.i0, SPARC.f31).emit(masm);
+        new Movxtod(SPARC.i0, RETURN_REGISTER_STORAGE).emit(masm);
     }
 
     public StackSlot[] getSlots() {
--- a/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/graph/FixedNodeProbabilityCache.java	Tue Sep 02 15:44:33 2014 -0700
+++ b/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/graph/FixedNodeProbabilityCache.java	Tue Sep 02 19:23:43 2014 -0700
@@ -99,10 +99,15 @@
             return cachedValue;
         }
 
-        double probability;
+        double probability = 0.0;
         if (current.predecessor() == null) {
             if (current instanceof MergeNode) {
-                probability = ((MergeNode) current).forwardEnds().stream().mapToDouble(this::applyAsDouble).sum();
+                MergeNode currentMerge = (MergeNode) current;
+                NodeInputList<AbstractEndNode> currentForwardEnds = currentMerge.forwardEnds();
+                // Using simple iteration instead of lambda as the lambda blows up the stack
+                for (AbstractEndNode endNode : currentForwardEnds) {
+                    probability += applyAsDouble(endNode);
+                }
                 if (current instanceof LoopBeginNode) {
                     probability *= ((LoopBeginNode) current).loopFrequency();
                 }
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.sparc/src/com/oracle/graal/sparc/SPARCScratchRegister.java	Tue Sep 02 19:23:43 2014 -0700
@@ -0,0 +1,57 @@
+package com.oracle.graal.sparc;
+
+import com.oracle.graal.api.code.*;
+
+public class SPARCScratchRegister implements AutoCloseable {
+    private final ThreadLocal<Boolean> locked = new ThreadLocal<>();
+    private final ThreadLocal<Exception> where = new ThreadLocal<>();
+    private final Register register;
+    private static final SPARCScratchRegister scratch1 = new SPARCScratchRegister(SPARC.g3);
+    private static final SPARCScratchRegister scratch2 = new SPARCScratchRegister(SPARC.g1);
+
+    private SPARCScratchRegister(Register register) {
+        super();
+        this.register = register;
+    }
+
+    public Register getRegister() {
+        if (locked.get() == null) {
+            locked.set(false);
+        }
+        boolean isLocked = locked.get();
+        if (isLocked) {
+            where.get().printStackTrace();
+            throw new RuntimeException("Temp Register is already taken!");
+        } else {
+            where.set(new Exception());
+            locked.set(true);
+            return register;
+        }
+    }
+
+    public void close() {
+        boolean isLocked = locked.get();
+        if (isLocked) {
+            locked.set(false);
+        } else {
+            throw new RuntimeException("Temp Register is not taken!");
+        }
+    }
+
+    public static SPARCScratchRegister get() {
+        if (scratch1.isLocked()) {
+            return scratch2;
+        } else {
+            return scratch1;
+        }
+    }
+
+    public boolean isLocked() {
+        Boolean isLocked = locked.get();
+        if (isLocked == null) {
+            return false;
+        } else {
+            return isLocked;
+        }
+    }
+}
--- a/src/cpu/sparc/vm/graalCodeInstaller_sparc.cpp	Tue Sep 02 15:44:33 2014 -0700
+++ b/src/cpu/sparc/vm/graalCodeInstaller_sparc.cpp	Tue Sep 02 19:23:43 2014 -0700
@@ -25,6 +25,7 @@
 #include "graal/graalRuntime.hpp"
 #include "graal/graalCompilerToVM.hpp"
 #include "graal/graalJavaAccess.hpp"
+#include "vmreg_sparc.inline.hpp"
 
 jint CodeInstaller::pd_next_offset(NativeInstruction* inst, jint pc_offset, oop method) {
   if (inst->is_call() || inst->is_jump()) {
@@ -146,3 +147,22 @@
       break;
   }
 }
+
+// convert Graal register indices (as used in oop maps) to HotSpot registers
+VMReg CodeInstaller::get_hotspot_reg(jint graal_reg) {
+  if (graal_reg < RegisterImpl::number_of_registers) {
+    return as_Register(graal_reg)->as_VMReg();
+  } else {
+    jint floatRegisterNumber = graal_reg - RegisterImpl::number_of_registers;
+    floatRegisterNumber += MAX2(0, floatRegisterNumber-32); // Beginning with f32, only every second register is going to be addressed
+    if (floatRegisterNumber < FloatRegisterImpl::number_of_registers) {
+      return as_FloatRegister(floatRegisterNumber)->as_VMReg();
+    }
+    ShouldNotReachHere();
+    return NULL;
+  }
+}
+
+bool CodeInstaller::is_general_purpose_reg(VMReg hotspotRegister) {
+  return !hotspotRegister->is_FloatRegister();
+}
--- a/src/cpu/x86/vm/graalCodeInstaller_x86.cpp	Tue Sep 02 15:44:33 2014 -0700
+++ b/src/cpu/x86/vm/graalCodeInstaller_x86.cpp	Tue Sep 02 19:23:43 2014 -0700
@@ -32,6 +32,7 @@
 #include "asm/register.hpp"
 #include "classfile/vmSymbols.hpp"
 #include "code/vmreg.hpp"
+#include "vmreg_x86.inline.hpp"
 
 jint CodeInstaller::pd_next_offset(NativeInstruction* inst, jint pc_offset, oop method) {
   if (inst->is_call() || inst->is_jump()) {
@@ -209,3 +210,21 @@
       break;
   }
 }
+
+// convert Graal register indices (as used in oop maps) to HotSpot registers
+VMReg CodeInstaller::get_hotspot_reg(jint graal_reg) {
+  if (graal_reg < RegisterImpl::number_of_registers) {
+    return as_Register(graal_reg)->as_VMReg();
+  } else {
+    jint floatRegisterNumber = graal_reg - RegisterImpl::number_of_registers;
+    if (floatRegisterNumber < XMMRegisterImpl::number_of_registers) {
+      return as_XMMRegister(floatRegisterNumber)->as_VMReg();
+    }
+    ShouldNotReachHere();
+    return NULL;
+  }
+}
+
+bool CodeInstaller::is_general_purpose_reg(VMReg hotspotRegister) {
+  return !(hotspotRegister->is_FloatRegister() || hotspotRegister->is_XMMRegister());
+}
--- a/src/share/vm/graal/graalCodeInstaller.cpp	Tue Sep 02 15:44:33 2014 -0700
+++ b/src/share/vm/graal/graalCodeInstaller.cpp	Tue Sep 02 19:23:43 2014 -0700
@@ -57,27 +57,6 @@
   return asMethod(HotSpotResolvedJavaMethod::metaspaceMethod(hotspot_method));
 }
 
-// convert Graal register indices (as used in oop maps) to HotSpot registers
-VMReg get_hotspot_reg(jint graal_reg) {
-  if (graal_reg < RegisterImpl::number_of_registers) {
-    return as_Register(graal_reg)->as_VMReg();
-  } else {
-    int remainder = graal_reg - RegisterImpl::number_of_registers;
-#ifdef TARGET_ARCH_x86
-    if (remainder < XMMRegisterImpl::number_of_registers) {
-      return as_XMMRegister(remainder)->as_VMReg();
-    }
-#endif
-#ifdef TARGET_ARCH_sparc
-    if (remainder < FloatRegisterImpl::number_of_registers) {
-      return as_FloatRegister(remainder)->as_VMReg();
-    }
-#endif
-    ShouldNotReachHere();
-    return NULL;
-  }
-}
-
 const int MapWordBits = 64;
 
 static bool is_bit_set(oop bitset, int i) {
@@ -155,7 +134,7 @@
     for (jint i = 0; i < slots->length(); i++) {
       oop graal_reg = registers->obj_at(i);
       jint graal_reg_number = code_Register::number(graal_reg);
-      VMReg hotspot_reg = get_hotspot_reg(graal_reg_number);
+      VMReg hotspot_reg = CodeInstaller::get_hotspot_reg(graal_reg_number);
       // HotSpot stack slots are 4 bytes
       jint graal_slot = ((jint*) slots->base(T_INT))[i];
       jint hotspot_slot = graal_slot * VMRegImpl::slots_per_word;
@@ -227,10 +206,8 @@
   if (value->is_a(RegisterValue::klass())) {
     oop reg = RegisterValue::reg(value);
     jint number = code_Register::number(reg);
-    jint encoding = code_Register::encoding(reg);
-    oop registerCategory = code_Register::registerCategory(reg);
-    jint referenceMapOffset = RegisterCategory::referenceMapOffset(registerCategory);
-    if (number < RegisterImpl::number_of_registers) {
+    VMReg hotspotRegister = get_hotspot_reg(number);
+    if (is_general_purpose_reg(hotspotRegister)) {
       Location::Type locationType;
       if (type == T_INT) {
         locationType = reference ? Location::narrowoop : Location::int_in_long;
@@ -244,7 +221,7 @@
         assert(type == T_OBJECT && reference, "unexpected type in cpu register");
         locationType = Location::oop;
       }
-      ScopeValue* value = new LocationValue(Location::new_reg_loc(locationType, as_Register(number)->as_VMReg()));
+      ScopeValue* value = new LocationValue(Location::new_reg_loc(locationType, hotspotRegister));
       if (type == T_LONG && !reference) {
         second = value;
       }
@@ -259,25 +236,11 @@
         locationType = Location::dbl;
       }
       assert(!reference, "unexpected type in floating point register");
-      jint floatRegisterNumber = number - referenceMapOffset;
-#ifdef TARGET_ARCH_x86
-      ScopeValue* value = new LocationValue(Location::new_reg_loc(locationType, as_XMMRegister(floatRegisterNumber)->as_VMReg()));
+      ScopeValue* value = new LocationValue(Location::new_reg_loc(locationType, hotspotRegister));
       if (type == T_DOUBLE) {
         second = value;
       }
       return value;
-#else
-#ifdef TARGET_ARCH_sparc
-      floatRegisterNumber += MAX2(0, floatRegisterNumber-32); // Beginning with f32, only every second register is going to be addressed
-      ScopeValue* value = new LocationValue(Location::new_reg_loc(locationType, as_FloatRegister(floatRegisterNumber)->as_VMReg()));
-      if (type == T_DOUBLE) {
-        second = value;
-      }
-      return value;
-#else
-      ShouldNotReachHere("Platform currently does not support floating point values.");
-#endif
-#endif
     }
   } else if (value->is_a(StackSlot::klass())) {
       Location::Type locationType;
--- a/src/share/vm/graal/graalCodeInstaller.hpp	Tue Sep 02 15:44:33 2014 -0700
+++ b/src/share/vm/graal/graalCodeInstaller.hpp	Tue Sep 02 19:23:43 2014 -0700
@@ -86,12 +86,15 @@
   void pd_relocate_JavaMethod(oop method, jint pc_offset);
   void pd_relocate_poll(address pc, jint mark);
 
+
 public:
 
   CodeInstaller() {};
   GraalEnv::CodeInstallResult install(Handle& compiled_code, CodeBlob*& cb, Handle installed_code, Handle speculation_log);
 
   static address runtime_call_target_address(oop runtime_call);
+  static VMReg get_hotspot_reg(jint graalRegisterNumber);
+  static bool is_general_purpose_reg(VMReg hotspotRegister);
 
 protected:
 
@@ -131,4 +134,6 @@
  */
 Method* getMethodFromHotSpotMethod(oop hotspot_method);
 
+
+
 #endif // SHARE_VM_GRAAL_GRAAL_CODE_INSTALLER_HPP
--- a/test/blacklist_sparc.txt	Tue Sep 02 15:44:33 2014 -0700
+++ b/test/blacklist_sparc.txt	Tue Sep 02 19:23:43 2014 -0700
@@ -1,310 +1,5 @@
-com.oracle.graal.jtt.lang.Object_equals01
-com.oracle.graal.replacements.test.CheckCastTest
-com.oracle.graal.hotspot.test.AheadOfTimeCompilationTest
-com.oracle.graal.jtt.reflect.Invoke_except01
-com.oracle.graal.jtt.bytecode.BC_fastore
-com.oracle.graal.compiler.test.deopt.MonitorDeoptTest
-com.oracle.graal.jtt.loop.LoopParseLong
-com.oracle.graal.jtt.bytecode.BC_baload
-com.oracle.graal.jtt.threads.ThreadLocal01
-com.oracle.graal.jtt.jdk.UnsafeAllocateInstance01
-com.oracle.graal.jtt.threads.ThreadLocal02
-com.oracle.graal.jtt.optimize.ConditionalElimination01
-com.oracle.graal.jtt.threads.ThreadLocal03
-com.oracle.graal.jtt.except.BC_athrow3
-com.oracle.graal.jtt.except.BC_checkcast
-com.oracle.graal.jtt.micro.VarArgs_short01
-com.oracle.graal.replacements.test.InvokeTest
-com.oracle.graal.jtt.reflect.Invoke_virtual01
-com.oracle.graal.jtt.lang.Math_cos
-com.oracle.graal.jtt.lang.Math_log10
-com.oracle.graal.jtt.optimize.Narrow_char02
-com.oracle.graal.jtt.lang.Math_sin
-com.oracle.graal.jtt.bytecode.BC_lookupswitch05
-com.oracle.graal.jtt.except.BC_aastore0
-com.oracle.graal.jtt.reflect.Class_getDeclaredField01
-com.oracle.graal.jtt.micro.VarArgs_double01
-com.oracle.graal.jtt.micro.String_format02
-com.oracle.graal.compiler.hsail.test.lambda.ArrayListSetTest
-com.oracle.graal.jtt.optimize.List_reorder_bug
-com.oracle.graal.jtt.hotpath.HP_idea
-com.oracle.graal.jtt.except.Throw_Synchronized01
-com.oracle.graal.jtt.lang.Bridge_method01
-com.oracle.graal.compiler.test.IfReorderTest
-com.oracle.graal.jtt.optimize.Switch02
-com.oracle.graal.jtt.jdk.Thread_setName
-com.oracle.graal.jtt.reflect.Array_set01
-com.oracle.graal.jtt.reflect.Array_set02
-com.oracle.graal.jtt.except.BC_checkcast5
-com.oracle.graal.jtt.micro.VarArgs_float01
-com.oracle.graal.jtt.bytecode.BC_monitorenter
-com.oracle.graal.jtt.hotpath.HP_array04
-com.oracle.graal.compiler.hsail.test.lambda.StringSubstringTest
-com.oracle.graal.jtt.hotpath.HP_array03
-com.oracle.graal.jtt.hotpath.HP_array02
-com.oracle.graal.jtt.threads.Thread_isInterrupted03
-com.oracle.graal.jtt.threads.Thread_isInterrupted02
-com.oracle.graal.jtt.threads.Thread_isInterrupted05
-com.oracle.graal.jtt.lang.ClassLoader_loadClass01
-com.oracle.graal.jtt.optimize.NCE_02
-com.oracle.graal.jtt.lang.Object_hashCode01
-com.oracle.graal.jtt.loop.Loop09
-com.oracle.graal.compiler.hsail.test.lambda.DremTest
 com.oracle.graal.replacements.test.StandardMethodSubstitutionsTest
-com.oracle.graal.jtt.jdk.UnsafeAccess01
-com.oracle.graal.jtt.loop.LoopSwitch01
-com.oracle.graal.jtt.except.Catch_NASE_2
-com.oracle.graal.jtt.threads.Thread_setPriority01
-com.oracle.graal.jtt.except.BC_checkcast3
-com.oracle.graal.jtt.reflect.Invoke_main03
-com.oracle.graal.jtt.except.BC_aastore1
-com.oracle.graal.jtt.except.BC_saload
-com.oracle.graal.jtt.threads.Monitor_contended01
-com.oracle.graal.jtt.lang.Class_getName02
-com.oracle.graal.jtt.reflect.Invoke_main01
-com.oracle.graal.jtt.lang.Math_sqrt
-com.oracle.graal.jtt.bytecode.BC_ldc_06
-com.oracle.graal.jtt.optimize.ConditionalElimination02
-com.oracle.graal.jtt.lang.String_intern02
-com.oracle.truffle.sl.test.SLSimpleTestSuite
-com.oracle.graal.jtt.micro.Bubblesort
-com.oracle.graal.jtt.lang.String_intern03
-com.oracle.graal.jtt.hotpath.HP_demo01
-com.oracle.graal.jtt.optimize.ArrayLength01
-com.oracle.graal.replacements.test.DynamicNewArrayTest
-com.oracle.graal.jtt.micro.InvokeVirtual_02
-com.oracle.graal.jtt.lang.Object_getClass01
-com.oracle.graal.jtt.micro.Matrix01
-com.oracle.graal.replacements.test.NewInstanceTest
-com.oracle.graal.jtt.lang.Class_getSimpleName01
-com.oracle.graal.jtt.lang.Class_getSimpleName02
-com.oracle.graal.jtt.bytecode.BC_d2l02
-com.oracle.graal.jtt.except.BC_checkcast6
-com.oracle.graal.jtt.lang.Class_getSuperClass01
-com.oracle.graal.jtt.lang.Class_getInterfaces01
-com.oracle.graal.jtt.lang.Class_Literal01
 com.oracle.graal.replacements.test.StringSubstitutionsTest
-com.oracle.graal.jtt.except.BC_checkcast4
-com.oracle.graal.jtt.bytecode.BC_f2l02
-com.oracle.graal.jtt.micro.VarArgs_long01
-com.oracle.graal.compiler.test.ea.UnsafeEATest
-com.oracle.graal.jtt.except.Catch_NASE_1
-com.oracle.graal.jtt.bytecode.BC_iastore
-com.oracle.graal.compiler.test.ShortCircuitNodeTest
-com.oracle.graal.jtt.threads.Thread_isInterrupted04
-com.oracle.graal.jtt.jdk.EnumMap02
-com.oracle.graal.jtt.threads.Monitor_notowner01
-com.oracle.graal.hotspot.test.ArrayCopyIntrinsificationTest
-com.oracle.graal.jtt.bytecode.BC_putfield_01
-com.oracle.graal.jtt.lang.Math_tan
-com.oracle.graal.jtt.bytecode.BC_aaload
-com.oracle.graal.jtt.optimize.Narrow_short03
-com.oracle.graal.jtt.optimize.Narrow_short02
-com.oracle.graal.jtt.optimize.ArrayCopy01
-com.oracle.graal.jtt.bytecode.BC_athrow
-com.oracle.graal.jtt.except.BC_sastore
-com.oracle.graal.jtt.bytecode.BC_d2i02
-com.oracle.graal.jtt.threads.Object_wait01
-com.oracle.graal.jtt.bytecode.BC_sastore
-com.oracle.graal.jtt.bytecode.BC_l2i_2
-com.oracle.graal.jtt.micro.BigObjectParams02
-com.oracle.graal.jtt.except.StackTrace_NPE_01
-com.oracle.graal.compiler.test.CommonedConstantsTest
-com.oracle.graal.jtt.bytecode.BC_getfield
-com.oracle.graal.jtt.bytecode.BC_laload
-com.oracle.graal.hotspot.test.WriteBarrierAdditionTest
-com.oracle.graal.jtt.hotpath.HP_life
-com.oracle.graal.hotspot.test.CRC32SubstitutionsTest
-com.oracle.graal.jtt.lang.Boxed_TYPE_01
-com.oracle.graal.jtt.reflect.Class_getDeclaredMethod01
-com.oracle.graal.jtt.threads.Thread_new02
-com.oracle.graal.jtt.threads.Thread_new01
-com.oracle.graal.jtt.except.BC_caload
-com.oracle.graal.compiler.hsail.test.StaticMethod16InArraysTest
-com.oracle.graal.jtt.jdk.Unsafe_compareAndSwap
-com.oracle.graal.replacements.test.MonitorTest
-com.oracle.graal.jtt.except.Throw_Synchronized05
-com.oracle.graal.jtt.reflect.Array_newInstance02
-com.oracle.graal.jtt.reflect.Array_newInstance03
-com.oracle.graal.jtt.reflect.Array_newInstance01
-com.oracle.graal.jtt.reflect.Array_newInstance06
-com.oracle.graal.jtt.micro.VarArgs_byte01
-com.oracle.graal.jtt.except.BC_laload
-com.oracle.graal.compiler.test.ea.EscapeAnalysisTest
-com.oracle.graal.jtt.except.Throw_Synchronized02
-com.oracle.graal.jtt.except.Throw_Synchronized04
-com.oracle.graal.jtt.optimize.NestedLoop_EA
-com.oracle.graal.jtt.except.BC_newarray
-com.oracle.graal.jtt.loop.Loop15
-com.oracle.graal.compiler.hsail.test.lambda.ObjectArrayInstanceDerivedTest
-com.oracle.graal.jtt.bytecode.BC_checkcast01
-com.oracle.graal.jtt.except.BC_anewarray
 com.oracle.graal.hotspot.amd64.test.CompressedNullCheckTest
-com.oracle.graal.compiler.test.MemoryArithmeticTest
-com.oracle.graal.jtt.bytecode.BC_getfield_o
-com.oracle.graal.jtt.lang.Class_getComponentType01
-com.oracle.graal.jtt.reflect.Array_newInstance04
-com.oracle.graal.jtt.reflect.Method_getParameterTypes01
-com.oracle.graal.compiler.test.inlining.InliningTest
-com.oracle.graal.hotspot.test.InstalledCodeExecuteHelperTest
-com.oracle.graal.jtt.except.BC_castore
-com.oracle.graal.jtt.lang.Class_isInstance06
-com.oracle.graal.jtt.lang.Class_isInstance07
-com.oracle.graal.jtt.threads.Thread_join03
-com.oracle.graal.jtt.threads.Thread_join01
-com.oracle.graal.jtt.except.BC_putfield
-com.oracle.graal.jtt.lang.Class_forName03
-com.oracle.graal.jtt.lang.Class_forName04
-com.oracle.graal.jtt.lang.Class_forName05
-com.oracle.graal.jtt.hotspot.Test6186134
-com.oracle.graal.jtt.optimize.NCE_03
-com.oracle.graal.jtt.micro.String_format01
-com.oracle.graal.jtt.except.BC_lastore
-com.oracle.graal.jtt.bytecode.BC_monitorenter02
-com.oracle.graal.jtt.micro.ReferenceMap01
-com.oracle.graal.jtt.bytecode.BC_instanceof
-com.oracle.graal.jtt.except.Catch_Unresolved
-com.oracle.graal.compiler.test.MemoryScheduleTest
-com.oracle.graal.jtt.bytecode.BC_castore
-com.oracle.graal.jtt.except.Throw_InCatch03
-com.oracle.graal.jtt.except.Throw_InCatch02
-com.oracle.graal.jtt.except.Throw_InCatch01
-com.oracle.graal.jtt.except.BC_iaload
-com.oracle.graal.jtt.lang.Double_toString
-com.oracle.graal.jtt.optimize.ABCE_02
-com.oracle.graal.replacements.test.CompiledExceptionHandlerTest
-com.oracle.graal.jtt.except.Throw_Synchronized03
-com.oracle.graal.jtt.threads.Thread_join02
-com.oracle.graal.jtt.threads.SynchronizedLoopExit01
-com.oracle.graal.jtt.bytecode.BC_daload
-com.oracle.graal.jtt.optimize.Conditional01
-com.oracle.graal.jtt.lang.JDK_ClassLoaders02
-com.oracle.graal.jtt.bytecode.BC_putfield_03
-com.oracle.graal.jtt.bytecode.BC_putfield_02
-com.oracle.graal.jtt.micro.BigInterfaceParams01
-com.oracle.graal.jtt.micro.VarArgs_String01
-com.oracle.graal.jtt.optimize.LongToSomethingArray01
-com.oracle.graal.jtt.except.BC_checkcast1
-com.oracle.graal.jtt.except.Catch_NPE_07
-com.oracle.graal.jtt.except.Catch_NPE_06
-com.oracle.graal.jtt.except.Catch_NPE_02
-com.oracle.graal.jtt.except.Catch_NPE_01
 com.oracle.graal.replacements.test.ArraysSubstitutionsTest
-com.oracle.graal.jtt.except.StackTrace_CCE_00
-com.oracle.graal.jtt.lang.ProcessEnvironment_init
-com.oracle.graal.jtt.except.BC_bastore
-com.oracle.graal.jtt.except.BC_baload
-com.oracle.graal.jtt.lang.Class_asSubclass01
-com.oracle.graal.jtt.bytecode.BC_invokevirtual
-com.oracle.graal.compiler.test.BoxingEliminationTest
-com.oracle.graal.compiler.test.deopt.CompiledMethodTest
-com.oracle.graal.compiler.ptx.test.ArrayPTXTest
-com.oracle.graal.jtt.reflect.Class_getMethod01
-com.oracle.graal.compiler.test.InfopointReasonTest
-com.oracle.graal.jtt.reflect.Class_getMethod02
-com.oracle.graal.jtt.bytecode.BC_invokespecial2
-com.oracle.graal.jtt.reflect.Method_getReturnType01
-com.oracle.graal.replacements.test.InstanceOfTest
-com.oracle.graal.jtt.bytecode.BC_invokespecial
-com.oracle.graal.jtt.lang.Object_toString02
-com.oracle.graal.jtt.lang.Object_toString01
-com.oracle.graal.jtt.jdk.EnumMap01
-com.oracle.graal.jtt.except.BC_checkcast2
-com.oracle.graal.replacements.test.InstanceOfDynamicTest
-com.oracle.graal.hotspot.test.HotSpotNodeSubstitutionsTest
-com.oracle.graal.replacements.test.UnsignedMathTest
-com.oracle.graal.jtt.reflect.Field_get03
-com.oracle.graal.jtt.bytecode.BC_putfield_04
-com.oracle.graal.hotspot.test.CompressedOopTest
-com.oracle.graal.jtt.except.BC_daload
-com.oracle.graal.hotspot.amd64.test.AMD64HotSpotFrameOmissionTest
-com.oracle.graal.jtt.hotpath.HP_allocate04
-com.oracle.graal.jtt.hotpath.HP_allocate03
-com.oracle.graal.jtt.optimize.NCE_01
-com.oracle.graal.jtt.optimize.NCE_04
-com.oracle.graal.jtt.lang.Class_getName01
-com.oracle.graal.hotspot.test.HotSpotMonitorValueTest
-com.oracle.graal.jtt.threads.Thread_getState02
-com.oracle.graal.jtt.except.BC_arraylength
-com.oracle.graal.jtt.bytecode.BC_caload
-com.oracle.graal.replacements.test.UnsafeSubstitutionsTest
-com.oracle.graal.jtt.bytecode.BC_saload
-com.oracle.graal.hotspot.test.HotSpotNmethodTest
-com.oracle.graal.replacements.test.DeoptimizeOnExceptionTest
-com.oracle.graal.jtt.optimize.ArrayCopyGeneric
-com.oracle.graal.jtt.lang.Class_forName01
-com.oracle.graal.jtt.except.BC_monitorenter
-com.oracle.graal.jtt.except.Catch_Loop02
-com.oracle.graal.jtt.bytecode.BC_lastore
-com.oracle.graal.jtt.except.BC_getfield
-com.oracle.graal.jtt.except.BC_aaload1
-com.oracle.graal.jtt.except.BC_aaload0
-com.oracle.graal.jtt.except.BC_dastore
-com.oracle.graal.jtt.micro.VarArgs_char01
-com.oracle.graal.jtt.optimize.NCE_FlowSensitive05
-com.oracle.graal.jtt.optimize.NCE_FlowSensitive03
-com.oracle.graal.jtt.bytecode.BC_aaload_1
-com.oracle.graal.jtt.lang.Math_abs
-com.oracle.graal.hotspot.test.CompileTheWorldTest
-com.oracle.graal.jtt.micro.FloatingReads
-com.oracle.graal.jtt.except.BC_fastore
-com.oracle.graal.jtt.optimize.ArrayCopy05
-com.oracle.graal.jtt.bytecode.BC_aastore
-com.oracle.graal.compiler.test.LockEliminationTest
-com.oracle.graal.jtt.hotpath.HP_invoke01
-com.oracle.graal.jtt.bytecode.BC_dastore
-com.oracle.graal.jtt.loop.DegeneratedLoop
-com.oracle.graal.jtt.hotpath.HP_array01
-com.oracle.graal.jtt.except.BC_iastore
-com.oracle.graal.jtt.except.BC_athrow2
-com.oracle.graal.jtt.except.BC_athrow0
-com.oracle.graal.jtt.except.BC_athrow1
-com.oracle.graal.jtt.micro.VarArgs_int01
-com.oracle.graal.jtt.micro.BigVirtualParams01
-com.oracle.graal.jtt.jdk.Class_getName
-com.oracle.graal.jtt.reflect.Array_newInstance05
-com.oracle.graal.jtt.optimize.ABCE_01
-com.oracle.graal.jtt.micro.InvokeVirtual_01
-com.oracle.graal.jtt.except.StackTrace_AIOOBE_00
-com.oracle.graal.jtt.bytecode.BC_invokeinterface
-com.oracle.graal.jtt.micro.BigMixedParams04
-com.oracle.graal.jtt.reflect.Invoke_main02
-com.oracle.graal.jtt.threads.Object_wait02
-com.oracle.graal.jtt.threads.Object_wait03
-com.oracle.graal.jtt.threads.Object_wait04
-com.oracle.graal.jtt.except.Catch_Unresolved02
-com.oracle.graal.jtt.except.Catch_Unresolved03
 com.oracle.graal.compiler.test.CheckGraalInvariants
-com.oracle.graal.jtt.except.Catch_Unresolved01
-com.oracle.graal.jtt.optimize.Narrow_byte03
-com.oracle.graal.jtt.except.BC_faload
-com.oracle.graal.nodes.test.LoopPhiCanonicalizerTest
-com.oracle.graal.jtt.bytecode.BC_f2i02
-com.oracle.graal.jtt.bytecode.BC_iaload
-com.oracle.graal.jtt.reflect.Array_set03
-com.oracle.graal.jtt.lang.Class_forName02
-com.oracle.graal.compiler.hsail.test.lambda.ObjectArrayInstanceTest
-com.oracle.graal.jtt.micro.VarArgs_boolean01
-com.oracle.graal.jtt.lang.Math_log
-com.oracle.graal.compiler.test.FlowSensitiveReductionTest
-com.oracle.graal.jtt.bytecode.BC_faload
-com.oracle.graal.jtt.bytecode.BC_multianewarray03
-com.oracle.graal.jtt.loop.Loop06
-com.oracle.graal.jtt.loop.Loop07
-com.oracle.graal.jtt.loop.Loop13
-com.oracle.graal.jtt.bytecode.BC_bastore
-com.oracle.graal.jtt.except.Catch_Two02
-com.oracle.graal.jtt.except.Catch_Two03
-com.oracle.graal.jtt.except.Catch_Two01
-com.oracle.graal.jtt.optimize.Narrow_byte02
-com.oracle.graal.jtt.loop.Loop05
-com.oracle.graal.jtt.loop.Loop12
-com.oracle.graal.jtt.jdk.System_setOut
-com.oracle.graal.jtt.except.Catch_Loop03
-com.oracle.graal.jtt.micro.BC_invokevirtual2
-com.oracle.graal.jtt.optimize.Narrow_char03
-com.oracle.graal.jtt.optimize.ArrayCopy02
-com.oracle.graal.jtt.optimize.ArrayCopy04
-com.oracle.graal.jtt.optimize.ArrayCopy06
-com.oracle.graal.replacements.test.NewArrayTest
-com.oracle.graal.jtt.optimize.ArrayCopy03