--- a/GRAAL_AUTHORS	Wed Jun 27 11:48:26 2012 +0200
+++ b/GRAAL_AUTHORS	Wed Jun 27 17:35:32 2012 +0200
@@ -1,20 +1,7 @@
-Doug Simon (doug.simon@oracle.com)
-* Since December 2011
-
-Christian Wimmer (christian.wimmer@oracle.com)
-* Since December 2011
-
-Lukas Stadler (stadler@ssw.jku.at)
-* July - September 2010: Initial feature-complete implementation, remote compilation
-* Since April 2011: New IR design
-
-Gilles Duboscq (gilles.duboscq@oracle.com)
-* Since April 2011: New IR design
-
-Peter Hofer (hofer@ssw.jku.at)
-* Since May 2011: Graphviz visualization
-
-Thomas Wuerthinger (thomas.wuerthinger@oracle.com)
-* June 2011: Initial prototype
-* October 2010 - January 2011: Bug fixes (all DaCapo's pass), better performance on SciMark than C1
-* Since April 2011: New IR design
+Gilles Duboscq (gdub)
+Peter Hofer
+Christian Humer (chumer)
+Christian Wimmer (cwimmer)
+Doug Simon (dnsimon)
+Lukas Stadler (lstadler)
+Thomas Wuerthinger (thomaswue)

--- a/graal/com.oracle.graal.alloc/src/com/oracle/graal/alloc/simple/AssignRegisters.java	Wed Jun 27 11:48:26 2012 +0200
+++ b/graal/com.oracle.graal.alloc/src/com/oracle/graal/alloc/simple/AssignRegisters.java	Wed Jun 27 17:35:32 2012 +0200
@@ -24,8 +24,10 @@
 
 import static com.oracle.graal.alloc.util.LocationUtil.*;
 
-import com.oracle.max.cri.ci.*;
+import java.util.*;
+
 import com.oracle.graal.alloc.util.*;
+import com.oracle.graal.api.meta.*;
 import com.oracle.graal.debug.*;
 import com.oracle.graal.lir.*;
 import com.oracle.graal.lir.LIRInstruction.*;
@@ -40,13 +42,13 @@
         this.frameMap = frameMap;
     }
 
