# HG changeset patch
# User Morris Meyer <morris.meyer@oracle.com>
# Date 1369406247 14400
# Node ID e723f9031785551473a58ea46936b4e2f11411aa
# Parent  c010c12ab682cd8f29b898103237c1bac55f7871
re-architected SPARC assembler to be Fmt class specific, initial arithmetic

diff -r c010c12ab682 -r e723f9031785 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	Fri May 24 12:02:30 2013 +0200
+++ b/graal/com.oracle.graal.asm.sparc/src/com/oracle/graal/asm/sparc/SPARCAssembler.java	Fri May 24 10:37:27 2013 -0400
@@ -22,14 +22,166 @@
  */
 package com.oracle.graal.asm.sparc;
 
-import com.oracle.graal.api.code.*;
-import com.oracle.graal.sparc.*;
+import com.oracle.graal.api.code.Register;
+import com.oracle.graal.api.code.RegisterConfig;
+import com.oracle.graal.api.code.TargetDescription;
+import com.oracle.graal.api.meta.Kind;
+import com.oracle.graal.hotspot.HotSpotGraalRuntime;
 
 /**
  * This class implements an assembler that can encode most SPARC instructions.
  */
 public class SPARCAssembler extends AbstractSPARCAssembler {
 
+    public static class Fmt1 {
+        public Fmt1(SPARCAssembler masm, int op, int disp30) {
+            assert op == 1;
+            assert ((disp30 & 0xc0000000) == 0);
+
+            masm.emitInt(op << 30 | disp30);
+        }
+    }
+
+    public static class Fmt2a {
+        public Fmt2a(SPARCAssembler masm, int op, int rd, int op2, int imm22) {
+            assert op == 0;
+            assert rd < 0x40;
+            assert op2 < 0x8;
+
+            masm.emitInt(op << 30 | rd << 25 | op2 << 22 | (imm22 & 0x003fffff));
+        }
+    }
+
+    public static class Fmt2b {
+        public Fmt2b(SPARCAssembler masm, int op, int a, int cond, int op2, int disp22) {
+            assert op == 0;
+            assert op == 0;
+            assert cond < 0x10;
+            assert op2 < 0x8;
+
+            masm.emitInt(op << 30 | a << 29 | cond << 25 | op2 << 22 | (disp22 & 0x003fffff));
+        }
+    }
+
+    public static class Fmt2c {
+        public Fmt2c(SPARCAssembler masm, int op, int a, int cond, int op2, int cc, int predict, int disp19) {
+            assert predict < 2;
+            assert op == 0;
+            assert cond < 0x10;
+            assert op2 < 0x8;
+
+            masm.emitInt(op << 30 | a << 29 | cond << 25 | op2 << 22 | cc << 20 | predict | (disp19 & 0x0007ffff));
+        }
+    }
+
+    public static class Fmt2d {
+        public Fmt2d(SPARCAssembler masm, int op, int a, int rcond, int op2, int d16hi, int predict, int rs1, int d16lo) {
+            assert predict == 0 || predict == 1;
+            assert rcond >= 0 && rcond < 0x8;
+            assert op == 0;
+            assert op2 >= 0 && op2 < 0x8;
+            assert rs1 >= 0 && rs1 < 0x20;
+
+            masm.emitInt(op << 30 | a << 29 | rcond << 25 | op2 << 22 | d16hi & 3 | predict << 18 | rs1 << 14 | (d16lo & 0x003fff));
+        }
+    }
+
+    public static class Fmt3a {
+        public Fmt3a(SPARCAssembler masm, int op, int rd, int op3, int rs1, int rs2) {
+            assert  op == 2 || op == 3;
+            assert op3 >= 0 && op3 < 0x40;
+            assert rs1 >= 0 && rs1 < 0x20;
+            assert rs2 >= 0 && rs2 < 0x20;
+            assert  rd >= 0 &&  rd < 0x20;
+
+            masm.emitInt(op << 30 | rd << 25 | op3 << 19 |  rs1 << 14 | rs2);
+        }
+    }
+
+    public static class Fmt3b {
+        public Fmt3b(SPARCAssembler masm, int op, int rd, int op3, int rs1, int simm13) {
+            assert  op == 2 || op == 3;
+            assert op3 >= 0 && op3 < 0x40;
+            assert rs1 >= 0 && rs1 < 0x20;
+            assert  rd >= 0 &&  rd < 0x20;
+
+            masm.emitInt(op << 30 | rd << 25 | op3 << 19 |  rs1 << 14 | (simm13 & 0x1fff));
+        }
+    }
+
+    public static class Fmt3e {
+        public Fmt3e(SPARCAssembler masm, int op, int op3, int rcond, int rs1, int rs2, int rd) {
+            assert  op == 2 || op == 3;
+            assert op3 >= 0 && op3 < 0x40;
+            assert rcond >= 0 && rcond < 0x8;
+            assert rs1 >= 0 && rs1 < 0x20;
+            assert rs2 >= 0 && rs2 < 0x20;
+            assert  rd >= 0 &&  rd < 0x20;
+
+            masm.emitInt(op << 30 | rd << 25 | op3 << 19 |  rs1 << 14 | rcond << 10 | rs2);
+        }
+    }
+
+    public static class Fmt3f {
+        public Fmt3f(SPARCAssembler masm, int op, int op3, int rcond, int rs1, int simm10, int rd) {
+            assert  op == 2 || op == 3;
+            assert op3 >= 0 && op3 < 0x40;
+            assert rs1 >= 0 && rs1 < 0x20;
+            assert  rd >= 0 &&  rd < 0x20;
+
+            masm.emitInt(op << 30 | rd << 25 | op3 << 19 |  rs1 << 14 | rcond << 10 | (simm10 & 0x000003ff));
+        }
+    }
+
+    public static class Fmt3p {
+        public Fmt3p(SPARCAssembler masm, int op, int op3, int opf, int rs1, int rs2, int rd) {
+            assert  op == 2 || op == 3;
+            assert op3 >= 0 && op3 < 0x40;
+            assert opf >= 0 && opf < 0x200;
+            assert rs1 >= 0 && rs1 < 0x20;
+            assert rs2 >= 0 && rs2 < 0x20;
+            assert  rd >= 0 &&  rd < 0x20;
+
+            masm.emitInt(op << 30 | rd << 25 | op3 << 19 |  rs1 << 14 | opf << 5 | rs2);
+        }
+    }
+
+    public static class Fmt3q {
+        public Fmt3q(SPARCAssembler masm, int op, int op3, int rs1, int rd) {
+            assert  op == 2 || op == 3;
+            assert op3 >= 0 && op3 < 0x40;
+            assert rs1 >= 0 && rs1 < 0x20;
+            assert  rd >= 0 &&  rd < 0x20;
+
+            masm.emitInt(op << 30 | rd << 25 | op3 << 19 |  rs1 << 14);
+        }
+    }
+
+    public static class Fmt4c {
+        public Fmt4c(SPARCAssembler masm, int op, int op3, int cond, int cc, int rs2, int rd) {
+            assert op == 2;
+            assert op3 >= 0 && op3 < 0x40;
+            assert  cc >= 0 &&  cc < 0x8;
+            assert cond >= 0 && cond < 0x10;
+            assert rs2 >= 0 && rs2 < 0x20;
+            assert  rd >= 0 &&  rd < 0x20;
+
+            masm.emitInt(op << 30 | rd << 25 | op3 << 19 | ((cc << 15) & 0x00040000) | cond << 14 | ((cc << 11) & 0x3) | rs2);
+        }
+    }
+
+    public static class Fmt4d {
+        public Fmt4d(SPARCAssembler masm, int op, int op3, int cond, int cc, int simm11, int rd) {
+            assert op == 2;
+            assert op3 >= 0 && op3 < 0x40;
+            assert  cc >= 0 &&  cc < 0x8;
+            assert cond >= 0 && cond < 0x10;
+            assert  rd >= 0 &&  rd < 0x20;
+
+            masm.emitInt(op << 30 | rd << 25 | op3 << 19 | ((cc << 15) & 0x00040000) | cond << 14 | ((cc << 11) & 0x3) | simm11 & 0x00004000);
+        }
+    }
+
     public static final int ImmedTrue = 0x00002000;
 
     public enum Ops {
@@ -94,8 +246,31 @@
         Srlx((0x26 << 19) & 0x01F80000, "srlx"),
         Sra((0x27 << 19) & 0x01F80000, "srax"),
         Srax((0x27 << 19) & 0x01F80000, "srax"),
-        Rdreg((0x27 << 19) & 0x01F80000, "rdreg"),
-        Membar((0x27 << 19) & 0x01F80000, "membar");
+        Rdreg((0x28 << 19) & 0x01F80000, "rdreg"),
+        Membar((0x28 << 19) & 0x01F80000, "membar"),
+
+        Flushw((0x2B << 19) & 0x01F80000, "flushw"),
+        Movcc((0x2C << 19) & 0x01F80000, "movcc"),
+        Sdivx((0x2D << 19) & 0x01F80000, "sdivx"),
+        Popc((0x2E << 19) & 0x01F80000, "popc"),
+        Movr((0x2F << 19) & 0x01F80000, "movr"),
+
+        Sir((0x30 << 19) & 0x01F80000, "sir"),
+        Wrreg((0x30 << 19) & 0x01F80000, "wrreg"),
+        Saved((0x31 << 19) & 0x01F80000, "saved"),
+
+        Fpop1((0x34 << 19) & 0x01F80000, "fpop1"),
+        Fpop2((0x35 << 19) & 0x01F80000, "fpop2"),
+        Impdep1((0x36 << 19) & 0x01F80000, "impdep1"),
+        Impdep2((0x37 << 19) & 0x01F80000, "impdep2"),
+        Jmpl((0x38 << 19) & 0x01F80000, "jmpl"),
+        Rett((0x39 << 19) & 0x01F80000, "rett"),
+        Trap((0x3a << 19) & 0x01F80000, "trap"),
+        Flush((0x3b << 19) & 0x01F80000, "flush"),
+        Save((0x3c << 19) & 0x01F80000, "save"),
+        Restore((0x3d << 19) & 0x01F80000, "restore"),
+        Done((0x3e << 19) & 0x01F80000, "done"),
+        Retry((0x3e << 19) & 0x01F80000, "retry");
 
         private final int value;
         private final String operator;
@@ -114,23 +289,189 @@
         }
     }
 
-    @SuppressWarnings("unused")
-    public SPARCAssembler(TargetDescription target) {
-        super(target);
-        // TODO Auto-generated constructor stub
-        SPARC sparc;
+    public enum Opfs {
+        Fadds((0x41 << 5) & 0x00003FE0, "fadds"),
+        Faddd((0x42 << 5) & 0x00003FE0, "faddd"),
+        Faddq((0x43 << 5) & 0x00003FE0, "faddq"),
+        Fsubs((0x45 << 5) & 0x00003FE0, "fsubs"),
+        Fsubd((0x46 << 5) & 0x00003FE0, "fsubd"),
+        Fsubq((0x47 << 5) & 0x00003FE0, "fsubq");
+
+        private final int value;
+        private final String operator;
+
+        private Opfs(int value, String op) {
+            this.value = value;
+            this.operator = op;
+        }
+
+        public int getValue() {
+            return value;
+        }
+
+        public String getOperator() {
+            return operator;
+        }
+    }
+
+    public enum MembarMask {
+        StoreStore(1 << 3, "storestore"),
+        LoadStore(1 << 2, "loadstore"),
+        StoreLoad(1 << 1, "storeload"),
+        LoadLoad(1 << 0, "loadload"),
+        Sync(1 << 6, "sync"),
+        MemIssue(1 << 5, "memissue"),
+        LookAside(1 << 4, "lookaside");
+
+        private final int value;
+        private final String operator;
+
+        private MembarMask(int value, String op) {
+            this.value = value;
+            this.operator = op;
+        }
+
+        public int getValue() {
+            return value | 0x2000;
+        }
+
+        public String getOperator() {
+            return operator;
+        }
+    }
+
+    public enum CC {
+        Icc(4, "icc"),
+        Xcc(6, "xcc"),
+        Ptrcc(HotSpotGraalRuntime.wordKind() == Kind.Long ? Xcc.getValue() : Icc.getValue(), "ptrcc"),
+        Fcc0(0, "fcc0"),
+        Fcc1(1, "fcc1"),
+        Fcc2(2, "fcc2"),
+        Fcc3(3, "fcc3");
+
+        private final int value;
+        private final String operator;
+
+        private CC(int value, String op) {
+            this.value = value;
+            this.operator = op;
+        }
+
+        public int getValue() {
+            return value;
+        }
+
+        public String getOperator() {
+            return operator;
+        }
     }
 
-    public static final int rs1(int val) {
-        return val;
+    public enum Condition {
+        // for FBfcc & FBPfcc instruction
+
+        F_Never(0, "f_never"),
+        F_NotEqual(1, "f_notEqual"),
+        F_NotZero(1, "f_notZero"),
+        F_LessOrGreater(2, "f_lessOrGreater"),
+        F_UnorderedOrLess(3, "f_unorderedOrLess"),
+        F_Less(4, "f_less"),
+        F_UnorderedOrGreater(5, "f_unorderedOrGreater"),
+        F_Greater(6, "f_greater"),
+        F_Unordered(7, "f_unordered"),
+        F_Always(8, "f_always"),
+        F_Equal(9, "f_equal"),
+        F_Zero(9, "f_zero"),
+        F_UnorderedOrEqual(10, "f_unorderedOrEqual"),
+        F_GreaterOrEqual(11, "f_greaterOrEqual"),
+        F_UnorderedGreaterOrEqual(12, "f_unorderedGreaterOrEqual"),
+        F_LessOrEqual(13, "f_lessOrEqual"),
+        F_UnorderedOrLessOrEqual(14, "f_unorderedOrLessOrEqual"),
+        F_Ordered(15, "f_ordered"),
+
+        // for integers
+        Never(0, "never"),
+        Equal(1, "equal"),
+        Zero(1, "zero"),
+        LessEqual(2, "lessEqual"),
+        Less(3, "less"),
+        LessEqualUnsigned(4, "lessEqualUnsigned"),
+        LessUnsigned(5, "lessUnsigned"),
+        CarrySet(5, "carrySet"),
+        Negative(6, "negative"),
+        OverflowSet(7, "overflowSet"),
+        Always(8, "always"),
+        NotEqual(9, "notEqual"),
+        NotZero(9, "notZero"),
+        Greater(10, "greater"),
+        GreaterEqual(11, "greaterEqual"),
+        GreaterUnsigned(12, "greaterUnsigned"),
+        GreaterEqualUnsigned(13, "greaterEqualUnsigned"),
+        CarryClear(13, "carryClear"),
+        Positive(14, "positive"),
+        OverflowClear(15, "overflowClear");
+
+        private final int value;
+        private final String operator;
+
+        private Condition(int value, String op) {
+            this.value = value;
+            this.operator = op;
+        }
+
+        public int getValue() {
+            return value;
+        }
+
+        public String getOperator() {
+            return operator;
+        }
     }
 
-    public static final int rs2(int val) {
-        return val;
+    public enum RCondition {
+        Rc_z(1, "rc_z"),
+        Rc_lez(2, "rc_lez"),
+        Rc_lz(3, "rc_lz"),
+        Rc_nz(5, "rc_nz"),
+        Rc_gz(6, "rc_gz"),
+        Rc_gez(7, "rc_gez"),
+        Rc_last(Rc_gez.getValue(), "rc_last");
+
+        private final int value;
+        private final String operator;
+
+        private RCondition(int value, String op) {
+            this.value = value;
+            this.operator = op;
+        }
+
+        public int getValue() {
+            return value;
+        }
+
+        public String getOperator() {
+            return operator;
+        }
     }
 
-    public static final int rd(int val) {
-        return val;
+    public static int getFloatEncoding(int reg) {
+        assert reg < 32;
+        return reg;
+    }
+
+    public static int getDoubleEncoding(int reg) {
+            assert reg < 64 && ((reg & 1) == 0);
+            // ignore v8 assertion for now
+            return (reg & 0x1e) | ((reg & 0x20) >> 5);
+    }
+
+    public static int getQuadEncoding(int reg) {
+            assert reg < 64 && ((reg & 3) == 0);
+            // ignore v8 assertion for now
+            return (reg & 0x1c) | ((reg & 0x20) >> 5);
+    }
+
+    public SPARCAssembler(TargetDescription target, @SuppressWarnings("unused") RegisterConfig registerConfig) {
+        super(target);
     }
 
     public static final int sx1 = 0x00001000;
@@ -140,372 +481,583 @@
         return x & ((1 << nbits) - 1);
     }
 
-    public final void add(Register src1, Register src2, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Add.getValue() | rs1(src1.encoding()) | rs2(src2.encoding()) | rd(dst.encoding()));
+    private static int fcn(int val) {
+        assert val < 0x20;
+        return (val << 25);
     }
 
-    public final void add(Register src1, int simm13, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Add.getValue() | rs1(src1.encoding()) | ImmedTrue | simm(simm13, 13) | rd(dst.encoding()));
+    public static class Add extends Fmt3b {
+        public Add(SPARCAssembler masm, int simm13, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Add.getValue(), src2.encoding(), simm13);
+        }
+        public Add(SPARCAssembler masm, Register src1, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Add.getValue(), src2.encoding(), src1.encoding());
+        }
+    }
+
+    public static class Addc extends Fmt3b {
+        public Addc(SPARCAssembler masm, int simm13, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Addc.getValue(), src2.encoding(), simm13);
+        }
+        public Addc(SPARCAssembler masm, Register src1, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Addc.getValue(), src2.encoding(), src1.encoding());
+        }
     }
 
