# HG changeset patch
# User Christian Humer <christian.humer@gmail.com>
# Date 1374594497 -7200
# Node ID 1b11e3c8529c95806c2a218b3045eb10a2a77555
# Parent  7a0ba9b20fec98183718c813f30079e3246cf6d0# Parent  f2008a93ad5407fa4dc633e4ff0701e781c9d1e2
Merge.

diff -r 7a0ba9b20fec -r 1b11e3c8529c graal/com.oracle.graal.api.code/src/com/oracle/graal/api/code/DebugInfo.java
--- a/graal/com.oracle.graal.api.code/src/com/oracle/graal/api/code/DebugInfo.java	Tue Jul 23 17:47:56 2013 +0200
+++ b/graal/com.oracle.graal.api.code/src/com/oracle/graal/api/code/DebugInfo.java	Tue Jul 23 17:48:17 2013 +0200
@@ -31,7 +31,7 @@
  * <ul>
  * <li>a {@linkplain #getBytecodePosition() bytecode position}</li>
  * <li>a reference map for {@linkplain #getRegisterRefMap() registers}</li>
- * <li>a reference map for {@linkplain #getRegisterRefMap() stack slots} in the current frame</li>
+ * <li>a reference map for {@linkplain #getFrameRefMap() stack slots} in the current frame</li>
  * <li>a map from bytecode locals and operand stack slots to their values or locations from which
  * their values can be read</li>
  * <li>a map from the registers (in the caller's frame) to the slots where they are saved in the
diff -r 7a0ba9b20fec -r 1b11e3c8529c graal/com.oracle.graal.asm.sparc/src/com/oracle/graal/asm/sparc/SPARCAssembler.java
--- a/graal/com.oracle.graal.asm.sparc/src/com/oracle/graal/asm/sparc/SPARCAssembler.java	Tue Jul 23 17:47:56 2013 +0200
+++ b/graal/com.oracle.graal.asm.sparc/src/com/oracle/graal/asm/sparc/SPARCAssembler.java	Tue Jul 23 17:48:17 2013 +0200
@@ -395,7 +395,7 @@
         }
 
         public void verify() {
-            assert (disp30 & DISP30_MASK) == 0;
+            assert isDisp30(disp30) : disp30;
         }
     }
 
@@ -1316,15 +1316,41 @@
         return x & ((1 << nbits) - 1);
     }
 
-    private static final int max13 = ((1 << 12) - 1);
-    private static final int min13 = -(1 << 12);
-
-    public static boolean isSimm13(int src) {
-        return min13 <= src && src <= max13;
+    /**
+     * Minimum value for signed immediate ranges.
+     */
+    public static long minSimm(long nbits) {
+        return -(1L << (nbits - 1));
+    }
+
+    /**
+     * Maximum value for signed immediate ranges.
+     */
+    public static long maxSimm(long nbits) {
+        return (1L << (nbits - 1)) - 1;
     }
 
-    public static boolean isSimm13(long src) {
-        return NumUtil.isInt(src) && min13 <= src && src <= max13;
+    /**
+     * Test if imm is within signed immediate range for nbits.
+     */
+    public static boolean isSimm(long imm, int nbits) {
+        return minSimm(nbits) <= imm && imm <= maxSimm(nbits);
+    }
+
+    public static boolean isSimm13(int imm) {
+        return isSimm(imm, 13);
+    }
+
+    public static boolean isSimm13(long imm) {
+        return NumUtil.isInt(imm) && isSimm(imm, 13);
+    }
+
+    public static boolean isDisp30(long imm) {
+        return isSimm(imm, 30);
+    }
+
+    public static boolean isWordDisp30(long imm) {
+        return isSimm(imm, 30 + 2);
     }
 
     public static final int hi22(int x) {
diff -r 7a0ba9b20fec -r 1b11e3c8529c graal/com.oracle.graal.asm.sparc/src/com/oracle/graal/asm/sparc/SPARCMacroAssembler.java
--- a/graal/com.oracle.graal.asm.sparc/src/com/oracle/graal/asm/sparc/SPARCMacroAssembler.java	Tue Jul 23 17:47:56 2013 +0200
+++ b/graal/com.oracle.graal.asm.sparc/src/com/oracle/graal/asm/sparc/SPARCMacroAssembler.java	Tue Jul 23 17:48:17 2013 +0200
@@ -324,19 +324,24 @@
         }
     }
 
-    public static class Setx {
+    /**
+     * This instruction is like sethi but for 64-bit values.
+     */
+    public static class Sethix {
+
+        private static final int INSTRUCTION_SIZE = 7;
 
         private long value;
         private Register dst;
         private boolean forceRelocatable;
 
-        public Setx(long value, Register dst, boolean forceRelocatable) {
+        public Sethix(long value, Register dst, boolean forceRelocatable) {
             this.value = value;
             this.dst = dst;
             this.forceRelocatable = forceRelocatable;
         }
 
-        public Setx(long value, Register dst) {
+        public Sethix(long value, Register dst) {
             this(value, dst, false);
         }
 
@@ -344,28 +349,6 @@
             int hi = (int) (value >> 32);
             int lo = (int) (value & ~0);
 
-// if (isSimm13(lo) && value == lo) {
-// new Or(g0, lo, dst).emit(masm);
-// } else if (hi == 0) {
-// new Sethi(lo, dst).emit(masm); // hardware version zero-extends to upper 32
-// if (lo10(lo) != 0) {
-// new Or(dst, lo10(lo), dst).emit(masm);
-// }
-// } else if (hi == -1) {
-// new Sethi(~lo, dst).emit(masm); // hardware version zero-extends to upper 32
-// new Xor(dst, ~lo10(~0), dst).emit(masm);
-// new Add(dst, lo10(lo), dst).emit(masm);
-// } else if (lo == 0) {
-// if (isSimm13(hi)) {
-// new Or(g0, hi, dst).emit(masm);
-// } else {
-// new Sethi(hi, dst).emit(masm); // hardware version zero-extends to upper 32
-// if (lo10(hi) != 0) {
-// new Or(dst, lo10(hi), dst).emit(masm);
-// }
-// }
-// new Sllx(dst, 32, dst).emit(masm);
-
             // This is the same logic as MacroAssembler::internal_set.
             final int startPc = masm.codeBuffer.position();
 
@@ -402,10 +385,32 @@
             }
             // Pad out the instruction sequence so it can be patched later.
             if (forceRelocatable) {
-                while (masm.codeBuffer.position() < (startPc + (7 * 4))) {
+                while (masm.codeBuffer.position() < (startPc + (INSTRUCTION_SIZE * 4))) {
                     new Nop().emit(masm);
                 }
             }
+        }
+    }
+
+    public static class Setx {
+
+        private long value;
+        private Register dst;
+        private boolean forceRelocatable;
+
+        public Setx(long value, Register dst, boolean forceRelocatable) {
+            this.value = value;
+            this.dst = dst;
+            this.forceRelocatable = forceRelocatable;
+        }
+
+        public Setx(long value, Register dst) {
+            this(value, dst, false);
+        }
+
+        public void emit(SPARCMacroAssembler masm) {
+            new Sethix(value, dst, forceRelocatable).emit(masm);
+            int lo = (int) (value & ~0);
             if (lo10(lo) != 0 || forceRelocatable) {
                 new Add(dst, lo10(lo), dst).emit(masm);
             }
diff -r 7a0ba9b20fec -r 1b11e3c8529c graal/com.oracle.graal.compiler.hsail/src/com/oracle/graal/compiler/hsail/HSAILLIRGenerator.java
--- a/graal/com.oracle.graal.compiler.hsail/src/com/oracle/graal/compiler/hsail/HSAILLIRGenerator.java	Tue Jul 23 17:47:56 2013 +0200
+++ b/graal/com.oracle.graal.compiler.hsail/src/com/oracle/graal/compiler/hsail/HSAILLIRGenerator.java	Tue Jul 23 17:48:17 2013 +0200
@@ -690,7 +690,7 @@
     }
 
     @Override
-    public void visitCompareAndSwap(CompareAndSwapNode node) {
+    public void visitCompareAndSwap(LoweredCompareAndSwapNode node, Value address) {
         throw new InternalError("NYI");
     }
 
diff -r 7a0ba9b20fec -r 1b11e3c8529c graal/com.oracle.graal.compiler.ptx/src/com/oracle/graal/compiler/ptx/PTXLIRGenerator.java
--- a/graal/com.oracle.graal.compiler.ptx/src/com/oracle/graal/compiler/ptx/PTXLIRGenerator.java	Tue Jul 23 17:47:56 2013 +0200
+++ b/graal/com.oracle.graal.compiler.ptx/src/com/oracle/graal/compiler/ptx/PTXLIRGenerator.java	Tue Jul 23 17:48:17 2013 +0200
@@ -62,7 +62,7 @@
 import com.oracle.graal.nodes.*;
 import com.oracle.graal.nodes.calc.Condition;
 import com.oracle.graal.nodes.calc.ConvertNode;
-import com.oracle.graal.nodes.java.CompareAndSwapNode;
+import com.oracle.graal.nodes.java.*;
 
 /**
  * This class implements the PTX specific portion of the LIR generator.
@@ -731,7 +731,7 @@
     }
 
     @Override
-    public void visitCompareAndSwap(CompareAndSwapNode node) {
+    public void visitCompareAndSwap(LoweredCompareAndSwapNode node, Value address) {
         throw new InternalError("NYI");
     }
 
diff -r 7a0ba9b20fec -r 1b11e3c8529c graal/com.oracle.graal.compiler.sparc/src/com/oracle/graal/compiler/sparc/SPARCLIRGenerator.java
--- a/graal/com.oracle.graal.compiler.sparc/src/com/oracle/graal/compiler/sparc/SPARCLIRGenerator.java	Tue Jul 23 17:47:56 2013 +0200
+++ b/graal/com.oracle.graal.compiler.sparc/src/com/oracle/graal/compiler/sparc/SPARCLIRGenerator.java	Tue Jul 23 17:48:17 2013 +0200
@@ -54,13 +54,11 @@
 import com.oracle.graal.lir.sparc.SPARCControlFlow.SequentialSwitchOp;
 import com.oracle.graal.lir.sparc.SPARCControlFlow.SwitchRangesOp;
 import com.oracle.graal.lir.sparc.SPARCControlFlow.TableSwitchOp;
-import com.oracle.graal.lir.sparc.SPARCMove.LoadOp;
 import com.oracle.graal.lir.sparc.SPARCMove.MembarOp;
 import com.oracle.graal.lir.sparc.SPARCMove.MoveFromRegOp;
 import com.oracle.graal.lir.sparc.SPARCMove.MoveToRegOp;
 import com.oracle.graal.lir.sparc.SPARCMove.NullCheckOp;
 import com.oracle.graal.lir.sparc.SPARCMove.StackLoadAddressOp;
-import com.oracle.graal.lir.sparc.SPARCMove.StoreOp;
 import com.oracle.graal.nodes.*;
 import com.oracle.graal.nodes.calc.*;
 import com.oracle.graal.nodes.calc.ConvertNode.Op;
@@ -94,6 +92,32 @@
     }
 
     @Override
+    public boolean canStoreConstant(Constant c) {
+        // SPARC can only store integer null constants (via g0)
+        switch (c.getKind()) {
+            case Float:
+            case Double:
+                return false;
+            default:
+                return c.isNull();
+        }
+    }
+
+    @Override
+    public boolean canInlineConstant(Constant c) {
+        switch (c.getKind()) {
+            case Int:
+                return SPARCAssembler.isSimm13(c.asInt()) && !runtime.needsDataPatch(c);
+            case Long:
+                return SPARCAssembler.isSimm13(c.asLong()) && !runtime.needsDataPatch(c);
+            case Object:
+                return c.isNull();
+            default:
+                return true;
+        }
+    }
+
+    @Override
     public Variable emitMove(Value input) {
         Variable result = newVariable(input.getKind());
         emitMove(result, input);
@@ -117,6 +141,87 @@
     }
 
     @Override
+    public SPARCAddressValue emitAddress(Value base, long displacement, Value index, int scale) {
+        AllocatableValue baseRegister;
+        long finalDisp = displacement;
+        if (isConstant(base)) {
+            if (asConstant(base).isNull()) {
+                baseRegister = Value.ILLEGAL;
+            } else if (asConstant(base).getKind() != Kind.Object) {
+                finalDisp += asConstant(base).asLong();
+                baseRegister = Value.ILLEGAL;
+            } else {
+                baseRegister = load(base);
+            }
+        } else {
+            baseRegister = asAllocatable(base);
+        }
+
+        AllocatableValue indexRegister;
+        if (!index.equals(Value.ILLEGAL) && scale != 0) {
+            if (isConstant(index)) {
+                finalDisp += asConstant(index).asLong() * scale;
+                indexRegister = Value.ILLEGAL;
+            } else {
+                if (scale != 1) {
+                    Variable longIndex = newVariable(Kind.Long);
+                    emitMove(longIndex, index);
+                    indexRegister = emitMul(longIndex, Constant.forLong(scale));
+                } else {
+                    indexRegister = asAllocatable(index);
+                }
+
+                // if (baseRegister.equals(Value.ILLEGAL)) {
+                // baseRegister = asAllocatable(indexRegister);
+                // } else {
+                // Variable newBase = newVariable(Kind.Long);
+                // emitMove(newBase, baseRegister);
+                // baseRegister = newBase;
+                // baseRegister = emitAdd(baseRegister, indexRegister);
+                // }
+            }
+        } else {
+            indexRegister = Value.ILLEGAL;
+        }
+
+        int displacementInt;
+
+        // If we don't have an index register we can use a displacement, otherwise load the
+        // displacement into a register and add it to the base.
+        if (indexRegister.equals(Value.ILLEGAL)) {
+            // TODO What if displacement if too big?
+            displacementInt = (int) finalDisp;
+        } else {
+            displacementInt = 0;
+            AllocatableValue displacementRegister = load(Constant.forLong(finalDisp));
+            if (baseRegister.equals(Value.ILLEGAL)) {
+                baseRegister = displacementRegister;
+            } else {
+                Variable longBase = newVariable(Kind.Long);
+                emitMove(longBase, baseRegister);
+                baseRegister = emitAdd(longBase, displacementRegister);
+            }
+        }
+
+        return new SPARCAddressValue(target().wordKind, baseRegister, indexRegister, displacementInt);
+    }
+
+    protected SPARCAddressValue asAddressValue(Value address) {
+        if (address instanceof SPARCAddressValue) {
+            return (SPARCAddressValue) address;
+        } else {
+            return emitAddress(address, 0, Value.ILLEGAL, 0);
+        }
+    }
+
+    @Override
+    public Value emitAddress(StackSlot address) {
+        Variable result = newVariable(target().wordKind);
+        append(new StackLoadAddressOp(result, address));
+        return result;
+    }
+
+    @Override
     protected boolean peephole(ValueNode valueNode) {
         // No peephole optimizations for now
         return false;
@@ -267,7 +372,12 @@
 
     @Override
     protected void emitForeignCall(ForeignCallLinkage linkage, Value result, Value[] arguments, Value[] temps, LIRFrameState info) {
-        throw new InternalError("NYI");
+        long maxOffset = linkage.getMaxCallTargetOffset();
+        if (SPARCAssembler.isWordDisp30(maxOffset)) {
+            append(new SPARCCall.DirectNearForeignCallOp(linkage, result, arguments, temps, info));
+        } else {
+            append(new SPARCCall.DirectFarForeignCallOp(this, linkage, result, arguments, temps, info));
+        }
     }
 
     @Override
@@ -354,121 +464,6 @@
     }
 
     @Override
-    public boolean canInlineConstant(Constant c) {
-        switch (c.getKind()) {
-            case Int:
-                return SPARCAssembler.isSimm13(c.asInt()) && !runtime.needsDataPatch(c);
-            case Long:
-                return SPARCAssembler.isSimm13(c.asLong()) && !runtime.needsDataPatch(c);
-            case Object:
-                return c.isNull();
-            default:
-                return true;
-        }
-    }
-
-    @Override
-    public boolean canStoreConstant(Constant c) {
-        throw new InternalError("NYI");
-    }
-
-    @Override
-    public SPARCAddressValue emitAddress(Value base, long displacement, Value index, int scale) {
-        AllocatableValue baseRegister;
-        long finalDisp = displacement;
-        if (isConstant(base)) {
-            if (asConstant(base).isNull()) {
-                baseRegister = Value.ILLEGAL;
-            } else if (asConstant(base).getKind() != Kind.Object) {
-                finalDisp += asConstant(base).asLong();
-                baseRegister = Value.ILLEGAL;
-            } else {
-                baseRegister = load(base);
-            }
-        } else {
-            baseRegister = asAllocatable(base);
-        }
-
-        AllocatableValue indexRegister;
-        if (!index.equals(Value.ILLEGAL) && scale != 0) {
-            if (isConstant(index)) {
-                finalDisp += asConstant(index).asLong() * scale;
-                indexRegister = Value.ILLEGAL;
-            } else {
-                if (scale != 1) {
-                    Variable longIndex = newVariable(Kind.Long);
-                    emitMove(longIndex, index);
-                    indexRegister = emitMul(longIndex, Constant.forLong(scale));
-                } else {
-                    indexRegister = asAllocatable(index);
-                }
-
-// if (baseRegister.equals(Value.ILLEGAL)) {
-// baseRegister = asAllocatable(indexRegister);
-// } else {
-// Variable newBase = newVariable(Kind.Long);
-// emitMove(newBase, baseRegister);
-// baseRegister = newBase;
-// baseRegister = emitAdd(baseRegister, indexRegister);
-// }
-            }
-        } else {
-            indexRegister = Value.ILLEGAL;
-        }
-
-        int displacementInt;
-
-        // If we don't have an index register we can use a displacement, otherwise load the
-        // displacement into a register and add it to the base.
-        if (indexRegister.equals(Value.ILLEGAL)) {
-            // TODO What if displacement if too big?
-            displacementInt = (int) finalDisp;
-        } else {
-            displacementInt = 0;
-            AllocatableValue displacementRegister = load(Constant.forLong(finalDisp));
-            if (baseRegister.equals(Value.ILLEGAL)) {
-                baseRegister = displacementRegister;
-            } else {
-                Variable longBase = newVariable(Kind.Long);
-                emitMove(longBase, baseRegister);
-                baseRegister = emitAdd(longBase, displacementRegister);
-            }
-        }
-
-        return new SPARCAddressValue(target().wordKind, baseRegister, indexRegister, displacementInt);
-    }
-
-    private SPARCAddressValue asAddress(Value address) {
-        if (address instanceof SPARCAddressValue) {
-            return (SPARCAddressValue) address;
-        } else {
-            return emitAddress(address, 0, Value.ILLEGAL, 0);
-        }
-    }
-
-    @Override
-    public Variable emitLoad(Kind kind, Value address, DeoptimizingNode deopting) {
-        SPARCAddressValue loadAddress = asAddress(address);
-        Variable result = newVariable(kind);
-        append(new LoadOp(kind, result, loadAddress, deopting != null ? state(deopting) : null));
-        return result;
-    }
-
-    @Override
-    public void emitStore(Kind kind, Value address, Value inputVal, DeoptimizingNode deopting) {
-        SPARCAddressValue storeAddress = asAddress(address);
-        Variable input = load(inputVal);
-        append(new StoreOp(kind, storeAddress, input, deopting != null ? state(deopting) : null));
-    }
-
-    @Override
-    public Value emitAddress(StackSlot address) {
-        Variable result = newVariable(target().wordKind);
-        append(new StackLoadAddressOp(result, address));
-        return result;
-    }
-
-    @Override
     public Value emitNegate(Value input) {
         Variable result = newVariable(input.getKind());
         switch (input.getKind()) {
@@ -680,7 +675,7 @@
                 append(new Op2Stack(ISHL, result, a, loadNonConst(b)));
                 break;
             case Long:
-                append(new Op1Stack(LSHL, result, loadNonConst(b)));
+                append(new Op2Stack(LSHL, result, a, loadNonConst(b)));
                 break;
             default:
                 throw GraalInternalError.shouldNotReachHere();
@@ -696,7 +691,7 @@
                 append(new Op2Stack(ISHR, result, a, loadNonConst(b)));
                 break;
             case Long:
-                append(new Op1Stack(LSHR, result, loadNonConst(b)));
+                append(new Op2Stack(LSHR, result, a, loadNonConst(b)));
                 break;
             default:
                 throw GraalInternalError.shouldNotReachHere();
@@ -808,7 +803,7 @@
     }
 
     @Override
-    public void visitCompareAndSwap(CompareAndSwapNode i) {
+    public void visitCompareAndSwap(LoweredCompareAndSwapNode i, Value address) {
         throw new InternalError("NYI");
     }
 
diff -r 7a0ba9b20fec -r 1b11e3c8529c graal/com.oracle.graal.compiler.test/src/com/oracle/graal/compiler/test/ConditionalEliminationTest.java
--- a/graal/com.oracle.graal.compiler.test/src/com/oracle/graal/compiler/test/ConditionalEliminationTest.java	Tue Jul 23 17:47:56 2013 +0200
+++ b/graal/com.oracle.graal.compiler.test/src/com/oracle/graal/compiler/test/ConditionalEliminationTest.java	Tue Jul 23 17:48:17 2013 +0200
@@ -39,6 +39,8 @@
  */
 public class ConditionalEliminationTest extends GraalCompilerTest {
 
+    public static Object field;
+
     static class Entry {
 
         final String name;
@@ -108,7 +110,7 @@
                 }
             } else {
                 if (b == null) {
-                    return 3;
+                    return -3;
                 } else {
                     return 4;
                 }
@@ -196,4 +198,34 @@
         assertEquals(InvokeKind.Special, ((MethodCallTargetNode) invoke.callTarget()).invokeKind());
     }
 
+    public static void testTypeMergingSnippet(Object o, boolean b) {
+        if (b) {
+            if (!(o instanceof Double)) {
+                return;
+            }
+        } else {
+            if (!(o instanceof Integer)) {
+                return;
+            }
+        }
+
+        /*
+         * For this test the conditional elimination has to correctly merge the type information it
+         * has about o, so that it can remove the check on Number.
+         */
+        if (!(o instanceof Number)) {
+            field = o;
+        }
+    }
+
+    @Test
+    public void testTypeMerging() {
+        StructuredGraph graph = parse("testTypeMergingSnippet");
+        new CanonicalizerPhase.Instance(runtime(), null, true).apply(graph);
+        new ConditionalEliminationPhase(runtime()).apply(graph);
+        new CanonicalizerPhase.Instance(runtime(), null, true).apply(graph);
+
+        assertEquals(0, graph.getNodes().filter(StoreFieldNode.class).count());
+    }
+
 }
diff -r 7a0ba9b20fec -r 1b11e3c8529c graal/com.oracle.graal.hotspot.amd64/src/com/oracle/graal/hotspot/amd64/AMD64HotSpotLIRGenerator.java
--- a/graal/com.oracle.graal.hotspot.amd64/src/com/oracle/graal/hotspot/amd64/AMD64HotSpotLIRGenerator.java	Tue Jul 23 17:47:56 2013 +0200
+++ b/graal/com.oracle.graal.hotspot.amd64/src/com/oracle/graal/hotspot/amd64/AMD64HotSpotLIRGenerator.java	Tue Jul 23 17:48:17 2013 +0200
@@ -468,31 +468,19 @@
     }
 
     @Override
-    public void visitCompareAndSwap(CompareAndSwapNode node) {
-        Kind kind = node.newValue().kind();
-        assert kind == node.expected().kind();
-
-        Value expected = loadNonConst(operand(node.expected()));
-        Variable newValue = load(operand(node.newValue()));
-
-        AMD64AddressValue address;
-        int displacement = node.displacement();
-        Value index = operand(node.offset());
-        if (isConstant(index) && NumUtil.isInt(asConstant(index).asLong() + displacement)) {
-            assert !runtime.needsDataPatch(asConstant(index));
-            displacement += (int) asConstant(index).asLong();
-            address = new AMD64AddressValue(kind, load(operand(node.object())), displacement);
-        } else {
-            address = new AMD64AddressValue(kind, load(operand(node.object())), load(index), Scale.Times1, displacement);
-        }
-
+    public void visitCompareAndSwap(LoweredCompareAndSwapNode node, Value address) {
+        Kind kind = node.getNewValue().kind();
+        assert kind == node.getExpectedValue().kind();
+        Value expected = loadNonConst(operand(node.getExpectedValue()));
+        Variable newValue = load(operand(node.getNewValue()));
+        AMD64AddressValue addressValue = asAddressValue(address);
         RegisterValue raxRes = AMD64.rax.asValue(kind);
         emitMove(raxRes, expected);
         if (runtime().config.useCompressedOops && node.isCompressible()) {
             Variable scratch = newVariable(Kind.Long);
-            append(new CompareAndSwapCompressedOp(raxRes, address, raxRes, newValue, scratch, runtime().config.narrowOopBase, runtime().config.narrowOopShift, runtime().config.logMinObjAlignment));
+            append(new CompareAndSwapCompressedOp(raxRes, addressValue, raxRes, newValue, scratch, runtime().config.narrowOopBase, runtime().config.narrowOopShift, runtime().config.logMinObjAlignment));
         } else {
-            append(new CompareAndSwapOp(raxRes, address, raxRes, newValue));
+            append(new CompareAndSwapOp(raxRes, addressValue, raxRes, newValue));
         }
         Variable result = newVariable(node.kind());
         append(new CondMoveOp(result, Condition.EQ, load(Constant.TRUE), Constant.FALSE));
diff -r 7a0ba9b20fec -r 1b11e3c8529c graal/com.oracle.graal.hotspot.amd64/src/com/oracle/graal/hotspot/amd64/AMD64HotSpotUnwindOp.java
--- a/graal/com.oracle.graal.hotspot.amd64/src/com/oracle/graal/hotspot/amd64/AMD64HotSpotUnwindOp.java	Tue Jul 23 17:47:56 2013 +0200
+++ b/graal/com.oracle.graal.hotspot.amd64/src/com/oracle/graal/hotspot/amd64/AMD64HotSpotUnwindOp.java	Tue Jul 23 17:48:17 2013 +0200
@@ -29,7 +29,6 @@
 
 import com.oracle.graal.api.code.*;
 import com.oracle.graal.asm.amd64.*;
-import com.oracle.graal.hotspot.*;
 import com.oracle.graal.hotspot.stubs.*;
 import com.oracle.graal.lir.*;
 import com.oracle.graal.lir.amd64.*;
@@ -60,6 +59,6 @@
         Register returnAddress = asRegister(cc.getArgument(1));
         masm.movq(returnAddress, new AMD64Address(rsp, 0));
 
-        AMD64Call.directJmp(tasm, masm, tasm.runtime.lookupForeignCall(HotSpotBackend.UNWIND_EXCEPTION_TO_CALLER));
+        AMD64Call.directJmp(tasm, masm, linkage);
     }
 }
diff -r 7a0ba9b20fec -r 1b11e3c8529c graal/com.oracle.graal.hotspot.sparc/src/com/oracle/graal/hotspot/sparc/SPARCHotSpotBackend.java
--- a/graal/com.oracle.graal.hotspot.sparc/src/com/oracle/graal/hotspot/sparc/SPARCHotSpotBackend.java	Tue Jul 23 17:47:56 2013 +0200
+++ b/graal/com.oracle.graal.hotspot.sparc/src/com/oracle/graal/hotspot/sparc/SPARCHotSpotBackend.java	Tue Jul 23 17:48:17 2013 +0200
@@ -22,6 +22,8 @@
  */
 package com.oracle.graal.hotspot.sparc;
 
+import java.util.*;
+
 import sun.misc.*;
 
 import com.oracle.graal.api.code.*;
@@ -36,6 +38,7 @@
 import com.oracle.graal.hotspot.stubs.Stub;
 import com.oracle.graal.lir.*;
 import com.oracle.graal.lir.asm.*;
+import com.oracle.graal.lir.sparc.*;
 import com.oracle.graal.nodes.*;
 
 import static com.oracle.graal.sparc.SPARC.*;
@@ -93,7 +96,7 @@
         }
     }
 
-    class HotSpotFrameContext implements FrameContext {
+    public class HotSpotFrameContext implements FrameContext {
 
         final boolean isStub;
 
@@ -138,6 +141,7 @@
     public TargetMethodAssembler newAssembler(LIRGenerator lirGen, CompilationResult compilationResult) {
         SPARCHotSpotLIRGenerator gen = (SPARCHotSpotLIRGenerator) lirGen;
         FrameMap frameMap = gen.frameMap;
+        assert gen.deoptimizationRescueSlot == null || frameMap.frameNeedsAllocating() : "method that can deoptimize must have a frame";
 
         Stub stub = gen.getStub();
         AbstractAssembler masm = createAssembler(frameMap);
@@ -150,6 +154,12 @@
             tasm.compilationResult.setCustomStackAreaOffset(frameMap.offsetForStackSlot(deoptimizationRescueSlot));
         }
 
+        if (stub != null) {
+            // SPARC stubs always enter a frame which saves the registers.
+            final Set<Register> definedRegisters = new HashSet<>();
+            stub.initDestroyedRegisters(definedRegisters);
+        }
+
         return tasm;
     }
 
@@ -165,13 +175,15 @@
 
         if (unverifiedStub != null) {
             tasm.recordMark(Marks.MARK_UNVERIFIED_ENTRY);
-            CallingConvention cc = regConfig.getCallingConvention(JavaCallee, null, new JavaType[]{runtime().lookupJavaType(Object.class)}, target, false);
+            // We need to use JavaCall here because we haven't entered the frame yet.
+            CallingConvention cc = regConfig.getCallingConvention(JavaCall, null, new JavaType[]{runtime().lookupJavaType(Object.class)}, target, 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, g0).emit(masm);
-            new Cmp(inlineCacheKlass, g0).emit(masm);
+            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
         }
@@ -186,10 +198,9 @@
         HotSpotFrameContext frameContext = (HotSpotFrameContext) tasm.frameContext;
         if (frameContext != null && !frameContext.isStub) {
             tasm.recordMark(Marks.MARK_EXCEPTION_HANDLER_ENTRY);
-// SPARCCall.directCall(tasm, asm, runtime().lookupForeignCall(EXCEPTION_HANDLER), null, false,
-// null);
+            SPARCCall.directCall(tasm, masm, runtime().lookupForeignCall(EXCEPTION_HANDLER), null, false, null);
             tasm.recordMark(Marks.MARK_DEOPT_HANDLER_ENTRY);
-// SPARCCall.directCall(tasm, asm, runtime().lookupForeignCall(DEOPT_HANDLER), null, false, null);
+            SPARCCall.directCall(tasm, masm, runtime().lookupForeignCall(DEOPT_HANDLER), null, false, null);
         } else {
             // No need to emit the stubs for entries back into the method since
             // it has no calls that can cause such "return" entries
@@ -198,8 +209,8 @@
 
         if (unverifiedStub != null) {
             masm.bind(unverifiedStub);
-// SPARCCall.directJmp(tasm, asm, runtime().lookupForeignCall(IC_MISS_HANDLER));
-            // throw new InternalError("g0 must be scratch register");
+            Register scratch = g3;
+            SPARCCall.indirectJmp(tasm, masm, scratch, runtime().lookupForeignCall(IC_MISS_HANDLER));
         }
     }
 }
diff -r 7a0ba9b20fec -r 1b11e3c8529c graal/com.oracle.graal.hotspot.sparc/src/com/oracle/graal/hotspot/sparc/SPARCHotSpotDeoptimizeCallerOp.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.hotspot.sparc/src/com/oracle/graal/hotspot/sparc/SPARCHotSpotDeoptimizeCallerOp.java	Tue Jul 23 17:48:17 2013 +0200
@@ -0,0 +1,73 @@
+/*
+ * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package com.oracle.graal.hotspot.sparc;
+
+import static com.oracle.graal.sparc.SPARC.*;
+import static com.oracle.graal.asm.sparc.SPARCMacroAssembler.*;
+import static com.oracle.graal.hotspot.HotSpotBackend.*;
+import static com.oracle.graal.hotspot.HotSpotGraalRuntime.*;
+
+import com.oracle.graal.api.code.*;
+import com.oracle.graal.api.meta.*;
+import com.oracle.graal.asm.sparc.*;
+import com.oracle.graal.hotspot.*;
+import com.oracle.graal.lir.*;
+import com.oracle.graal.lir.sparc.*;
+import com.oracle.graal.lir.asm.*;
+
+/**
+ * Removes the current frame and tail calls the uncommon trap routine.
+ */
+@Opcode("DEOPT_CALLER")
+final class SPARCHotSpotDeoptimizeCallerOp extends SPARCHotSpotEpilogueOp {
+
+    private final DeoptimizationAction action;
+    private final DeoptimizationReason reason;
+
+    SPARCHotSpotDeoptimizeCallerOp(DeoptimizationAction action, DeoptimizationReason reason) {
+        this.action = action;
+        this.reason = reason;
+    }
+
+    @Override
+    public void emitCode(TargetMethodAssembler tasm, SPARCMacroAssembler masm) {
+        leaveFrame(tasm);
+
+// SPARCHotSpotBackend backend = (SPARCHotSpotBackend)
+// HotSpotGraalRuntime.graalRuntime().getBackend();
+// final boolean isStub = true;
+// HotSpotFrameContext frameContext = backend.new HotSpotFrameContext(isStub);
+// frameContext.enter(tasm);
+
+        HotSpotGraalRuntime runtime = graalRuntime();
+        Register thread = runtime.getRuntime().threadRegister();
+
+        Register scratch = g5;
+        new Mov(tasm.runtime.encodeDeoptActionAndReason(action, reason), scratch).emit(masm);
+        new Stw(scratch, new SPARCAddress(thread, runtime.getConfig().pendingDeoptimizationOffset)).emit(masm);
+
+        SPARCCall.indirectJmp(tasm, masm, scratch, tasm.runtime.lookupForeignCall(UNCOMMON_TRAP));
+
+// frameContext.leave(tasm);
+    }
+}
diff -r 7a0ba9b20fec -r 1b11e3c8529c graal/com.oracle.graal.hotspot.sparc/src/com/oracle/graal/hotspot/sparc/SPARCHotSpotEpilogueOp.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.hotspot.sparc/src/com/oracle/graal/hotspot/sparc/SPARCHotSpotEpilogueOp.java	Tue Jul 23 17:48:17 2013 +0200
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package com.oracle.graal.hotspot.sparc;
+
+import com.oracle.graal.lir.sparc.*;
+import com.oracle.graal.lir.asm.*;
+
+/**
+ * Superclass for operations that leave a method's frame.
+ */
+abstract class SPARCHotSpotEpilogueOp extends SPARCLIRInstruction {
+
+    protected void leaveFrame(TargetMethodAssembler tasm) {
+        if (tasm.frameContext != null) {
+            tasm.frameContext.leave(tasm);
+        }
+    }
+}
diff -r 7a0ba9b20fec -r 1b11e3c8529c graal/com.oracle.graal.hotspot.sparc/src/com/oracle/graal/hotspot/sparc/SPARCHotSpotJumpToExceptionHandlerInCallerOp.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.hotspot.sparc/src/com/oracle/graal/hotspot/sparc/SPARCHotSpotJumpToExceptionHandlerInCallerOp.java	Tue Jul 23 17:48:17 2013 +0200
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package com.oracle.graal.hotspot.sparc;
+
+import static com.oracle.graal.asm.sparc.SPARCMacroAssembler.*;
+import static com.oracle.graal.sparc.SPARC.*;
+import static com.oracle.graal.api.code.ValueUtil.*;
+import static com.oracle.graal.hotspot.HotSpotGraalRuntime.*;
+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.sparc.*;
+import com.oracle.graal.lir.*;
+import com.oracle.graal.lir.asm.*;
+
+/**
+ * Sets up the arguments for an exception handler in the callers frame, removes the current frame
+ * and jumps to the handler.
+ */
+@Opcode("JUMP_TO_EXCEPTION_HANDLER_IN_CALLER")
+final class SPARCHotSpotJumpToExceptionHandlerInCallerOp extends SPARCHotSpotEpilogueOp {
+
+    @Use(REG) AllocatableValue handlerInCallerPc;
+    @Use(REG) AllocatableValue exception;
+    @Use(REG) AllocatableValue exceptionPc;
+
+    SPARCHotSpotJumpToExceptionHandlerInCallerOp(AllocatableValue handlerInCallerPc, AllocatableValue exception, AllocatableValue exceptionPc) {
+        this.handlerInCallerPc = handlerInCallerPc;
+        this.exception = exception;
+        this.exceptionPc = exceptionPc;
+    }
+
+    @Override
+    public void emitCode(TargetMethodAssembler tasm, SPARCMacroAssembler masm) {
+        leaveFrame(tasm);
+
+        // Restore SP from L7 if the exception PC is a method handle call site.
+        Register thread = graalRuntime().getRuntime().threadRegister();
+        int isMethodHandleReturnOffset = graalRuntime().getConfig().threadIsMethodHandleReturnOffset;
+        SPARCAddress dst = new SPARCAddress(thread, isMethodHandleReturnOffset);
+        new Lduw(dst, o7).emit(masm);
+        new Cmp(o7, o7).emit(masm);
+        new Movcc(ConditionFlag.NotZero, CC.Icc, l7, sp).emit(masm);
+
+        new Jmpl(asRegister(handlerInCallerPc), 0, g0).emit(masm);
+    }
+}
diff -r 7a0ba9b20fec -r 1b11e3c8529c graal/com.oracle.graal.hotspot.sparc/src/com/oracle/graal/hotspot/sparc/SPARCHotSpotLIRGenerator.java
--- a/graal/com.oracle.graal.hotspot.sparc/src/com/oracle/graal/hotspot/sparc/SPARCHotSpotLIRGenerator.java	Tue Jul 23 17:47:56 2013 +0200
+++ b/graal/com.oracle.graal.hotspot.sparc/src/com/oracle/graal/hotspot/sparc/SPARCHotSpotLIRGenerator.java	Tue Jul 23 17:48:17 2013 +0200
@@ -23,17 +23,21 @@
 package com.oracle.graal.hotspot.sparc;
 
 import static com.oracle.graal.api.code.ValueUtil.*;
+import static com.oracle.graal.hotspot.HotSpotBackend.*;
 
 import java.lang.reflect.*;
 
 import com.oracle.graal.api.code.*;
 import com.oracle.graal.api.meta.*;
+import com.oracle.graal.compiler.gen.*;
 import com.oracle.graal.compiler.sparc.*;
+import com.oracle.graal.graph.*;
 import com.oracle.graal.hotspot.*;
 import com.oracle.graal.hotspot.meta.*;
 import com.oracle.graal.hotspot.nodes.*;
 import com.oracle.graal.hotspot.stubs.*;
 import com.oracle.graal.lir.*;
+import com.oracle.graal.lir.sparc.*;
 import com.oracle.graal.lir.sparc.SPARCMove.*;
 import com.oracle.graal.nodes.*;
 import com.oracle.graal.nodes.java.MethodCallTargetNode.InvokeKind;
@@ -55,6 +59,32 @@
      */
     StackSlot deoptimizationRescueSlot;
 
+    @SuppressWarnings("hiding")
+    @Override
+    protected DebugInfoBuilder createDebugInfoBuilder(NodeMap<Value> nodeOperands) {
+        assert runtime().config.basicLockSize == 8;
+        HotSpotLockStack lockStack = new HotSpotLockStack(frameMap, Kind.Long);
+        return new HotSpotDebugInfoBuilder(nodeOperands, lockStack);
+    }
+
+    @Override
+    public StackSlot getLockSlot(int lockDepth) {
+        return ((HotSpotDebugInfoBuilder) debugInfoBuilder).lockStack().makeLockSlot(lockDepth);
+    }
+
+    @Override
+    protected boolean needOnlyOopMaps() {
+        // Stubs only need oop maps
+        return graph.start() instanceof StubStartNode;
+    }
+
+    Stub getStub() {
+        if (graph.start() instanceof StubStartNode) {
+            return ((StubStartNode) graph.start()).getStub();
+        }
+        return null;
+    }
+
     @Override
     public void visitSafepointNode(SafepointNode i) {
         LIRFrameState info = state(i);
@@ -62,8 +92,37 @@
     }
 
     @Override
+    public void visitDirectCompareAndSwap(DirectCompareAndSwapNode x) {
+        Kind kind = x.newValue().kind();
+        assert kind == x.expectedValue().kind();
+
+        Variable address = load(operand(x.object()));
+        Value offset = operand(x.offset());
+        Variable cmpValue = (Variable) loadNonConst(operand(x.expectedValue()));
+        Variable newValue = load(operand(x.newValue()));
+
+        if (ValueUtil.isConstant(offset)) {
+            assert !runtime.needsDataPatch(asConstant(offset));
+            Variable longAddress = newVariable(Kind.Long);
+            emitMove(longAddress, address);
+            address = emitAdd(longAddress, asConstant(offset));
+        } else {
+            if (isLegal(offset)) {
+                address = emitAdd(address, offset);
+            }
+        }
+
+        append(new CompareAndSwapOp(address, cmpValue, newValue));
+
+        Variable result = newVariable(x.kind());
+        emitMove(result, newValue);
+        setResult(x, result);
+    }
+
+    @Override
     public void emitTailcall(Value[] args, Value address) {
-        throw new InternalError("NYI");
+// append(new AMD64TailcallOp(args, address));
+        throw GraalInternalError.unimplemented();
     }
 
     @Override
@@ -89,57 +148,120 @@
 // emitMove(targetAddress, operand(callTarget.computedAddress()));
 // append(new AMD64IndirectCallOp(callTarget.target(), result, parameters, temps, metaspaceMethod,
 // targetAddress, callState));
-        throw new InternalError("NYI");
+        throw GraalInternalError.unimplemented();
+    }
+
+    @Override
+    public void emitUnwind(Value exception) {
+        ForeignCallLinkage linkage = getRuntime().lookupForeignCall(HotSpotBackend.UNWIND_EXCEPTION_TO_CALLER);
+        CallingConvention linkageCc = linkage.getCallingConvention();
+        assert linkageCc.getArgumentCount() == 2;
+        RegisterValue exceptionParameter = (RegisterValue) linkageCc.getArgument(0);
+        emitMove(exceptionParameter, exception);
+        append(new SPARCHotSpotUnwindOp(exceptionParameter));
+        throw GraalInternalError.unimplemented();
+    }
+
+    @Override
+    public void emitDeoptimize(DeoptimizationAction action, DeoptimizingNode deopting) {
+// append(new AMD64DeoptimizeOp(action, deopting.getDeoptimizationReason(), state(deopting)));
+        throw GraalInternalError.unimplemented();
     }
 
     @Override
     public void emitDeoptimizeCaller(DeoptimizationAction action, DeoptimizationReason reason) {
-        throw new InternalError("NYI");
+        append(new SPARCHotSpotDeoptimizeCallerOp(action, reason));
     }
 
     @Override
     public void emitPatchReturnAddress(ValueNode address) {
-        throw new InternalError("NYI");
+        append(new SPARCHotSpotPatchReturnAddressOp(load(operand(address))));
     }
 
     @Override
     public void emitJumpToExceptionHandlerInCaller(ValueNode handlerInCallerPc, ValueNode exception, ValueNode exceptionPc) {
-        throw new InternalError("NYI");
+        Variable handler = load(operand(handlerInCallerPc));
+        ForeignCallLinkage linkage = getRuntime().lookupForeignCall(EXCEPTION_HANDLER_IN_CALLER);
+        CallingConvention linkageCc = linkage.getCallingConvention();
+        assert linkageCc.getArgumentCount() == 2;
+        RegisterValue exceptionFixed = (RegisterValue) linkageCc.getArgument(0);
+        RegisterValue exceptionPcFixed = (RegisterValue) linkageCc.getArgument(1);
+        emitMove(exceptionFixed, operand(exception));
+        emitMove(exceptionPcFixed, operand(exceptionPc));
+        SPARCHotSpotJumpToExceptionHandlerInCallerOp op = new SPARCHotSpotJumpToExceptionHandlerInCallerOp(handler, exceptionFixed, exceptionPcFixed);
+        append(op);
+    }
+
+    private static boolean isCompressCandidate(DeoptimizingNode access) {
+        return access != null && ((HeapAccess) access).isCompressible();
+    }
+
+    @Override
+    public Variable emitLoad(Kind kind, Value address, DeoptimizingNode access) {
+        SPARCAddressValue loadAddress = asAddressValue(address);
+        Variable result = newVariable(kind);
+        assert access == null || access instanceof HeapAccess;
+        if (isCompressCandidate(access)) {
+            if (runtime().config.useCompressedOops && kind == Kind.Object) {
+// append(new LoadCompressedPointer(kind, result, loadAddress, access != null ? state(access) :
+// null, runtime().config.narrowOopBase, runtime().config.narrowOopShift,
+// runtime().config.logMinObjAlignment));
+                throw GraalInternalError.unimplemented();
+            } else if (runtime().config.useCompressedKlassPointers && kind == Kind.Long) {
+// append(new LoadCompressedPointer(kind, result, loadAddress, access != null ? state(access) :
+// null, runtime().config.narrowKlassBase, runtime().config.narrowKlassShift,
+// runtime().config.logKlassAlignment));
+                throw GraalInternalError.unimplemented();
+            } else {
+                append(new LoadOp(kind, result, loadAddress, access != null ? state(access) : null));
+            }
+        } else {
+            append(new LoadOp(kind, result, loadAddress, access != null ? state(access) : null));
+        }
+        return result;
     }
 
     @Override
-    public void visitDirectCompareAndSwap(DirectCompareAndSwapNode x) {
-        Kind kind = x.newValue().kind();
-        assert kind == x.expectedValue().kind();
-
-        Variable address = load(operand(x.object()));
-        Value offset = operand(x.offset());
-        Variable cmpValue = (Variable) loadNonConst(operand(x.expectedValue()));
-        Variable newValue = load(operand(x.newValue()));
-
-        if (ValueUtil.isConstant(offset)) {
-            assert !runtime.needsDataPatch(asConstant(offset));
-            address = emitAdd(address, asConstant(offset));
-        } else {
-            if (isLegal(offset)) {
-                address = emitAdd(address, offset);
+    public void emitStore(Kind kind, Value address, Value inputVal, DeoptimizingNode access) {
+        SPARCAddressValue storeAddress = asAddressValue(address);
+        LIRFrameState state = access != null ? state(access) : null;
+        if (isConstant(inputVal)) {
+            Constant c = asConstant(inputVal);
+            if (canStoreConstant(c)) {
+                if (inputVal.getKind() == Kind.Object) {
+                    append(new StoreConstantOp(kind, storeAddress, c, state, runtime().config.useCompressedOops && isCompressCandidate(access)));
+                } else if (inputVal.getKind() == Kind.Long) {
+                    append(new StoreConstantOp(kind, storeAddress, c, state, runtime().config.useCompressedKlassPointers && isCompressCandidate(access)));
+                } else {
+                    append(new StoreConstantOp(kind, storeAddress, c, state, false));
+                }
+                return;
             }
         }
-
-        append(new CompareAndSwapOp(address, cmpValue, newValue));
-
-        Variable result = newVariable(x.kind());
-        emitMove(result, newValue);
-        setResult(x, result);
+        Variable input = load(inputVal);
+        if (isCompressCandidate(access)) {
+            if (runtime().config.useCompressedOops && kind == Kind.Object) {
+// if (input.getKind() == Kind.Object) {
+// Variable scratch = newVariable(Kind.Long);
+// append(new StoreCompressedPointer(kind, storeAddress, input, scratch, state,
+// runtime().config.narrowOopBase, runtime().config.narrowOopShift,
+// runtime().config.logMinObjAlignment));
+// } else {
+// // the input oop is already compressed
+// append(new StoreOp(input.getKind(), storeAddress, input, state));
+// }
+                throw GraalInternalError.unimplemented();
+            } else if (runtime().config.useCompressedKlassPointers && kind == Kind.Long) {
+// Variable scratch = newVariable(Kind.Long);
+// append(new StoreCompressedPointer(kind, storeAddress, input, scratch, state,
+// runtime().config.narrowKlassBase, runtime().config.narrowKlassShift,
+// runtime().config.logKlassAlignment));
+                throw GraalInternalError.unimplemented();
+            } else {
+                append(new StoreOp(kind, storeAddress, input, state));
+            }
+        } else {
+            append(new StoreOp(kind, storeAddress, input, state));
+        }
     }
-
-    @Override
-    public StackSlot getLockSlot(int lockDepth) {
-        throw new InternalError("NYI");
-    }
-
-    public Stub getStub() {
-        throw new InternalError("NYI");
-    }
-
 }
diff -r 7a0ba9b20fec -r 1b11e3c8529c graal/com.oracle.graal.hotspot.sparc/src/com/oracle/graal/hotspot/sparc/SPARCHotSpotPatchReturnAddressOp.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.hotspot.sparc/src/com/oracle/graal/hotspot/sparc/SPARCHotSpotPatchReturnAddressOp.java	Tue Jul 23 17:48:17 2013 +0200
@@ -0,0 +1,55 @@
+/*
+ * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package com.oracle.graal.hotspot.sparc;
+
+import static com.oracle.graal.sparc.SPARC.*;
+import static com.oracle.graal.asm.sparc.SPARCMacroAssembler.*;
+import static com.oracle.graal.lir.LIRInstruction.OperandFlag.*;
+
+import com.oracle.graal.api.meta.*;
+import com.oracle.graal.asm.sparc.*;
+import com.oracle.graal.lir.*;
+import com.oracle.graal.lir.sparc.*;
+import com.oracle.graal.lir.asm.*;
+
+/**
+ * Patch the return address of the current frame.
+ */
+@Opcode("PATCH_RETURN")
+final class SPARCHotSpotPatchReturnAddressOp extends SPARCLIRInstruction {
+
+    @Use(REG) AllocatableValue address;
+
+    SPARCHotSpotPatchReturnAddressOp(AllocatableValue address) {
+        this.address = address;
+    }
+
+    @Override
+    public void emitCode(TargetMethodAssembler tasm, SPARCMacroAssembler masm) {
+        // FIXME This is non-trivial. On SPARC we need to flush all register windows first before we
+        // can patch the return address (see: frame::patch_pc).
+        // int frameSize = tasm.frameMap.frameSize();
+        // new Stx(asRegister(address), new SPARCAddress(sp, frameSize));
+        new Ldx(new SPARCAddress(g0, g0), g0).emit(masm);
+    }
+}
diff -r 7a0ba9b20fec -r 1b11e3c8529c graal/com.oracle.graal.hotspot.sparc/src/com/oracle/graal/hotspot/sparc/SPARCHotSpotRegisterConfig.java
--- a/graal/com.oracle.graal.hotspot.sparc/src/com/oracle/graal/hotspot/sparc/SPARCHotSpotRegisterConfig.java	Tue Jul 23 17:47:56 2013 +0200
+++ b/graal/com.oracle.graal.hotspot.sparc/src/com/oracle/graal/hotspot/sparc/SPARCHotSpotRegisterConfig.java	Tue Jul 23 17:48:17 2013 +0200
@@ -95,14 +95,16 @@
         // @formatter:off
         if (reserveForHeapBase) {
             registers = new Register[] {
-                    // TODO this is not complete
+                        // TODO this is not complete
+                        o0, o1, o2, o3, o4, o5, /*o6,*/ o7,
                         l0, l1, l2, l3, l4, l5, l6, l7,
                         i0, i1, i2, i3, i4, i5, /*i6,*/ i7,
                         f0, f1, f2, f3, f4, f5, f6, f7
                       };
         } else {
             registers = new Register[] {
-                    // TODO this is not complete
+                        // TODO this is not complete
+                        o0, o1, o2, o3, o4, o5, /*o6,*/ o7,
                         l0, l1, l2, l3, l4, l5, l6, l7,
                         i0, i1, i2, i3, i4, i5, /*i6,*/ i7,
                         f0, f1, f2, f3, f4, f5, f6, f7
diff -r 7a0ba9b20fec -r 1b11e3c8529c graal/com.oracle.graal.hotspot.sparc/src/com/oracle/graal/hotspot/sparc/SPARCHotSpotRuntime.java
--- a/graal/com.oracle.graal.hotspot.sparc/src/com/oracle/graal/hotspot/sparc/SPARCHotSpotRuntime.java	Tue Jul 23 17:47:56 2013 +0200
+++ b/graal/com.oracle.graal.hotspot.sparc/src/com/oracle/graal/hotspot/sparc/SPARCHotSpotRuntime.java	Tue Jul 23 17:48:17 2013 +0200
@@ -76,7 +76,7 @@
 
     @Override
     public Register stackPointerRegister() {
-        throw new InternalError("NYI: SPARC: Define stack pointer register.");
+        return sp;
     }
 
     @Override
diff -r 7a0ba9b20fec -r 1b11e3c8529c graal/com.oracle.graal.hotspot.sparc/src/com/oracle/graal/hotspot/sparc/SPARCHotSpotUnwindOp.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.hotspot.sparc/src/com/oracle/graal/hotspot/sparc/SPARCHotSpotUnwindOp.java	Tue Jul 23 17:48:17 2013 +0200
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package com.oracle.graal.hotspot.sparc;
+
+import static com.oracle.graal.sparc.SPARC.*;
+import static com.oracle.graal.api.code.ValueUtil.*;
+import static com.oracle.graal.hotspot.HotSpotBackend.*;
+import static com.oracle.graal.lir.LIRInstruction.OperandFlag.*;
+
+import com.oracle.graal.api.code.*;
+import com.oracle.graal.asm.sparc.*;
+import com.oracle.graal.asm.sparc.SPARCMacroAssembler.Mov;
+import com.oracle.graal.hotspot.stubs.*;
+import com.oracle.graal.lir.*;
+import com.oracle.graal.lir.sparc.*;
+import com.oracle.graal.lir.asm.*;
+
+/**
+ * Removes the current frame and jumps to the {@link UnwindExceptionToCallerStub}.
+ */
+@Opcode("UNWIND")
+final class SPARCHotSpotUnwindOp extends SPARCHotSpotEpilogueOp {
+
+    @Use({REG}) protected RegisterValue exception;
+
+    SPARCHotSpotUnwindOp(RegisterValue exception) {
+        this.exception = exception;
+    }
+
+    @Override
+    public void emitCode(TargetMethodAssembler tasm, SPARCMacroAssembler masm) {
+        leaveFrame(tasm);
+
+        ForeignCallLinkage linkage = tasm.runtime.lookupForeignCall(UNWIND_EXCEPTION_TO_CALLER);
+        CallingConvention cc = linkage.getCallingConvention();
+        assert cc.getArgumentCount() == 2;
+        assert exception.equals(cc.getArgument(0));
+
+        // Get return address (is in o7 after leave).
+        Register returnAddress = asRegister(cc.getArgument(1));
+        new Mov(o7, returnAddress).emit(masm);
+
+        Register scratch = g5;
+        SPARCCall.indirectJmp(tasm, masm, scratch, linkage);
+    }
+}
diff -r 7a0ba9b20fec -r 1b11e3c8529c graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/meta/HotSpotRuntime.java
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/meta/HotSpotRuntime.java	Tue Jul 23 17:47:56 2013 +0200
+++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/meta/HotSpotRuntime.java	Tue Jul 23 17:48:17 2013 +0200
@@ -580,11 +580,9 @@
             // Separate out GC barrier semantics
             CompareAndSwapNode cas = (CompareAndSwapNode) n;
             LocationNode location = IndexedLocationNode.create(ANY_LOCATION, cas.expected().kind(), cas.displacement(), cas.offset(), graph, 1);
-            cas.setLocation(location);
-            cas.setBarrierType(getCompareAndSwapBarrier(cas));
-            if (cas.expected().kind() == Kind.Object) {
-                cas.setCompressible();
-            }
+            LoweredCompareAndSwapNode atomicNode = graph.add(new LoweredCompareAndSwapNode(cas.object(), location, cas.expected(), cas.newValue(), getCompareAndSwapBarrier(cas),
+                            cas.expected().kind() == Kind.Object));
+            graph.replaceFixedWithFixed(cas, atomicNode);
         } else if (n instanceof LoadIndexedNode) {
             LoadIndexedNode loadIndexed = (LoadIndexedNode) n;
             GuardingNode boundsCheck = createBoundsCheck(loadIndexed, tool);
diff -r 7a0ba9b20fec -r 1b11e3c8529c graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/phases/WriteBarrierAdditionPhase.java
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/phases/WriteBarrierAdditionPhase.java	Tue Jul 23 17:47:56 2013 +0200
+++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/phases/WriteBarrierAdditionPhase.java	Tue Jul 23 17:48:17 2013 +0200
@@ -43,7 +43,7 @@
         for (WriteNode node : graph.getNodes(WriteNode.class)) {
             addWriteNodeBarriers(node, graph);
         }
-        for (CompareAndSwapNode node : graph.getNodes(CompareAndSwapNode.class)) {
+        for (LoweredCompareAndSwapNode node : graph.getNodes(LoweredCompareAndSwapNode.class)) {
             addCASBarriers(node, graph);
         }
         for (ArrayRangeWriteNode node : graph.getNodes(ArrayRangeWriteNode.class)) {
@@ -93,19 +93,19 @@
 
     }
 
-    private static void addCASBarriers(CompareAndSwapNode node, StructuredGraph graph) {
+    private static void addCASBarriers(LoweredCompareAndSwapNode node, StructuredGraph graph) {
         BarrierType barrierType = node.getBarrierType();
         if (barrierType == BarrierType.PRECISE) {
             if (useG1GC()) {
-                graph.addBeforeFixed(node, graph.add(new G1PreWriteBarrier(node.object(), node.expected(), node.getLocation(), false, false)));
-                graph.addAfterFixed(node, graph.add(new G1PostWriteBarrier(node.object(), node.newValue(), node.getLocation(), true)));
+                graph.addBeforeFixed(node, graph.add(new G1PreWriteBarrier(node.object(), node.getExpectedValue(), node.getLocation(), false, false)));
+                graph.addAfterFixed(node, graph.add(new G1PostWriteBarrier(node.object(), node.getNewValue(), node.getLocation(), true)));
             } else {
                 graph.addAfterFixed(node, graph.add(new SerialWriteBarrier(node.object(), node.getLocation(), true)));
             }
         } else if (barrierType == BarrierType.IMPRECISE) {
             if (useG1GC()) {
-                graph.addBeforeFixed(node, graph.add(new G1PreWriteBarrier(node.object(), node.expected(), node.getLocation(), false, false)));
-                graph.addAfterFixed(node, graph.add(new G1PostWriteBarrier(node.object(), node.newValue(), node.getLocation(), false)));
+                graph.addBeforeFixed(node, graph.add(new G1PreWriteBarrier(node.object(), node.getExpectedValue(), node.getLocation(), false, false)));
+                graph.addAfterFixed(node, graph.add(new G1PostWriteBarrier(node.object(), node.getNewValue(), node.getLocation(), false)));
             } else {
                 graph.addAfterFixed(node, graph.add(new SerialWriteBarrier(node.object(), node.getLocation(), false)));
             }
diff -r 7a0ba9b20fec -r 1b11e3c8529c graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/phases/WriteBarrierVerificationPhase.java
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/phases/WriteBarrierVerificationPhase.java	Tue Jul 23 17:47:56 2013 +0200
+++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/phases/WriteBarrierVerificationPhase.java	Tue Jul 23 17:48:17 2013 +0200
@@ -113,7 +113,7 @@
 
     private static boolean isObjectWrite(Node node) {
         if ((node instanceof WriteNode && (((WriteNode) node).getBarrierType() != BarrierType.NONE)) ||
-                        (node instanceof CompareAndSwapNode && (((CompareAndSwapNode) node).getBarrierType() != BarrierType.NONE))) {
+                        (node instanceof LoweredCompareAndSwapNode && (((LoweredCompareAndSwapNode) node).getBarrierType() != BarrierType.NONE))) {
             return true;
         }
         return false;
@@ -146,9 +146,9 @@
         if (write instanceof WriteNode) {
             writtenObject = ((WriteNode) write).object();
             writtenLocation = ((WriteNode) write).location();
-        } else if (write instanceof CompareAndSwapNode) {
-            writtenObject = ((CompareAndSwapNode) write).object();
-            writtenLocation = ((CompareAndSwapNode) write).getLocation();
+        } else if (write instanceof LoweredCompareAndSwapNode) {
+            writtenObject = ((LoweredCompareAndSwapNode) write).object();
+            writtenLocation = ((LoweredCompareAndSwapNode) write).getLocation();
         } else {
             assert false : "Node must be of type requiring a write barrier";
         }
diff -r 7a0ba9b20fec -r 1b11e3c8529c graal/com.oracle.graal.java/src/com/oracle/graal/java/FrameStateBuilder.java
--- a/graal/com.oracle.graal.java/src/com/oracle/graal/java/FrameStateBuilder.java	Tue Jul 23 17:47:56 2013 +0200
+++ b/graal/com.oracle.graal.java/src/com/oracle/graal/java/FrameStateBuilder.java	Tue Jul 23 17:48:17 2013 +0200
@@ -195,7 +195,7 @@
                 return null;
             }
 
-            PhiNode phi = graph.unique(new PhiNode(currentValue.kind(), block));
+            PhiNode phi = graph.add(new PhiNode(currentValue.kind(), block));
             for (int i = 0; i < block.phiPredecessorCount(); i++) {
                 phi.addInput(currentValue);
             }
@@ -290,7 +290,7 @@
         }
         assert !block.isPhiAtMerge(value) : "phi function for this block already created";
 
-        PhiNode phi = graph.unique(new PhiNode(value.kind(), block));
+        PhiNode phi = graph.add(new PhiNode(value.kind(), block));
         phi.addInput(value);
         return phi;
     }
diff -r 7a0ba9b20fec -r 1b11e3c8529c graal/com.oracle.graal.lir.sparc/src/com/oracle/graal/lir/sparc/SPARCArithmetic.java
--- a/graal/com.oracle.graal.lir.sparc/src/com/oracle/graal/lir/sparc/SPARCArithmetic.java	Tue Jul 23 17:47:56 2013 +0200
+++ b/graal/com.oracle.graal.lir.sparc/src/com/oracle/graal/lir/sparc/SPARCArithmetic.java	Tue Jul 23 17:48:17 2013 +0200
@@ -264,10 +264,10 @@
                     new Add(asIntReg(src2), -(tasm.asIntConst(src1)), asIntReg(dst)).emit(masm);
                     break;
                 case IAND:
-                    throw new InternalError("NYI");
+                    throw GraalInternalError.unimplemented();
                 case IDIV:
                     assert isSimm13(tasm.asIntConst(src1));
-                    throw new InternalError("NYI");
+                    throw GraalInternalError.unimplemented();
                     // new Sdivx(masm, asIntReg(src1), asIntReg(src2),
                     // asIntReg(dst));
                 case FSUB:
@@ -311,6 +311,14 @@
                     assert isSimm13(tasm.asIntConst(src2));
                     new Xor(asIntReg(src1), tasm.asIntConst(src2), asIntReg(dst)).emit(masm);
                     break;
+                case LADD:
+                    assert isSimm13(tasm.asIntConst(src2));
+                    new Add(asLongReg(src1), tasm.asIntConst(src2), asLongReg(dst)).emit(masm);
+                    break;
+                case LSUB:
+                    assert isSimm13(tasm.asIntConst(src2));
+                    new Sub(asLongReg(src1), tasm.asIntConst(src2), asLongReg(dst)).emit(masm);
+                    break;
                 case LMUL:
                     assert isSimm13(tasm.asIntConst(src2));
                     new Mulx(asLongReg(src1), tasm.asIntConst(src2), asLongReg(dst)).emit(masm);
@@ -319,6 +327,10 @@
                     assert isSimm13(tasm.asIntConst(src2));
                     new Add(asLongReg(src1), tasm.asIntConst(src2), asLongReg(dst)).emit(masm);
                     break;
+                case LSHL:
+                    assert isSimm13(tasm.asIntConst(src2));
+                    new Sll(asLongReg(src1), tasm.asIntConst(src2), asLongReg(dst)).emit(masm);
+                    break;
                 case LUSHR:
                     assert isSimm13(tasm.asIntConst(src2));
                     new Srl(asLongReg(src1), tasm.asIntConst(src2), asLongReg(dst)).emit(masm);
@@ -365,7 +377,7 @@
                     new Sra(asIntReg(src1), asIntReg(src2), asIntReg(dst)).emit(masm);
                     break;
                 case IREM:
-                    throw new InternalError("NYI");
+                    throw GraalInternalError.unimplemented();
                 case LADD:
                     new Add(asLongReg(src1), asLongReg(src2), asLongReg(dst)).emit(masm);
                     break;
@@ -400,7 +412,7 @@
                 case LUDIV:
                 case LUREM:
                 case LREM:
-                    throw new InternalError("NYI");
+                    throw GraalInternalError.unimplemented();
                 case FADD:
                     new Fadds(asFloatReg(src1), asFloatReg(src2), asFloatReg(dst)).emit(masm);
                     break;
@@ -414,7 +426,7 @@
                     new Fdivs(asFloatReg(src1), asFloatReg(src2), asFloatReg(dst)).emit(masm);
                     break;
                 case FREM:
-                    throw new InternalError("NYI");
+                    throw GraalInternalError.unimplemented();
                 case DADD:
                     new Faddd(asDoubleReg(src1), asDoubleReg(src2), asDoubleReg(dst)).emit(masm);
                     break;
@@ -428,7 +440,7 @@
                     new Fdivd(asDoubleReg(src1), asDoubleReg(src2), asDoubleReg(dst)).emit(masm);
                     break;
                 case DREM:
-                    throw new InternalError("NYI");
+                    throw GraalInternalError.unimplemented();
                 default:
                     throw GraalInternalError.shouldNotReachHere("missing: " + opcode);
             }
@@ -507,7 +519,7 @@
                 rk = result.getKind();
                 xsk = x.getKind().getStackKind();
                 ysk = y.getKind().getStackKind();
-                assert rk == Kind.Int && xsk == Kind.Int && ysk == Kind.Int : "opcode=" + opcode + ", rk=" + rk + ", xsk=" + xsk + ", ysk=" + ysk;
+                assert rk == Kind.Int && xsk == Kind.Int && ysk == Kind.Int;
                 break;
             case LADD:
             case LSUB:
@@ -517,13 +529,18 @@
             case LAND:
             case LOR:
             case LXOR:
+                rk = result.getKind();
+                xk = x.getKind();
+                yk = y.getKind();
+                assert rk == Kind.Long && xk == Kind.Long && yk == Kind.Long;
+                break;
             case LSHL:
             case LSHR:
             case LUSHR:
                 rk = result.getKind();
                 xk = x.getKind();
                 yk = y.getKind();
-                assert rk == Kind.Long && xk == Kind.Long && yk == Kind.Long;
+                assert rk == Kind.Long && xk == Kind.Long && (yk == Kind.Int || yk == Kind.Long);
                 break;
             case FADD:
             case FSUB:
@@ -543,10 +560,10 @@
                 rk = result.getKind();
                 xk = x.getKind();
                 yk = y.getKind();
-                assert rk == Kind.Double && xk == Kind.Double && yk == Kind.Double;
+                assert rk == Kind.Double && xk == Kind.Double && yk == Kind.Double : "opcode=" + opcode + ", result kind=" + rk + ", x kind=" + xk + ", y kind=" + yk;
                 break;
             default:
-                throw new InternalError("NYI: " + opcode);
+                throw GraalInternalError.shouldNotReachHere("missing: " + opcode);
         }
     }
 }
diff -r 7a0ba9b20fec -r 1b11e3c8529c graal/com.oracle.graal.lir.sparc/src/com/oracle/graal/lir/sparc/SPARCCall.java
--- a/graal/com.oracle.graal.lir.sparc/src/com/oracle/graal/lir/sparc/SPARCCall.java	Tue Jul 23 17:47:56 2013 +0200
+++ b/graal/com.oracle.graal.lir.sparc/src/com/oracle/graal/lir/sparc/SPARCCall.java	Tue Jul 23 17:48:17 2013 +0200
@@ -153,14 +153,13 @@
         }
         int before = masm.codeBuffer.position();
         if (scratch != null) {
-// // offset might not fit a 32-bit immediate, generate an
-// // indirect call with a 64-bit immediate
-// masm.movq(scratch, 0L);
-// masm.call(scratch);
-// } else {
-// masm.call();
+            // offset might not fit a 30-bit displacement, generate an
+            // indirect call with a 64-bit immediate
+            new Sethix(0L, scratch, true).emit(masm);
+            new Jmpl(scratch, 0, r15).emit(masm);
+        } else {
+            new Call(0).emit(masm);
         }
-        new Call(0).emit(masm);
         int after = masm.codeBuffer.position();
         tasm.recordDirectCall(before, after, callTarget, info);
         tasm.recordExceptionHandlers(after, info);
@@ -168,14 +167,14 @@
         new Nop().emit(masm);  // delay slot
     }
 
-    public static void directJmp(TargetMethodAssembler tasm, SPARCMacroAssembler masm, InvokeTarget target) {
+    public static void indirectJmp(TargetMethodAssembler tasm, SPARCMacroAssembler masm, Register dst, InvokeTarget target) {
         int before = masm.codeBuffer.position();
-// masm.jmp(0, true);
+        new Sethix(0L, dst, true).emit(masm);
+        new Jmp(new SPARCAddress(dst, 0)).emit(masm);
         int after = masm.codeBuffer.position();
-        tasm.recordDirectCall(before, after, target, null);
+        tasm.recordIndirectCall(before, after, target, null);
 // masm.ensureUniquePC();
         new Nop().emit(masm);  // delay slot
-        throw new InternalError("NYI");
     }
 
     public static void indirectCall(TargetMethodAssembler tasm, SPARCMacroAssembler masm, Register dst, InvokeTarget callTarget, LIRFrameState info) {
diff -r 7a0ba9b20fec -r 1b11e3c8529c graal/com.oracle.graal.lir.sparc/src/com/oracle/graal/lir/sparc/SPARCControlFlow.java
--- a/graal/com.oracle.graal.lir.sparc/src/com/oracle/graal/lir/sparc/SPARCControlFlow.java	Tue Jul 23 17:47:56 2013 +0200
+++ b/graal/com.oracle.graal.lir.sparc/src/com/oracle/graal/lir/sparc/SPARCControlFlow.java	Tue Jul 23 17:48:17 2013 +0200
@@ -73,6 +73,9 @@
                 case GT:
                     new Bpg(CC.Xcc, destination.label()).emit(masm);
                     break;
+                case AT:
+                    new Bpgu(CC.Xcc, destination.label()).emit(masm);
+                    break;
                 default:
                     throw GraalInternalError.shouldNotReachHere();
             }
diff -r 7a0ba9b20fec -r 1b11e3c8529c graal/com.oracle.graal.lir.sparc/src/com/oracle/graal/lir/sparc/SPARCMove.java
--- a/graal/com.oracle.graal.lir.sparc/src/com/oracle/graal/lir/sparc/SPARCMove.java	Tue Jul 23 17:47:56 2013 +0200
+++ b/graal/com.oracle.graal.lir.sparc/src/com/oracle/graal/lir/sparc/SPARCMove.java	Tue Jul 23 17:48:17 2013 +0200
@@ -264,6 +264,51 @@
         }
     }
 
+    public static class StoreConstantOp extends MemOp {
+
+        protected final Constant input;
+        private final boolean compress;
+
+        public StoreConstantOp(Kind kind, SPARCAddressValue address, Constant input, LIRFrameState state, boolean compress) {
+            super(kind, address, state);
+            this.input = input;
+            this.compress = compress;
+            if (input.isNonNull()) {
+                throw GraalInternalError.shouldNotReachHere("Can only store null constants to memory");
+            }
+        }
+
+        @Override
+        public void emitMemAccess(SPARCMacroAssembler masm) {
+            switch (kind) {
+                case Boolean:
+                case Byte:
+                    new Stb(g0, address.toAddress()).emit(masm);
+                    break;
+                case Char:
+                case Short:
+                    new Sth(g0, address.toAddress()).emit(masm);
+                    break;
+                case Int:
+                    new Stw(g0, address.toAddress()).emit(masm);
+                    break;
+                case Long:
+                case Object:
+                    if (compress) {
+                        new Stw(g0, address.toAddress()).emit(masm);
+                    } else {
+                        new Stx(g0, address.toAddress()).emit(masm);
+                    }
+                    break;
+                case Float:
+                case Double:
+                    throw GraalInternalError.shouldNotReachHere("Cannot store float constants to memory");
+                default:
+                    throw GraalInternalError.shouldNotReachHere();
+            }
+        }
+    }
+
     public static void move(TargetMethodAssembler tasm, SPARCMacroAssembler masm, Value result, Value input) {
         if (isRegister(input)) {
             if (isRegister(result)) {
@@ -314,9 +359,11 @@
                 new Stw(asRegister(input), dest).emit(masm);
                 break;
             case Long:
+            case Object:
+                new Stx(asRegister(input), dest).emit(masm);
+                break;
             case Float:
             case Double:
-            case Object:
             default:
                 throw GraalInternalError.shouldNotReachHere();
         }
@@ -342,21 +389,25 @@
             case Int:
                 if (tasm.runtime.needsDataPatch(input)) {
                     tasm.recordDataReferenceInCode(input, 0, true);
+                    new Setuw(input.asInt(), asRegister(result)).emit(masm);
+                } else {
+                    if (input.isDefaultForKind()) {
+                        new Clr(asRegister(result)).emit(masm);
+                    } else {
+                        new Setuw(input.asInt(), asRegister(result)).emit(masm);
+                    }
                 }
-                new Setuw(input.asInt(), asRegister(result)).emit(masm);
                 break;
             case Long: {
                 if (tasm.runtime.needsDataPatch(input)) {
-                    new Nop().emit(masm);
                     tasm.recordDataReferenceInCode(input, 0, true);
                     new Setx(input.asLong(), asRegister(result), true).emit(masm);
-                    new Nop().emit(masm);
                 } else {
-                    new Nop().emit(masm);
-                    new Nop().emit(masm);
-                    new Setx(input.asLong(), asRegister(result)).emit(masm);
-                    new Nop().emit(masm);
-                    new Nop().emit(masm);
+                    if (input.isDefaultForKind()) {
+                        new Clr(asRegister(result)).emit(masm);
+                    } else {
+                        new Setx(input.asLong(), asRegister(result)).emit(masm);
+                    }
                 }
                 break;
             }
diff -r 7a0ba9b20fec -r 1b11e3c8529c graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/java/CompareAndSwapNode.java
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/java/CompareAndSwapNode.java	Tue Jul 23 17:47:56 2013 +0200
+++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/java/CompareAndSwapNode.java	Tue Jul 23 17:48:17 2013 +0200
@@ -25,7 +25,6 @@
 import static com.oracle.graal.graph.UnsafeAccess.*;
 
 import com.oracle.graal.api.meta.*;
-import com.oracle.graal.graph.*;
 import com.oracle.graal.nodes.*;
 import com.oracle.graal.nodes.extended.*;
 import com.oracle.graal.nodes.spi.*;
@@ -35,7 +34,7 @@
  * Represents an atomic compare-and-swap operation The result is a boolean that contains whether the
  * value matched the expected value.
  */
-public class CompareAndSwapNode extends AbstractStateSplit implements StateSplit, LIRLowerable, Lowerable, MemoryCheckpoint.Single, Node.IterableNodeType, HeapAccess {
+public class CompareAndSwapNode extends AbstractStateSplit implements StateSplit, Lowerable, MemoryCheckpoint.Single {
 
     @Input private ValueNode object;
     @Input private ValueNode offset;
@@ -43,8 +42,6 @@
     @Input private ValueNode newValue;
     @Input private LocationNode location;
     private final int displacement;
-    private BarrierType barrierType;
-    private boolean compressible;
 
     public ValueNode object() {
         return object;
@@ -75,24 +72,6 @@
         this.location = location;
     }
 
-    @Override
-    public BarrierType getBarrierType() {
-        return barrierType;
-    }
-
-    public void setBarrierType(BarrierType type) {
-        this.barrierType = type;
-    }
-
-    @Override
-    public boolean isCompressible() {
-        return compressible;
-    }
-
-    public void setCompressible() {
-        this.compressible = true;
-    }
-
     public CompareAndSwapNode(ValueNode object, int displacement, ValueNode offset, ValueNode expected, ValueNode newValue) {
         super(StampFactory.forKind(Kind.Boolean.getStackKind()));
         assert expected.kind() == newValue.kind();
@@ -101,8 +80,6 @@
         this.expected = expected;
         this.newValue = newValue;
         this.displacement = displacement;
-        this.barrierType = BarrierType.NONE;
-        this.compressible = false;
     }
 
     @Override
@@ -111,11 +88,6 @@
     }
 
     @Override
-    public void generate(LIRGeneratorTool gen) {
-        gen.visitCompareAndSwap(this);
-    }
-
-    @Override
     public void lower(LoweringTool tool, LoweringType loweringType) {
         tool.getRuntime().lower(this, tool);
     }
diff -r 7a0ba9b20fec -r 1b11e3c8529c graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/java/LoadFieldNode.java
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/java/LoadFieldNode.java	Tue Jul 23 17:47:56 2013 +0200
+++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/java/LoadFieldNode.java	Tue Jul 23 17:48:17 2013 +0200
@@ -22,8 +22,11 @@
  */
 package com.oracle.graal.nodes.java;
 
+import java.lang.reflect.*;
+
 import com.oracle.graal.api.meta.*;
 import com.oracle.graal.graph.*;
+import com.oracle.graal.graph.iterators.*;
 import com.oracle.graal.nodes.*;
 import com.oracle.graal.nodes.spi.*;
 import com.oracle.graal.nodes.type.*;
@@ -57,11 +60,15 @@
     @Override
     public ValueNode canonical(CanonicalizerTool tool) {
         MetaAccessProvider runtime = tool.runtime();
-        if (tool.canonicalizeReads()) {
+        if (tool.canonicalizeReads() && runtime != null) {
             ConstantNode constant = asConstant(runtime);
             if (constant != null) {
                 return constant;
             }
+            PhiNode phi = asPhi(runtime);
+            if (phi != null) {
+                return phi;
+            }
         }
         return this;
     }
@@ -70,16 +77,34 @@
      * Gets a constant value for this load if possible.
      */
     public ConstantNode asConstant(MetaAccessProvider runtime) {
-        if (runtime != null) {
-            Constant constant = null;
-            if (isStatic()) {
-                constant = field().readConstantValue(null);
-            } else if (object().isConstant() && !object().isNullConstant()) {
-                constant = field().readConstantValue(object().asConstant());
+        Constant constant = null;
+        if (isStatic()) {
+            constant = field().readConstantValue(null);
+        } else if (object().isConstant() && !object().isNullConstant()) {
+            constant = field().readConstantValue(object().asConstant());
+        }
+        if (constant != null) {
+            return ConstantNode.forConstant(constant, runtime, graph());
+        }
+        return null;
+    }
+
+    private PhiNode asPhi(MetaAccessProvider runtime) {
+        if (!isStatic() && Modifier.isFinal(field.getModifiers()) && object() instanceof PhiNode && ((PhiNode) object()).values().filter(NodePredicates.isNotA(ConstantNode.class)).isEmpty()) {
+            PhiNode phi = (PhiNode) object();
+            Constant[] constants = new Constant[phi.valueCount()];
+            for (int i = 0; i < phi.valueCount(); i++) {
+                Constant constantValue = field().readConstantValue(phi.valueAt(i).asConstant());
+                if (constantValue == null) {
+                    return null;
+                }
+                constants[i] = constantValue;
             }
-            if (constant != null) {
-                return ConstantNode.forConstant(constant, runtime, graph());
+            PhiNode newPhi = graph().add(new PhiNode(stamp(), phi.merge()));
+            for (int i = 0; i < phi.valueCount(); i++) {
+                newPhi.addInput(ConstantNode.forConstant(constants[i], runtime, graph()));
             }
+            return newPhi;
         }
         return null;
     }
diff -r 7a0ba9b20fec -r 1b11e3c8529c graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/java/LoweredCompareAndSwapNode.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/java/LoweredCompareAndSwapNode.java	Tue Jul 23 17:48:17 2013 +0200
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package com.oracle.graal.nodes.java;
+
+import com.oracle.graal.api.meta.*;
+import com.oracle.graal.graph.*;
+import com.oracle.graal.nodes.*;
+import com.oracle.graal.nodes.extended.*;
+import com.oracle.graal.nodes.spi.*;
+import com.oracle.graal.nodes.type.*;
+
+/**
+ * Represents the lowered version of an atomic compare-and-swap operation{@code CompareAndSwapNode}.
+ */
+public class LoweredCompareAndSwapNode extends AccessNode implements StateSplit, LIRLowerable, MemoryCheckpoint.Single, Node.IterableNodeType {
+
+    @Input private ValueNode object;
+    @Input private ValueNode expectedValue;
+    @Input private ValueNode newValue;
+    @Input private LocationNode location;
+    @Input(notDataflow = true) private FrameState stateAfter;
+
+    public FrameState stateAfter() {
+        return stateAfter;
+    }
+
+    public void setStateAfter(FrameState x) {
+        assert x == null || x.isAlive() : "frame state must be in a graph";
+        updateUsages(stateAfter, x);
+        stateAfter = x;
+    }
+
+    public boolean hasSideEffect() {
+        return true;
+    }
+
+    public ValueNode getObject() {
+        return object;
+    }
+
+    public ValueNode getExpectedValue() {
+        return expectedValue;
+    }
+
+    public ValueNode getNewValue() {
+        return newValue;
+    }
+
+    public LocationNode getLocation() {
+        return location;
+    }
+
+    public LoweredCompareAndSwapNode(ValueNode object, LocationNode location, ValueNode expectedValue, ValueNode newValue, BarrierType barrierType, boolean compressible) {
+        super(object, location, StampFactory.forKind(Kind.Boolean.getStackKind()), barrierType, compressible);
+        assert expectedValue.kind() == newValue.kind();
+        this.object = object;
+        this.expectedValue = expectedValue;
+        this.newValue = newValue;
+        this.location = location;
+    }
+
+    @Override
+    public LocationIdentity getLocationIdentity() {
+        return location.getLocationIdentity();
+    }
+
+    @Override
+    public void generate(LIRGeneratorTool gen) {
+        gen.visitCompareAndSwap(this, getLocation().generateAddress(gen, gen.operand(getObject())));
+    }
+}
diff -r 7a0ba9b20fec -r 1b11e3c8529c graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/spi/GraalCodeCacheProvider.java
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/spi/GraalCodeCacheProvider.java	Tue Jul 23 17:47:56 2013 +0200
+++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/spi/GraalCodeCacheProvider.java	Tue Jul 23 17:48:17 2013 +0200
@@ -48,7 +48,7 @@
     void lower(Node n, LoweringTool tool);
 
     /**
-     * Reconstruct the array index from a location node that was created as a lowering of an indexed
+     * Reconstructs the array index from a location node that was created as a lowering of an indexed
      * access to an array.
      * 
      * @param location a location pointing to an element in an array
diff -r 7a0ba9b20fec -r 1b11e3c8529c graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/spi/LIRGeneratorTool.java
--- a/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/spi/LIRGeneratorTool.java	Tue Jul 23 17:47:56 2013 +0200
+++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/spi/LIRGeneratorTool.java	Tue Jul 23 17:48:17 2013 +0200
@@ -118,7 +118,7 @@
 
     void visitLoopEnd(LoopEndNode i);
 
-    void visitCompareAndSwap(CompareAndSwapNode i);
+    void visitCompareAndSwap(LoweredCompareAndSwapNode i, Value address);
 
     // These methods define the contract a runtime specific backend must provide.
 
diff -r 7a0ba9b20fec -r 1b11e3c8529c graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/CanonicalizerPhase.java
--- a/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/CanonicalizerPhase.java	Tue Jul 23 17:47:56 2013 +0200
+++ b/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/CanonicalizerPhase.java	Tue Jul 23 17:48:17 2013 +0200
@@ -158,7 +158,10 @@
                 int mark = graph.getMark();
                 if (!tryKillUnused(node)) {
                     if (!tryCanonicalize(node, graph)) {
-                        tryInferStamp(node, graph);
+                        if (tryInferStamp(node, graph)) {
+                            // the improved stamp may enable additional canonicalization
+                            tryCanonicalize(node, graph);
+                        }
                     }
                 }
 
@@ -296,7 +299,7 @@
          * this method also checks if the stamp now describes a constant integer value, in which
          * case the node is replaced with a constant.
          */
-        private void tryInferStamp(Node node, StructuredGraph graph) {
+        private boolean tryInferStamp(Node node, StructuredGraph graph) {
             if (node.isAlive() && node instanceof ValueNode) {
                 ValueNode valueNode = (ValueNode) node;
                 METRIC_INFER_STAMP_CALLED.increment();
@@ -310,9 +313,11 @@
                         for (Node usage : valueNode.usages()) {
                             workList.addAgain(usage);
                         }
+                        return true;
                     }
                 }
             }
+            return false;
         }
 
         private final class Tool implements SimplifierTool {
diff -r 7a0ba9b20fec -r 1b11e3c8529c graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/ConditionalEliminationPhase.java
--- a/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/ConditionalEliminationPhase.java	Tue Jul 23 17:47:56 2013 +0200
+++ b/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/ConditionalEliminationPhase.java	Tue Jul 23 17:48:17 2013 +0200
@@ -114,7 +114,7 @@
                         break;
                     }
                 }
-                if (type == null && type != node.objectStamp().type()) {
+                if (type != null && type != node.objectStamp().type()) {
                     newKnownTypes.put(node, type);
                 }
             }
diff -r 7a0ba9b20fec -r 1b11e3c8529c graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/InliningUtil.java
--- a/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/InliningUtil.java	Tue Jul 23 17:47:56 2013 +0200
+++ b/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/InliningUtil.java	Tue Jul 23 17:48:17 2013 +0200
@@ -609,7 +609,7 @@
 
             PhiNode returnValuePhi = null;
             if (invoke.asNode().kind() != Kind.Void) {
-                returnValuePhi = graph.unique(new PhiNode(invoke.asNode().kind(), returnMerge));
+                returnValuePhi = graph.add(new PhiNode(invoke.asNode().kind(), returnMerge));
             }
 
             MergeNode exceptionMerge = null;
@@ -622,7 +622,7 @@
 
                 FixedNode exceptionSux = exceptionEdge.next();
                 graph.addBeforeFixed(exceptionSux, exceptionMerge);
-                exceptionObjectPhi = graph.unique(new PhiNode(Kind.Object, exceptionMerge));
+                exceptionObjectPhi = graph.add(new PhiNode(Kind.Object, exceptionMerge));
                 exceptionMerge.setStateAfter(exceptionEdge.stateAfter().duplicateModified(invoke.stateAfter().bci, true, Kind.Object, exceptionObjectPhi));
             }
 
diff -r 7a0ba9b20fec -r 1b11e3c8529c graal/com.oracle.graal.sparc/src/com/oracle/graal/sparc/SPARC.java
--- a/graal/com.oracle.graal.sparc/src/com/oracle/graal/sparc/SPARC.java	Tue Jul 23 17:47:56 2013 +0200
+++ b/graal/com.oracle.graal.sparc/src/com/oracle/graal/sparc/SPARC.java	Tue Jul 23 17:48:17 2013 +0200
@@ -41,38 +41,38 @@
     public static final RegisterCategory FPU = new RegisterCategory("FPU");
 
     // General purpose registers
-    public static final Register r0  = new Register(0, 0, "r0", CPU);
-    public static final Register r1  = new Register(1, 1, "r1", CPU);
-    public static final Register r2  = new Register(2, 2, "r2", CPU);
-    public static final Register r3  = new Register(3, 3, "r3", CPU);
-    public static final Register r4  = new Register(4, 4, "r4", CPU);
-    public static final Register r5  = new Register(5, 5, "r5", CPU);
-    public static final Register r6  = new Register(6, 6, "r6", CPU);
-    public static final Register r7  = new Register(7, 7, "r7", CPU);
-    public static final Register r8  = new Register(8, 8, "r8", CPU);
-    public static final Register r9  = new Register(9, 9, "r9", CPU);
-    public static final Register r10 = new Register(10, 10, "r10", CPU);
-    public static final Register r11 = new Register(11, 11, "r11", CPU);
-    public static final Register r12 = new Register(12, 12, "r12", CPU);
-    public static final Register r13 = new Register(13, 13, "r13", CPU);
-    public static final Register r14 = new Register(14, 14, "r14", CPU);
-    public static final Register r15 = new Register(15, 15, "r15", CPU);
-    public static final Register r16 = new Register(16, 16, "r16", CPU);
-    public static final Register r17 = new Register(17, 17, "r17", CPU);
-    public static final Register r18 = new Register(18, 18, "r18", CPU);
-    public static final Register r19 = new Register(19, 19, "r19", CPU);
-    public static final Register r20 = new Register(20, 20, "r20", CPU);
-    public static final Register r21 = new Register(21, 21, "r21", CPU);
-    public static final Register r22 = new Register(22, 22, "r22", CPU);
-    public static final Register r23 = new Register(23, 23, "r23", CPU);
-    public static final Register r24 = new Register(24, 24, "r24", CPU);
-    public static final Register r25 = new Register(25, 25, "r25", CPU);
-    public static final Register r26 = new Register(26, 26, "r26", CPU);
-    public static final Register r27 = new Register(27, 27, "r27", CPU);
-    public static final Register r28 = new Register(28, 28, "r28", CPU);
-    public static final Register r29 = new Register(29, 29, "r29", CPU);
-    public static final Register r30 = new Register(30, 30, "r30", CPU);
-    public static final Register r31 = new Register(31, 31, "r31", CPU);
+    public static final Register r0  = new Register(0, 0, "g0", CPU);
+    public static final Register r1  = new Register(1, 1, "g1", CPU);
+    public static final Register r2  = new Register(2, 2, "g2", CPU);
+    public static final Register r3  = new Register(3, 3, "g3", CPU);
+    public static final Register r4  = new Register(4, 4, "g4", CPU);
+    public static final Register r5  = new Register(5, 5, "g5", CPU);
+    public static final Register r6  = new Register(6, 6, "g6", CPU);
+    public static final Register r7  = new Register(7, 7, "g7", CPU);
+    public static final Register r8  = new Register(8, 8, "o0", CPU);
+    public static final Register r9  = new Register(9, 9, "o1", CPU);
+    public static final Register r10 = new Register(10, 10, "o2", CPU);
+    public static final Register r11 = new Register(11, 11, "o3", CPU);
+    public static final Register r12 = new Register(12, 12, "o4", CPU);
+    public static final Register r13 = new Register(13, 13, "o5", CPU);
+    public static final Register r14 = new Register(14, 14, "o6", CPU);
+    public static final Register r15 = new Register(15, 15, "o7", CPU);
+    public static final Register r16 = new Register(16, 16, "l0", CPU);
+    public static final Register r17 = new Register(17, 17, "l1", CPU);
+    public static final Register r18 = new Register(18, 18, "l2", CPU);
+    public static final Register r19 = new Register(19, 19, "l3", CPU);
+    public static final Register r20 = new Register(20, 20, "l4", CPU);
+    public static final Register r21 = new Register(21, 21, "l5", CPU);
+    public static final Register r22 = new Register(22, 22, "l6", CPU);
+    public static final Register r23 = new Register(23, 23, "l7", CPU);
+    public static final Register r24 = new Register(24, 24, "i0", CPU);
+    public static final Register r25 = new Register(25, 25, "i1", CPU);
+    public static final Register r26 = new Register(26, 26, "i2", CPU);
+    public static final Register r27 = new Register(27, 27, "i3", CPU);
+    public static final Register r28 = new Register(28, 28, "i4", CPU);
+    public static final Register r29 = new Register(29, 29, "i5", CPU);
+    public static final Register r30 = new Register(30, 30, "i6", CPU);
+    public static final Register r31 = new Register(31, 31, "i7", CPU);
 
     public static final Register g0 = r0;
     public static final Register g1 = r1;
diff -r 7a0ba9b20fec -r 1b11e3c8529c graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/OptimizedCallTarget.java
--- a/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/OptimizedCallTarget.java	Tue Jul 23 17:47:56 2013 +0200
+++ b/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/OptimizedCallTarget.java	Tue Jul 23 17:48:17 2013 +0200
@@ -50,7 +50,7 @@
         this.originalInvokeCounter = compilationThreshold;
         this.rootNode.setCallTarget(this);
 
-        if (TruffleProfiling.getValue()) {
+        if (TruffleCallTargetProfiling.getValue()) {
             registerCallTarget(this);
         }
     }
@@ -64,6 +64,7 @@
 
     // TruffleProfiling
     private int callCount;
+    private int invalidationCount;
 
     // TraceTruffleCompilation
     long timeCompilationStarted;
@@ -75,7 +76,7 @@
 
     @Override
     public Object call(PackedFrame caller, Arguments args) {
-        if (TruffleProfiling.getValue()) {
+        if (TruffleCallTargetProfiling.getValue()) {
             callCount++;
         }
         if (CompilerDirectives.injectBranchProbability(CompilerDirectives.FASTPATH_PROBABILITY, compiledMethod != null)) {
@@ -90,19 +91,22 @@
     }
 
     private Object compiledCodeInvalidated(PackedFrame caller, Arguments args) {
+        CompilerAsserts.neverPartOfCompilation();
         compiledMethod = null;
         int invalidationReprofileCount = TruffleInvalidationReprofileCount.getValue();
         invokeCounter = invalidationReprofileCount;
+        invalidationCount++;
         if (TruffleFunctionInlining.getValue()) {
             originalInvokeCounter += invalidationReprofileCount;
         }
         if (TraceTruffleCompilation.getValue()) {
-            OUT.printf("[truffle] invalidated %-48s |Alive %5.0fms\n", rootNode, (System.nanoTime() - timeCompilationFinished) / 1e6);
+            OUT.printf("[truffle] invalidated %-48s |Alive %5.0fms |Inv %d\n", rootNode, (System.nanoTime() - timeCompilationFinished) / 1e6, invalidationCount);
         }
         return call(caller, args);
     }
 
     private Object interpreterCall(PackedFrame caller, Arguments args) {
+        CompilerAsserts.neverPartOfCompilation();
         invokeCounter--;
         loopAndInvokeCounter--;
         if (disableCompilation || loopAndInvokeCounter > 0 || invokeCounter > 0) {
@@ -138,7 +142,7 @@
                                     (timeCompilationFinished - timeCompilationStarted) / 1e6, (timePartialEvaluationFinished - timeCompilationStarted) / 1e6,
                                     (timeCompilationFinished - timePartialEvaluationFinished) / 1e6, nodeCountPartialEval, nodeCountLowered, codeSize);
                 }
-                if (TruffleProfiling.getValue()) {
+                if (TruffleCallTargetProfiling.getValue()) {
                     resetProfiling();
                 }
             }
@@ -237,16 +241,16 @@
             return inlined;
         }
 
-        private void printCallSiteInfo(InliningPolicy policy, List<InlinableCallSiteInfo> inlinableCallSites, String msg) {
+        private static void printCallSiteInfo(InliningPolicy policy, List<InlinableCallSiteInfo> inlinableCallSites, String msg) {
             for (InlinableCallSiteInfo candidate : inlinableCallSites) {
                 printCallSiteInfo(policy, candidate, msg);
             }
         }
 
-        private void printCallSiteInfo(InliningPolicy policy, InlinableCallSiteInfo callSite, String msg) {
+        private static void printCallSiteInfo(InliningPolicy policy, InlinableCallSiteInfo callSite, String msg) {
             String calls = String.format("%4s/%4s", callSite.getCallCount(), policy.callerInvocationCount);
             String nodes = String.format("%3s/%3s", callSite.getInlineNodeCount(), policy.callerNodeCount);
-            OUT.printf("[truffle] %-9s %-50s |Nodes %6s |Calls %6s %7.3f |into %s\n", msg, callSite.getCallSite(), nodes, calls, policy.metric(callSite), target.getRootNode());
+            OUT.printf("[truffle] %-9s %-50s |Nodes %6s |Calls %6s %7.3f |%s\n", msg, callSite.getCallSite(), nodes, calls, policy.metric(callSite), callSite.getCallSite().getCallTarget());
         }
 
         private static final class InliningPolicy {
@@ -377,9 +381,10 @@
         int totalInlinedCallSiteCount = 0;
         int totalNotInlinedCallSiteCount = 0;
         int totalNodeCount = 0;
+        int totalInvalidationCount = 0;
 
         OUT.println();
-        OUT.printf("%-50s | %-10s | %s / %s | %s\n", "Call Target", "Call Count", "Calls Sites Inlined", "Not Inlined", "Node Count");
+        OUT.printf("%-50s | %-10s | %s / %s | %s | %s\n", "Call Target", "Call Count", "Calls Sites Inlined", "Not Inlined", "Node Count", "Inv");
         for (OptimizedCallTarget callTarget : sortedCallTargets) {
             if (callTarget.callCount == 0) {
                 continue;
@@ -389,14 +394,17 @@
             int nodeCount = NodeUtil.countNodes(callTarget.rootNode);
             int inlinedCallSiteCount = NodeUtil.countNodes(callTarget.rootNode, InlinedCallSite.class);
             String comment = callTarget.compiledMethod == null ? " int" : "";
-            OUT.printf("%-50s | %10s | %15s | %15s | %10s%s\n", callTarget.getRootNode(), callTarget.callCount, inlinedCallSiteCount, notInlinedCallSiteCount, nodeCount, comment);
+            comment += callTarget.disableCompilation ? " fail" : "";
+            OUT.printf("%-50s | %10d | %15d | %15d | %10d | %3d%s\n", callTarget.getRootNode(), callTarget.callCount, inlinedCallSiteCount, notInlinedCallSiteCount, nodeCount,
+                            callTarget.invalidationCount, comment);
 
             totalCallCount += callTarget.callCount;
             totalInlinedCallSiteCount += inlinedCallSiteCount;
             totalNotInlinedCallSiteCount += notInlinedCallSiteCount;
             totalNodeCount += nodeCount;
+            totalInvalidationCount += callTarget.invalidationCount;
         }
-        OUT.printf("%-50s | %10s | %15s | %15s | %10s\n", "Total", totalCallCount, totalInlinedCallSiteCount, totalNotInlinedCallSiteCount, totalNodeCount);
+        OUT.printf("%-50s | %10d | %15d | %15d | %10d | %3d\n", "Total", totalCallCount, totalInlinedCallSiteCount, totalNotInlinedCallSiteCount, totalNodeCount, totalInvalidationCount);
     }
 
     private static void registerCallTarget(OptimizedCallTarget callTarget) {
@@ -405,7 +413,7 @@
 
     private static Map<OptimizedCallTarget, Integer> callTargets;
     static {
-        if (TruffleProfiling.getValue()) {
+        if (TruffleCallTargetProfiling.getValue()) {
             callTargets = new WeakHashMap<>();
 
             Runtime.getRuntime().addShutdownHook(new Thread() {
diff -r 7a0ba9b20fec -r 1b11e3c8529c graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/TruffleCompilerImpl.java
--- a/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/TruffleCompilerImpl.java	Tue Jul 23 17:47:56 2013 +0200
+++ b/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/TruffleCompilerImpl.java	Tue Jul 23 17:48:17 2013 +0200
@@ -64,7 +64,7 @@
     private final HotSpotGraalRuntime graalRuntime;
     private final TruffleCache truffleCache;
 
-    private static final Class[] SKIPPED_EXCEPTION_CLASSES = new Class[]{SlowPathException.class, UnexpectedResultException.class, ArithmeticException.class, InvalidInstalledCodeException.class};
+    private static final Class[] SKIPPED_EXCEPTION_CLASSES = new Class[]{SlowPathException.class, UnexpectedResultException.class, ArithmeticException.class};
 
     public static final OptimisticOptimizations Optimizations = OptimisticOptimizations.ALL.remove(OptimisticOptimizations.Optimization.UseExceptionProbability,
                     OptimisticOptimizations.Optimization.RemoveNeverExecutedCode, OptimisticOptimizations.Optimization.UseTypeCheckedInlining, OptimisticOptimizations.Optimization.UseTypeCheckHints);
diff -r 7a0ba9b20fec -r 1b11e3c8529c graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/TruffleCompilerOptions.java
--- a/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/TruffleCompilerOptions.java	Tue Jul 23 17:47:56 2013 +0200
+++ b/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/TruffleCompilerOptions.java	Tue Jul 23 17:48:17 2013 +0200
@@ -88,6 +88,6 @@
     @Option(help = "")
     public static final OptionValue<Boolean> TraceTruffleInliningDetails = new OptionValue<>(false);
     @Option(help = "")
-    public static final OptionValue<Boolean> TruffleProfiling = new StableOptionValue<>(false);
+    public static final OptionValue<Boolean> TruffleCallTargetProfiling = new StableOptionValue<>(false);
     // @formatter:on
 }
diff -r 7a0ba9b20fec -r 1b11e3c8529c graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/substitutions/OptimizedCallTargetSubstitutions.java
--- a/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/substitutions/OptimizedCallTargetSubstitutions.java	Tue Jul 23 17:47:56 2013 +0200
+++ b/graal/com.oracle.graal.truffle/src/com/oracle/graal/truffle/substitutions/OptimizedCallTargetSubstitutions.java	Tue Jul 23 17:48:17 2013 +0200
@@ -35,6 +35,9 @@
     @MacroSubstitution(macro = NeverInlineMacroNode.class, isStatic = false)
     public static native Object interpreterCall(OptimizedCallTarget target, PackedFrame caller, Arguments args);
 
+    @MacroSubstitution(macro = NeverInlineMacroNode.class, isStatic = false)
+    public static native Object compiledCodeInvalidated(OptimizedCallTarget target, PackedFrame caller, Arguments args);
+
     @MethodSubstitution
     private static FrameWithoutBoxing createFrame(FrameDescriptor descriptor, PackedFrame caller, Arguments args) {
         return NewFrameNode.allocate(descriptor, caller, args);
diff -r 7a0ba9b20fec -r 1b11e3c8529c graal/com.oracle.graal.virtual/src/com/oracle/graal/virtual/phases/ea/PEReadEliminationClosure.java
--- a/graal/com.oracle.graal.virtual/src/com/oracle/graal/virtual/phases/ea/PEReadEliminationClosure.java	Tue Jul 23 17:47:56 2013 +0200
+++ b/graal/com.oracle.graal.virtual/src/com/oracle/graal/virtual/phases/ea/PEReadEliminationClosure.java	Tue Jul 23 17:48:17 2013 +0200
@@ -70,7 +70,7 @@
                 ValueNode cachedValue = state.getReadCache(object, store.field());
 
                 ValueNode value = state.getScalarAlias(store.value());
-                if (value == cachedValue) {
+                if (GraphUtil.unproxify(value) == GraphUtil.unproxify(cachedValue)) {
                     effects.deleteFixedNode(store);
                     deleted = true;
                 }
diff -r 7a0ba9b20fec -r 1b11e3c8529c graal/com.oracle.graal.virtual/src/com/oracle/graal/virtual/phases/ea/ReadEliminationClosure.java
--- a/graal/com.oracle.graal.virtual/src/com/oracle/graal/virtual/phases/ea/ReadEliminationClosure.java	Tue Jul 23 17:47:56 2013 +0200
+++ b/graal/com.oracle.graal.virtual/src/com/oracle/graal/virtual/phases/ea/ReadEliminationClosure.java	Tue Jul 23 17:48:17 2013 +0200
@@ -36,8 +36,8 @@
 import com.oracle.graal.nodes.util.*;
 import com.oracle.graal.phases.schedule.*;
 import com.oracle.graal.virtual.phases.ea.ReadEliminationBlockState.CacheEntry;
+import com.oracle.graal.virtual.phases.ea.ReadEliminationBlockState.LoadCacheEntry;
 import com.oracle.graal.virtual.phases.ea.ReadEliminationBlockState.ReadCacheEntry;
-import com.oracle.graal.virtual.phases.ea.ReadEliminationBlockState.LoadCacheEntry;
 
 public class ReadEliminationClosure extends EffectsClosure<ReadEliminationBlockState> {
 
@@ -106,6 +106,8 @@
                 }
                 state.killReadCache(write.location().getLocationIdentity());
                 state.addCacheEntry(identifier, value);
+            } else {
+                state.killReadCache(write.location().getLocationIdentity());
             }
         } else if (node instanceof MemoryCheckpoint.Single) {
             processIdentity(state, ((MemoryCheckpoint.Single) node).getLocationIdentity());
diff -r 7a0ba9b20fec -r 1b11e3c8529c graal/com.oracle.truffle.api/src/com/oracle/truffle/api/nodes/Node.java
--- a/graal/com.oracle.truffle.api/src/com/oracle/truffle/api/nodes/Node.java	Tue Jul 23 17:47:56 2013 +0200
+++ b/graal/com.oracle.truffle.api/src/com/oracle/truffle/api/nodes/Node.java	Tue Jul 23 17:48:17 2013 +0200
@@ -33,11 +33,6 @@
  */
 public abstract class Node implements Cloneable {
 
-    /**
-     * Utility constant representing an empty node array.
-     */
-    public static final Node[] EMPTY_ARRAY = new Node[0];
-
     private Node parent;
 
     private SourceSection sourceSection;
@@ -193,6 +188,22 @@
     }
 
     /**
+     * Checks if this node is properly adopted by a parent and can be replaced.
+     * 
+     * @return {@code true} if it is safe to replace this node.
+     */
+    public final boolean isReplaceable() {
+        if (getParent() != null) {
+            for (Node sibling : getParent().getChildren()) {
+                if (sibling == this) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    /**
      * Intended to be implemented by subclasses of {@link Node} to receive a notification when the
      * node is rewritten. This method is invoked before the actual replace has happened.
      * 
diff -r 7a0ba9b20fec -r 1b11e3c8529c graal/com.oracle.truffle.api/src/com/oracle/truffle/api/nodes/NodeUtil.java
--- a/graal/com.oracle.truffle.api/src/com/oracle/truffle/api/nodes/NodeUtil.java	Tue Jul 23 17:47:56 2013 +0200
+++ b/graal/com.oracle.truffle.api/src/com/oracle/truffle/api/nodes/NodeUtil.java	Tue Jul 23 17:48:17 2013 +0200
@@ -344,7 +344,11 @@
         for (long fieldOffset : nodeClass.childrenOffsets) {
             Node[] children = (Node[]) unsafe.getObject(node, fieldOffset);
             if (children != null) {
-                nodes.addAll(Arrays.asList(children));
+                for (Node child : children) {
+                    if (child != null) {
+                        nodes.add(child);
+                    }
+                }
             }
         }
 
@@ -545,23 +549,25 @@
     }
 
     public static int countNodes(Node root, Class<?> clazz) {
-        NodeCountVisitor nodeCount = new NodeCountVisitor(clazz);
+        NodeCountVisitor nodeCount = new NodeCountVisitor(root, clazz);
         root.accept(nodeCount);
         return nodeCount.nodeCount;
     }
 
     private static final class NodeCountVisitor implements NodeVisitor {
 
+        int nodeCount;
+        private final Node root;
         private final Class<?> clazz;
-        int nodeCount;
 
-        private NodeCountVisitor(Class<?> clazz) {
+        private NodeCountVisitor(Node root, Class<?> clazz) {
+            this.root = root;
             this.clazz = clazz;
         }
 
         @Override
         public boolean visit(Node node) {
-            if (node instanceof RootNode && nodeCount > 0) {
+            if (node instanceof RootNode && node != root) {
                 return false;
             }
             if (clazz == null || clazz.isInstance(node)) {
@@ -589,7 +595,7 @@
             p.print("  ");
         }
         if (parent == null) {
-            p.println(node.getClass().getSimpleName());
+            p.println(nodeName(node));
         } else {
             String fieldName = "unknownField";
             NodeField[] fields = NodeClass.get(parent.getClass()).fields;
@@ -611,7 +617,7 @@
             }
             p.print(fieldName);
             p.print(" = ");
-            p.println(node.getClass().getSimpleName());
+            p.println(nodeName(node));
         }
 
         for (Node child : node.getChildren()) {
@@ -649,7 +655,7 @@
             return;
         }
 
-        p.print(node.getClass().getSimpleName());
+        p.print(nodeName(node));
 
         ArrayList<NodeField> childFields = new ArrayList<>();
         String sep = "";
@@ -704,4 +710,7 @@
         }
     }
 
+    private static String nodeName(Node node) {
+        return node.getClass().getSimpleName();
+    }
 }
diff -r 7a0ba9b20fec -r 1b11e3c8529c src/cpu/sparc/vm/graalCodeInstaller_sparc.hpp
--- a/src/cpu/sparc/vm/graalCodeInstaller_sparc.hpp	Tue Jul 23 17:47:56 2013 +0200
+++ b/src/cpu/sparc/vm/graalCodeInstaller_sparc.hpp	Tue Jul 23 17:48:17 2013 +0200
@@ -29,8 +29,14 @@
 #include "graal/graalJavaAccess.hpp"
 
 inline jint CodeInstaller::pd_next_offset(NativeInstruction* inst, jint pc_offset, oop method) {
-  assert(inst->is_call() || inst->is_jump(), "sanity");
-  return pc_offset + NativeCall::instruction_size;
+  if (inst->is_call() || inst->is_jump()) {
+    return pc_offset + NativeCall::instruction_size;
+  } else if (inst->is_sethi()) {
+    return pc_offset + NativeFarCall::instruction_size;
+  } else {
+    fatal("unsupported type of instruction for call site");
+    return 0;
+  }
 }
 
 inline void CodeInstaller::pd_site_DataPatch(int pc_offset, oop site) {
@@ -107,7 +113,22 @@
 }
 
 inline void CodeInstaller::pd_relocate_ForeignCall(NativeInstruction* inst, jlong foreign_call_destination) {
-  fatal("CodeInstaller::pd_relocate_ForeignCall - sparc unimp");
+  address pc = (address) inst;
+  if (inst->is_call()) {
+    NativeCall* call = nativeCall_at(pc);
+    call->set_destination((address) foreign_call_destination);
+    _instructions->relocate(call->instruction_address(), runtime_call_Relocation::spec());
+  } else if (inst->is_sethi()) {
+    NativeFarCall* call = nativeFarCall_at(pc);
+    call->set_destination((address) foreign_call_destination);
+    _instructions->relocate(call->instruction_address(), runtime_call_Relocation::spec());
+  } else {
+    NativeJump* jump = nativeJump_at((address) (inst));
+    jump->set_jump_destination((address) foreign_call_destination);
+    _instructions->relocate((address)inst, runtime_call_Relocation::spec());
+    fatal("CodeInstaller::pd_relocate_ForeignCall - verify me!");
+  }
+  TRACE_graal_3("relocating (foreign call) at %p", inst);
 }
 
 inline void CodeInstaller::pd_relocate_JavaMethod(oop hotspot_method, jint pc_offset) {
@@ -127,7 +148,6 @@
       NativeCall* call = nativeCall_at(_instructions->start() + pc_offset);
       call->set_destination(SharedRuntime::get_resolve_virtual_call_stub());
       _instructions->relocate(call->instruction_address(), virtual_call_Relocation::spec(_invoke_mark_pc));
-      /*, Assembler::call32_operand); */
       break;
     }
     case MARK_INVOKESTATIC: {
@@ -135,16 +155,13 @@
       NativeCall* call = nativeCall_at(_instructions->start() + pc_offset);
       call->set_destination(SharedRuntime::get_resolve_static_call_stub());
       _instructions->relocate(call->instruction_address(), relocInfo::static_call_type);
-      /*, Assembler::call32_operand); */
       break;
     }
     case MARK_INVOKESPECIAL: {
       assert(method == NULL || !method->is_static(), "cannot call static method with invokespecial");
       NativeCall* call = nativeCall_at(_instructions->start() + pc_offset);
       call->set_destination(SharedRuntime::get_resolve_opt_virtual_call_stub());
-//      _instructions->relocate(call->instruction_address(),
-//                              relocInfo::opt_virtual_call_type, Assembler::call32_operand);
-      fatal("NYI");
+      _instructions->relocate(call->instruction_address(), relocInfo::opt_virtual_call_type);
       break;
     }
     default:
diff -r 7a0ba9b20fec -r 1b11e3c8529c src/share/vm/graal/graalCodeInstaller.cpp
--- a/src/share/vm/graal/graalCodeInstaller.cpp	Tue Jul 23 17:47:56 2013 +0200
+++ b/src/share/vm/graal/graalCodeInstaller.cpp	Tue Jul 23 17:48:17 2013 +0200
@@ -734,12 +734,9 @@
   
   if (target->is_a(SystemDictionary::HotSpotInstalledCode_klass())) {
     assert(inst->is_jump(), "jump expected");
-
     CodeBlob* cb = (CodeBlob*) (address) HotSpotInstalledCode::codeBlob(target);
     assert(cb != NULL, "npe");
-    
     CodeInstaller::pd_relocate_CodeBlob(cb, inst);
-
     return;
   }
 
@@ -755,7 +752,6 @@
 
   if (foreign_call != NULL) {
     jlong foreign_call_destination = HotSpotForeignCallLinkage::address(foreign_call);
-
     CodeInstaller::pd_relocate_ForeignCall(inst, foreign_call_destination);
   } else { // method != NULL
     assert(hotspot_method != NULL, "unexpected JavaMethod");
@@ -764,7 +760,9 @@
     TRACE_graal_3("method call");
     CodeInstaller::pd_relocate_JavaMethod(hotspot_method, pc_offset);
   }
+
   _next_call_type = MARK_INVOKE_INVALID;
+
   if (debug_info != NULL) {
     _debug_recorder->end_safepoint(next_pc_offset);
   }