-    private CiBitMap curRegisterRefMap;
-    private CiBitMap curFrameRefMap;
+    private BitSet curRegisterRefMap;
+    private BitSet curFrameRefMap;
 
     public void execute() {
-        ValueProcedure useProc =          new ValueProcedure() { @Override public CiValue doValue(CiValue value) { return use(value); } };
-        ValueProcedure defProc =          new ValueProcedure() { @Override public CiValue doValue(CiValue value) { return def(value); } };
-        ValueProcedure setReferenceProc = new ValueProcedure() { @Override public CiValue doValue(CiValue value) { return setReference(value); } };
+        ValueProcedure useProc =          new ValueProcedure() { @Override public Value doValue(Value value) { return use(value); } };
+        ValueProcedure defProc =          new ValueProcedure() { @Override public Value doValue(Value value) { return def(value); } };
+        ValueProcedure setReferenceProc = new ValueProcedure() { @Override public Value doValue(Value value) { return setReference(value); } };
 
         Debug.log("==== start assign registers ====");
         for (int i = lir.linearScanOrder().size() - 1; i >= 0; i--) {
@@ -70,12 +72,12 @@
 
                 if (op.info != null) {
                     Debug.log("    registerRefMap: %s  frameRefMap: %s", curRegisterRefMap, curFrameRefMap);
-                    op.info.finish(new CiBitMap(curRegisterRefMap), new CiBitMap(curFrameRefMap), frameMap);
+                    op.info.finish((BitSet) (curRegisterRefMap.clone()), (BitSet) (curFrameRefMap.clone()), frameMap);
 
                     if (op instanceof LIRXirInstruction) {
                         LIRXirInstruction xir = (LIRXirInstruction) op;
                         if (xir.infoAfter != null) {
-                            xir.infoAfter.finish(new CiBitMap(curRegisterRefMap), new CiBitMap(curFrameRefMap), frameMap);
+                            xir.infoAfter.finish((BitSet) (curRegisterRefMap.clone()), (BitSet) (curFrameRefMap.clone()), frameMap);
                         }
                     }
                 }
@@ -89,10 +91,10 @@
         Debug.log("==== end assign registers ====");
     }
 
-    private CiValue use(CiValue value) {
+    private Value use(Value value) {
         Debug.log("    use %s", value);
         if (isLocation(value)) {
-            CiValue location = asLocation(value).location;
+            Value location = asLocation(value).location;
             frameMap.setReference(location, curRegisterRefMap, curFrameRefMap);
             return location;
         } else {
@@ -101,10 +103,10 @@
         }
     }
 
-    private CiValue def(CiValue value) {
+    private Value def(Value value) {
         Debug.log("    def %s", value);
         if (isLocation(value)) {
-            CiValue location = asLocation(value).location;
+            Value location = asLocation(value).location;
             frameMap.clearReference(location, curRegisterRefMap, curFrameRefMap);
             return location;
         } else {
@@ -113,7 +115,7 @@
         }
     }
 
-    private CiValue setReference(CiValue value) {
+    private Value setReference(Value value) {
         Debug.log("    setReference %s", value);
         frameMap.setReference(asLocation(value).location, curRegisterRefMap, curFrameRefMap);
         return value;

--- a/graal/com.oracle.graal.alloc/src/com/oracle/graal/alloc/simple/DataFlowAnalysis.java	Wed Jun 27 11:48:26 2012 +0200
+++ b/graal/com.oracle.graal.alloc/src/com/oracle/graal/alloc/simple/DataFlowAnalysis.java	Wed Jun 27 17:35:32 2012 +0200
@@ -22,13 +22,13 @@
  */
 package com.oracle.graal.alloc.simple;
 
-import static com.oracle.max.cri.ci.CiValueUtil.*;
-import static com.oracle.graal.lir.ValueUtil.*;
+import static com.oracle.graal.api.code.ValueUtil.*;
+import static com.oracle.graal.lir.LIRValueUtil.*;
 
 import java.util.*;
 
-import com.oracle.max.cri.ci.*;
-import com.oracle.max.cri.ri.*;
+import com.oracle.graal.api.code.*;
+import com.oracle.graal.api.meta.*;
 import com.oracle.graal.debug.*;
 import com.oracle.graal.lir.*;
 import com.oracle.graal.lir.LIRInstruction.*;
@@ -36,9 +36,9 @@
 
 public class DataFlowAnalysis {
     private final LIR lir;
-    private final RiRegisterConfig registerConfig;
+    private final RegisterConfig registerConfig;
 
-    public DataFlowAnalysis(LIR lir, RiRegisterConfig registerConfig) {
+    public DataFlowAnalysis(LIR lir, RegisterConfig registerConfig) {
         this.lir = lir;
         this.registerConfig = registerConfig;
     }
@@ -57,8 +57,8 @@
         return lir.numVariables();
     }
 
-    private boolean isAllocatableRegister(CiValue value) {
-        return isRegister(value) && registerConfig.getAttributesMap()[asRegister(value).number].isAllocatable;
+    private boolean isAllocatableRegister(Value value) {
+        return isRegister(value) && registerConfig.getAttributesMap()[asRegister(value).number].isAllocatable();
     }
 
 
@@ -93,14 +93,14 @@
         Object entry = killedValues(op.id() + (end ? 1 : 0));
         if (entry == null) {
             // Nothing to do
-        } else if (entry instanceof CiValue) {
-            CiValue newValue = proc.doValue((CiValue) entry, null, null);
+        } else if (entry instanceof Value) {
+            Value newValue = proc.doValue((Value) entry, null, null);
             assert newValue == entry : "procedure does not allow to change values";
         } else {
-            CiValue[] values = (CiValue[]) entry;
+            Value[] values = (Value[]) entry;
             for (int i = 0; i < values.length; i++) {
                 if (values[i] != null) {
-                    CiValue newValue = proc.doValue(values[i], null, null);
+                    Value newValue = proc.doValue(values[i], null, null);
                     assert newValue == values[i] : "procedure does not allow to change values";
                 }
             }
@@ -115,7 +115,7 @@
      * Numbers all instructions in all blocks. The numbering follows the {@linkplain ComputeLinearScanOrder linear scan order}.
      */
     private void numberInstructions() {
-        ValueProcedure defProc = new ValueProcedure() { @Override public CiValue doValue(CiValue value) { return setDef(value); } };
+        ValueProcedure defProc = new ValueProcedure() { @Override public Value doValue(Value value) { return setDef(value); } };
 
         int numInstructions = 0;
         for (Block block : blocks()) {
@@ -140,7 +140,7 @@
         assert curOpId == numInstructions << 1;
     }
 
-    private CiValue setDef(CiValue value) {
+    private Value setDef(Value value) {
         if (isVariable(value)) {
             assert definitions[asVariable(value).index] == 0 : "Variable defined twice";
             definitions[asVariable(value).index] = curOpId;
@@ -154,10 +154,10 @@
     private int curOpId;
 
     private void backwardDataFlow() {
-        ValueProcedure inputProc =    new ValueProcedure() { @Override public CiValue doValue(CiValue value) { return use(value, curOpId); } };
-        ValueProcedure aliveProc =    new ValueProcedure() { @Override public CiValue doValue(CiValue value) { return use(value, curOpId + 1); } };
-        ValueProcedure tempProc =     new ValueProcedure() { @Override public CiValue doValue(CiValue value) { return def(value, true); } };
-        ValueProcedure outputProc =   new ValueProcedure() { @Override public CiValue doValue(CiValue value) { return def(value, false); } };
+        ValueProcedure inputProc =    new ValueProcedure() { @Override public Value doValue(Value value) { return use(value, curOpId); } };
+        ValueProcedure aliveProc =    new ValueProcedure() { @Override public Value doValue(Value value) { return use(value, curOpId + 1); } };
+        ValueProcedure tempProc =     new ValueProcedure() { @Override public Value doValue(Value value) { return def(value, true); } };
+        ValueProcedure outputProc =   new ValueProcedure() { @Override public Value doValue(Value value) { return def(value, false); } };
 
         blockLiveIn = new BitSet[blocks().size()];
         registerLive = new BitSet();
@@ -211,7 +211,7 @@
         Debug.log("==== end backward data flow analysis ====");
     }
 
-    private CiValue use(CiValue value, int killOpId) {
+    private Value use(Value value, int killOpId) {
         Debug.log("    use %s", value);
         if (isVariable(value)) {
             int variableIdx = asVariable(value).index;
@@ -233,7 +233,7 @@
         return value;
     }
 
-    private CiValue def(CiValue value, boolean isTemp) {
+    private Value def(Value value, boolean isTemp) {
         Debug.log("    def %s", value);
         if (isVariable(value)) {
             int variableIdx = asVariable(value).index;
@@ -261,7 +261,7 @@
         return value;
     }
 
-    private void kill(CiValue value, int opId) {
+    private void kill(Value value, int opId) {
         if (opId < 0) {
             return;
         }
@@ -284,10 +284,10 @@
         Object entry = killedValues(opId);
         if (entry == null) {
             setKilledValues(opId, value);
-        } else if (entry instanceof CiValue) {
-            setKilledValues(opId, new CiValue[] {(CiValue) entry, value});
+        } else if (entry instanceof Value) {
+            setKilledValues(opId, new Value[] {(Value) entry, value});
         } else {
-            CiValue[] killed = (CiValue[]) entry;
+            Value[] killed = (Value[]) entry;
             for (int i = 0; i < killed.length; i++) {
                 if (killed[i] == null) {
                     killed[i] = value;

--- a/graal/com.oracle.graal.alloc/src/com/oracle/graal/alloc/simple/LinearScanAllocator.java	Wed Jun 27 11:48:26 2012 +0200
+++ b/graal/com.oracle.graal.alloc/src/com/oracle/graal/alloc/simple/LinearScanAllocator.java	Wed Jun 27 17:35:32 2012 +0200
@@ -22,14 +22,13 @@
  */
 package com.oracle.graal.alloc.simple;
 
-import static com.oracle.max.cri.ci.CiValueUtil.*;
 import static com.oracle.graal.alloc.util.LocationUtil.*;
-
 import java.util.*;
 
-import com.oracle.max.cri.ci.*;
-import com.oracle.max.cri.ci.CiRegister.RegisterFlag;
 import com.oracle.graal.alloc.util.*;
+import com.oracle.graal.api.code.*;
+import com.oracle.graal.api.code.Register.*;
+import com.oracle.graal.api.meta.*;
 import com.oracle.graal.debug.*;
 import com.oracle.graal.graph.*;
 import com.oracle.graal.lir.*;
@@ -60,17 +59,17 @@
         }
 
         @Override
-        protected CiValue scratchRegister(Variable spilled) {
+        protected Value scratchRegister(Variable spilled) {
             GraalInternalError.shouldNotReachHere("needs working implementation");
 
-            EnumMap<RegisterFlag, CiRegister[]> categorizedRegs = frameMap.registerConfig.getCategorizedAllocatableRegisters();
-            CiRegister[] availableRegs = categorizedRegs.get(spilled.flag);
-            for (CiRegister reg : availableRegs) {
+            EnumMap<RegisterFlag, Register[]> categorizedRegs = frameMap.registerConfig.getCategorizedAllocatableRegisters();
+            Register[] availableRegs = categorizedRegs.get(spilled.flag);
+            for (Register reg : availableRegs) {
                 if (curInRegisterState[reg.number] == null && curOutRegisterState[reg.number] == null) {
                     return reg.asValue(spilled.kind);
                 }
             }
-            throw new CiBailout("No register found");
+            throw new BailoutException("No register found");
         }
     }
 
@@ -106,8 +105,8 @@
         return frameMap.target.arch.registers.length;
     }
 
-    private boolean isAllocatableRegister(CiValue value) {
-        return isRegister(value) && frameMap.registerConfig.getAttributesMap()[asRegister(value).number].isAllocatable;
+    private boolean isAllocatableRegister(Value value) {
+        return isRegister(value) && frameMap.registerConfig.getAttributesMap()[asRegister(value).number].isAllocatable();
     }
 
 
@@ -141,8 +140,8 @@
 
     private MoveResolver moveResolver;
     private LocationMap curLocations;
-    private CiValue[] curInRegisterState;
-    private CiValue[] curOutRegisterState;
+    private Value[] curInRegisterState;
+    private Value[] curOutRegisterState;
     private BitSet curLiveIn;
     private LIRInstruction curOp;
 
@@ -181,19 +180,19 @@
     }
 
     private void allocate() {
-        ValueProcedure recordUseProc =    new ValueProcedure() { @Override public CiValue doValue(CiValue value, OperandMode mode, EnumSet<OperandFlag> flags) { return recordUse(value); } };
-        ValueProcedure killNonLiveProc =  new ValueProcedure() { @Override public CiValue doValue(CiValue value) { return killNonLive(value); } };
-        ValueProcedure unblockProc =      new ValueProcedure() { @Override public CiValue doValue(CiValue value) { return unblock(value); } };
-        ValueProcedure killProc =         new ValueProcedure() { @Override public CiValue doValue(CiValue value) { return kill(value); } };
-        ValueProcedure blockProc =        new ValueProcedure() { @Override public CiValue doValue(CiValue value) { return block(value); } };
-        ValueProcedure useProc =          new ValueProcedure() { @Override public CiValue doValue(CiValue value, OperandMode mode, EnumSet<OperandFlag> flags) { return use(value, mode, flags); } };
-        ValueProcedure defProc =          new ValueProcedure() { @Override public CiValue doValue(CiValue value, OperandMode mode, EnumSet<OperandFlag> flags) { return def(value, mode, flags); } };
+        ValueProcedure recordUseProc =    new ValueProcedure() { @Override public Value doValue(Value value, OperandMode mode, EnumSet<OperandFlag> flags) { return recordUse(value); } };
+        ValueProcedure killNonLiveProc =  new ValueProcedure() { @Override public Value doValue(Value value) { return killNonLive(value); } };
+        ValueProcedure unblockProc =      new ValueProcedure() { @Override public Value doValue(Value value) { return unblock(value); } };
+        ValueProcedure killProc =         new ValueProcedure() { @Override public Value doValue(Value value) { return kill(value); } };
+        ValueProcedure blockProc =        new ValueProcedure() { @Override public Value doValue(Value value) { return block(value); } };
+        ValueProcedure useProc =          new ValueProcedure() { @Override public Value doValue(Value value, OperandMode mode, EnumSet<OperandFlag> flags) { return use(value, mode, flags); } };
+        ValueProcedure defProc =          new ValueProcedure() { @Override public Value doValue(Value value, OperandMode mode, EnumSet<OperandFlag> flags) { return def(value, mode, flags); } };
 
         Debug.log("==== start linear scan allocation ====");
         canonicalSpillLocations = new LocationMap(lir.numVariables());
         hintRegisterLocations = new LocationMap(lir.numVariables());
-        curInRegisterState = new CiValue[maxRegisterNum()];
-        curOutRegisterState = new CiValue[maxRegisterNum()];
+        curInRegisterState = new Value[maxRegisterNum()];
+        curOutRegisterState = new Value[maxRegisterNum()];
         for (Block block : lir.linearScanOrder()) {
             Debug.log("start block %s %s", block, block.getLoop());
 
@@ -273,7 +272,7 @@
         Debug.log("==== end linear scan allocation ====");
     }
 
-    private CiValue killNonLive(CiValue value) {
+    private Value killNonLive(Value value) {
         assert isLocation(value);
         if (!curLiveIn.get(asLocation(value).variable.index)) {
             return null;
@@ -286,7 +285,7 @@
         return value;
     }
 
-    private CiValue unblock(CiValue value) {
+    private Value unblock(Value value) {
         if (isAllocatableRegister(value)) {
             Debug.log("    unblock register %s", value);
             int regNum = asRegister(value).number;
@@ -296,7 +295,7 @@
         return value;
     }
 
-    private CiValue kill(CiValue value) {
+    private Value kill(Value value) {
         if (isVariable(value)) {
             Location location = curLocations.get(asVariable(value));
             Debug.log("    kill location %s", location);
@@ -312,7 +311,7 @@
     }
 
 
-    private CiValue block(CiValue value) {
+    private Value block(Value value) {
         if (isAllocatableRegister(value)) {
             Debug.log("    block %s", value);
             int regNum = asRegister(value).number;
@@ -324,15 +323,15 @@
 
     private void spillCallerSaveRegisters() {
         Debug.log("    spill caller save registers in curInRegisterState %s", Arrays.toString(curInRegisterState));
-        for (CiRegister reg : frameMap.registerConfig.getCallerSaveRegisters()) {
-            CiValue in = curInRegisterState[reg.number];
+        for (Register reg : frameMap.registerConfig.getCallerSaveRegisters()) {
+            Value in = curInRegisterState[reg.number];
             if (in != null && isLocation(in)) {
                 spill(asLocation(in));
             }
         }
     }
 
-    private CiValue recordUse(CiValue value) {
+    private Value recordUse(Value value) {
         if (isVariable(value)) {
             assert lastUseFor(asVariable(value)) <= curOp.id();
             setLastUseFor(asVariable(value), curOp.id());
@@ -341,7 +340,7 @@
         return value;
     }
 
-    private CiValue use(CiValue value, OperandMode mode, EnumSet<OperandFlag> flags) {
+    private Value use(Value value, OperandMode mode, EnumSet<OperandFlag> flags) {
         assert mode == OperandMode.Input || mode == OperandMode.Alive;
         if (isVariable(value)) {
             // State values are not recorded beforehand because it does not matter if they are spilled. Still, it is necessary to record them as used now.
@@ -376,7 +375,7 @@
 
     private static final EnumSet<OperandFlag> SPILL_FLAGS = EnumSet.of(OperandFlag.Register, OperandFlag.Stack);
 
-    private CiValue def(CiValue value, OperandMode mode, EnumSet<OperandFlag> flags) {
+    private Value def(Value value, OperandMode mode, EnumSet<OperandFlag> flags) {
         assert mode == OperandMode.Temp || mode == OperandMode.Output;
         if (isVariable(value)) {
             Debug.log("    def %s %s", mode, value);
@@ -391,8 +390,8 @@
 
     private void fixupEvicted() {
         for (int i = 0; i < curInRegisterState.length; i++) {
-            CiValue in = curInRegisterState[i];
-            CiValue out = curOutRegisterState[i];
+            Value in = curInRegisterState[i];
+            Value out = curOutRegisterState[i];
 
             if (in != null && in != out && isLocation(in) && curLocations.get(asLocation(in).variable) == in) {
                 Debug.log("    %s was evicted by %s, need to allocate new location", in, out);
@@ -409,13 +408,13 @@
 
     private void phiRegisterHints(Block block) {
         Debug.log("    phi register hints for %s", block);
-        CiValue[] phiDefinitions = ((StandardOp.PhiLabelOp) block.lir.get(0)).getPhiDefinitions();
+        Value[] phiDefinitions = ((StandardOp.PhiLabelOp) block.lir.get(0)).getPhiDefinitions();
         for (Block pred : block.getPredecessors()) {
-            CiValue[] phiInputs = ((StandardOp.PhiJumpOp) pred.lir.get(pred.lir.size() - 1)).getPhiInputs();
+            Value[] phiInputs = ((StandardOp.PhiJumpOp) pred.lir.get(pred.lir.size() - 1)).getPhiInputs();
 
             for (int i = 0; i < phiDefinitions.length; i++) {
-                CiValue phiDefinition = phiDefinitions[i];
-                CiValue phiInput = phiInputs[i];
+                Value phiDefinition = phiDefinitions[i];
+                Value phiInput = phiInputs[i];
 
                 if (isVariable(phiDefinition)) {
                     Location hintResult = processRegisterHint(asVariable(phiDefinition), OperandMode.Output, phiInput);
@@ -427,12 +426,12 @@
         }
     }
 
-    private Location processRegisterHint(Variable variable, OperandMode mode, CiValue registerHint) {
+    private Location processRegisterHint(Variable variable, OperandMode mode, Value registerHint) {
         if (registerHint == null) {
             return null;
         }
         Debug.log("      try registerHint for %s %s: %s", mode, variable, registerHint);
-        CiRegister hint = null;
+        Register hint = null;
         if (isRegister(registerHint)) {
             hint = asRegister(registerHint);
         } else if (isLocation(registerHint) && isRegister(asLocation(registerHint).location)) {
@@ -446,9 +445,9 @@
 
     private Location allocateRegister(final Variable variable, final OperandMode mode, EnumSet<OperandFlag> flags) {
         if (flags.contains(OperandFlag.RegisterHint)) {
-            CiValue hintResult = curOp.forEachRegisterHint(variable, mode, new ValueProcedure() {
+            Value hintResult = curOp.forEachRegisterHint(variable, mode, new ValueProcedure() {
                 @Override
-                public CiValue doValue(CiValue registerHint) {
+                public Value doValue(Value registerHint) {
                     return processRegisterHint(variable, mode, registerHint);
                 }
             });
@@ -457,16 +456,16 @@
             }
         }
 
-        CiValue hintResult = processRegisterHint(variable, mode, hintRegisterLocations.get(variable));
+        Value hintResult = processRegisterHint(variable, mode, hintRegisterLocations.get(variable));
         if (hintResult != null) {
             return asLocation(hintResult);
         }
 
-        EnumMap<RegisterFlag, CiRegister[]> categorizedRegs = frameMap.registerConfig.getCategorizedAllocatableRegisters();
-        CiRegister[] availableRegs = categorizedRegs.get(variable.flag);
+        EnumMap<RegisterFlag, Register[]> categorizedRegs = frameMap.registerConfig.getCategorizedAllocatableRegisters();
+        Register[] availableRegs = categorizedRegs.get(variable.flag);
 
         Location bestSpillCandidate = null;
-        for (CiRegister reg : availableRegs) {
+        for (Register reg : availableRegs) {
             if (isFree(reg, mode)) {
                 return selectRegister(reg, variable, mode);
             } else {
@@ -500,7 +499,7 @@
         }
         curLocations.put(newLoc);
 
-        CiRegister reg = asRegister(value.location);
+        Register reg = asRegister(value.location);
         assert curInRegisterState[reg.number] == value;
         curInRegisterState[reg.number] = null;
         if (curOutRegisterState[reg.number] == value) {
@@ -508,7 +507,7 @@
         }
     }
 
-    private boolean isFree(CiRegister reg, OperandMode mode) {
+    private boolean isFree(Register reg, OperandMode mode) {
         switch (mode) {
             case Input:  return curInRegisterState[reg.number] == null;
             case Alive:  return curInRegisterState[reg.number] == null && curOutRegisterState[reg.number] == null;
@@ -518,9 +517,9 @@
         }
     }
 
-    private Location spillCandidate(CiRegister reg) {
-        CiValue in = curInRegisterState[reg.number];
-        CiValue out = curOutRegisterState[reg.number];
+    private Location spillCandidate(Register reg) {
+        Value in = curInRegisterState[reg.number];
+        Value out = curOutRegisterState[reg.number];
         if (in == out && in != null && isLocation(in) && lastUseFor(asLocation(in).variable) < curOp.id()) {
             return asLocation(in);
         }
@@ -549,7 +548,7 @@
         return result;
     }
 
-    private Location selectRegister(CiRegister reg, Variable variable, OperandMode mode) {
+    private Location selectRegister(Register reg, Variable variable, OperandMode mode) {
         assert isFree(reg, mode);
 
         Location loc = new Location(variable, reg.asValue(variable.kind));
@@ -580,7 +579,7 @@
         final BitSet liveState = new BitSet();
         curLocations.forEachLocation(new ValueProcedure() {
             @Override
-            public CiValue doValue(CiValue value) {
+            public Value doValue(Value value) {
                 liveState.set(asLocation(value).variable.index);
 
                 for (Block pred : block.getPredecessors()) {
@@ -604,7 +603,7 @@
         sb.append("  current lcoations: ");
         curLocations.forEachLocation(new ValueProcedure() {
             @Override
-            public CiValue doValue(CiValue value) {
+            public Value doValue(Value value) {
                 sb.append(value).append(" ");
                 return value;
             }

--- a/graal/com.oracle.graal.alloc/src/com/oracle/graal/alloc/simple/ResolveDataFlow.java	Wed Jun 27 11:48:26 2012 +0200
+++ b/graal/com.oracle.graal.alloc/src/com/oracle/graal/alloc/simple/ResolveDataFlow.java	Wed Jun 27 17:35:32 2012 +0200
@@ -26,8 +26,8 @@
 
 import java.util.*;
 
-import com.oracle.max.cri.ci.*;
 import com.oracle.graal.alloc.util.*;
+import com.oracle.graal.api.meta.*;
 import com.oracle.graal.debug.*;
 import com.oracle.graal.graph.*;
 import com.oracle.graal.lir.*;
@@ -49,7 +49,7 @@
     private LocationMap curFromLocations;
 
     public void execute() {
-        ValueProcedure locMappingProc = new ValueProcedure() { @Override public CiValue doValue(CiValue value) { return locMapping(value); } };
+        ValueProcedure locMappingProc = new ValueProcedure() { @Override public Value doValue(Value value) { return locMapping(value); } };
 
         Debug.log("==== start resolve data flow ====");
         for (Block toBlock : lir.linearScanOrder()) {
@@ -87,7 +87,7 @@
         Debug.log("==== end resolve data flow ====");
     }
 
-    private CiValue locMapping(CiValue value) {
+    private Value locMapping(Value value) {
         Location to = asLocation(value);
         Location from = curFromLocations.get(to.variable);
         if (value != from && from != null) {
@@ -96,7 +96,7 @@
         return value;
     }
 
-    private void phiMapping(CiValue[] inputs, CiValue[] outputs) {
+    private void phiMapping(Value[] inputs, Value[] outputs) {
         assert inputs.length == outputs.length;
         for (int i = 0; i < inputs.length; i++) {
             if (inputs[i] != outputs[i]) {

--- a/graal/com.oracle.graal.alloc/src/com/oracle/graal/alloc/simple/SpillAllAllocator.java	Wed Jun 27 11:48:26 2012 +0200
+++ b/graal/com.oracle.graal.alloc/src/com/oracle/graal/alloc/simple/SpillAllAllocator.java	Wed Jun 27 17:35:32 2012 +0200
@@ -22,14 +22,13 @@
  */
 package com.oracle.graal.alloc.simple;
 
-import static com.oracle.max.cri.ci.CiValueUtil.*;
 import static com.oracle.graal.alloc.util.LocationUtil.*;
-
 import java.util.*;
 
-import com.oracle.max.cri.ci.*;
-import com.oracle.max.cri.ci.CiRegister.RegisterFlag;
 import com.oracle.graal.alloc.util.*;
+import com.oracle.graal.api.code.*;
+import com.oracle.graal.api.code.Register.*;
+import com.oracle.graal.api.meta.*;
 import com.oracle.graal.debug.*;
 import com.oracle.graal.graph.*;
 import com.oracle.graal.lir.*;
@@ -57,15 +56,15 @@
         }
 
         @Override
-        protected CiValue scratchRegister(Variable spilled) {
-            EnumMap<RegisterFlag, CiRegister[]> categorizedRegs = frameMap.registerConfig.getCategorizedAllocatableRegisters();
-            CiRegister[] availableRegs = categorizedRegs.get(spilled.flag);
-            for (CiRegister reg : availableRegs) {
+        protected Value scratchRegister(Variable spilled) {
+            EnumMap<RegisterFlag, Register[]> categorizedRegs = frameMap.registerConfig.getCategorizedAllocatableRegisters();
+            Register[] availableRegs = categorizedRegs.get(spilled.flag);
+            for (Register reg : availableRegs) {
                 if (curInRegisterState[reg.number] == null && curOutRegisterState[reg.number] == null) {
                     return reg.asValue(spilled.kind);
                 }
             }
-            throw new CiBailout("No register found");
+            throw new BailoutException("No register found");
         }
     }
 
@@ -102,8 +101,8 @@
         return frameMap.target.arch.registers.length;
     }
 
-    private boolean isAllocatableRegister(CiValue value) {
-        return isRegister(value) && frameMap.registerConfig.getAttributesMap()[asRegister(value).number].isAllocatable;
+    private boolean isAllocatableRegister(Value value) {
+        return isRegister(value) && frameMap.registerConfig.getAttributesMap()[asRegister(value).number].isAllocatable();
     }
 
 
@@ -149,14 +148,14 @@
     }
 
     private void allocate() {
-        ValueProcedure killNonLiveProc =  new ValueProcedure() { @Override public CiValue doValue(CiValue value) { return killNonLive(value); } };
-        ValueProcedure killBeginProc =    new ValueProcedure() { @Override public CiValue doValue(CiValue value) { return kill(value, false); } };
-        ValueProcedure killEndProc =      new ValueProcedure() { @Override public CiValue doValue(CiValue value) { return kill(value, true); } };
-        ValueProcedure killLocationProc = new ValueProcedure() { @Override public CiValue doValue(CiValue value) { return killLocation(value); } };
-        ValueProcedure blockProc =        new ValueProcedure() { @Override public CiValue doValue(CiValue value) { return block(value); } };
-        ValueProcedure loadProc =         new ValueProcedure() { @Override public CiValue doValue(CiValue value, OperandMode mode, EnumSet<OperandFlag> flags) { return load(value, mode, flags); } };
-        ValueProcedure spillProc =        new ValueProcedure() { @Override public CiValue doValue(CiValue value, OperandMode mode, EnumSet<OperandFlag> flags) { return spill(value, mode, flags); } };
-        ValueProcedure useSlotProc =      new ValueProcedure() { @Override public CiValue doValue(CiValue value) { return useSlot(value); } };
+        ValueProcedure killNonLiveProc =  new ValueProcedure() { @Override public Value doValue(Value value) { return killNonLive(value); } };
+        ValueProcedure killBeginProc =    new ValueProcedure() { @Override public Value doValue(Value value) { return kill(value, false); } };
+        ValueProcedure killEndProc =      new ValueProcedure() { @Override public Value doValue(Value value) { return kill(value, true); } };
+        ValueProcedure killLocationProc = new ValueProcedure() { @Override public Value doValue(Value value) { return killLocation(value); } };
+        ValueProcedure blockProc =        new ValueProcedure() { @Override public Value doValue(Value value) { return block(value); } };
+        ValueProcedure loadProc =         new ValueProcedure() { @Override public Value doValue(Value value, OperandMode mode, EnumSet<OperandFlag> flags) { return load(value, mode, flags); } };
+        ValueProcedure spillProc =        new ValueProcedure() { @Override public Value doValue(Value value, OperandMode mode, EnumSet<OperandFlag> flags) { return spill(value, mode, flags); } };
+        ValueProcedure useSlotProc =      new ValueProcedure() { @Override public Value doValue(Value value) { return useSlot(value); } };
 
         Debug.log("==== start spill all allocation ====");
         curInRegisterState = new Object[maxRegisterNum()];
@@ -224,7 +223,7 @@
         Debug.log("==== end spill all allocation ====");
     }
 
-    private CiValue killNonLive(CiValue value) {
+    private Value killNonLive(Value value) {
         assert isLocation(value);
         if (!curLiveIn.get(asLocation(value).variable.index)) {
             return null;
@@ -232,7 +231,7 @@
         return value;
     }
 
-    private CiValue kill(CiValue value, boolean end) {
+    private Value kill(Value value, boolean end) {
         if (isVariable(value)) {
             Debug.log("    kill variable %s", value);
 
@@ -268,7 +267,7 @@
         return value;
     }
 
-    private CiValue killLocation(CiValue value) {
+    private Value killLocation(Value value) {
         Debug.log("    kill location %s", value);
         assert isAllocatableRegister(asLocation(value).location);
 
@@ -279,7 +278,7 @@
         return null;
     }
 
-    private CiValue block(CiValue value) {
+    private Value block(Value value) {
         if (isAllocatableRegister(value)) {
             Debug.log("    block %s", value);
             int regNum = asRegister(value).number;
@@ -290,7 +289,7 @@
         return value;
     }
 
-    private CiValue load(CiValue value, OperandMode mode, EnumSet<OperandFlag> flags) {
+    private Value load(Value value, OperandMode mode, EnumSet<OperandFlag> flags) {
         assert mode == OperandMode.Input || mode == OperandMode.Alive;
         if (flags.contains(OperandFlag.Stack)) {
             return useSlot(value);
@@ -314,7 +313,7 @@
         }
     }
 
-    private CiValue spill(CiValue value, OperandMode mode, EnumSet<OperandFlag> flags) {
+    private Value spill(Value value, OperandMode mode, EnumSet<OperandFlag> flags) {
         assert mode == OperandMode.Temp || mode == OperandMode.Output;
         if (flags.contains(OperandFlag.Stack)) {
             return defSlot(value);
@@ -335,7 +334,7 @@
         }
     }
 
-    private CiValue useSlot(CiValue value) {
+    private Value useSlot(Value value) {
         if (isVariable(value)) {
             Debug.log("    useSlot %s", value);
             Location stackLoc = curStackLocations.get(asVariable(value));
@@ -347,7 +346,7 @@
         }
     }
 
-    private CiValue defSlot(CiValue value) {
+    private Value defSlot(Value value) {
         if (isVariable(value)) {
             Debug.log("    assignSlot %s", value);
             Location stackLoc = new Location(asVariable(value), frameMap.allocateSpillSlot(value.kind));
@@ -362,11 +361,11 @@
 
     private Location allocateRegister(final Variable variable, final Object[] inRegisterState, final Object[] outRegisterState, OperandMode mode, EnumSet<OperandFlag> flags) {
         if (flags.contains(OperandFlag.RegisterHint)) {
-            CiValue result = curInstruction.forEachRegisterHint(variable, mode, new ValueProcedure() {
+            Value result = curInstruction.forEachRegisterHint(variable, mode, new ValueProcedure() {
                 @Override
-                public CiValue doValue(CiValue registerHint) {
+                public Value doValue(Value registerHint) {
                     Debug.log("      registerHint %s", registerHint);
-                    CiRegister hint = null;
+                    Register hint = null;
                     if (isRegister(registerHint)) {
                         hint = asRegister(registerHint);
                     } else if (isLocation(registerHint) && isRegister(asLocation(registerHint).location)) {
@@ -384,23 +383,23 @@
             }
         }
 
-        EnumMap<RegisterFlag, CiRegister[]> categorizedRegs = frameMap.registerConfig.getCategorizedAllocatableRegisters();
-        CiRegister[] availableRegs = categorizedRegs.get(variable.flag);
+        EnumMap<RegisterFlag, Register[]> categorizedRegs = frameMap.registerConfig.getCategorizedAllocatableRegisters();
+        Register[] availableRegs = categorizedRegs.get(variable.flag);
 
-        for (CiRegister reg : availableRegs) {
+        for (Register reg : availableRegs) {
             if (isFree(reg, inRegisterState, outRegisterState)) {
                 return selectRegister(reg, variable, inRegisterState, outRegisterState);
             }
 
         }
-        throw new CiBailout("No register found");
+        throw new BailoutException("No register found");
     }
 
-    private static boolean isFree(CiRegister reg, Object[] inRegisterState, Object[] outRegisterState) {
+    private static boolean isFree(Register reg, Object[] inRegisterState, Object[] outRegisterState) {
         return (inRegisterState == null || inRegisterState[reg.number] == null) && (outRegisterState == null || outRegisterState[reg.number] == null);
     }
 
-    private Location selectRegister(CiRegister reg, Variable variable, Object[] inRegisterState, Object[] outRegisterState) {
+    private Location selectRegister(Register reg, Variable variable, Object[] inRegisterState, Object[] outRegisterState) {
         Location loc = new Location(variable, reg.asValue(variable.kind));
         if (inRegisterState != null) {
             inRegisterState[reg.number] = loc;
@@ -418,7 +417,7 @@
         final BitSet liveState = new BitSet();
         curStackLocations.forEachLocation(new ValueProcedure() {
             @Override
-            public CiValue doValue(CiValue value) {
+            public Value doValue(Value value) {
                 liveState.set(asLocation(value).variable.index);
 
                 for (Block pred : block.getPredecessors()) {
@@ -437,7 +436,7 @@
     }
 
     private boolean checkNoCallerSavedRegister() {
-        for (CiRegister reg : frameMap.registerConfig.getCallerSaveRegisters()) {
+        for (Register reg : frameMap.registerConfig.getCallerSaveRegisters()) {
             assert curOutRegisterState[reg.number] == null || curOutRegisterState[reg.number] == curInstruction : "caller saved register in use accross call site";
         }
         return true;
@@ -456,7 +455,7 @@
         sb.append("  curVariableLocations: ");
         curStackLocations.forEachLocation(new ValueProcedure() {
             @Override
-            public CiValue doValue(CiValue value) {
+            public Value doValue(Value value) {
                 sb.append(value).append(" ");
                 return value;
             }

--- a/graal/com.oracle.graal.alloc/src/com/oracle/graal/alloc/util/IntervalPrinter.java	Wed Jun 27 11:48:26 2012 +0200
+++ b/graal/com.oracle.graal.alloc/src/com/oracle/graal/alloc/util/IntervalPrinter.java	Wed Jun 27 17:35:32 2012 +0200
@@ -22,14 +22,12 @@
  */
 package com.oracle.graal.alloc.util;
 
-import static com.oracle.max.cri.ci.CiValueUtil.*;
 import static com.oracle.graal.alloc.util.LocationUtil.*;
-
 import java.util.*;
 
-import com.oracle.max.cri.ci.*;
-import com.oracle.max.cri.ri.*;
 import com.oracle.graal.alloc.simple.*;
+import com.oracle.graal.api.code.*;
+import com.oracle.graal.api.meta.*;
 import com.oracle.graal.debug.*;
 import com.oracle.graal.lir.*;
 import com.oracle.graal.lir.LIRInstruction.*;
@@ -37,7 +35,7 @@
 
 public final class IntervalPrinter {
 
-    public static void printBeforeAllocation(String label, LIR lir, RiRegisterConfig registerConfig, DataFlowAnalysis dataFlow) {
+    public static void printBeforeAllocation(String label, LIR lir, RegisterConfig registerConfig, DataFlowAnalysis dataFlow) {
         if (Debug.isDumpEnabled()) {
             IntervalPrinter printer = new IntervalPrinter(lir, registerConfig, dataFlow, null);
             Debug.dump(lir, label);
@@ -45,7 +43,7 @@
         }
     }
 
-    public static void printAfterAllocation(String label, LIR lir, RiRegisterConfig registerConfig, DataFlowAnalysis dataFlow, LocationMap[] blockEndLocations) {
+    public static void printAfterAllocation(String label, LIR lir, RegisterConfig registerConfig, DataFlowAnalysis dataFlow, LocationMap[] blockEndLocations) {
         if (Debug.isDumpEnabled()) {
             IntervalPrinter printer = new IntervalPrinter(lir, registerConfig, dataFlow, blockEndLocations);
             Debug.dump(lir, label);
@@ -98,13 +96,13 @@
 
 
     private final LIR lir;
-    private final RiRegisterConfig registerConfig;
+    private final RegisterConfig registerConfig;
     private final DataFlowAnalysis dataFlow;
     private final LocationMap[] blockEndLocations;
     private final Variable[] variables;
     private final Map<String, Interval> intervals;
 
-    private IntervalPrinter(LIR lir, RiRegisterConfig registerConfig, DataFlowAnalysis dataFlow, LocationMap[] blockEndLocations) {
+    private IntervalPrinter(LIR lir, RegisterConfig registerConfig, DataFlowAnalysis dataFlow, LocationMap[] blockEndLocations) {
         this.lir = lir;
         this.registerConfig = registerConfig;
         this.dataFlow = dataFlow;
@@ -113,15 +111,15 @@
         this.intervals = new HashMap<>();
     }
 
-    private boolean isAllocatableRegister(CiValue value) {
-        return isRegister(value) && registerConfig.getAttributesMap()[asRegister(value).number].isAllocatable;
+    private boolean isAllocatableRegister(Value value) {
+        return isRegister(value) && registerConfig.getAttributesMap()[asRegister(value).number].isAllocatable();
     }
 
     private int curOpId;
     private String curUseKind;
 
     public Interval[] execute() {
-        ValueProcedure varProc = new ValueProcedure() { @Override public CiValue doValue(CiValue value) { return var(value); } };
+        ValueProcedure varProc = new ValueProcedure() { @Override public Value doValue(Value value) { return var(value); } };
 
         for (Block block : lir.linearScanOrder()) {
             for (LIRInstruction op : block.lir) {
@@ -129,8 +127,8 @@
             }
         }
 
-        ValueProcedure useProc = new ValueProcedure() { @Override public CiValue doValue(CiValue value, OperandMode mode, EnumSet<OperandFlag> flags) { return use(value, mode, flags); } };
-        ValueProcedure defProc = new ValueProcedure() { @Override public CiValue doValue(CiValue value, OperandMode mode, EnumSet<OperandFlag> flags) { return def(value, flags); } };
+        ValueProcedure useProc = new ValueProcedure() { @Override public Value doValue(Value value, OperandMode mode, EnumSet<OperandFlag> flags) { return use(value, mode, flags); } };
+        ValueProcedure defProc = new ValueProcedure() { @Override public Value doValue(Value value, OperandMode mode, EnumSet<OperandFlag> flags) { return def(value, flags); } };
 
         intervals.put("call", new Interval(-2, "call", "", "call", "hasCall"));
         intervals.put("st", new Interval(-1, "st", "", "st", "hasState"));
@@ -192,7 +190,7 @@
         return intervalsArray;
     }
 
-    public CiValue var(CiValue value) {
+    public Value var(Value value) {
         if (isLocation(value)) {
             variables[asLocation(value).variable.index] = asLocation(value).variable;
         } else if (isVariable(value)) {
@@ -201,7 +199,7 @@
         return value;
     }
 
-    private Interval findInterval(CiValue value) {
+    private Interval findInterval(Value value) {
         Interval interval;
         if (isLocation(value)) {
             Interval parent = findInterval(asLocation(value).variable);
@@ -237,7 +235,7 @@
         }
     }
 
-    private CiValue use(CiValue value, OperandMode mode, EnumSet<OperandFlag> flags) {
+    private Value use(Value value, OperandMode mode, EnumSet<OperandFlag> flags) {
         Interval interval = findInterval(value);
         if (interval != null) {
             if (interval.uses.size() == 0 || interval.uses.get(interval.uses.size() - 1).pos != curOpId) {
@@ -250,7 +248,7 @@
         return value;
     }
 
-    private CiValue def(CiValue value, EnumSet<OperandFlag> flags) {
+    private Value def(Value value, EnumSet<OperandFlag> flags) {
         Interval interval = findInterval(value);
         if (interval != null) {
             interval.uses.add(new UsePosition(curOpId, useKind(flags)));
@@ -264,7 +262,7 @@
         return value;
     }
 
-    private CiValue out(CiValue value) {
+    private Value out(Value value) {
         Interval interval = findInterval(value);
         if (interval != null) {
             interval.lastTo = curOpId;

--- a/graal/com.oracle.graal.alloc/src/com/oracle/graal/alloc/util/Location.java	Wed Jun 27 11:48:26 2012 +0200
+++ b/graal/com.oracle.graal.alloc/src/com/oracle/graal/alloc/util/Location.java	Wed Jun 27 17:35:32 2012 +0200
@@ -22,16 +22,16 @@
  */
 package com.oracle.graal.alloc.util;
 
-import com.oracle.max.cri.ci.*;
+import com.oracle.graal.api.meta.*;
 import com.oracle.graal.lir.*;
 
-public class Location extends CiValue {
+public class Location extends Value {
     private static final long serialVersionUID = -1786677729152726126L;
 
     public final Variable variable;
-    public final CiValue location;
+    public final Value location;
 
-    public Location(Variable variable, CiValue location) {
+    public Location(Variable variable, Value location) {
         super(variable.kind);
         this.variable = variable;
         this.location = location;

--- a/graal/com.oracle.graal.alloc/src/com/oracle/graal/alloc/util/LocationMap.java	Wed Jun 27 11:48:26 2012 +0200
+++ b/graal/com.oracle.graal.alloc/src/com/oracle/graal/alloc/util/LocationMap.java	Wed Jun 27 17:35:32 2012 +0200
@@ -26,7 +26,7 @@
 
 import java.util.*;
 
-import com.oracle.max.cri.ci.*;
+import com.oracle.graal.api.meta.*;
 import com.oracle.graal.lir.*;
 import com.oracle.graal.lir.LIRInstruction.*;
 
@@ -57,7 +57,7 @@
     public void forEachLocation(ValueProcedure proc) {
         for (int i = 0; i < locations.length; i++) {
             if (locations[i] != null) {
-                CiValue newValue = proc.doValue(locations[i], null, null);
+                Value newValue = proc.doValue(locations[i], null, null);
                 assert newValue == null || asLocation(newValue).variable == locations[i].variable;
                 locations[i] = (Location) newValue;
             }

--- a/graal/com.oracle.graal.alloc/src/com/oracle/graal/alloc/util/LocationUtil.java	Wed Jun 27 11:48:26 2012 +0200
+++ b/graal/com.oracle.graal.alloc/src/com/oracle/graal/alloc/util/LocationUtil.java	Wed Jun 27 17:35:32 2012 +0200
@@ -22,17 +22,17 @@
  */
 package com.oracle.graal.alloc.util;
 
-import com.oracle.max.cri.ci.*;
+import com.oracle.graal.api.meta.*;
 import com.oracle.graal.lir.*;
 
-public class LocationUtil extends ValueUtil {
+public class LocationUtil extends LIRValueUtil {
 
-    public static boolean isLocation(CiValue value) {
+    public static boolean isLocation(Value value) {
         assert value != null;
         return value instanceof Location;
     }
 
-    public static Location asLocation(CiValue value) {
+    public static Location asLocation(Value value) {
         assert value != null;
         return (Location) value;
     }

--- a/graal/com.oracle.graal.alloc/src/com/oracle/graal/alloc/util/MoveResolver.java	Wed Jun 27 11:48:26 2012 +0200
+++ b/graal/com.oracle.graal.alloc/src/com/oracle/graal/alloc/util/MoveResolver.java	Wed Jun 27 17:35:32 2012 +0200
@@ -22,12 +22,11 @@
  */
 package com.oracle.graal.alloc.util;
 
-import static com.oracle.max.cri.ci.CiValueUtil.*;
 import static com.oracle.graal.alloc.util.LocationUtil.*;
-
 import java.util.*;
 
-import com.oracle.max.cri.ci.*;
+import com.oracle.graal.api.code.*;
+import com.oracle.graal.api.meta.*;
 import com.oracle.graal.debug.*;
 import com.oracle.graal.graph.*;
 import com.oracle.graal.lir.*;
@@ -36,8 +35,8 @@
     private final LIR lir;
     private final FrameMap frameMap;
     private final int[] registersBlocked;
-    private final Map<CiValue, Integer> valuesBlocked;
-    private final List<CiValue> mappingFrom;
+    private final Map<Value, Integer> valuesBlocked;
+    private final List<Value> mappingFrom;
     private final List<Location> mappingTo;
     private final LIRInsertionBuffer insertionBuffer;
     private int insertPos;
@@ -70,7 +69,7 @@
         assert checkValid();
     }
 
-    public void add(CiValue from, Location to) {
+    public void add(Value from, Location to) {
         assert checkValid();
         assert isLocation(from) || isConstant(from);
         assert from != to;
@@ -120,14 +119,14 @@
         // Block all registers and stack slots that are used as inputs of a move.
         // When a register is blocked, no move to this register is emitted.
         // This is necessary for detecting cycles in moves.
-        for (CiValue from : mappingFrom) {
+        for (Value from : mappingFrom) {
             block(from);
         }
 
         while (mappingFrom.size() > 0) {
             boolean processed = false;
             for (int i = mappingFrom.size() - 1; i >= 0; i--) {
-                CiValue from = mappingFrom.get(i);
+                Value from = mappingFrom.get(i);
                 Location to = mappingTo.get(i);
 
                 if (safeToProcessMove(from, to)) {
@@ -153,19 +152,19 @@
         int exchangeOther = -1;
 
         for (int i = mappingFrom.size() - 1; i >= 0; i--) {
-            CiValue from = mappingFrom.get(i);
+            Value from = mappingFrom.get(i);
             Location to = mappingTo.get(i);
             assert !safeToProcessMove(from, to) : "would not be in this code otherwise";
 
             if (isConstant(from)) {
                 continue;
             }
-            CiValue fromLoc = asLocation(from).location;
+            Value fromLoc = asLocation(from).location;
 
             // Check if we can insert an exchange to save us from spilling.
             if (isRegister(fromLoc) && isRegister(to) && asRegister(fromLoc) != asRegister(to) && blockedCount(to) == 1) {
                 for (int j = mappingFrom.size() - 1; j >= 0; j--) {
-                    CiValue possibleOther = mappingFrom.get(j);
+                    Value possibleOther = mappingFrom.get(j);
                     if (isLocation(possibleOther)) {
                         if (asLocation(possibleOther).location == to.location) {
                             assert exchangeCandidate == -1 : "must not find twice because of blocked check above";
@@ -220,9 +219,9 @@
         }
     }
 
-    private void block(CiValue value) {
+    private void block(Value value) {
         if (isLocation(value)) {
-            CiValue location = asLocation(value).location;
+            Value location = asLocation(value).location;
             if (isRegister(location)) {
                 registersBlocked[asRegister(location).number]++;
             } else {
@@ -232,10 +231,10 @@
         }
     }
 
-    private void unblock(CiValue value) {
+    private void unblock(Value value) {
         if (isLocation(value)) {
             assert blockedCount(asLocation(value)) > 0;
-            CiValue location = asLocation(value).location;
+            Value location = asLocation(value).location;
             if (isRegister(location)) {
                 registersBlocked[asRegister(location).number]--;
             } else {
@@ -248,7 +247,7 @@
     }
 
     private int blockedCount(Location value) {
-        CiValue location = asLocation(value).location;
+        Value location = asLocation(value).location;
         if (isRegister(location)) {
             return registersBlocked[asRegister(location).number];
         } else {
@@ -257,7 +256,7 @@
         }
     }
 
-    private boolean safeToProcessMove(CiValue from, Location to) {
+    private boolean safeToProcessMove(Value from, Location to) {
         int count = blockedCount(to);
         return count == 0 || (count == 1 && isLocation(from) && asLocation(from).location == to.location);
     }
@@ -269,17 +268,17 @@
         throw GraalInternalError.unimplemented();
     }
 
-    private void insertMove(CiValue src, Location dst) {
+    private void insertMove(Value src, Location dst) {
         if (isStackSlot(dst.location) && isLocation(src) && isStackSlot(asLocation(src).location)) {
             // Move between two stack slots. We need a temporary registers. If the allocator can give
             // us a free register, we need two moves: src->scratch, scratch->dst
             // If the allocator cannot give us a free register (it returns a Location in this case),
             // we need to spill the scratch register first, so we need four moves in total.
 
-            CiValue scratch = scratchRegister(dst.variable);
+            Value scratch = scratchRegister(dst.variable);
 
             Location scratchSaved = null;
-            CiValue scratchRegister = scratch;
+            Value scratchRegister = scratch;
             if (isLocation(scratch)) {
                 scratchSaved = new Location(asLocation(scratch).variable, frameMap.allocateSpillSlot(scratch.kind));
                 insertMove(scratch, scratchSaved);
@@ -303,10 +302,10 @@
 
     /**
      * Provides a register that can be used by the move resolver. If the returned value is a
-     * {@link CiRegisterValue}, the register can be overwritten without precautions. If the
+     * {@link RegisterValue}, the register can be overwritten without precautions. If the
      * returned value is a {@link Location}, it needs to be spilled and rescued itself.
      */
-    protected abstract CiValue scratchRegister(Variable spilled);
+    protected abstract Value scratchRegister(Variable spilled);
 
     private boolean checkEmpty() {
         assert insertPos == -1;
@@ -327,7 +326,7 @@
         assert insertionBuffer.initialized() && insertPos != -1;
 
         for (int i = 0; i < mappingTo.size(); i++) {
-            CiValue from = mappingFrom.get(i);
+            Value from = mappingFrom.get(i);
             Location to = mappingTo.get(i);
 
             assert from.kind.stackKind() == to.kind;

--- a/graal/com.oracle.graal.alloc/src/com/oracle/graal/alloc/util/RegisterVerifier.java	Wed Jun 27 11:48:26 2012 +0200
+++ b/graal/com.oracle.graal.alloc/src/com/oracle/graal/alloc/util/RegisterVerifier.java	Wed Jun 27 17:35:32 2012 +0200
@@ -22,12 +22,11 @@
  */
 package com.oracle.graal.alloc.util;
 
-import static com.oracle.max.cri.ci.CiValueUtil.*;
 import static com.oracle.graal.alloc.util.LocationUtil.*;
-
 import java.util.*;
 
-import com.oracle.max.cri.ci.*;
+import com.oracle.graal.api.code.*;
+import com.oracle.graal.api.meta.*;
 import com.oracle.graal.debug.*;
 import com.oracle.graal.graph.*;
 import com.oracle.graal.lir.*;
@@ -45,11 +44,11 @@
     /**
      * Saved information of previous check.
      * <br>
-     * State mapping: mapping from registers and stack slots ({@link CiRegister} and {@link Integer} stack slot offsets) to the
-     * value that is currently contained in there ({@link Location} for operands that were variables; {@link CiRegisterValue} or
-     * {@link CiStackSlot} for operands that used fixed registers or stack slots).
+     * State mapping: mapping from registers and stack slots ({@link Register} and {@link Integer} stack slot offsets) to the
+     * value that is currently contained in there ({@link Location} for operands that were variables; {@link RegisterValue} or
+     * {@link StackSlot} for operands that used fixed registers or stack slots).
      */
-    private final Map<Object, CiValue>[] blockStates;
+    private final Map<Object, Value>[] blockStates;
 
     private void addToWorkList(Block block) {
         if (!workList.contains(block)) {
@@ -57,15 +56,15 @@
         }
     }
 
-    private Map<Object, CiValue> stateFor(Block block) {
+    private Map<Object, Value> stateFor(Block block) {
         return blockStates[block.getId()];
     }
 
-    private void setStateFor(Block block, Map<Object, CiValue> savedState) {
+    private void setStateFor(Block block, Map<Object, Value> savedState) {
         blockStates[block.getId()] = savedState;
     }
 
-    private static Map<Object, CiValue> copy(Map<Object, CiValue> inputState) {
+    private static Map<Object, Value> copy(Map<Object, Value> inputState) {
         return new HashMap<>(inputState);
     }
 
@@ -82,12 +81,12 @@
         this.blockStates = new Map[lir.linearScanOrder().size()];
     }
 
-    private Map<Object, CiValue> curInputState;
+    private Map<Object, Value> curInputState;
 
     private void verify(Block startBlock) {
-        ValueProcedure useProc =    new ValueProcedure() { @Override public CiValue doValue(CiValue value, OperandMode mode, EnumSet<OperandFlag> flags) { return use(value, flags); } };
-        ValueProcedure tempProc =   new ValueProcedure() { @Override public CiValue doValue(CiValue value) { return temp(value); } };
-        ValueProcedure outputProc = new ValueProcedure() { @Override public CiValue doValue(CiValue value) { return output(value); } };
+        ValueProcedure useProc =    new ValueProcedure() { @Override public Value doValue(Value value, OperandMode mode, EnumSet<OperandFlag> flags) { return use(value, flags); } };
+        ValueProcedure tempProc =   new ValueProcedure() { @Override public Value doValue(Value value) { return temp(value); } };
+        ValueProcedure outputProc = new ValueProcedure() { @Override public Value doValue(Value value) { return output(value); } };
 
         curInputState = new HashMap<>();
         setStateFor(startBlock, curInputState);
@@ -125,7 +124,7 @@
     }
 
     private void processSuccessor(Block succ) {
-        Map<Object, CiValue> savedState = stateFor(succ);
+        Map<Object, Value> savedState = stateFor(succ);
         if (savedState == null) {
             // Block was not processed before, so set initial inputState.
             Debug.log("  successor %s: initial visit", succ);
@@ -136,11 +135,11 @@
             // This block was already processed before.
             // Check if new inputState is consistent with savedState.
             Debug.log("  successor %s: state present", succ);
-            Iterator<Map.Entry<Object, CiValue>> iter = savedState.entrySet().iterator();
+            Iterator<Map.Entry<Object, Value>> iter = savedState.entrySet().iterator();
             while (iter.hasNext()) {
-                Map.Entry<Object, CiValue> entry = iter.next();
-                CiValue savedValue = entry.getValue();
-                CiValue inputValue = curInputState.get(entry.getKey());
+                Map.Entry<Object, Value> entry = iter.next();
+                Value savedValue = entry.getValue();
+                Value inputValue = curInputState.get(entry.getKey());
 
                 if (savedValue != inputValue) {
                     // Current inputState and previous savedState assume a different value in this register.
@@ -159,7 +158,7 @@
         Iterator<Object> iter = curInputState.keySet().iterator();
         while (iter.hasNext()) {
             Object value1 = iter.next();
-            if (value1 instanceof CiRegister && frameMap.registerConfig.getAttributesMap()[((CiRegister) value1).number].isCallerSave) {
+            if (value1 instanceof Register && frameMap.registerConfig.getAttributesMap()[((Register) value1).number].isCallerSave()) {
                 Debug.log("    remove caller save register %s", value1);
                 iter.remove();
             }
@@ -171,7 +170,7 @@
      * include the kind of the value because we do not want to distinguish between the same register with
      * different kinds.
      */
-    private Object key(CiValue value) {
+    private Object key(Value value) {
         if (isLocation(value)) {
             return key(asLocation(value).location);
         } else if (isRegister(value)) {
@@ -183,13 +182,13 @@
         }
     }
 
-    private boolean isIgnoredRegister(CiValue value) {
-        return isRegister(value) && !frameMap.registerConfig.getAttributesMap()[asRegister(value).number].isAllocatable;
+    private boolean isIgnoredRegister(Value value) {
+        return isRegister(value) && !frameMap.registerConfig.getAttributesMap()[asRegister(value).number].isAllocatable();
     }
 
-    private CiValue use(CiValue value, EnumSet<OperandFlag> flags) {
-        if (!isConstant(value) && value != CiValue.IllegalValue && !isIgnoredRegister(value)) {
-            CiValue actual = curInputState.get(key(value));
+    private Value use(Value value, EnumSet<OperandFlag> flags) {
+        if (!isConstant(value) && value != Value.IllegalValue && !isIgnoredRegister(value)) {
+            Value actual = curInputState.get(key(value));
             if (actual == null && flags.contains(OperandFlag.Uninitialized)) {
                 // OK, since uninitialized values are allowed explicitly.
             } else if (value != actual) {
@@ -201,16 +200,16 @@
         return value;
     }
 
-    private CiValue temp(CiValue value) {
-        if (!isConstant(value) && value != CiValue.IllegalValue && !isIgnoredRegister(value)) {
+    private Value temp(Value value) {
+        if (!isConstant(value) && value != Value.IllegalValue && !isIgnoredRegister(value)) {
             Debug.log("    temp %s -> remove key %s", value, key(value));
             curInputState.remove(key(value));
         }
         return value;
     }
 
-    private CiValue output(CiValue value) {
-        if (value != CiValue.IllegalValue && !isIgnoredRegister(value)) {
+    private Value output(Value value) {
+        if (value != Value.IllegalValue && !isIgnoredRegister(value)) {
             Debug.log("    output %s -> set key %s", value, key(value));
             curInputState.put(key(value), value);
         }
@@ -223,14 +222,14 @@
         Collections.sort(keys, new Comparator<Object>() {
             @Override
             public int compare(Object o1, Object o2) {
-                if (o1 instanceof CiRegister) {
-                    if (o2 instanceof CiRegister) {
-                        return ((CiRegister) o1).number - ((CiRegister) o2).number;
+                if (o1 instanceof Register) {
+                    if (o2 instanceof Register) {
+                        return ((Register) o1).number - ((Register) o2).number;
                     } else {
                         return -1;
                     }
                 } else {
-                    if (o2 instanceof CiRegister) {
+                    if (o2 instanceof Register) {
                         return 1;
                     } else {
                         return ((Integer) o1).intValue() - ((Integer) o2).intValue();

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.api.code/src/com/oracle/graal/api/code/Address.java	Wed Jun 27 17:35:32 2012 +0200
@@ -0,0 +1,198 @@
+/*
+ * Copyright (c) 2010, 2012, 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.api.code;
+
+import static com.oracle.graal.api.code.ValueUtil.*;
+
+import com.oracle.graal.api.meta.*;
+
+/**
+ * Represents an address in target machine memory, specified via some combination of a base register, an index register,
+ * a displacement and a scale. Note that the base and index registers may be a variable that will get a register assigned
+ * later by the register allocator.
+ */
+public final class Address extends Value {
+    private static final long serialVersionUID = -1003772042519945089L;
+
+    /**
+     * A sentinel value used as a place holder in an instruction stream for an address that will be patched.
+     */
+    public static final Address Placeholder = new Address(Kind.Illegal, Value.IllegalValue);
+
+    private Value base;
+    private Value index;
+    private final Scale scale;
+    private final int displacement;
+
+    /**
+     * Creates a {@code CiAddress} with given base register, no scaling and no displacement.
+     * @param kind the kind of the value being addressed
+     * @param base the base register
+     */
+    public Address(Kind kind, Value base) {
+        this(kind, base, IllegalValue, Scale.Times1, 0);
+    }
+
+    /**
+     * Creates a {@code CiAddress} with given base register, no scaling and a given displacement.
+     * @param kind the kind of the value being addressed
+     * @param base the base register
+     * @param displacement the displacement
+     */
+    public Address(Kind kind, Value base, int displacement) {
+        this(kind, base, IllegalValue, Scale.Times1, displacement);
+    }
+
+    /**
+     * Creates a {@code CiAddress} with given base and index registers, scaling and displacement.
+     * This is the most general constructor..
+     * @param kind the kind of the value being addressed
+     * @param base the base register
+     * @param index the index register
+     * @param scale the scaling factor
+     * @param displacement the displacement
+     */
+    public Address(Kind kind, Value base, Value index, Scale scale, int displacement) {
+        super(kind);
+        this.setBase(base);
+        this.setIndex(index);
+        this.scale = scale;
+        this.displacement = displacement;
+
+        assert !isConstant(base) && !isStackSlot(base);
+        assert !isConstant(index) && !isStackSlot(index);
+    }
+
+    /**
+     * A scaling factor used in complex addressing modes such as those supported by x86 platforms.
+     */
+    public enum Scale {
+        Times1(1, 0),
+        Times2(2, 1),
+        Times4(4, 2),
+        Times8(8, 3);
+
+        private Scale(int value, int log2) {
+            this.value = value;
+            this.log2 = log2;
+        }
+
+        /**
+         * The value (or multiplier) of this scale.
+         */
+        public final int value;
+
+        /**
+         * The {@linkplain #value value} of this scale log 2.
+         */
+        public final int log2;
+
+        public static Scale fromInt(int scale) {
+            switch (scale) {
+                case 1:  return Times1;
+                case 2:  return Times2;
+                case 4:  return Times4;
+                case 8:  return Times8;
+                default: throw new IllegalArgumentException(String.valueOf(scale));
+            }
+        }
+    }
+
+    @Override
+    public String toString() {
+        if (this == Placeholder) {
+            return "[<placeholder>]";
+        }
+
+        StringBuilder s = new StringBuilder();
+        s.append(kind.javaName).append("[");
+        String sep = "";
+        if (isLegal(getBase())) {
+            s.append(getBase());
+            sep = " + ";
+        }
+        if (isLegal(getIndex())) {
+            s.append(sep).append(getIndex()).append(" * ").append(getScale().value);
+            sep = " + ";
+        }
+        if (getDisplacement() < 0) {
+            s.append(" - ").append(-getDisplacement());
+        } else if (getDisplacement() > 0) {
+            s.append(sep).append(getDisplacement());
+        }
+        s.append("]");
+        return s.toString();
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj instanceof Address) {
+            Address addr = (Address) obj;
+            return kind == addr.kind && getDisplacement() == addr.getDisplacement() && getBase().equals(addr.getBase()) && getScale() == addr.getScale() && getIndex().equals(addr.getIndex());
+        }
+        return false;
+    }
+
+    @Override
+    public int hashCode() {
+        return getBase().hashCode() ^ getIndex().hashCode() ^ (getDisplacement() << 4) ^ (getScale().value << 8) ^ (kind.ordinal() << 12);
+    }
+
+    /**
+     * @return Base register that defines the start of the address computation.
+     * If not present, is denoted by {@link Value#IllegalValue}.
+     */
+    public Value getBase() {
+        return base;
+    }
+
+    public void setBase(Value base) {
+        this.base = base;
+    }
+
+    /**
+     * @return Index register, the value of which (possibly scaled by {@link #scale}) is added to {@link #base}.
+     * If not present, is denoted by {@link Value#IllegalValue}.
+     */
+    public Value getIndex() {
+        return index;
+    }
+
+    public void setIndex(Value index) {
+        this.index = index;
+    }
+
+    /**
+     * @return Scaling factor for indexing, dependent on target operand size.
+     */
+    public Scale getScale() {
+        return scale;
+    }
+
+    /**
+     * @return Optional additive displacement.
+     */
+    public int getDisplacement() {
+        return displacement;
+    }
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.api.code/src/com/oracle/graal/api/code/Architecture.java	Wed Jun 27 17:35:32 2012 +0200
@@ -0,0 +1,211 @@
+/*
+ * Copyright (c) 2009, 2011, 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.api.code;
+
+import java.util.*;
+
+import com.oracle.graal.api.code.Register.*;
+
+
+/**
+ * Represents a CPU architecture, including information such as its endianness, CPU
+ * registers, word width, etc.
+ */
+public abstract class Architecture {
+
+    /**
+     * The endianness of the architecture.
+     */
+    public static enum ByteOrder {
+        LittleEndian,
+        BigEndian
+    }
+
+    /**
+     * The number of bits required in a bit map covering all the registers that may store references.
+     * The bit position of a register in the map is the register's {@linkplain Register#number number}.
+     */
+    public final int registerReferenceMapBitCount;
+
+    /**
+     * Represents the natural size of words (typically registers and pointers) of this architecture, in bytes.
+     */
+    public final int wordSize;
+
+    /**
+     * The name of this architecture (e.g. "AMD64", "SPARCv9").
+     */
+    public final String name;
+
+    /**
+     * Array of all available registers on this architecture. The index of each register in this
+     * array is equal to its {@linkplain Register#number number}.
+     */
+    public final Register[] registers;
+
+    /**
+     * Map of all registers keyed by their {@linkplain Register#name names}.
+     */
+    public final HashMap<String, Register> registersByName;
+
+    /**
+     * The byte ordering can be either little or big endian.
+     */
+    public final ByteOrder byteOrder;
+
+    /**
+     * Mask of the barrier constants defined in {@link MemoryBarriers} denoting the barriers that
+     * are not required to be explicitly inserted under this architecture.
+     */
+    public final int implicitMemoryBarriers;
+
+    /**
+     * Determines the barriers in a given barrier mask that are explicitly required on this architecture.
+     *
+     * @param barriers a mask of the barrier constants defined in {@link MemoryBarriers}
+     * @return the value of {@code barriers} minus the barriers unnecessary on this architecture
+     */
+    public final int requiredBarriers(int barriers) {
+        return barriers & ~implicitMemoryBarriers;
+    }
+
+    /**
+     * Offset in bytes from the beginning of a call instruction to the displacement.
+     */
+    public final int machineCodeCallDisplacementOffset;
+
+    /**
+     * The size of the return address pushed to the stack by a call instruction.
+     * A value of 0 denotes that call linkage uses registers instead (e.g. SPARC).
+     */
+    public final int returnAddressSize;
+
+    private final EnumMap<RegisterFlag, Register[]> registersByTypeAndEncoding;
+
+    /**
+     * Gets the register for a given {@linkplain Register#encoding encoding} and type.
+     *
+     * @param encoding a register value as used in a machine instruction
+     * @param type the type of the register
+     */
+    public Register registerFor(int encoding, RegisterFlag type) {
+        Register[] regs = registersByTypeAndEncoding.get(type);
+        assert encoding >= 0 && encoding < regs.length;
+        Register reg = regs[encoding];
+        assert reg != null;
+        return reg;
+    }
+
+    protected Architecture(String name,
+                    int wordSize,
+                    ByteOrder byteOrder,
+                    Register[] registers,
+                    int implicitMemoryBarriers,
+                    int nativeCallDisplacementOffset,
+                    int registerReferenceMapBitCount,
+                    int returnAddressSize) {
+        this.name = name;
+        this.registers = registers;
+        this.wordSize = wordSize;
+        this.byteOrder = byteOrder;
+        this.implicitMemoryBarriers = implicitMemoryBarriers;
+        this.machineCodeCallDisplacementOffset = nativeCallDisplacementOffset;
+        this.registerReferenceMapBitCount = registerReferenceMapBitCount;
+        this.returnAddressSize = returnAddressSize;
+
+        registersByName = new HashMap<>(registers.length);
+        for (Register register : registers) {
+            registersByName.put(register.name, register);
+            assert registers[register.number] == register;
+        }
+
+        registersByTypeAndEncoding = new EnumMap<>(RegisterFlag.class);
+        EnumMap<RegisterFlag, Register[]> categorizedRegs = Register.categorize(registers);
+        for (RegisterFlag type : RegisterFlag.values()) {
+            Register[] regs = categorizedRegs.get(type);
+            int max = Register.maxRegisterEncoding(regs);
+            Register[] regsByEnc = new Register[max + 1];
+            for (Register reg : regs) {
+                regsByEnc[reg.encoding] = reg;
+            }
+            registersByTypeAndEncoding.put(type, regsByEnc);
+        }
+    }
+
+    /**
+     * Converts this architecture to a string.
+     * @return the string representation of this architecture
+     */
+    @Override
+    public final String toString() {
+        return name.toLowerCase();
+    }
+
+    /**
+     * Checks whether this is a 32-bit architecture.
+     * @return {@code true} if this architecture is 32-bit
+     */
+    public final boolean is32bit() {
+        return wordSize == 4;
+    }
+
+    /**
+     * Checks whether this is a 64-bit architecture.
+     * @return {@code true} if this architecture is 64-bit
+     */
+    public final boolean is64bit() {
+        return wordSize == 8;
+    }
+
+    // The following methods are architecture specific and not dependent on state
+    // stored in this class. They have convenient default implementations.
+
+    /**
+     * Checks whether this architecture's normal arithmetic instructions use a two-operand form
+     * (e.g. x86 which overwrites one operand register with the result when adding).
+     * @return {@code true} if this architecture uses two-operand mode
+     */
+    public boolean twoOperandMode() {
+        return false;
+    }
+
+    // TODO: Why enumerate the concrete subclasses here rather
+    // than use instanceof comparisons in code that cares?
+
+    /**
+     * Checks whether the architecture is x86.
+     * @return {@code true} if the architecture is x86
+     */
+    public boolean isX86() {
+        return false;
+    }
+
+    /**
+     * Checks whether the architecture is SPARC.
+     * @return {@code true} if the architecture is SPARC
+     */
+    public boolean isSPARC() {
+        return false;
+    }
+
+}