-    public final void addcc(Register src1, Register src2, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Addcc.getValue() | rs1(src1.encoding()) | rs2(src2.encoding()) | rd(dst.encoding()));
+    public static class Addcc extends Fmt3b {
+        public Addcc(SPARCAssembler masm, int simm13, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Addcc.getValue(), src2.encoding(), simm13);
+        }
+        public Addcc(SPARCAssembler masm, Register src1, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Addcc.getValue(), src2.encoding(), src1.encoding());
+        }
     }
 
-    public final void addcc(Register src1, int simm13, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Addcc.getValue() | rs1(src1.encoding()) | ImmedTrue | simm(simm13, 13) | rd(dst.encoding()));
+    public static class Addccc extends Fmt3b {
+        public Addccc(SPARCAssembler masm, int simm13, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Addccc.getValue(), src2.encoding(), simm13);
+        }
+        public Addccc(SPARCAssembler masm, Register src1, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Addccc.getValue(), src2.encoding(), src1.encoding());
+        }
     }
 
-    public final void addc(Register src1, Register src2, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Addc.getValue() | rs1(src1.encoding()) | rs2(src2.encoding()) | rd(dst.encoding()));
-    }
-
-    public final void addc(Register src1, int simm13, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Addc.getValue() | rs1(src1.encoding()) | ImmedTrue | simm(simm13, 13) | rd(dst.encoding()));
+    public static class And extends Fmt3b {
+        public And(SPARCAssembler masm, int simm13, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.And.getValue(), src2.encoding(), simm13);
+        }
+        public And(SPARCAssembler masm, Register src1, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.And.getValue(), src2.encoding(), src1.encoding());
+        }
     }
 
-    public final void addccc(Register src1, Register src2, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Addccc.getValue() | rs1(src1.encoding()) | rs2(src2.encoding()) | rd(dst.encoding()));
+    public static class Andcc extends Fmt3b {
+        public Andcc(SPARCAssembler masm, int simm13, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Andcc.getValue(), src2.encoding(), simm13);
+        }
+        public Andcc(SPARCAssembler masm, Register src1, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Andcc.getValue(), src2.encoding(), src1.encoding());
+        }
     }
 
-    public final void addccc(Register src1, int simm13, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Addccc.getValue() | rs1(src1.encoding()) | ImmedTrue | simm(simm13, 13) | rd(dst.encoding()));
-    }
-
-    public final void and(Register src1, Register src2, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.And.getValue() | rs1(src1.encoding()) | rs2(src2.encoding()) | rd(dst.encoding()));
+    public static class Andn extends Fmt3b {
+        public Andn(SPARCAssembler masm, int simm13, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Andn.getValue(), src2.encoding(), simm13);
+        }
+        public Andn(SPARCAssembler masm, Register src1, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Andn.getValue(), src2.encoding(), src1.encoding());
+        }
     }
 
-    public final void and(Register src1, int simm13, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.And.getValue() | rs1(src1.encoding()) | ImmedTrue | simm(simm13, 13) | rd(dst.encoding()));
+    public static class Andncc extends Fmt3b {
+        public Andncc(SPARCAssembler masm, int simm13, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Andncc.getValue(), src2.encoding(), simm13);
+        }
+        public Andncc(SPARCAssembler masm, Register src1, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Andncc.getValue(), src2.encoding(), src1.encoding());
+        }
     }
 
-    public final void andcc(Register src1, Register src2, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Andcc.getValue() | rs1(src1.encoding()) | rs2(src2.encoding()) | rd(dst.encoding()));
+    public static class Fadds extends Fmt3p {
+        public Fadds(SPARCAssembler masm, Register src1, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), Op3s.Fpop1.getValue(), Opfs.Fadds.getValue(),
+                    src1.encoding(), src2.encoding(), dst.encoding());
+        }
     }
 
-    public final void andcc(Register src1, int simm13, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Andcc.getValue() | rs1(src1.encoding()) | ImmedTrue | simm(simm13, 13) | rd(dst.encoding()));
+    public static class Faddd extends Fmt3p {
+        public Faddd(SPARCAssembler masm, Register src1, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), Op3s.Fpop1.getValue(), Opfs.Faddd.getValue(),
+                    src1.encoding(), src2.encoding(), dst.encoding());
+        }
     }
 
-    public final void andn(Register src1, Register src2, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Andn.getValue() | rs1(src1.encoding()) | rs2(src2.encoding()) | rd(dst.encoding()));
+    public static class Faddq extends Fmt3p {
+        public Faddq(SPARCAssembler masm, Register src1, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), Op3s.Fpop1.getValue(), Opfs.Faddq.getValue(),
+                    src1.encoding(), src2.encoding(), dst.encoding());
+        }
     }
 
-    public final void andn(Register src1, int simm13, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Andn.getValue() | rs1(src1.encoding()) | ImmedTrue | simm(simm13, 13) | rd(dst.encoding()));
+    public final void flushw() {
+        emitInt(Ops.ArithOp.getValue() | Op3s.Flushw.getValue());
     }
 
-    public final void andncc(Register src1, Register src2, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Andncc.getValue() | rs1(src1.encoding()) | rs2(src2.encoding()) | rd(dst.encoding()));
+    public static class Fsubs extends Fmt3p {
+        public Fsubs(SPARCAssembler masm, Register src1, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), Op3s.Fpop1.getValue(), Opfs.Fsubs.getValue(),
+                    src1.encoding(), src2.encoding(), dst.encoding());
+        }
     }
 
-    public final void andncc(Register src1, int simm13, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Andncc.getValue() | rs1(src1.encoding()) | ImmedTrue | simm(simm13, 13) | rd(dst.encoding()));
+    public static class Fsubd extends Fmt3p {
+        public Fsubd(SPARCAssembler masm, Register src1, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), Op3s.Fpop1.getValue(), Opfs.Fsubd.getValue(),
+                    src1.encoding(), src2.encoding(), dst.encoding());
+        }
     }
 
-    public final void mulscc(Register src1, Register src2, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Mulscc.getValue() | rs1(src1.encoding()) | rs2(src2.encoding()) | rd(dst.encoding()));
+    public static class Fsubq extends Fmt3p {
+        public Fsubq(SPARCAssembler masm, Register src1, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), Op3s.Fpop1.getValue(), Opfs.Fsubq.getValue(),
+                    src1.encoding(), src2.encoding(), dst.encoding());
+        }
     }
 
-    public final void mulscc(Register src1, int simm13, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Mulscc.getValue() | rs1(src1.encoding()) | ImmedTrue | simm(simm13, 13) | rd(dst.encoding()));
+    public static class Membar extends Fmt3b {
+        public Membar(SPARCAssembler masm, MembarMask mask) {
+            super(masm, Ops.ArithOp.getValue(), 0, Op3s.Membar.getValue(), 0xf, mask.getValue());
+        }
     }
 
-    public final void mulx(Register src1, Register src2, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Mulx.getValue() | rs1(src1.encoding()) | rs2(src2.encoding()) | rd(dst.encoding()));
+    public static class Movcc extends Fmt4c {
+        public Movcc(SPARCAssembler masm, Condition cond, CC cca, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), Op3s.Movcc.getValue(), cond.getValue(), cca.getValue(),
+                  src2.encoding(), dst.encoding());
+        }
+        public Movcc(SPARCAssembler masm, Condition cond, CC cca, int simm11a, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), Op3s.Movcc.getValue(), cond.getValue(), cca.getValue(),
+                  simm11a, dst.encoding());
+        }
     }
 
-    public final void mulx(Register src1, int simm13, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Mulx.getValue() | rs1(src1.encoding()) | ImmedTrue | simm(simm13, 13) | rd(dst.encoding()));
-    }
-
-    public final void or(Register src1, Register src2, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Or.getValue() | rs1(src1.encoding()) | rs2(src2.encoding()) | rd(dst.encoding()));
+    public static class Movr extends Fmt3f {
+        public Movr(SPARCAssembler masm, RCondition rc,  Register src1, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), Op3s.Movr.getValue(), rc.getValue(),
+                  src1.encoding(), src2.encoding(), dst.encoding());
+        }
+        public Movr(SPARCAssembler masm, RCondition rc, Register src1, int simm10, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), Op3s.Movr.getValue(), rc.getValue(),
+                    src1.encoding(), simm10, dst.encoding());
+        }
     }
 
-    public final void or(Register src1, int simm13, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Or.getValue() | rs1(src1.encoding()) | ImmedTrue | simm(simm13, 13) | rd(dst.encoding()));
+    @Deprecated
+    public static class Mulscc extends Fmt3b {
+        @Deprecated
+        public Mulscc(SPARCAssembler masm, int simm13, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Mulscc.getValue(), src2.encoding(), simm13);
+        }
+        @Deprecated
+        public Mulscc(SPARCAssembler masm, Register src1, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Mulscc.getValue(), src2.encoding(), src1.encoding());
+        }
     }
 
-    public final void orcc(Register src1, Register src2, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Orcc.getValue() | rs1(src1.encoding()) | rs2(src2.encoding()) | rd(dst.encoding()));
+    public static class Mulx extends Fmt3b {
+        public Mulx(SPARCAssembler masm, int simm13, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Mulx.getValue(), src2.encoding(), simm13);
+        }
+        public Mulx(SPARCAssembler masm, Register src1, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Mulx.getValue(), src2.encoding(), src1.encoding());
+        }
     }
 
-    public final void orcc(Register src1, int simm13, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Orcc.getValue() | rs1(src1.encoding()) | ImmedTrue | simm(simm13, 13) | rd(dst.encoding()));
+    public static class Or extends Fmt3b {
+        public Or(SPARCAssembler masm, int simm13, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Or.getValue(), src2.encoding(), simm13);
+        }
+        public Or(SPARCAssembler masm, Register src1, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Or.getValue(), src2.encoding(), src1.encoding());
+        }
     }
 
-    public final void orn(Register src1, Register src2, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Orn.getValue() | rs1(src1.encoding()) | rs2(src2.encoding()) | rd(dst.encoding()));
-    }
-
-    public final void orn(Register src1, int simm13, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Orn.getValue() | rs1(src1.encoding()) | ImmedTrue | simm(simm13, 13) | rd(dst.encoding()));
+    public static class Orcc extends Fmt3b {
+        public Orcc(SPARCAssembler masm, int simm13, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Orcc.getValue(), src2.encoding(), simm13);
+        }
+        public Orcc(SPARCAssembler masm, Register src1, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Orcc.getValue(), src2.encoding(), src1.encoding());
+        }
     }
 
-    public final void orncc(Register src1, Register src2, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Orncc.getValue() | rs1(src1.encoding()) | rs2(src2.encoding()) | rd(dst.encoding()));
+    public static class Orn extends Fmt3b {
+        public Orn(SPARCAssembler masm, int simm13, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Orn.getValue(), src2.encoding(), simm13);
+        }
+        public Orn(SPARCAssembler masm, Register src1, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Orn.getValue(), src2.encoding(), src1.encoding());
+        }
     }
 
-    public final void orncc(Register src1, int simm13, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Orncc.getValue() | rs1(src1.encoding()) | ImmedTrue | simm(simm13, 13) | rd(dst.encoding()));
+    public static class Orncc extends Fmt3b {
+        public Orncc(SPARCAssembler masm, int simm13, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Orncc.getValue(), src2.encoding(), simm13);
+        }
+        public Orncc(SPARCAssembler masm, Register src1, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Orncc.getValue(), src2.encoding(), src1.encoding());
+        }
     }
 
-    public final void rdy(Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Rdreg.getValue() | rd(dst.encoding()));
+    public static class Popc extends Fmt3b {
+        public Popc(SPARCAssembler masm, int simm13, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Popc.getValue(), 0, simm13);
+        }
+        public Popc(SPARCAssembler masm, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Popc.getValue(), 0, src2.encoding());
+        }
     }
 
     // A.44 Read State Register
 
-    public final void rdccr(Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Rdreg.getValue() | rd(dst.encoding()) | 0x00008000);
+    @Deprecated
+    public static class Rdy extends Fmt3q {
+        public Rdy(SPARCAssembler masm, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), Op3s.Rdreg.getValue(), 0, dst.encoding());
+        }
     }
 
