--- a/graal/com.oracle.graal.asm.sparc/src/com/oracle/graal/asm/sparc/SPARCMacroAssembler.java	Thu Jun 20 10:56:34 2013 -0700
+++ b/graal/com.oracle.graal.asm.sparc/src/com/oracle/graal/asm/sparc/SPARCMacroAssembler.java	Thu Jun 20 20:40:52 2013 -0700
@@ -22,9 +22,13 @@
  */
 package com.oracle.graal.asm.sparc;
 
+import static com.oracle.graal.sparc.SPARC.*;
 import static com.oracle.graal.asm.sparc.SPARCAssembler.CC.*;
 
 import com.oracle.graal.api.code.*;
+import com.oracle.graal.asm.*;
+import com.oracle.graal.asm.sparc.SPARCAssembler.*;
+import com.oracle.graal.debug.*;
 import com.oracle.graal.sparc.*;
 
 public class SPARCMacroAssembler extends SPARCAssembler {
@@ -33,51 +37,74 @@
         super(target, registerConfig);
     }
 
+    @Override
+    public void align(int modulus) {
+        if (codeBuffer.position() % modulus != 0) {
+            final int count = modulus - (codeBuffer.position() % modulus);
+            for (int i = 0; i < count; i++) {
+                new Nop().emit(this);
+            }
+        }
+    }
+
+    @Override
     @SuppressWarnings("unused")