-    public final void rdasi(Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Rdreg.getValue() | rd(dst.encoding()) | 0x0000C000);
+    public static class Rdccr extends Fmt3q {
+        public Rdccr(SPARCAssembler masm, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), Op3s.Rdreg.getValue(), 2, dst.encoding());
+        }
+    }
+
+    public static class Rdasi extends Fmt3q {
+        public Rdasi(SPARCAssembler masm, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), Op3s.Rdreg.getValue(), 3, dst.encoding());
+        }
+    }
+
+    public static class Rdtick extends Fmt3q {
+        public Rdtick(SPARCAssembler masm, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), Op3s.Rdreg.getValue(), 4, dst.encoding());
+        }
     }
 
-    public final void rdtick(Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Rdreg.getValue() | rd(dst.encoding()) | 0x00010000);
+    public static class Rdpc extends Fmt3q {
+        public Rdpc(SPARCAssembler masm, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), Op3s.Rdreg.getValue(), 5, dst.encoding());
+        }
+    }
+
+    public static class Rdfprs extends Fmt3q {
+        public Rdfprs(SPARCAssembler masm, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), Op3s.Rdreg.getValue(), 6, dst.encoding());
+        }
     }
 
-    public final void rdpc(Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Rdreg.getValue() | rd(dst.encoding()) | 0x00014000);
+    public final void restored() {
+        emitInt(Ops.ArithOp.getValue() | Op3s.Saved.getValue() | fcn(1));
+    }
+
+    public final void saved() {
+        emitInt(Ops.ArithOp.getValue() | Op3s.Saved.getValue() | fcn(0));
     }
 
-    public final void rdfprs(Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Rdreg.getValue() | rd(dst.encoding()) | 0x00018000);
+    @Deprecated
+    public static class Sdiv extends Fmt3b {
+        @Deprecated
+        public Sdiv(SPARCAssembler masm, int simm13, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Sdiv.getValue(), src2.encoding(), simm13);
+        }
+        @Deprecated
+        public Sdiv(SPARCAssembler masm, Register src1, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Sdiv.getValue(), src2.encoding(), src1.encoding());
+        }
     }
 
     @Deprecated
-    public final void sdiv(Register src1, Register src2, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Sdiv.getValue() | rs1(src1.encoding()) | rs2(src2.encoding()) | rd(dst.encoding()));
+    public static class Sdivcc extends Fmt3b {
+        @Deprecated
+        public Sdivcc(SPARCAssembler masm, int simm13, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Sdivcc.getValue(), src2.encoding(), simm13);
+        }
+        @Deprecated
+        public Sdivcc(SPARCAssembler masm, Register src1, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Sdivcc.getValue(), src2.encoding(), src1.encoding());
+        }
+    }
+
+    public static class Sdivx extends Fmt3b {
+        public Sdivx(SPARCAssembler masm, int simm13, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Sdivx.getValue(), src2.encoding(), simm13);
+        }
+        public Sdivx(SPARCAssembler masm, Register src1, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Sdivx.getValue(), src2.encoding(), src1.encoding());
+        }
+    }
+
+    public final void sir(int simm13a) {
+        emitInt(Ops.ArithOp.getValue() | Op3s.Sir.getValue() | ImmedTrue | simm(simm13a, 13));
+    }
+
+    public static class Sll extends Fmt3b {
+        public Sll(SPARCAssembler masm, int simm13, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Sll.getValue(), src2.encoding(), simm13);
+        }
+        public Sll(SPARCAssembler masm, Register src1, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Sll.getValue(), src2.encoding(), src1.encoding());
+        }
+    }
+
+    public static class Sllx extends Fmt3b {
+        public Sllx(SPARCAssembler masm, int simm13, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Sllx.getValue(), src2.encoding(), simm13);
+        }
+        public Sllx(SPARCAssembler masm, Register src1, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Sllx.getValue(), src2.encoding(), src1.encoding());
+        }
+    }
+
+    public static class Smul extends Fmt3b {
+        public Smul(SPARCAssembler masm, int simm13, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Smul.getValue(), src2.encoding(), simm13);
+        }
+        public Smul(SPARCAssembler masm, Register src1, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Smul.getValue(), src2.encoding(), src1.encoding());
+        }
     }
 
     @Deprecated
-    public final void sdiv(Register src1, int simm13, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Sdiv.getValue() | rs1(src1.encoding()) | ImmedTrue | simm(simm13, 13) | rd(dst.encoding()));
+    public static class Smulcc extends Fmt3b {
+        public Smulcc(SPARCAssembler masm, int simm13, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Smulcc.getValue(), src2.encoding(), simm13);
+        }
+        public Smulcc(SPARCAssembler masm, Register src1, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Smulcc.getValue(), src2.encoding(), src1.encoding());
+        }
+    }
+
+    public static class Sra extends Fmt3b {
+        public Sra(SPARCAssembler masm, int simm13, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Sra.getValue(), src2.encoding(), simm13);
+        }
+        public Sra(SPARCAssembler masm, Register src1, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Sra.getValue(), src2.encoding(), src1.encoding());
+        }
     }
 
-    @Deprecated
-    public final void sdivcc(Register src1, Register src2, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Sdivcc.getValue() | rs1(src1.encoding()) | rs2(src2.encoding()) | rd(dst.encoding()));
+    public static class Srax extends Fmt3b {
+        public Srax(SPARCAssembler masm, int simm13, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Srax.getValue(), src2.encoding(), simm13);
+        }
+        public Srax(SPARCAssembler masm, Register src1, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Srax.getValue(), src2.encoding(), src1.encoding());
+        }
+    }
+
+    public static class Srl extends Fmt3b {
+        public Srl(SPARCAssembler masm, int simm13, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Srl.getValue(), src2.encoding(), simm13);
+        }
+        public Srl(SPARCAssembler masm, Register src1, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Srl.getValue(), src2.encoding(), src1.encoding());
+        }
+    }
+
+    public static class Srlx extends Fmt3b {
+        public Srlx(SPARCAssembler masm, int simm13, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Srlx.getValue(), src2.encoding(), simm13);
+        }
+        public Srlx(SPARCAssembler masm, Register src1, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Srlx.getValue(), src2.encoding(), src1.encoding());
+        }
     }
 
     @Deprecated
-    public final void sdivcc(Register src1, int simm13, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Sdivcc.getValue() | rs1(src1.encoding()) | ImmedTrue | simm(simm13, 13) | rd(dst.encoding()));
-    }
-
-    public final void sll(Register src1, Register src2, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Sll.getValue() | rs1(src1.encoding()) | rs2(src2.encoding()) | rd(dst.encoding()));
-    }
-
-    public final void sll(Register src1, int imm5a, Register dst) {
-        assert imm5a < 0x40;
-        emitInt(Ops.ArithOp.getValue() | Op3s.Sll.getValue() | rs1(src1.encoding()) | ImmedTrue | imm5a | rd(dst.encoding()));
+    public final void stbar() {
+        emitInt(Ops.ArithOp.getValue() | Op3s.Membar.getValue() | 0x0003C000);
     }
 
-    public final void sllx(Register src1, Register src2, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Sllx.getValue() | sx1 | rs1(src1.encoding()) | rs2(src2.encoding()) | rd(dst.encoding()));
-    }
-
-    public final void sllx(Register src1, int imm5a, Register dst) {
-        assert imm5a < 0x40;
-        emitInt(Ops.ArithOp.getValue() | Op3s.Sllx.getValue() | sx1 | rs1(src1.encoding()) | ImmedTrue | imm5a | rd(dst.encoding()));
-    }
-
-    public final void smul(Register src1, Register src2, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Smul.getValue() | rs1(src1.encoding()) | rs2(src2.encoding()) | rd(dst.encoding()));
-    }
-
-    public final void smul(Register src1, int simm13, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Smul.getValue() | rs1(src1.encoding()) | ImmedTrue | simm(simm13, 13) | rd(dst.encoding()));
+    public static class Sub extends Fmt3b {
+        public Sub(SPARCAssembler masm, int simm13, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Sub.getValue(), src2.encoding(), simm13);
+        }
+        public Sub(SPARCAssembler masm, Register src1, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Sub.getValue(), src2.encoding(), src1.encoding());
+        }
     }
 
-    public final void smulcc(Register src1, Register src2, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Smulcc.getValue() | rs1(src1.encoding()) | rs2(src2.encoding()) | rd(dst.encoding()));
-    }
-
-    public final void smulcc(Register src1, int simm13, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Smulcc.getValue() | rs1(src1.encoding()) | ImmedTrue | simm(simm13, 13) | rd(dst.encoding()));
-    }
-
-    public final void sra(Register src1, Register src2, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Sra.getValue() | rs1(src1.encoding()) | rs2(src2.encoding()) | rd(dst.encoding()));
-    }
-
-    public final void sra(Register src1, int imm5a, Register dst) {
-        assert imm5a < 0x40;
-        emitInt(Ops.ArithOp.getValue() | Op3s.Sra.getValue() | rs1(src1.encoding()) | ImmedTrue | imm5a | rd(dst.encoding()));
+    public static class Subc extends Fmt3b {
+        public Subc(SPARCAssembler masm, int simm13, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Subc.getValue(), src2.encoding(), simm13);
+        }
+        public Subc(SPARCAssembler masm, Register src1, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Subc.getValue(), src2.encoding(), src1.encoding());
+        }
     }
 
-    public final void srax(Register src1, Register src2, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Srax.getValue() | sx1 | rs1(src1.encoding()) | rs2(src2.encoding()) | rd(dst.encoding()));
+    public static class Subcc extends Fmt3b {
+        public Subcc(SPARCAssembler masm, int simm13, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Subcc.getValue(), src2.encoding(), simm13);
+        }
+        public Subcc(SPARCAssembler masm, Register src1, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Subcc.getValue(), src2.encoding(), src1.encoding());
+        }
     }
 
-    public final void srax(Register src1, int imm5a, Register dst) {
-        assert imm5a < 0x40;
-        emitInt(Ops.ArithOp.getValue() | Op3s.Srax.getValue() | sx1 | rs1(src1.encoding()) | ImmedTrue | imm5a | rd(dst.encoding()));
-    }
-
-    public final void srl(Register src1, Register src2, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Srl.getValue() | rs1(src1.encoding()) | rs2(src2.encoding()) | rd(dst.encoding()));
-    }
-
-    public final void srl(Register src1, int imm5a, Register dst) {
-        assert imm5a < 0x40;
-        emitInt(Ops.ArithOp.getValue() | Op3s.Srl.getValue() | rs1(src1.encoding()) | ImmedTrue | imm5a | rd(dst.encoding()));
+    public static class Subccc extends Fmt3b {
+        public Subccc(SPARCAssembler masm, int simm13, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Subccc.getValue(), src2.encoding(), simm13);
+        }
+        public Subccc(SPARCAssembler masm, Register src1, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Subccc.getValue(), src2.encoding(), src1.encoding());
+        }
     }
 
-    public final void srlx(Register src1, Register src2, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Srlx.getValue() | sx1 | rs1(src1.encoding()) | rs2(src2.encoding()) | rd(dst.encoding()));
-    }
-
-    public final void srlx(Register src1, int imm5a, Register dst) {
-        assert imm5a < 0x40;
-        emitInt(Ops.ArithOp.getValue() | Op3s.Srlx.getValue() | sx1 | rs1(src1.encoding()) | ImmedTrue | imm5a | rd(dst.encoding()));
-    }
-
-    public final void sub(Register src1, Register src2, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Sub.getValue() | rs1(src1.encoding()) | rs2(src2.encoding()) | rd(dst.encoding()));
-    }
-
-    public final void sub(Register src1, int simm13, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Sub.getValue() | rs1(src1.encoding()) | ImmedTrue | simm(simm13, 13) | rd(dst.encoding()));
-    }
-
-    public final void subcc(Register src1, Register src2, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Subcc.getValue() | rs1(src1.encoding()) | rs2(src2.encoding()) | rd(dst.encoding()));
-    }
-
-    public final void subcc(Register src1, int simm13, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Subcc.getValue() | rs1(src1.encoding()) | ImmedTrue | simm(simm13, 13) | rd(dst.encoding()));
-    }
-
-    public final void subc(Register src1, Register src2, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Subc.getValue() | rs1(src1.encoding()) | rs2(src2.encoding()) | rd(dst.encoding()));
-    }
-
-    public final void subc(Register src1, int simm13, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Subc.getValue() | rs1(src1.encoding()) | ImmedTrue | simm(simm13, 13) | rd(dst.encoding()));
+    public static class Taddcc extends Fmt3b {
+        public Taddcc(SPARCAssembler masm, int simm13, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Taddcc.getValue(), src2.encoding(), simm13);
+        }
+        public Taddcc(SPARCAssembler masm, Register src1, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Taddcc.getValue(), src2.encoding(), src1.encoding());
+        }
     }
 
-    public final void subccc(Register src1, Register src2, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Subccc.getValue() | rs1(src1.encoding()) | rs2(src2.encoding()) | rd(dst.encoding()));
-    }
-
-    public final void subccc(Register src1, int simm13, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Subccc.getValue() | rs1(src1.encoding()) | ImmedTrue | simm(simm13, 13) | rd(dst.encoding()));
-    }
-
-    public final void taddcc(Register src1, Register src2, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Taddcc.getValue() | rs1(src1.encoding()) | rs2(src2.encoding()) | rd(dst.encoding()));
-    }
-
-    public final void taddcc(Register src1, int simm13, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Taddcc.getValue() | rs1(src1.encoding()) | ImmedTrue | simm(simm13, 13) | rd(dst.encoding()));
+    @Deprecated
+    public static class Taddcctv extends Fmt3b {
+        @Deprecated
+        public Taddcctv(SPARCAssembler masm, int simm13, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Taddcctv.getValue(), src2.encoding(), simm13);
+        }
+        @Deprecated
+        public Taddcctv(SPARCAssembler masm, Register src1, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Taddcctv.getValue(), src2.encoding(), src1.encoding());
+        }
     }
 
-    public final void taddcctv(Register src1, Register src2, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Taddcctv.getValue() | rs1(src1.encoding()) | rs2(src2.encoding()) | rd(dst.encoding()));
-    }
-
-    public final void taddcctv(Register src1, int simm13, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Taddcctv.getValue() | rs1(src1.encoding()) | ImmedTrue | simm(simm13, 13) | rd(dst.encoding()));
+    public static class Tsubcc extends Fmt3b {
+        public Tsubcc(SPARCAssembler masm, int simm13, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Tsubcc.getValue(), src2.encoding(), simm13);
+        }
+        public Tsubcc(SPARCAssembler masm, Register src1, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Tsubcc.getValue(), src2.encoding(), src1.encoding());
+        }
     }
 
-    public final void tsubcc(Register src1, Register src2, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Tsubcc.getValue() | rs1(src1.encoding()) | rs2(src2.encoding()) | rd(dst.encoding()));
-    }
-
-    public final void tsubcc(Register src1, int simm13, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Tsubcc.getValue() | rs1(src1.encoding()) | ImmedTrue | simm(simm13, 13) | rd(dst.encoding()));
-    }
-
-    public final void tsubcctv(Register src1, Register src2, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Tsubcctv.getValue() | rs1(src1.encoding()) | rs2(src2.encoding()) | rd(dst.encoding()));
-    }
-
-    public final void tsubcctv(Register src1, int simm13, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Tsubcctv.getValue() | rs1(src1.encoding()) | ImmedTrue | simm(simm13, 13) | rd(dst.encoding()));
+    @Deprecated
+    public static class Tsubcctv extends Fmt3b {
+        @Deprecated
+        public Tsubcctv(SPARCAssembler masm, int simm13, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Tsubcctv.getValue(), src2.encoding(), simm13);
+        }
+        @Deprecated
+        public Tsubcctv(SPARCAssembler masm, Register src1, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Tsubcctv.getValue(), src2.encoding(), src1.encoding());
+        }
     }
 
     @Deprecated
-    public final void udiv(Register src1, Register src2, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Udiv.getValue() | rs1(src1.encoding()) | rs2(src2.encoding()) | rd(dst.encoding()));
+    public static class Udiv extends Fmt3b {
+        @Deprecated
+        public Udiv(SPARCAssembler masm, int simm13, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Udiv.getValue(), src2.encoding(), simm13);
+        }
+        @Deprecated
+        public Udiv(SPARCAssembler masm, Register src1, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Udiv.getValue(), src2.encoding(), src1.encoding());
+        }
+    }
+
+    public static class Udivcc extends Fmt3b {
+        public Udivcc(SPARCAssembler masm, int simm13, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Udivcc.getValue(), src2.encoding(), simm13);
+        }
+        public Udivcc(SPARCAssembler masm, Register src1, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Udivcc.getValue(), src2.encoding(), src1.encoding());
+        }
     }
 
-    @Deprecated
-    public final void udiv(Register src1, int simm13, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Udiv.getValue() | rs1(src1.encoding()) | ImmedTrue | simm(simm13, 13) | rd(dst.encoding()));
+    public static class Udivx extends Fmt3b {
+        public Udivx(SPARCAssembler masm, int simm13, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Udivx.getValue(), src2.encoding(), simm13);
+        }
+        public Udivx(SPARCAssembler masm, Register src1, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Udivx.getValue(), src2.encoding(), src1.encoding());
+        }
     }
 
-    @Deprecated
-    public final void udivcc(Register src1, Register src2, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Udivcc.getValue() | rs1(src1.encoding()) | rs2(src2.encoding()) | rd(dst.encoding()));
+    public static class Umul extends Fmt3b {
+        public Umul(SPARCAssembler masm, int simm13, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Umul.getValue(), src2.encoding(), simm13);
+        }
+        public Umul(SPARCAssembler masm, Register src1, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Umul.getValue(), src2.encoding(), src1.encoding());
+        }
+    }
+
+    public static class Umulcc extends Fmt3b {
+        public Umulcc(SPARCAssembler masm, int simm13, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Umulcc.getValue(), src2.encoding(), simm13);
+        }
+        public Umulcc(SPARCAssembler masm, Register src1, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Umulcc.getValue(), src2.encoding(), src1.encoding());
+        }
     }
 
     @Deprecated
-    public final void udivcc(Register src1, int simm13, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Udivcc.getValue() | rs1(src1.encoding()) | ImmedTrue | simm(simm13, 13) | rd(dst.encoding()));
-    }
-
-    public final void udivx(Register src1, Register src2, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Udivx.getValue() | rs1(src1.encoding()) | rs2(src2.encoding()) | rd(dst.encoding()));
-    }
-
-    public final void udivx(Register src1, int simm13, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Udivx.getValue() | rs1(src1.encoding()) | ImmedTrue | simm(simm13, 13) | rd(dst.encoding()));
+    public static class Wry extends Fmt3b {
+        @Deprecated
+        public Wry(SPARCAssembler masm, int simm13, Register src2) {
+            super(masm, Ops.ArithOp.getValue(), 0, Op3s.Wrreg.getValue(), src2.encoding(), simm13);
+        }
+        @Deprecated
+        public Wry(SPARCAssembler masm, Register src1, Register src2) {
+            super(masm, Ops.ArithOp.getValue(), 0, Op3s.Wrreg.getValue(), src2.encoding(), src1.encoding());
+        }
     }
 
-    public final void umul(Register src1, Register src2, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Umul.getValue() | rs1(src1.encoding()) | rs2(src2.encoding()) | rd(dst.encoding()));
+    public static class Wrccr extends Fmt3b {
+        public Wrccr(SPARCAssembler masm, int simm13, Register src2) {
+            super(masm, Ops.ArithOp.getValue(), 2, Op3s.Wrreg.getValue(), src2.encoding(), simm13);
+        }
+        public Wrccr(SPARCAssembler masm, Register src1, Register src2) {
+            super(masm, Ops.ArithOp.getValue(), 2, Op3s.Wrreg.getValue(), src2.encoding(), src1.encoding());
+        }
     }
 
-    public final void umul(Register src1, int simm13, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Umul.getValue() | rs1(src1.encoding()) | ImmedTrue | simm(simm13, 13) | rd(dst.encoding()));
-    }
-
-    public final void umulcc(Register src1, Register src2, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Umulcc.getValue() | rs1(src1.encoding()) | rs2(src2.encoding()) | rd(dst.encoding()));
-    }
-
-    public final void umulcc(Register src1, int simm13, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Umulcc.getValue() | rs1(src1.encoding()) | ImmedTrue | simm(simm13, 13) | rd(dst.encoding()));
+    public static class Wrasi extends Fmt3b {
+        public Wrasi(SPARCAssembler masm, int simm13, Register src2) {
+            super(masm, Ops.ArithOp.getValue(), 3, Op3s.Wrreg.getValue(), src2.encoding(), simm13);
+        }
+        public Wrasi(SPARCAssembler masm, Register src1, Register src2) {
+            super(masm, Ops.ArithOp.getValue(), 3, Op3s.Wrreg.getValue(), src2.encoding(), src1.encoding());
+        }
     }
 
-    public final void xor(Register src1, Register src2, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Xor.getValue() | rs1(src1.encoding()) | rs2(src2.encoding()) | rd(dst.encoding()));
+    public static class Wrfprs extends Fmt3b {
+        public Wrfprs(SPARCAssembler masm, int simm13, Register src2) {
+            super(masm, Ops.ArithOp.getValue(), 6, Op3s.Wrreg.getValue(), src2.encoding(), simm13);
+        }
+        public Wrfprs(SPARCAssembler masm, Register src1, Register src2) {
+            super(masm, Ops.ArithOp.getValue(), 6, Op3s.Wrreg.getValue(), src2.encoding(), src1.encoding());
+        }
     }
 
-    public final void xor(Register src1, int simm13, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Xor.getValue() | rs1(src1.encoding()) | ImmedTrue | simm(simm13, 13) | rd(dst.encoding()));
-    }
-
-    public final void xorcc(Register src1, Register src2, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Xorcc.getValue() | rs1(src1.encoding()) | rs2(src2.encoding()) | rd(dst.encoding()));
-    }
-
-    public final void xorcc(Register src1, int simm13, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Xorcc.getValue() | rs1(src1.encoding()) | ImmedTrue | simm(simm13, 13) | rd(dst.encoding()));
+    public static class Xor extends Fmt3b {
+        public Xor(SPARCAssembler masm, int simm13, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Xor.getValue(), src2.encoding(), simm13);
+        }
+        public Xor(SPARCAssembler masm, Register src1, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Xor.getValue(), src2.encoding(), src1.encoding());
+        }
     }
 
-    public final void xnor(Register src1, Register src2, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Xnor.getValue() | rs1(src1.encoding()) | rs2(src2.encoding()) | rd(dst.encoding()));
-    }
-
-    public final void xnor(Register src1, int simm13, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Xnor.getValue() | rs1(src1.encoding()) | ImmedTrue | simm(simm13, 13) | rd(dst.encoding()));
+    public static class Xorcc extends Fmt3b {
+        public Xorcc(SPARCAssembler masm, int simm13, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Xorcc.getValue(), src2.encoding(), simm13);
+        }
+        public Xorcc(SPARCAssembler masm, Register src1, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Xorcc.getValue(), src2.encoding(), src1.encoding());
+        }
     }
 
-    public final void xnorcc(Register src1, Register src2, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Xnorcc.getValue() | rs1(src1.encoding()) | rs2(src2.encoding()) | rd(dst.encoding()));
+    public static class Xnor extends Fmt3b {
+        public Xnor(SPARCAssembler masm, int simm13, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Xnor.getValue(), src2.encoding(), simm13);
+        }
+        public Xnor(SPARCAssembler masm, Register src1, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Xnor.getValue(), src2.encoding(), src1.encoding());
+        }
     }
 
-    public final void xnorcc(Register src1, int simm13, Register dst) {
-        emitInt(Ops.ArithOp.getValue() | Op3s.Xnorcc.getValue() | rs1(src1.encoding()) | ImmedTrue | simm(simm13, 13) | rd(dst.encoding()));
+    public static class Xnorcc extends Fmt3b {
+        public Xnorcc(SPARCAssembler masm, int simm13, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Xnorcc.getValue(), src2.encoding(), simm13);
+        }
+        public Xnorcc(SPARCAssembler masm, Register src1, Register src2, Register dst) {
+            super(masm, Ops.ArithOp.getValue(), dst.encoding(), Op3s.Xnorcc.getValue(), src2.encoding(), src1.encoding());
+        }
     }
-
 }