-    public static class Bclr {
+    public void jmp(Label l) {
+        new Bpa(l).emit(this);
+        new Nop().emit(this);
+    }
 
-        public Bclr(SPARCAssembler asm, Register src, Register dst) {
-            new Andn(asm, dst, src, dst);
+    @Override
+    protected final void patchJumpTarget(int branch, int branchTarget) {
+        final int disp = branchTarget - branch;
+        Fmt00c fmt = Fmt00c.read(this, branch);
+        fmt.setDisp19(disp);
+        fmt.write(this, branch);
+    }
+
+    @Override
+    public AbstractAddress makeAddress(Register base, int displacement) {
+        throw new InternalError("NYI");
+    }
+
+    @Override
+    public AbstractAddress getPlaceholder() {
+        throw new InternalError("NYI");
+    }
+
+    @SuppressWarnings("unused")
+    public static class Bclr extends Andn {
+
+        public Bclr(Register src, Register dst) {
+            super(dst, src, dst);
         }
 
-        public Bclr(SPARCAssembler asm, int simm13, Register dst) {
-            new Andn(asm, dst, simm13, dst);
+        public Bclr(int simm13, Register dst) {
+            super(dst, simm13, dst);
         }
     }
 
     @SuppressWarnings("unused")
-    public static class Bset {
+    public static class Bset extends Or {
 
-        public Bset(SPARCAssembler asm, Register src, Register dst) {
-            new Or(asm, dst, src, dst);
+        public Bset(Register src, Register dst) {
+            super(dst, src, dst);
         }
 
-        public Bset(SPARCAssembler asm, int simm13, Register dst) {
-            new Or(asm, dst, simm13, dst);
+        public Bset(int simm13, Register dst) {
+            super(dst, simm13, dst);
         }
     }
 
     @SuppressWarnings("unused")
-    public static class Btog {
+    public static class Btst extends Andcc {
 
-        public Btog(SPARCAssembler asm, Register src, Register dst) {
-            new Xor(asm, dst, src, dst);
+        public Btst(Register src1, Register src2) {
+            super(src1, src2, g0);
         }
 
-        public Btog(SPARCAssembler asm, int simm13, Register dst) {
-            new Xor(asm, dst, simm13, dst);
-        }
-    }
-
-    @SuppressWarnings("unused")
-    public static class Btst {
-
-        public Btst(SPARCAssembler asm, Register src1, Register src2) {
-            new Andcc(asm, src1, src2, SPARC.g0);
-        }
-
-        public Btst(SPARCAssembler asm, Register src1, int simm13) {
-            new Andcc(asm, src1, simm13, SPARC.g0);
+        public Btst(Register src1, int simm13) {
+            super(src1, simm13, g0);
         }
     }
 
@@ -85,194 +112,202 @@
     public static class Clr {
 
         public Clr(SPARCAssembler asm, Register dst) {
-            new Or(asm, SPARC.g0, SPARC.g0, dst);
+            new Or(g0, g0, dst).emit(asm);
         }
 
         public Clr(SPARCAssembler asm, SPARCAddress addr) {
-            new Stw(asm, SPARC.g0, addr);
+            new Stw(g0, addr).emit(asm);
         }
     }
 
     @SuppressWarnings("unused")
-    public static class Clrb {
+    public static class Clrb extends Stb {
 
-        public Clrb(SPARCAssembler asm, SPARCAddress addr) {
-            new Stb(asm, SPARC.g0, addr);
+        public Clrb(SPARCAddress addr) {
+            super(g0, addr);
         }
     }
 
     @SuppressWarnings("unused")
-    public static class Clrh {
+    public static class Clrh extends Sth {
 
-        public Clrh(SPARCAssembler asm, SPARCAddress addr) {
-            new Sth(asm, SPARC.g0, addr);
+        public Clrh(SPARCAddress addr) {
+            super(g0, addr);
         }
     }
 
     @SuppressWarnings("unused")
-    public static class Clrx {
+    public static class Clrx extends Stx {
 
-        public Clrx(SPARCAssembler asm, SPARCAddress addr) {
-            new Stx(asm, SPARC.g0, addr);
+        public Clrx(SPARCAddress addr) {
+            super(g0, addr);
         }
     }
 
     @SuppressWarnings("unused")
-    public static class Clruw {
+    public static class Clruw extends Srl {
 
-        public Clruw(SPARCAssembler asm, Register src1, Register dst) {
+        public Clruw(Register src1, Register dst) {
+            super(src1, g0, dst);
             assert src1.encoding() != dst.encoding();
-            new Srl(asm, src1, SPARC.g0, dst);
         }
 
-        public Clruw(SPARCAssembler asm, Register dst) {
-            new Srl(asm, dst, SPARC.g0, dst);
+        public Clruw(Register dst) {
+            super(dst, g0, dst);
         }
     }
 
     @SuppressWarnings("unused")
-    public static class Cmp {
+    public static class Cmp extends Subcc {
 
-        public Cmp(SPARCAssembler asm, Register a, Register b) {
-            new Subcc(asm, a, b, SPARC.g0);
+        public Cmp(Register a, Register b) {
+            super(a, b, g0);
         }
 
-        public Cmp(SPARCAssembler asm, Register a, int simm13) {
-            new Subcc(asm, a, simm13, SPARC.g0);
+        public Cmp(Register a, int simm13) {
+            super(a, simm13, g0);
         }
     }
 
     @SuppressWarnings("unused")
-    public static class Dec {
+    public static class Dec extends Sub {
 
-        public Dec(SPARCAssembler asm, Register dst) {
-            new Sub(asm, dst, 1, dst);
+        public Dec(Register dst) {
+            super(dst, 1, dst);
         }
 
-        public Dec(SPARCAssembler asm, int simm13, Register dst) {
-            new Sub(asm, dst, simm13, dst);
+        public Dec(int simm13, Register dst) {
+            super(dst, simm13, dst);
         }
     }
 
     @SuppressWarnings("unused")
-    public static class Deccc {
+    public static class Deccc extends Subcc {
 
-        public Deccc(SPARCAssembler asm, Register dst) {
-            new Subcc(asm, dst, 1, dst);
+        public Deccc(Register dst) {
+            super(dst, 1, dst);
         }
 
-        public Deccc(SPARCAssembler asm, int simm13, Register dst) {
-            new Subcc(asm, dst, simm13, dst);
+        public Deccc(int simm13, Register dst) {
+            super(dst, simm13, dst);
         }
     }
 
     @SuppressWarnings("unused")
     public static class Inc {
 
-        public Inc(SPARCAssembler asm, Register dst) {
-            new Add(asm, dst, 1, dst);
+        public Inc(Register dst) {
+            new Add(dst, 1, dst);
         }
 
-        public Inc(SPARCAssembler asm, int simm13, Register dst) {
-            new Add(asm, dst, simm13, dst);
+        public Inc(int simm13, Register dst) {
+            new Add(dst, simm13, dst);
         }
     }
 
     @SuppressWarnings("unused")
     public static class Inccc {
 
-        public Inccc(SPARCAssembler asm, Register dst) {
-            new Addcc(asm, dst, 1, dst);
+        public Inccc(Register dst) {
+            new Addcc(dst, 1, dst);
         }
 
-        public Inccc(SPARCAssembler asm, int simm13, Register dst) {
-            new Addcc(asm, dst, simm13, dst);
+        public Inccc(int simm13, Register dst) {
+            new Addcc(dst, simm13, dst);
         }
     }
 
     @SuppressWarnings("unused")
-    public static class Jmp {
+    public static class Jmp extends Jmpl {
 
         public Jmp(SPARCAssembler asm, SPARCAddress address) {
-            new Jmpl(asm, address, SPARC.g0);
+            super(address.getBase(), address.getDisplacement(), g0);
         }
     }
 
     @SuppressWarnings("unused")
-    public static class Neg {
+    public static class Neg extends Sub {
 
-        public Neg(SPARCAssembler asm, Register src2, Register dst) {
+        public Neg(Register src2, Register dst) {
+            super(g0, src2, dst);
             assert src2.encoding() != dst.encoding();
-            new Sub(asm, SPARC.g0, src2, dst);
         }
 
-        public Neg(SPARCAssembler asm, Register dst) {
-            new Sub(asm, SPARC.g0, dst, dst);
+        public Neg(Register dst) {
+            super(g0, dst, dst);
         }
     }
 
     @SuppressWarnings("unused")
-    public static class Mov {
+    public static class Mov extends Or {
 
-        public Mov(SPARCAssembler asm, Register src1, Register dst) {
+        public Mov(Register src1, Register dst) {
+            super(g0, src1, dst);
             assert src1.encoding() != dst.encoding();
-            new Or(asm, SPARC.g0, src1, dst);
         }
 
-        public Mov(SPARCAssembler asm, int simm13, Register dst) {
-            new Or(asm, SPARC.g0, simm13, dst);
+        public Mov(int simm13, Register dst) {
+            super(g0, simm13, dst);
+        }
+    }
+
+    public static class Nop extends Sethi {
+
+        public Nop() {
+            super(0, r0);
         }
     }
 
     @SuppressWarnings("unused")
-    public static class Not {
+    public static class Not extends Xnor {
 
-        public Not(SPARCAssembler asm, Register src1, Register dst) {
+        public Not(Register src1, Register dst) {
+            super(src1, g0, dst);
             assert src1.encoding() != dst.encoding();
-            new Xnor(asm, src1, SPARC.g0, dst);
         }
 
-        public Not(SPARCAssembler asm, Register dst) {
-            new Xnor(asm, dst, SPARC.g0, dst);
+        public Not(Register dst) {
+            super(dst, g0, dst);
         }
     }
 
     @SuppressWarnings("unused")
-    public static class RestoreWindow {
+    public static class RestoreWindow extends Restore {
 
-        public RestoreWindow(SPARCAssembler asm) {
-            new Restore(asm, SPARC.g0, SPARC.g0, SPARC.g0);
+        public RestoreWindow() {
+            super(g0, g0, g0);
         }
     }
 
     @SuppressWarnings("unused")
-    public static class Ret {
+    public static class Ret extends Jmpl {
 
-        public Ret(SPARCAssembler asm) {
-            new Jmpl(asm, new SPARCAddress(SPARC.i0, 8), SPARC.g0);
-
+        public Ret() {
+            super(i7, 8, g0);
         }
     }
 
     @SuppressWarnings("unused")
-    public static class SaveWindow {
+    public static class SaveWindow extends Save {
 
-        public SaveWindow(SPARCAssembler asm) {
-            new Save(asm, SPARC.g0, SPARC.g0, SPARC.g0);
+        public SaveWindow() {
+            super(g0, g0, g0);
         }
     }
 
     @SuppressWarnings("unused")
     public static class Setuw {
 
-        public Setuw(SPARCAssembler asm, int value, Register dst) {
-            if (value >= 0 && ((value & 0x3FFF) == 0)) {
-                new Sethi(asm, hi22(value), dst);
+        public Setuw(SPARCAssembler masm, int value, Register dst) {
+            if (value == 0) {
+                new Clr(masm, dst);
             } else if (-4095 <= value && value <= 4096) {
-                new Or(asm, SPARC.g0, value, dst);
+                new Or(g0, value, dst).emit(masm);
+            } else if (value >= 0 && ((value & 0x3FFF) == 0)) {
+                new Sethi(hi22(value), dst).emit(masm);
             } else {
-                new Sethi(asm, hi22(value), dst);
-                new Or(asm, dst, lo10(value), dst);
+                new Sethi(hi22(value), dst).emit(masm);
+                new Or(dst, lo10(value), dst).emit(masm);
             }
         }
     }
@@ -285,50 +320,50 @@
             int lo = (int) (value & ~0);
 
             if (isSimm13(lo) && value == lo) {
-                new Or(asm, SPARC.g0, lo, dst);
+                new Or(g0, lo, dst).emit(asm);
             } else if (hi == 0) {
-                new Sethi(asm, lo, dst);   // hardware version zero-extends to upper 32
+                new Sethi(lo, dst).emit(asm);   // hardware version zero-extends to upper 32
                 if (lo10(lo) != 0) {
-                    new Or(asm, dst, lo10(lo), dst);
+                    new Or(dst, lo10(lo), dst).emit(asm);
                 }
             } else if (hi == -1) {
-                new Sethi(asm, ~lo, dst);  // hardware version zero-extends to upper 32
-                new Xor(asm, dst, lo10(lo) ^ ~lo10(~0), dst);
+                new Sethi(~lo, dst).emit(asm);  // hardware version zero-extends to upper 32
+                new Xor(dst, lo10(lo) ^ ~lo10(~0), dst).emit(asm);
             } else if (lo == 0) {
                 if (isSimm13(hi)) {
-                    new Or(asm, SPARC.g0, hi, dst);
+                    new Or(g0, hi, dst).emit(asm);
                 } else {
-                    new Sethi(asm, hi, dst);   // hardware version zero-extends to upper 32
+                    new Sethi(hi, dst).emit(asm);   // hardware version zero-extends to upper 32
                     if (lo10(hi) != 0) {
-                        new Or(asm, dst, lo10(hi), dst);
+                        new Or(dst, lo10(hi), dst).emit(asm);
                     }
                 }
-                new Sllx(asm, dst, 32, dst);
+                new Sllx(dst, 32, dst).emit(asm);
             } else {
-                new Sethi(asm, hi, tmp);
-                new Sethi(asm, lo, dst); // macro assembler version sign-extends
+                new Sethi(hi, tmp).emit(asm);
+                new Sethi(lo, dst).emit(asm); // macro assembler version sign-extends
                 if (lo10(hi) != 0) {
-                    new Or(asm, tmp, lo10(hi), tmp);
+                    new Or(tmp, lo10(hi), tmp).emit(asm);
                 }
                 if (lo10(lo) != 0) {
-                    new Or(asm, dst, lo10(lo), dst);
+                    new Or(dst, lo10(lo), dst).emit(asm);
                 }
-                new Sllx(asm, tmp, 32, tmp);
-                new Or(asm, dst, tmp, dst);
+                new Sllx(tmp, 32, tmp).emit(asm);
+                new Or(dst, tmp, dst).emit(asm);
             }
         }
     }
 
     @SuppressWarnings("unused")
-    public static class Signx {
+    public static class Signx extends Sra {
 
-        public Signx(SPARCAssembler asm, Register src1, Register dst) {
+        public Signx(Register src1, Register dst) {
+            super(src1, g0, dst);
             assert src1.encoding() != dst.encoding();
-            new Sra(asm, src1, SPARC.g0, dst);
         }
 
-        public Signx(SPARCAssembler asm, Register dst) {
-            new Sra(asm, dst, SPARC.g0, dst);
+        public Signx(Register dst) {
+            super(dst, g0, dst);
         }
     }
 
@@ -337,7 +372,7 @@
 
         public Trap(SPARCAssembler asm, int trap) {
             assert trap >= 0 && trap <= 0x7f;
-            new Ta(asm, Icc, SPARC.g0, trap);
+            new Ta(asm, Icc, g0, trap);
         }
     }
 }