diff -r c010c12ab682 -r e723f9031785 graal/com.oracle.graal.compiler.sparc.test/src/com/oracle/graal/compiler/sparc/test/BasicSPARCTest.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.compiler.sparc.test/src/com/oracle/graal/compiler/sparc/test/BasicSPARCTest.java	Fri May 24 10:37:27 2013 -0400
@@ -0,0 +1,53 @@
+/*
+ * 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.compiler.sparc.test;
+
+import java.lang.reflect.Method;
+
+import org.junit.Test;
+
+
+public class BasicSPARCTest extends SPARCTestBase {
+
+    @Test
+    public void testAdd() {
+        compile("testAddConst1I");
+    }
+
+    public int testAddConst1I(int a) {
+        return a + 1;
+    }
+
+    public static void main(String[] args) {
+        BasicSPARCTest test = new BasicSPARCTest();
+        Method[] methods = BasicSPARCTest.class.getMethods();
+        for (Method m : methods) {
+            String name = m.getName();
+            if (m.getAnnotation(Test.class) == null && name.startsWith("test")) {
+                // CheckStyle: stop system..print check
+                System.out.println(name + ": \n" + new String(test.compile(name).getTargetCode()));
+                // CheckStyle: resume system..print check
+            }
+        }
+    }
+}
diff -r c010c12ab682 -r e723f9031785 graal/com.oracle.graal.compiler.sparc.test/src/com/oracle/graal/compiler/sparc/test/SPARCTestBase.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.compiler.sparc.test/src/com/oracle/graal/compiler/sparc/test/SPARCTestBase.java	Fri May 24 10:37:27 2013 -0400
@@ -0,0 +1,69 @@
+/*
+ * 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.compiler.sparc.test;
+
+import static com.oracle.graal.api.code.CodeUtil.*;
+import static com.oracle.graal.hotspot.HotSpotGraalRuntime.*;
+
+import com.oracle.graal.api.code.*;
+import com.oracle.graal.api.code.CallingConvention.*;
+import com.oracle.graal.api.runtime.Graal;
+import com.oracle.graal.compiler.GraalCompiler;
+import com.oracle.graal.compiler.sparc.SPARCBackend;
+import com.oracle.graal.compiler.test.GraalCompilerTest;
+import com.oracle.graal.debug.Debug;
+import com.oracle.graal.java.GraphBuilderConfiguration;
+import com.oracle.graal.java.GraphBuilderPhase;
+import com.oracle.graal.nodes.StructuredGraph;
+import com.oracle.graal.nodes.spi.GraalCodeCacheProvider;
+import com.oracle.graal.phases.OptimisticOptimizations;
+import com.oracle.graal.phases.PhasePlan;
+import com.oracle.graal.phases.PhasePlan.PhasePosition;
+import com.oracle.graal.sparc.SPARC;
+
+public abstract class SPARCTestBase extends GraalCompilerTest {
+
+    private StructuredGraph sg;
+
+    protected CompilationResult compile(String test) {
+        StructuredGraph graph = parse(test);
+        sg = graph;
+        Debug.dump(graph, "Graph");
+        TargetDescription target = new TargetDescription(new SPARC(), true, 1, 0, true);
+        SPARCBackend sparcBackend = new SPARCBackend(Graal.getRequiredCapability(GraalCodeCacheProvider.class), target);
+        PhasePlan phasePlan = new PhasePlan();
+        GraphBuilderPhase graphBuilderPhase = new GraphBuilderPhase(runtime, GraphBuilderConfiguration.getDefault(), OptimisticOptimizations.NONE);
+        phasePlan.addPhase(PhasePosition.AFTER_PARSING, graphBuilderPhase);
+        CallingConvention cc = getCallingConvention(runtime, Type.JavaCallee, graph.method(), false);
+        CompilationResult result = GraalCompiler.compileGraph(graph, cc, graph.method(), runtime, graalRuntime().getReplacements(),
+                                                              sparcBackend, target, null, phasePlan, OptimisticOptimizations.NONE,
+                                                              new SpeculationLog());
+        return result;
+    }
+
+    protected StructuredGraph getStructuredGraph() {
+        return sg;
+    }
+
+}
+
diff -r c010c12ab682 -r e723f9031785 graal/com.oracle.graal.compiler.sparc/src/com/oracle/graal/compiler/sparc/SPARCBackend.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.compiler.sparc/src/com/oracle/graal/compiler/sparc/SPARCBackend.java	Fri May 24 10:37:27 2013 -0400
@@ -0,0 +1,85 @@
+/*
+ * 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.compiler.sparc;
+
+import com.oracle.graal.api.code.CallingConvention;
+import com.oracle.graal.api.code.CodeCacheProvider;
+import com.oracle.graal.api.code.CompilationResult;
+import com.oracle.graal.api.code.TargetDescription;
+import com.oracle.graal.api.meta.ResolvedJavaMethod;
+import com.oracle.graal.asm.AbstractAssembler;
+import com.oracle.graal.asm.sparc.SPARCAssembler;
+import com.oracle.graal.compiler.gen.LIRGenerator;
+import com.oracle.graal.compiler.target.Backend;
+import com.oracle.graal.lir.FrameMap;
+import com.oracle.graal.lir.LIR;
+import com.oracle.graal.lir.asm.FrameContext;
+import com.oracle.graal.lir.asm.TargetMethodAssembler;
+import com.oracle.graal.nodes.StructuredGraph;
+
+public class SPARCBackend extends Backend {
+
+    public SPARCBackend(CodeCacheProvider runtime, TargetDescription target) {
+        super(runtime, target);
+    }
+
+    @Override
+    public LIRGenerator newLIRGenerator(StructuredGraph graph, FrameMap frameMap, CallingConvention cc, LIR lir) {
+        return new SPARCLIRGenerator(graph, runtime(), target, frameMap, cc, lir);
+    }
+
+    @Override
+    protected AbstractAssembler createAssembler(FrameMap frameMap) {
+        return new SPARCAssembler(target, frameMap.registerConfig);
+    }
+
+    class HotSpotFrameContext implements FrameContext {
+
+        @Override
+        public void enter(TargetMethodAssembler tasm) {
+        }
+
+        @Override
+        public void leave(TargetMethodAssembler tasm) {
+        }
+    }
+    @Override
+    public TargetMethodAssembler newAssembler(LIRGenerator lirGen, CompilationResult compilationResult) {
+        FrameMap frameMap = lirGen.frameMap;
+        AbstractAssembler masm = createAssembler(frameMap);
+        HotSpotFrameContext frameContext = new HotSpotFrameContext();
+        TargetMethodAssembler tasm = new TargetMethodAssembler(target, runtime(), frameMap, masm, frameContext, compilationResult);
+        tasm.setFrameSize(frameMap.frameSize());
+        return tasm;
+    }
+
+    @Override
+    public void emitCode(TargetMethodAssembler tasm, LIRGenerator lirGen, ResolvedJavaMethod installedCodeOwner) {
+
+        // Emit code for the LIR
+        lirGen.lir.emitCode(tasm);
+
+    }
+
+
+}
diff -r c010c12ab682 -r e723f9031785 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	Fri May 24 12:02:30 2013 +0200
+++ b/graal/com.oracle.graal.compiler.sparc/src/com/oracle/graal/compiler/sparc/SPARCLIRGenerator.java	Fri May 24 10:37:27 2013 -0400
@@ -23,30 +23,88 @@
 
 package com.oracle.graal.compiler.sparc;
 
-import com.oracle.graal.api.code.*;
-import com.oracle.graal.api.meta.*;
-import com.oracle.graal.compiler.gen.*;
-import com.oracle.graal.lir.*;
-import com.oracle.graal.lir.sparc.*;
-import com.oracle.graal.nodes.*;
-import com.oracle.graal.nodes.calc.*;
+import static com.oracle.graal.api.code.ValueUtil.isRegister;
+import static com.oracle.graal.api.code.ValueUtil.isStackSlot;
+import static com.oracle.graal.lir.sparc.SPARCArithmetic.DADD;
+import static com.oracle.graal.lir.sparc.SPARCArithmetic.FADD;
+import static com.oracle.graal.lir.sparc.SPARCArithmetic.IADD;
+import static com.oracle.graal.lir.sparc.SPARCArithmetic.LADD;
+
+import com.oracle.graal.api.code.CallingConvention;
+import com.oracle.graal.api.code.CodeCacheProvider;
+import com.oracle.graal.api.code.DeoptimizationAction;
+import com.oracle.graal.api.code.ForeignCallLinkage;
+import com.oracle.graal.api.code.StackSlot;
+import com.oracle.graal.api.code.TargetDescription;
+import com.oracle.graal.api.meta.AllocatableValue;
+import com.oracle.graal.api.meta.Constant;
+import com.oracle.graal.api.meta.Kind;
+import com.oracle.graal.api.meta.Value;
+import com.oracle.graal.compiler.gen.LIRGenerator;
+import com.oracle.graal.compiler.target.LIRGenLowerable;
+import com.oracle.graal.graph.GraalInternalError;
+import com.oracle.graal.lir.FrameMap;
+import com.oracle.graal.lir.LIR;
+import com.oracle.graal.lir.LIRFrameState;
+import com.oracle.graal.lir.LIRInstruction;
+import com.oracle.graal.lir.LabelRef;
+import com.oracle.graal.lir.Variable;
+import com.oracle.graal.lir.sparc.SPARCMove.MoveFromRegOp;
+import com.oracle.graal.lir.sparc.SPARCMove.MoveToRegOp;
+import com.oracle.graal.lir.sparc.SPARCArithmetic.Op2Stack;
+import com.oracle.graal.nodes.BreakpointNode;
+import com.oracle.graal.nodes.DeoptimizingNode;
+import com.oracle.graal.nodes.DirectCallTargetNode;
+import com.oracle.graal.nodes.IndirectCallTargetNode;
+import com.oracle.graal.nodes.InfopointNode;
+import com.oracle.graal.nodes.SafepointNode;
+import com.oracle.graal.nodes.StructuredGraph;
+import com.oracle.graal.nodes.ValueNode;
+import com.oracle.graal.nodes.calc.Condition;
 import com.oracle.graal.nodes.calc.ConvertNode.Op;
-import com.oracle.graal.nodes.java.*;
+import com.oracle.graal.nodes.java.CompareAndSwapNode;
 
 /**
  * This class implements the SPARC specific portion of the LIR generator.
  */
 public class SPARCLIRGenerator extends LIRGenerator {
 
+    public static class SPARCSpillMoveFactory implements LIR.SpillMoveFactory {
+
+        @Override
+        public LIRInstruction createMove(AllocatableValue result, Value input) {
+            throw new InternalError("NYI");
+        }
+    }
+
     public SPARCLIRGenerator(StructuredGraph graph, CodeCacheProvider runtime, TargetDescription target, FrameMap frameMap, CallingConvention cc, LIR lir) {
         super(graph, runtime, target, frameMap, cc, lir);
-        // SPARC: Implement lir generator.
+        lir.spillMoveFactory = new SPARCSpillMoveFactory();
+    }
+
+    @Override
+    protected void emitNode(ValueNode node) {
+        if (node instanceof LIRGenLowerable) {
+            ((LIRGenLowerable) node).generate(this);
+        } else {
+            super.emitNode(node);
+        }
     }
 
     @Override
     public Variable emitMove(Value input) {
-        // SPARC: Auto-generated method stub
-        return null;
+        Variable result = newVariable(input.getKind());
+        emitMove(result, input);
+        return result;
+    }
+
+    @Override
+    public void emitMove(AllocatableValue dst, Value src) {
+        if (isRegister(src) || isStackSlot(dst)) {
+            append(new MoveFromRegOp(dst, src));
+        } else {
+            append(new MoveToRegOp(dst, src));
+        }
     }
 
     @Override
@@ -63,8 +121,6 @@
 
     @Override
     public void emitJump(LabelRef label) {
-        @SuppressWarnings("unused")
-        SPARCLIRInstruction instruction = null;
         // SPARC: Auto-generated method stub
 
     }
@@ -72,19 +128,16 @@
     @Override
     public void emitCompareBranch(Value left, Value right, Condition cond, boolean unorderedIsTrue, LabelRef label) {
         // SPARC: Auto-generated method stub
-
     }
 
     @Override
     public void emitOverflowCheckBranch(LabelRef label, boolean negated) {
         // SPARC: Auto-generated method stub
-
     }
 
     @Override
     public void emitIntegerTestBranch(Value left, Value right, boolean negated, LabelRef label) {
         // SPARC: Auto-generated method stub
-
     }
 
     @Override
@@ -102,37 +155,31 @@
     @Override
     protected void emitDirectCall(DirectCallTargetNode callTarget, Value result, Value[] parameters, Value[] temps, LIRFrameState callState) {
         // SPARC: Auto-generated method stub
-
     }
 
     @Override
     protected void emitIndirectCall(IndirectCallTargetNode callTarget, Value result, Value[] parameters, Value[] temps, LIRFrameState callState) {
         // SPARC: Auto-generated method stub
-
     }
 
     @Override
     protected void emitForeignCall(ForeignCallLinkage linkage, Value result, Value[] arguments, Value[] temps, LIRFrameState info) {
         // SPARC: Auto-generated method stub
-
     }
 
     @Override
     protected void emitSequentialSwitch(Constant[] keyConstants, LabelRef[] keyTargets, LabelRef defaultTarget, Value key) {
         // SPARC: Auto-generated method stub
-
     }
 
     @Override
     protected void emitSwitchRanges(int[] lowKeys, int[] highKeys, LabelRef[] targets, LabelRef defaultTarget, Value key) {
         // SPARC: Auto-generated method stub
-
     }
 
     @Override
     protected void emitTableSwitch(int lowKey, LabelRef defaultTarget, LabelRef[] targets, Value key) {
         // SPARC: Auto-generated method stub
-
     }
 
     @Override
@@ -150,13 +197,11 @@
     @Override
     public void emitBitScanReverse(Variable result, Value operand) {
         // SPARC: Auto-generated method stub
-
     }
 
     @Override
     public void emitMathAbs(Variable result, Variable input) {
         // SPARC: Auto-generated method stub
-
     }
 
     @Override
@@ -168,31 +213,26 @@
     @Override
     public void emitMathLog(Variable result, Variable input, boolean base10) {
         // SPARC: Auto-generated method stub
-
     }
 
     @Override
     public void emitMathCos(Variable result, Variable input) {
         // SPARC: Auto-generated method stub
-
     }
 
     @Override
     public void emitMathSin(Variable result, Variable input) {
         // SPARC: Auto-generated method stub
-
     }
 
     @Override
     public void emitMathTan(Variable result, Variable input) {
         // SPARC: Auto-generated method stub
-
     }
 
     @Override
     public void emitByteSwap(Variable result, Value operand) {
         // SPARC: Auto-generated method stub
-
     }
 
     @Override
@@ -208,12 +248,6 @@
     }
 
     @Override
-    public void emitMove(AllocatableValue dst, Value src) {
-        // SPARC: Auto-generated method stub
-
-    }
-
-    @Override
     public Value emitAddress(Value base, long displacement, Value index, int scale) {
         // SPARC: Auto-generated method stub
         return null;
@@ -245,8 +279,24 @@
 
     @Override
     public Value emitAdd(Value a, Value b) {
-        // SPARC: Auto-generated method stub
-        return null;
+        Variable result = newVariable(a.getKind());
+        switch (a.getKind()) {
+            case Int:
+                append(new Op2Stack(IADD, result, a, loadNonConst(b)));
+                break;
+            case Long:
+                append(new Op2Stack(LADD, result, a, loadNonConst(b)));
+                break;
+            case Float:
+                append(new Op2Stack(FADD, result, a, loadNonConst(b)));
+                break;
+            case Double:
+                append(new Op2Stack(DADD, result, a, loadNonConst(b)));
+                break;
+            default:
+                throw GraalInternalError.shouldNotReachHere("missing: " + a.getKind() + " prim: " + a.getKind().isPrimitive());
+        }
+        return result;
     }
 
     @Override
@@ -330,48 +380,40 @@
     @Override
     public void emitMembar(int barriers) {
         // SPARC: Auto-generated method stub
-
     }
 
     @Override
     public void emitDeoptimize(DeoptimizationAction action, DeoptimizingNode deopting) {
         // SPARC: Auto-generated method stub
-
     }
 
     @Override
     public void visitCompareAndSwap(CompareAndSwapNode i) {
         // SPARC: Auto-generated method stub
-
     }
 
     @Override
     public void visitSafepointNode(SafepointNode i) {
         // SPARC: Auto-generated method stub
-
     }
 
     @Override
     public void visitBreakpointNode(BreakpointNode i) {
         // SPARC: Auto-generated method stub
-
     }
 
     @Override
     public void emitUnwind(Value operand) {
         // SPARC: Auto-generated method stub
-
     }
 
     @Override
     public void emitNullCheck(ValueNode v, DeoptimizingNode deopting) {
         // SPARC: Auto-generated method stub
-
     }
 
     @Override
     public void visitInfopointNode(InfopointNode i) {
         // SPARC: Auto-generated method stub
-
     }
 }
diff -r c010c12ab682 -r e723f9031785 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	Fri May 24 12:02:30 2013 +0200
+++ b/graal/com.oracle.graal.hotspot.sparc/src/com/oracle/graal/hotspot/sparc/SPARCHotSpotBackend.java	Fri May 24 10:37:27 2013 -0400
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.
+ * 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
@@ -24,14 +24,17 @@
 
 import com.oracle.graal.api.code.*;
 import com.oracle.graal.api.meta.*;
-import com.oracle.graal.asm.*;
-import com.oracle.graal.compiler.gen.*;
-import com.oracle.graal.compiler.sparc.*;
+import com.oracle.graal.asm.AbstractAssembler;
+import com.oracle.graal.asm.sparc.SPARCAssembler;
+import com.oracle.graal.compiler.gen.LIRGenerator;
+import com.oracle.graal.compiler.sparc.SPARCLIRGenerator;
 import com.oracle.graal.hotspot.*;
 import com.oracle.graal.hotspot.meta.*;
+import com.oracle.graal.hotspot.stubs.Stub;
 import com.oracle.graal.lir.*;
 import com.oracle.graal.lir.asm.*;
 import com.oracle.graal.nodes.*;
+import static com.oracle.graal.phases.GraalOptions.*;
 
 /**
  * HotSpot SPARC specific backend.
@@ -49,14 +52,44 @@
 
     @Override
     protected AbstractAssembler createAssembler(FrameMap frameMap) {
-        // SPARC: Create assembler.
-        return null;
+        return new SPARCAssembler(target, frameMap.registerConfig);
+    }
+
+    class HotSpotFrameContext implements FrameContext {
+
+        final boolean isStub;
+
+        HotSpotFrameContext(boolean isStub) {
+            this.isStub = isStub;
+        }
+
+        @Override
+        public void enter(TargetMethodAssembler tasm) {
+        }
+
+        @Override
+        public void leave(TargetMethodAssembler tasm) {
+        }
     }
 
     @Override
     public TargetMethodAssembler newAssembler(LIRGenerator lirGen, CompilationResult compilationResult) {
-        // SPARC: Create assembler.
-        return null;
+        SPARCHotSpotLIRGenerator gen = (SPARCHotSpotLIRGenerator) lirGen;
+        FrameMap frameMap = gen.frameMap;
+        LIR lir = gen.lir;
+        boolean omitFrame = CanOmitFrame && !frameMap.frameNeedsAllocating() && !lir.hasArgInCallerFrame();
+
+        Stub stub = gen.getStub();
+        AbstractAssembler masm = createAssembler(frameMap);
+        HotSpotFrameContext frameContext = omitFrame ? null : new HotSpotFrameContext(stub != null);
+        TargetMethodAssembler tasm = new TargetMethodAssembler(target, runtime(), frameMap, masm, frameContext, compilationResult);
+        tasm.setFrameSize(frameMap.frameSize());
+        StackSlot deoptimizationRescueSlot = gen.deoptimizationRescueSlot;
+        if (deoptimizationRescueSlot != null && stub == null) {
+            tasm.compilationResult.setCustomStackAreaOffset(frameMap.offsetForStackSlot(deoptimizationRescueSlot));
+        }
+
+        return tasm;
     }
 
     @Override
diff -r c010c12ab682 -r e723f9031785 graal/com.oracle.graal.hotspot.sparc/src/com/oracle/graal/hotspot/sparc/SPARCHotSpotLIRGenerator.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.hotspot.sparc/src/com/oracle/graal/hotspot/sparc/SPARCHotSpotLIRGenerator.java	Fri May 24 10:37:27 2013 -0400
@@ -0,0 +1,90 @@
+/*
+ * 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.hotspot.sparc;
+
+import com.oracle.graal.api.code.CallingConvention;
+import com.oracle.graal.api.code.CodeCacheProvider;
+import com.oracle.graal.api.code.DeoptimizationAction;
+import com.oracle.graal.api.code.StackSlot;
+import com.oracle.graal.api.code.TargetDescription;
+import com.oracle.graal.api.meta.DeoptimizationReason;
+import com.oracle.graal.api.meta.Value;
+import com.oracle.graal.compiler.sparc.SPARCLIRGenerator;
+import com.oracle.graal.hotspot.HotSpotLIRGenerator;
+import com.oracle.graal.hotspot.nodes.DirectCompareAndSwapNode;
+import com.oracle.graal.hotspot.stubs.Stub;
+import com.oracle.graal.lir.FrameMap;
+import com.oracle.graal.lir.LIR;
+import com.oracle.graal.nodes.StructuredGraph;
+import com.oracle.graal.nodes.ValueNode;
+
+public class SPARCHotSpotLIRGenerator  extends SPARCLIRGenerator implements HotSpotLIRGenerator {
+
+    public StackSlot deoptimizationRescueSlot;
+
+    public SPARCHotSpotLIRGenerator(StructuredGraph graph,
+            CodeCacheProvider runtime, TargetDescription target,
+            FrameMap frameMap, CallingConvention cc, LIR lir) {
+        super(graph, runtime, target, frameMap, cc, lir);
+        // TODO Auto-generated constructor stub
+    }
+
+    @Override
+    public void emitTailcall(Value[] args, Value address) {
+        // TODO Auto-generated method stub
+    }
+
+    @Override
+    public void emitDeoptimizeCaller(DeoptimizationAction action,
+            DeoptimizationReason reason) {
+        // TODO Auto-generated method stub
+    }
+
+    @Override
+    public void emitPatchReturnAddress(ValueNode address) {
+        // TODO Auto-generated method stub
+    }
+
+    @Override
+    public void emitJumpToExceptionHandlerInCaller(ValueNode handlerInCallerPc,
+            ValueNode exception, ValueNode exceptionPc) {
+        // TODO Auto-generated method stub
+    }
+
+    @Override
+    public void visitDirectCompareAndSwap(DirectCompareAndSwapNode x) {
+        // TODO Auto-generated method stub
+    }
+
+    @Override
+    public StackSlot getLockSlot(int lockDepth) {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    public Stub getStub() {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+}
diff -r c010c12ab682 -r e723f9031785 graal/com.oracle.graal.lir.sparc/.settings/org.eclipse.jdt.core.prefs
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.lir.sparc/.settings/org.eclipse.jdt.core.prefs	Fri May 24 10:37:27 2013 -0400
@@ -0,0 +1,417 @@
+eclipse.preferences.version=1
+org.eclipse.jdt.core.builder.cleanOutputFolder=clean
+org.eclipse.jdt.core.builder.duplicateResourceTask=warning
+org.eclipse.jdt.core.builder.invalidClasspath=abort
+org.eclipse.jdt.core.builder.recreateModifiedClassFileInOutputFolder=ignore
+org.eclipse.jdt.core.builder.resourceCopyExclusionFilter=*.launch
+org.eclipse.jdt.core.circularClasspath=error
+org.eclipse.jdt.core.classpath.exclusionPatterns=enabled
+org.eclipse.jdt.core.classpath.multipleOutputLocations=enabled
+org.eclipse.jdt.core.codeComplete.argumentPrefixes=
+org.eclipse.jdt.core.codeComplete.argumentSuffixes=
+org.eclipse.jdt.core.codeComplete.fieldPrefixes=
+org.eclipse.jdt.core.codeComplete.fieldSuffixes=
+org.eclipse.jdt.core.codeComplete.localPrefixes=
+org.eclipse.jdt.core.codeComplete.localSuffixes=
+org.eclipse.jdt.core.codeComplete.staticFieldPrefixes=
+org.eclipse.jdt.core.codeComplete.staticFieldSuffixes=
+org.eclipse.jdt.core.codeComplete.staticFinalFieldPrefixes=
+org.eclipse.jdt.core.codeComplete.staticFinalFieldSuffixes=
+org.eclipse.jdt.core.compiler.annotation.missingNonNullByDefaultAnnotation=ignore
+org.eclipse.jdt.core.compiler.annotation.nonnull=org.eclipse.jdt.annotation.NonNull
+org.eclipse.jdt.core.compiler.annotation.nonnullbydefault=org.eclipse.jdt.annotation.NonNullByDefault
+org.eclipse.jdt.core.compiler.annotation.nullable=org.eclipse.jdt.annotation.Nullable
+org.eclipse.jdt.core.compiler.annotation.nullanalysis=disabled
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.7
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.7
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.doc.comment.support=enabled
+org.eclipse.jdt.core.compiler.maxProblemPerUnit=100
+org.eclipse.jdt.core.compiler.problem.annotationSuperInterface=warning
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.autoboxing=ignore
+org.eclipse.jdt.core.compiler.problem.comparingIdentical=warning
+org.eclipse.jdt.core.compiler.problem.deadCode=warning
+org.eclipse.jdt.core.compiler.problem.deprecation=warning
+org.eclipse.jdt.core.compiler.problem.deprecationInDeprecatedCode=enabled
+org.eclipse.jdt.core.compiler.problem.deprecationWhenOverridingDeprecatedMethod=enabled
+org.eclipse.jdt.core.compiler.problem.discouragedReference=warning
+org.eclipse.jdt.core.compiler.problem.emptyStatement=warning
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.problem.explicitlyClosedAutoCloseable=ignore
+org.eclipse.jdt.core.compiler.problem.fallthroughCase=ignore
+org.eclipse.jdt.core.compiler.problem.fatalOptionalError=enabled
+org.eclipse.jdt.core.compiler.problem.fieldHiding=warning
+org.eclipse.jdt.core.compiler.problem.finalParameterBound=warning
+org.eclipse.jdt.core.compiler.problem.finallyBlockNotCompletingNormally=ignore
+org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
+org.eclipse.jdt.core.compiler.problem.hiddenCatchBlock=warning
+org.eclipse.jdt.core.compiler.problem.includeNullInfoFromAsserts=disabled
+org.eclipse.jdt.core.compiler.problem.incompatibleNonInheritedInterfaceMethod=warning
+org.eclipse.jdt.core.compiler.problem.incompleteEnumSwitch=ignore
+org.eclipse.jdt.core.compiler.problem.indirectStaticAccess=ignore
+org.eclipse.jdt.core.compiler.problem.invalidJavadoc=error
+org.eclipse.jdt.core.compiler.problem.invalidJavadocTags=enabled
+org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsDeprecatedRef=enabled
+org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsNotVisibleRef=enabled
+org.eclipse.jdt.core.compiler.problem.invalidJavadocTagsVisibility=private
+org.eclipse.jdt.core.compiler.problem.localVariableHiding=warning
+org.eclipse.jdt.core.compiler.problem.methodWithConstructorName=error
+org.eclipse.jdt.core.compiler.problem.missingDeprecatedAnnotation=error
+org.eclipse.jdt.core.compiler.problem.missingHashCodeMethod=warning
+org.eclipse.jdt.core.compiler.problem.missingJavadocComments=ignore
+org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsOverriding=enabled
+org.eclipse.jdt.core.compiler.problem.missingJavadocCommentsVisibility=public
+org.eclipse.jdt.core.compiler.problem.missingJavadocTagDescription=return_tag
+org.eclipse.jdt.core.compiler.problem.missingJavadocTags=ignore
+org.eclipse.jdt.core.compiler.problem.missingJavadocTagsMethodTypeParameters=disabled
+org.eclipse.jdt.core.compiler.problem.missingJavadocTagsOverriding=enabled
+org.eclipse.jdt.core.compiler.problem.missingJavadocTagsVisibility=private
+org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotation=error
+org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotationForInterfaceMethodImplementation=disabled
+org.eclipse.jdt.core.compiler.problem.missingSerialVersion=warning
+org.eclipse.jdt.core.compiler.problem.missingSynchronizedOnInheritedMethod=warning
+org.eclipse.jdt.core.compiler.problem.noEffectAssignment=warning
+org.eclipse.jdt.core.compiler.problem.noImplicitStringConversion=warning
+org.eclipse.jdt.core.compiler.problem.nonExternalizedStringLiteral=ignore
+org.eclipse.jdt.core.compiler.problem.nullAnnotationInferenceConflict=error
+org.eclipse.jdt.core.compiler.problem.nullReference=warning
+org.eclipse.jdt.core.compiler.problem.nullSpecViolation=error
+org.eclipse.jdt.core.compiler.problem.nullUncheckedConversion=warning
+org.eclipse.jdt.core.compiler.problem.overridingPackageDefaultMethod=warning
+org.eclipse.jdt.core.compiler.problem.parameterAssignment=warning
+org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment=warning
+org.eclipse.jdt.core.compiler.problem.potentialNullReference=ignore
+org.eclipse.jdt.core.compiler.problem.potentiallyUnclosedCloseable=ignore
+org.eclipse.jdt.core.compiler.problem.rawTypeReference=ignore
+org.eclipse.jdt.core.compiler.problem.redundantNullAnnotation=warning
+org.eclipse.jdt.core.compiler.problem.redundantNullCheck=ignore
+org.eclipse.jdt.core.compiler.problem.redundantSpecificationOfTypeArguments=warning
+org.eclipse.jdt.core.compiler.problem.redundantSuperinterface=ignore
+org.eclipse.jdt.core.compiler.problem.reportMethodCanBePotentiallyStatic=ignore
+org.eclipse.jdt.core.compiler.problem.reportMethodCanBeStatic=warning
+org.eclipse.jdt.core.compiler.problem.specialParameterHidingField=disabled
+org.eclipse.jdt.core.compiler.problem.staticAccessReceiver=warning
+org.eclipse.jdt.core.compiler.problem.suppressOptionalErrors=enabled
+org.eclipse.jdt.core.compiler.problem.suppressWarnings=enabled
+org.eclipse.jdt.core.compiler.problem.syntheticAccessEmulation=ignore
+org.eclipse.jdt.core.compiler.problem.typeParameterHiding=warning
+org.eclipse.jdt.core.compiler.problem.unavoidableGenericTypeProblems=enabled
+org.eclipse.jdt.core.compiler.problem.uncheckedTypeOperation=warning
+org.eclipse.jdt.core.compiler.problem.unclosedCloseable=ignore
+org.eclipse.jdt.core.compiler.problem.undocumentedEmptyBlock=ignore
+org.eclipse.jdt.core.compiler.problem.unhandledWarningToken=error
+org.eclipse.jdt.core.compiler.problem.unnecessaryElse=ignore
+org.eclipse.jdt.core.compiler.problem.unnecessaryTypeCheck=warning
+org.eclipse.jdt.core.compiler.problem.unqualifiedFieldAccess=ignore
+org.eclipse.jdt.core.compiler.problem.unsafeTypeOperation=warning
+org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException=warning
+org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionExemptExceptionAndThrowable=enabled
+org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionIncludeDocCommentReference=enabled
+org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionWhenOverriding=disabled
+org.eclipse.jdt.core.compiler.problem.unusedImport=warning
+org.eclipse.jdt.core.compiler.problem.unusedLabel=warning
+org.eclipse.jdt.core.compiler.problem.unusedLocal=warning
+org.eclipse.jdt.core.compiler.problem.unusedObjectAllocation=ignore
+org.eclipse.jdt.core.compiler.problem.unusedParameter=warning
+org.eclipse.jdt.core.compiler.problem.unusedParameterIncludeDocCommentReference=enabled
+org.eclipse.jdt.core.compiler.problem.unusedParameterWhenImplementingAbstract=disabled
+org.eclipse.jdt.core.compiler.problem.unusedParameterWhenOverridingConcrete=disabled
+org.eclipse.jdt.core.compiler.problem.unusedPrivateMember=warning
+org.eclipse.jdt.core.compiler.problem.unusedWarningToken=warning
+org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=warning
+org.eclipse.jdt.core.compiler.processAnnotations=disabled
+org.eclipse.jdt.core.compiler.source=1.7
+org.eclipse.jdt.core.compiler.taskCaseSensitive=enabled
+org.eclipse.jdt.core.compiler.taskPriorities=NORMAL,HIGH,NORMAL
+org.eclipse.jdt.core.compiler.taskTags=TODO,FIXME,XXX
+org.eclipse.jdt.core.formatter.align_type_members_on_columns=false
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_allocation_expression=16
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_annotation=0
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_enum_constant=48
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_explicit_constructor_call=16
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_method_invocation=16
+org.eclipse.jdt.core.formatter.alignment_for_arguments_in_qualified_allocation_expression=16
+org.eclipse.jdt.core.formatter.alignment_for_assignment=0
+org.eclipse.jdt.core.formatter.alignment_for_binary_expression=16
+org.eclipse.jdt.core.formatter.alignment_for_compact_if=16
+org.eclipse.jdt.core.formatter.alignment_for_conditional_expression=80
+org.eclipse.jdt.core.formatter.alignment_for_enum_constants=48
+org.eclipse.jdt.core.formatter.alignment_for_expressions_in_array_initializer=16
+org.eclipse.jdt.core.formatter.alignment_for_method_declaration=0
+org.eclipse.jdt.core.formatter.alignment_for_multiple_fields=16
+org.eclipse.jdt.core.formatter.alignment_for_parameters_in_constructor_declaration=16
+org.eclipse.jdt.core.formatter.alignment_for_parameters_in_method_declaration=16
+org.eclipse.jdt.core.formatter.alignment_for_resources_in_try=80
+org.eclipse.jdt.core.formatter.alignment_for_selector_in_method_invocation=0
+org.eclipse.jdt.core.formatter.alignment_for_superclass_in_type_declaration=16
+org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_enum_declaration=48
+org.eclipse.jdt.core.formatter.alignment_for_superinterfaces_in_type_declaration=16
+org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_constructor_declaration=16
+org.eclipse.jdt.core.formatter.alignment_for_throws_clause_in_method_declaration=16
+org.eclipse.jdt.core.formatter.alignment_for_union_type_in_multicatch=16
+org.eclipse.jdt.core.formatter.blank_lines_after_imports=1
+org.eclipse.jdt.core.formatter.blank_lines_after_package=1
+org.eclipse.jdt.core.formatter.blank_lines_before_field=0
+org.eclipse.jdt.core.formatter.blank_lines_before_first_class_body_declaration=1
+org.eclipse.jdt.core.formatter.blank_lines_before_imports=1
+org.eclipse.jdt.core.formatter.blank_lines_before_member_type=1
+org.eclipse.jdt.core.formatter.blank_lines_before_method=1
+org.eclipse.jdt.core.formatter.blank_lines_before_new_chunk=1
+org.eclipse.jdt.core.formatter.blank_lines_before_package=0
+org.eclipse.jdt.core.formatter.blank_lines_between_import_groups=1
+org.eclipse.jdt.core.formatter.blank_lines_between_type_declarations=1
+org.eclipse.jdt.core.formatter.brace_position_for_annotation_type_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_anonymous_type_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_array_initializer=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_block=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_block_in_case=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_constructor_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_enum_constant=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_enum_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_method_declaration=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_switch=end_of_line
+org.eclipse.jdt.core.formatter.brace_position_for_type_declaration=end_of_line
+org.eclipse.jdt.core.formatter.comment.clear_blank_lines=false
+org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_block_comment=false
+org.eclipse.jdt.core.formatter.comment.clear_blank_lines_in_javadoc_comment=false
+org.eclipse.jdt.core.formatter.comment.format_block_comments=true
+org.eclipse.jdt.core.formatter.comment.format_comments=true
+org.eclipse.jdt.core.formatter.comment.format_header=false
+org.eclipse.jdt.core.formatter.comment.format_html=true
+org.eclipse.jdt.core.formatter.comment.format_javadoc_comments=true
+org.eclipse.jdt.core.formatter.comment.format_line_comments=true
+org.eclipse.jdt.core.formatter.comment.format_source_code=true
+org.eclipse.jdt.core.formatter.comment.indent_parameter_description=true
+org.eclipse.jdt.core.formatter.comment.indent_root_tags=true
+org.eclipse.jdt.core.formatter.comment.insert_new_line_before_root_tags=insert
+org.eclipse.jdt.core.formatter.comment.insert_new_line_for_parameter=do not insert
+org.eclipse.jdt.core.formatter.comment.line_length=100
+org.eclipse.jdt.core.formatter.comment.new_lines_at_block_boundaries=true
+org.eclipse.jdt.core.formatter.comment.new_lines_at_javadoc_boundaries=true
+org.eclipse.jdt.core.formatter.comment.preserve_white_space_between_code_and_line_comments=true
+org.eclipse.jdt.core.formatter.compact_else_if=true
+org.eclipse.jdt.core.formatter.continuation_indentation=4
+org.eclipse.jdt.core.formatter.continuation_indentation_for_array_initializer=4
+org.eclipse.jdt.core.formatter.disabling_tag=@formatter\:off
+org.eclipse.jdt.core.formatter.enabling_tag=@formatter\:on
+org.eclipse.jdt.core.formatter.format_guardian_clause_on_one_line=false
+org.eclipse.jdt.core.formatter.format_line_comment_starting_on_first_column=true
+org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_annotation_declaration_header=true
+org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_constant_header=true
+org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_enum_declaration_header=true
+org.eclipse.jdt.core.formatter.indent_body_declarations_compare_to_type_header=true
+org.eclipse.jdt.core.formatter.indent_breaks_compare_to_cases=true
+org.eclipse.jdt.core.formatter.indent_empty_lines=false
+org.eclipse.jdt.core.formatter.indent_statements_compare_to_block=true
+org.eclipse.jdt.core.formatter.indent_statements_compare_to_body=true
+org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_cases=true
+org.eclipse.jdt.core.formatter.indent_switchstatements_compare_to_switch=true
+org.eclipse.jdt.core.formatter.indentation.size=4
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation=insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_field=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_local_variable=insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_member=insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_method=insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_package=insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_parameter=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_annotation_on_type=insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_label=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_after_opening_brace_in_array_initializer=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_at_end_of_file_if_missing=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_catch_in_try_statement=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_closing_brace_in_array_initializer=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_else_in_if_statement=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_finally_in_try_statement=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_before_while_in_do_statement=do not insert
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_annotation_declaration=insert
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_anonymous_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_block=insert
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_constant=insert
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_enum_declaration=insert
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_method_body=insert
+org.eclipse.jdt.core.formatter.insert_new_line_in_empty_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_after_and_in_type_parameter=insert
+org.eclipse.jdt.core.formatter.insert_space_after_assignment_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_at_in_annotation_type_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_binary_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_arguments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_closing_angle_bracket_in_type_parameters=insert
+org.eclipse.jdt.core.formatter.insert_space_after_closing_brace_in_block=insert
+org.eclipse.jdt.core.formatter.insert_space_after_closing_paren_in_cast=insert
+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_assert=insert
+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_case=insert
+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_conditional=insert
+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_for=insert
+org.eclipse.jdt.core.formatter.insert_space_after_colon_in_labeled_statement=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_allocation_expression=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_annotation=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_array_initializer=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_parameters=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_constructor_declaration_throws=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_constant_arguments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_enum_declarations=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_explicitconstructorcall_arguments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_increments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_for_inits=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_parameters=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_declaration_throws=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_method_invocation_arguments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_field_declarations=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_multiple_local_declarations=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_parameterized_type_reference=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_superinterfaces=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_arguments=insert
+org.eclipse.jdt.core.formatter.insert_space_after_comma_in_type_parameters=insert
+org.eclipse.jdt.core.formatter.insert_space_after_ellipsis=insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_parameterized_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_angle_bracket_in_type_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_brace_in_array_initializer=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_allocation_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_bracket_in_array_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_annotation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_cast=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_catch=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_constructor_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_enum_constant=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_for=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_if=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_method_invocation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_parenthesized_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_switch=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_synchronized=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_try=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_opening_paren_in_while=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_postfix_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_prefix_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_question_in_conditional=insert
+org.eclipse.jdt.core.formatter.insert_space_after_question_in_wildcard=do not insert
+org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_for=insert
+org.eclipse.jdt.core.formatter.insert_space_after_semicolon_in_try_resources=insert
+org.eclipse.jdt.core.formatter.insert_space_after_unary_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_and_in_type_parameter=insert
+org.eclipse.jdt.core.formatter.insert_space_before_assignment_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_before_at_in_annotation_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_binary_operator=insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_parameterized_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_angle_bracket_in_type_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_brace_in_array_initializer=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_allocation_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_bracket_in_array_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_annotation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_cast=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_catch=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_constructor_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_enum_constant=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_for=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_if=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_method_invocation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_parenthesized_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_switch=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_synchronized=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_try=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_closing_paren_in_while=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_assert=insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_case=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_conditional=insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_default=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_for=insert
+org.eclipse.jdt.core.formatter.insert_space_before_colon_in_labeled_statement=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_allocation_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_annotation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_array_initializer=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_constructor_declaration_throws=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_constant_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_enum_declarations=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_explicitconstructorcall_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_increments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_for_inits=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_declaration_throws=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_method_invocation_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_field_declarations=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_multiple_local_declarations=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_parameterized_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_superinterfaces=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_comma_in_type_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_ellipsis=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_parameterized_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_arguments=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_angle_bracket_in_type_parameters=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_annotation_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_anonymous_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_array_initializer=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_block=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_constructor_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_constant=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_enum_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_method_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_switch=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_brace_in_type_declaration=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_allocation_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_bracket_in_array_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_annotation_type_member_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_catch=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_constructor_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_enum_constant=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_for=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_if=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_method_invocation=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_parenthesized_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_switch=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_synchronized=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_try=insert
+org.eclipse.jdt.core.formatter.insert_space_before_opening_paren_in_while=insert
+org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_return=insert
+org.eclipse.jdt.core.formatter.insert_space_before_parenthesized_expression_in_throw=insert
+org.eclipse.jdt.core.formatter.insert_space_before_postfix_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_prefix_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_question_in_conditional=insert
+org.eclipse.jdt.core.formatter.insert_space_before_question_in_wildcard=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_semicolon=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_for=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_semicolon_in_try_resources=do not insert
+org.eclipse.jdt.core.formatter.insert_space_before_unary_operator=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_brackets_in_array_type_reference=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_braces_in_array_initializer=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_brackets_in_array_allocation_expression=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_annotation_type_member_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_constructor_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_enum_constant=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_declaration=do not insert
+org.eclipse.jdt.core.formatter.insert_space_between_empty_parens_in_method_invocation=do not insert
+org.eclipse.jdt.core.formatter.join_lines_in_comments=true
+org.eclipse.jdt.core.formatter.join_wrapped_lines=true
+org.eclipse.jdt.core.formatter.keep_else_statement_on_same_line=false
+org.eclipse.jdt.core.formatter.keep_empty_array_initializer_on_one_line=true
+org.eclipse.jdt.core.formatter.keep_imple_if_on_one_line=false
+org.eclipse.jdt.core.formatter.keep_then_statement_on_same_line=false
+org.eclipse.jdt.core.formatter.lineSplit=200
+org.eclipse.jdt.core.formatter.never_indent_block_comments_on_first_column=true
+org.eclipse.jdt.core.formatter.never_indent_line_comments_on_first_column=true
+org.eclipse.jdt.core.formatter.number_of_blank_lines_at_beginning_of_method_body=0
+org.eclipse.jdt.core.formatter.number_of_empty_lines_to_preserve=1
+org.eclipse.jdt.core.formatter.put_empty_statement_on_new_line=true
+org.eclipse.jdt.core.formatter.tabulation.char=space
+org.eclipse.jdt.core.formatter.tabulation.size=4
+org.eclipse.jdt.core.formatter.use_on_off_tags=true
+org.eclipse.jdt.core.formatter.use_tabs_only_for_leading_indentations=false
+org.eclipse.jdt.core.formatter.wrap_before_binary_operator=false
+org.eclipse.jdt.core.formatter.wrap_before_or_operator_multicatch=true
+org.eclipse.jdt.core.formatter.wrap_outer_expressions_when_nested=true
+org.eclipse.jdt.core.incompatibleJDKLevel=ignore
+org.eclipse.jdt.core.incompleteClasspath=error
diff -r c010c12ab682 -r e723f9031785 graal/com.oracle.graal.lir.sparc/src/com/oracle/graal/lir/sparc/SPARCArithmetic.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.lir.sparc/src/com/oracle/graal/lir/sparc/SPARCArithmetic.java	Fri May 24 10:37:27 2013 -0400
@@ -0,0 +1,224 @@
+/*
+ * 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.lir.sparc;
+
+import static com.oracle.graal.api.code.ValueUtil.asFloatReg;
+import static com.oracle.graal.api.code.ValueUtil.asIntReg;
+import static com.oracle.graal.api.code.ValueUtil.asLongReg;
+import static com.oracle.graal.api.code.ValueUtil.isConstant;
+import static com.oracle.graal.lir.LIRInstruction.OperandFlag.CONST;
+import static com.oracle.graal.lir.LIRInstruction.OperandFlag.HINT;
+import static com.oracle.graal.lir.LIRInstruction.OperandFlag.REG;
+import static com.oracle.graal.lir.LIRInstruction.OperandFlag.STACK;
+
+import com.oracle.graal.api.meta.Kind;
+import com.oracle.graal.api.meta.Value;
+import com.oracle.graal.asm.sparc.SPARCAssembler;
+import static com.oracle.graal.asm.sparc.SPARCAssembler.Add;
+import static com.oracle.graal.asm.sparc.SPARCAssembler.And;
+import static com.oracle.graal.asm.sparc.SPARCAssembler.Fadds;
+import static com.oracle.graal.asm.sparc.SPARCAssembler.Fsubs;
+import static com.oracle.graal.asm.sparc.SPARCAssembler.Mulx;
+import static com.oracle.graal.asm.sparc.SPARCAssembler.Or;
+import static com.oracle.graal.asm.sparc.SPARCAssembler.Sdivx;
+import static com.oracle.graal.asm.sparc.SPARCAssembler.Sll;
+import static com.oracle.graal.asm.sparc.SPARCAssembler.Srl;
+import static com.oracle.graal.asm.sparc.SPARCAssembler.Sra;
+import static com.oracle.graal.asm.sparc.SPARCAssembler.Sub;
+import static com.oracle.graal.asm.sparc.SPARCAssembler.Xor;
+
+import com.oracle.graal.graph.GraalInternalError;
+import com.oracle.graal.lir.LIRFrameState;
+import com.oracle.graal.lir.asm.TargetMethodAssembler;
+
+// @formatter:off
+public enum SPARCArithmetic {
+    IADD, ISUB, IMUL, IDIV, IDIVREM, IREM, IUDIV, IUREM, IAND, IOR, IXOR, ISHL, ISHR, IUSHR,
+    LADD, LSUB, LMUL, LDIV, LDIVREM, LREM, LUDIV, LUREM, LAND, LOR, LXOR, LSHL, LSHR, LUSHR,
+    FADD, FSUB, FMUL, FDIV, FREM, FAND, FOR, FXOR,
+    DADD, DSUB, DMUL, DDIV, DREM, DAND, DOR, DXOR,
+    INEG, LNEG, FNEG, DNEG,
+    I2L, L2I, I2B, I2C, I2S,
+    F2D, D2F,
+    I2F, I2D, F2I, D2I,
+    L2F, L2D, F2L, D2L,
+    MOV_I2F, MOV_L2D, MOV_F2I, MOV_D2L;
+
+    public static class Op2Stack extends SPARCLIRInstruction {
+        @Opcode private final SPARCArithmetic opcode;
+        @Def({REG, HINT}) protected Value result;
+        @Use({REG, STACK, CONST}) protected Value x;
+        @Alive({REG, STACK, CONST}) protected Value y;
+
+        public Op2Stack(SPARCArithmetic opcode, Value result, Value x, Value y) {
+            this.opcode = opcode;
+            this.result = result;
+            this.x = x;
+            this.y = y;
+        }
+
+        @Override
+        public void emitCode(TargetMethodAssembler tasm, SPARCAssembler masm) {
+            emit(tasm, masm, opcode, result, x, y, null);
+        }
+
+        @Override
+        public void verify() {
+            super.verify();
+            verifyKind(opcode, result, x, y);
+        }
+    }
+
+    public static void emit(TargetMethodAssembler tasm, SPARCAssembler masm, SPARCArithmetic opcode, Value dst, Value src1, Value src2, LIRFrameState info) {
+        int exceptionOffset = -1;
+        if (isConstant(src1)) {
+            switch (opcode) {
+            case ISUB:  throw new InternalError("NYI");
+            case IAND:  throw new InternalError("NYI");
+            case IDIV:  throw new InternalError("NYI");
+            case FSUB:  throw new InternalError("NYI");
+            case FDIV:  throw new InternalError("NYI");
+            case DSUB:  throw new InternalError("NYI");
+            case DDIV:  throw new InternalError("NYI");
+            default:
+                throw GraalInternalError.shouldNotReachHere();
+            }
+        } else if (isConstant(src2)) {
+            switch (opcode) {
+            case IADD:  throw new InternalError("NYI");
+            case ISUB:  throw new InternalError("NYI");
+            case IMUL:  throw new InternalError("NYI");
+            case IAND:  throw new InternalError("NYI");
+            case ISHL:  throw new InternalError("NYI");
+            case ISHR:  throw new InternalError("NYI");
+            case IUSHR: throw new InternalError("NYI");
+            case IXOR:  throw new InternalError("NYI");
+            case LXOR:  throw new InternalError("NYI");
+            case LUSHR: throw new InternalError("NYI");
+            case FADD:  throw new InternalError("NYI");
+            case FMUL:  throw new InternalError("NYI");
+            case FDIV:  throw new InternalError("NYI");
+            case DADD:  throw new InternalError("NYI");
+            case DMUL:  throw new InternalError("NYI");
+            case DDIV:  throw new InternalError("NYI");
+            default:
+                throw GraalInternalError.shouldNotReachHere();
+            }
+        } else {
+            switch (opcode) {
+            case IADD:
+                new Add(masm, asIntReg(src1), asIntReg(src2), asIntReg(dst));
+                break;
+            case ISUB:
+                new Sub(masm, asIntReg(src1), asIntReg(src2), asIntReg(dst));
+                break;
+            case IMUL:
+                new Mulx(masm, asIntReg(src1), asIntReg(src2), asIntReg(dst));
+                break;
+            case IDIV:
+                new Sdivx(masm, asIntReg(src1), asIntReg(src2), asIntReg(dst));
+                break;
+            case IAND:
+                new And(masm, asIntReg(src1), asIntReg(src2), asIntReg(dst));
+                break;
+            case IOR:
+                new Or(masm, asIntReg(src1), asIntReg(src2), asIntReg(dst));
+                break;
+            case IXOR:
+                new Xor(masm, asIntReg(src1), asIntReg(src2), asIntReg(dst));
+                break;
+            case ISHL:
+                new Sll(masm, asIntReg(src1), asIntReg(src2), asIntReg(dst));
+                break;
+            case ISHR:
+                new Srl(masm, asIntReg(src1), asIntReg(src2), asIntReg(dst));
+                break;
+            case IUSHR:
+                new Sra(masm, asIntReg(src1), asIntReg(src2), asIntReg(dst));
+                break;
+            case IREM:  throw new InternalError("NYI");
+            case LADD:
+                new Add(masm, asLongReg(src1), asLongReg(src2), asLongReg(dst));
+                break;
+            case LSUB:
+                new Sub(masm, asLongReg(src1), asLongReg(src2), asLongReg(dst));
+                break;
+            case LMUL:
+                new Mulx(masm, asLongReg(src1), asLongReg(src2), asLongReg(dst));
+                break;
+            case LDIV:
+                new Sdivx(masm, asLongReg(src1), asLongReg(src2), asLongReg(dst));
+                break;
+            case LAND:
+                new And(masm, asLongReg(src1), asLongReg(src2), asLongReg(dst));
+                break;
+            case LOR:
+                new Or(masm, asLongReg(src1), asLongReg(src2), asLongReg(dst));
+                break;
+            case LXOR:
+                new Xor(masm, asLongReg(src1), asLongReg(src2), asLongReg(dst));
+                break;
+            case LSHL:
+                new Sll(masm, asLongReg(src1), asLongReg(src2), asLongReg(dst));
+                break;
+            case LSHR:
+                new Srl(masm, asLongReg(src1), asLongReg(src2), asLongReg(dst));
+                break;
+            case LUSHR:
+                new Sra(masm, asLongReg(src1), asLongReg(src2), asIntReg(dst));
+                break;
+            case LREM:  throw new InternalError("NYI");
+            case FADD:
+                new Fadds(masm, asFloatReg(src1), asFloatReg(src2), asFloatReg(dst));
+                break;
+            case FSUB:
+                new Fsubs(masm, asFloatReg(src1), asFloatReg(src2), asFloatReg(dst));
+                break;
+            case FMUL:  throw new InternalError("NYI");
+            case FDIV:  throw new InternalError("NYI");
+            case FREM:  throw new InternalError("NYI");
+            case DADD:  throw new InternalError("NYI");
+            case DSUB:  throw new InternalError("NYI");
+            case DMUL:  throw new InternalError("NYI");
+            case DDIV:  throw new InternalError("NYI");
+            case DREM:  throw new InternalError("NYI");
+            default:
+                throw GraalInternalError.shouldNotReachHere("missing: "  + opcode);
+            }
+        }
+
+        if (info != null) {
+            assert exceptionOffset != -1;
+            tasm.recordImplicitException(exceptionOffset, info);
+        }
+    }
+
+    private static void verifyKind(SPARCArithmetic opcode, Value result, Value x, Value y) {
+        if (((opcode.name().startsWith("I") && result.getKind() == Kind.Int && x.getKind().getStackKind() == Kind.Int && y.getKind().getStackKind() == Kind.Int)
+            || (opcode.name().startsWith("L") && result.getKind() == Kind.Long && x.getKind() == Kind.Long && y.getKind() == Kind.Long)
+            || (opcode.name().startsWith("F") && result.getKind() == Kind.Float && x.getKind() == Kind.Float && y.getKind() == Kind.Float)
+            || (opcode.name().startsWith("D") && result.getKind() == Kind.Double && x.getKind() == Kind.Double && y.getKind() == Kind.Double)) == false) {
+                throw GraalInternalError.shouldNotReachHere("opcode: "  + opcode.name() + " x: " + x.getKind() + " y: " + y.getKind());
+        }
+    }
+}
diff -r c010c12ab682 -r e723f9031785 graal/com.oracle.graal.lir.sparc/src/com/oracle/graal/lir/sparc/SPARCMove.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.lir.sparc/src/com/oracle/graal/lir/sparc/SPARCMove.java	Fri May 24 10:37:27 2013 -0400
@@ -0,0 +1,170 @@
+/*
+ * 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.lir.sparc;
+
+import static com.oracle.graal.api.code.ValueUtil.asRegister;
+import static com.oracle.graal.api.code.ValueUtil.isConstant;
+import static com.oracle.graal.api.code.ValueUtil.isRegister;
+import static com.oracle.graal.lir.LIRInstruction.OperandFlag.CONST;
+import static com.oracle.graal.lir.LIRInstruction.OperandFlag.HINT;
+import static com.oracle.graal.lir.LIRInstruction.OperandFlag.REG;
+import static com.oracle.graal.lir.LIRInstruction.OperandFlag.STACK;
+
+import com.oracle.graal.api.meta.AllocatableValue;
+import com.oracle.graal.api.meta.Constant;
+import com.oracle.graal.api.meta.Value;
+import com.oracle.graal.asm.sparc.SPARCAssembler;
+import com.oracle.graal.graph.GraalInternalError;
+import com.oracle.graal.lir.LIRInstruction.Opcode;
+import com.oracle.graal.lir.StandardOp.MoveOp;
+import com.oracle.graal.lir.asm.TargetMethodAssembler;
+
+public class SPARCMove {
+
+    @Opcode("MOVE")
+    public static class MoveToRegOp extends SPARCLIRInstruction implements MoveOp {
+
+        @Def({REG, HINT}) protected AllocatableValue result;
+        @Use({REG, STACK, CONST}) protected Value input;
+
+        public MoveToRegOp(AllocatableValue result, Value input) {
+            this.result = result;
+            this.input = input;
+        }
+
+        @Override
+        public void emitCode(TargetMethodAssembler tasm, SPARCAssembler masm) {
+            move(tasm, masm, getResult(), getInput());
+        }
+
+        @Override
+        public Value getInput() {
+            return input;
+        }
+
+        @Override
+        public AllocatableValue getResult() {
+            return result;
+        }
+    }
+
+    @Opcode("MOVE")
+    public static class MoveFromRegOp extends SPARCLIRInstruction implements MoveOp {
+
+        @Def({REG, STACK}) protected AllocatableValue result;
+        @Use({REG, CONST, HINT}) protected Value input;
+
+        public MoveFromRegOp(AllocatableValue result, Value input) {
+            this.result = result;
+            this.input = input;
+        }
+
+        @Override
+        public void emitCode(TargetMethodAssembler tasm, SPARCAssembler masm) {
+            move(tasm, masm, getResult(), getInput());
+        }
+
+        @Override
+        public Value getInput() {
+            return input;
+        }
+
+        @Override
+        public AllocatableValue getResult() {
+            return result;
+        }
+    }
+
+    public static void move(TargetMethodAssembler tasm, SPARCAssembler masm, Value result, Value input) {
+        if (isRegister(input)) {
+            if (isRegister(result)) {
+                reg2reg(masm, result, input);
+            } else {
+                throw GraalInternalError.shouldNotReachHere();
+            }
+        } else if (isConstant(input)) {
+            if (isRegister(result)) {
+                const2reg(tasm, masm, result, (Constant) input);
+            } else {
+                throw GraalInternalError.shouldNotReachHere();
+            }
+        } else {
+            throw GraalInternalError.shouldNotReachHere();
+        }
+    }
+
+    private static void reg2reg(@SuppressWarnings("unused") SPARCAssembler masm, Value result, Value input) {
+        if (asRegister(input).equals(asRegister(result))) {
+            return;
+        }
+        switch (input.getKind()) {
+            case Int:
+                // masm.mov_s32(asRegister(result), asRegister(input));
+                break;
+            case Long:
+             // masm.mov_s64(asRegister(result), asRegister(input));
+                break;
+            case Float:
+             // masm.mov_f32(asRegister(result), asRegister(input));
+                break;
+            case Double:
+             // masm.mov_f64(asRegister(result), asRegister(input));
+                break;
+            case Object:
+             // masm.mov_u64(asRegister(result), asRegister(input));
+                break;
+            default:
+                throw GraalInternalError.shouldNotReachHere("missing: " + input.getKind());
+        }
+    }
+
+    @SuppressWarnings("unused")
+    private static void const2reg(TargetMethodAssembler tasm, SPARCAssembler masm, Value result, Constant input) {
+        switch (input.getKind().getStackKind()) {
+            case Int:
+                if (tasm.runtime.needsDataPatch(input)) {
+                    tasm.recordDataReferenceInCode(input, 0, true);
+                }
+             // masm.mov_s32(asRegister(result), input.asInt());
+                break;
+            case Long:
+                if (tasm.runtime.needsDataPatch(input)) {
+                    tasm.recordDataReferenceInCode(input, 0, true);
+                }
+             // masm.mov_s64(asRegister(result), input.asLong());
+                break;
+            case Object:
+                if (input.isNull()) {
+                 // masm.mov_u64(asRegister(result), 0x0L);
+                } else if (tasm.target.inlineObjects) {
+                    tasm.recordDataReferenceInCode(input, 0, true);
+                 // masm.mov_u64(asRegister(result), 0xDEADDEADDEADDEADL);
+                } else {
+                 // masm.mov_u64(asRegister(result), tasm.recordDataReferenceInCode(input, 0, false));
+                }
+                break;
+            default:
+                throw GraalInternalError.shouldNotReachHere("missing: " + input.getKind());
+        }
+    }
+}
diff -r c010c12ab682 -r e723f9031785 make/build-graal.xml
--- a/make/build-graal.xml	Fri May 24 12:02:30 2013 +0200
+++ b/make/build-graal.xml	Fri May 24 10:37:27 2013 -0400
@@ -59,7 +59,6 @@
       <src path="${src.dir}/com.oracle.graal.compiler.amd64"/>
       <src path="${src.dir}/com.oracle.graal.replacements.amd64"/>
       <src path="${src.dir}/com.oracle.graal.hotspot.amd64"/>
-      <src path="${src.dir}/com.oracle.graal.sparc"/>
       <src path="${src.dir}/com.oracle.graal.asm.sparc"/>
       <src path="${src.dir}/com.oracle.graal.lir.sparc"/>
       <src path="${src.dir}/com.oracle.graal.compiler.sparc"/>
diff -r c010c12ab682 -r e723f9031785 mx/projects
--- a/mx/projects	Fri May 24 12:02:30 2013 +0200
+++ b/mx/projects	Fri May 24 10:37:27 2013 -0400
@@ -113,7 +113,7 @@
 # graal.hotspot.sparc
 project@com.oracle.graal.hotspot.sparc@subDir=graal
 project@com.oracle.graal.hotspot.sparc@sourceDirs=src
-project@com.oracle.graal.hotspot.sparc@dependencies=com.oracle.graal.hotspot,com.oracle.graal.compiler.sparc
+project@com.oracle.graal.hotspot.sparc@dependencies=com.oracle.graal.compiler.sparc
 project@com.oracle.graal.hotspot.sparc@checkstyle=com.oracle.graal.graph
 project@com.oracle.graal.hotspot.sparc@javaCompliance=1.7
 
@@ -188,7 +188,7 @@
 # graal.lir.sparc
 project@com.oracle.graal.lir.sparc@subDir=graal
 project@com.oracle.graal.lir.sparc@sourceDirs=src
-project@com.oracle.graal.lir.sparc@dependencies=com.oracle.graal.lir,com.oracle.graal.asm.sparc
+project@com.oracle.graal.lir.sparc@dependencies=com.oracle.graal.asm.sparc
 project@com.oracle.graal.lir.sparc@checkstyle=com.oracle.graal.graph
 project@com.oracle.graal.lir.sparc@javaCompliance=1.7
 
@@ -309,7 +309,7 @@
 # graal.compiler.sparc
 project@com.oracle.graal.compiler.sparc@subDir=graal
 project@com.oracle.graal.compiler.sparc@sourceDirs=src
-project@com.oracle.graal.compiler.sparc@dependencies=com.oracle.graal.compiler,com.oracle.graal.lir.sparc
+project@com.oracle.graal.compiler.sparc@dependencies=com.oracle.graal.lir.sparc
 project@com.oracle.graal.compiler.sparc@checkstyle=com.oracle.graal.graph
 project@com.oracle.graal.compiler.sparc@javaCompliance=1.7
 
@@ -392,7 +392,7 @@
 # graal.asm.sparc
 project@com.oracle.graal.asm.sparc@subDir=graal
 project@com.oracle.graal.asm.sparc@sourceDirs=src
-project@com.oracle.graal.asm.sparc@dependencies=com.oracle.graal.asm,com.oracle.graal.sparc
+project@com.oracle.graal.asm.sparc@dependencies=com.oracle.graal.hotspot
 project@com.oracle.graal.asm.sparc@checkstyle=com.oracle.graal.graph
 project@com.oracle.graal.asm.sparc@javaCompliance=1.7