--- a/graal/com.oracle.graal.api.code/src/com/oracle/graal/api/code/BytecodeFrame.java	Thu May 28 16:54:14 2015 +0200
+++ b/graal/com.oracle.graal.api.code/src/com/oracle/graal/api/code/BytecodeFrame.java	Thu May 28 17:44:05 2015 +0200
@@ -22,7 +22,6 @@
  */
 package com.oracle.graal.api.code;
 
-import java.io.*;
 import java.util.*;
 
 import com.oracle.graal.api.meta.*;
@@ -32,9 +31,7 @@
  * where to find the local variables, operand stack values and locked objects of the bytecode
  * frame(s).
  */
-public class BytecodeFrame extends BytecodePosition implements Serializable {
-
-    private static final long serialVersionUID = -345025397165977565L;
+public class BytecodeFrame extends BytecodePosition {
 
     /**
      * An array of values representing how to reconstruct the state of the Java frame. This is array

--- a/graal/com.oracle.graal.api.code/src/com/oracle/graal/api/code/BytecodePosition.java	Thu May 28 16:54:14 2015 +0200
+++ b/graal/com.oracle.graal.api.code/src/com/oracle/graal/api/code/BytecodePosition.java	Thu May 28 17:44:05 2015 +0200
@@ -22,7 +22,6 @@
  */
 package com.oracle.graal.api.code;
 
-import java.io.*;
 import java.util.*;
 
 import com.oracle.graal.api.meta.*;
@@ -33,9 +32,7 @@
  * system to reconstruct a source-level stack trace for exceptions and to create
  * {@linkplain BytecodeFrame frames} for deoptimization.
  */
-public class BytecodePosition implements Serializable {
-
-    private static final long serialVersionUID = 8633885274526033515L;
+public class BytecodePosition {
 
     private final BytecodePosition caller;
     private final ResolvedJavaMethod method;
@@ -109,4 +106,15 @@
     public BytecodePosition getCaller() {
         return caller;
     }
+
+    /**
+     * Adds a caller to the current position returning the new position.
+     */
+    public BytecodePosition addCaller(BytecodePosition link) {
+        if (getCaller() == null) {
+            return new BytecodePosition(link, getMethod(), getBCI());
+        } else {
+            return new BytecodePosition(getCaller().addCaller(link), getMethod(), getBCI());
+        }
+    }
 }

--- a/graal/com.oracle.graal.api.code/src/com/oracle/graal/api/code/CodeUtil.java	Thu May 28 16:54:14 2015 +0200
+++ b/graal/com.oracle.graal.api.code/src/com/oracle/graal/api/code/CodeUtil.java	Thu May 28 17:44:05 2015 +0200
@@ -294,6 +294,9 @@
      */
     public static StringBuilder append(StringBuilder sb, BytecodeFrame frame) {
         MetaUtil.appendLocation(sb.append("at "), frame.getMethod(), frame.getBCI());
+        assert sb.charAt(sb.length() - 1) == ']';
+        sb.deleteCharAt(sb.length() - 1);
+        sb.append(", duringCall: ").append(frame.duringCall).append(", rethrow: ").append(frame.rethrowException).append(']');
         if (frame.values != null && frame.values.length > 0) {
             sb.append(NEW_LINE);
             String table = tabulateValues(frame);

--- a/graal/com.oracle.graal.api.code/src/com/oracle/graal/api/code/CompilationResult.java	Thu May 28 16:54:14 2015 +0200
+++ b/graal/com.oracle.graal.api.code/src/com/oracle/graal/api/code/CompilationResult.java	Thu May 28 17:44:05 2015 +0200
@@ -25,27 +25,23 @@
 import static com.oracle.graal.api.meta.MetaUtil.*;
 import static java.util.Collections.*;
 
-import java.io.*;
 import java.util.*;
 
+import com.oracle.graal.api.code.CodeUtil.RefMapFormatter;
 import com.oracle.graal.api.meta.Assumptions.Assumption;
-import com.oracle.graal.api.code.CodeUtil.RefMapFormatter;
 import com.oracle.graal.api.meta.*;
 
 /**
  * Represents the output from compiling a method, including the compiled machine code, associated
  * data and references, relocation information, deoptimization information, etc.
  */
-public class CompilationResult implements Serializable {
-
-    private static final long serialVersionUID = -1319947729753702434L;
+public class CompilationResult {
 
     /**
      * Represents a code position with associated additional information.
      */
-    public abstract static class Site implements Serializable {
+    public abstract static class Site {
 
-        private static final long serialVersionUID = -8214214947651979102L;
         /**
          * The position (or offset) of this site with respect to the start of the target method.
          */
@@ -74,7 +70,6 @@
      */
     public static class Infopoint extends Site implements Comparable<Infopoint> {
 
-        private static final long serialVersionUID = 2479806696381720162L;
         public final DebugInfo debugInfo;
 
         public final InfopointReason reason;
@@ -124,8 +119,6 @@
      */
     public static final class Call extends Infopoint {
 
-        private static final long serialVersionUID = 1440741241631046954L;
-
         /**
          * The target of the call.
          */
@@ -183,9 +176,7 @@
     /**
      * Represents some external data that is referenced by the code.
      */
-    public abstract static class Reference implements Serializable {
-
-        private static final long serialVersionUID = 4841246083028477946L;
+    public abstract static class Reference {
 
         @Override
         public abstract int hashCode();
@@ -196,8 +187,6 @@
 
     public static final class ConstantReference extends Reference {
 
-        private static final long serialVersionUID = 5841121930949053612L;
-
         private final VMConstant constant;
 
         public ConstantReference(VMConstant constant) {
@@ -233,8 +222,6 @@
 
     public static final class DataSectionReference extends Reference {
 
-        private static final long serialVersionUID = 9011681879878139182L;
-
         private boolean initialized;
         private int offset;
 
@@ -281,7 +268,6 @@
      */
     public static final class DataPatch extends Site {
 
-        private static final long serialVersionUID = 5771730331604867476L;
         public Reference reference;
 
         public DataPatch(int pcOffset, Reference reference) {
@@ -314,9 +300,8 @@
      * {@link CompilationResult#getTargetCode()}. This is optional information that can be used to
      * enhance a disassembly of the code.
      */
-    public abstract static class CodeAnnotation implements Serializable {
+    public abstract static class CodeAnnotation {
 
-        private static final long serialVersionUID = -7903959680749520748L;
         public final int position;
 
         public CodeAnnotation(int position) {
@@ -342,10 +327,6 @@
      */
     public static final class CodeComment extends CodeAnnotation {
 
-        /**
-         *
-         */
-        private static final long serialVersionUID = 6802287188701961401L;
         public final String value;
 
         public CodeComment(int position, String comment) {
@@ -384,8 +365,6 @@
      */
     public static final class JumpTable extends CodeAnnotation {
 
-        private static final long serialVersionUID = 2222194398353801831L;
-
         /**
          * The low value in the key range (inclusive).
          */
@@ -434,7 +413,6 @@
      */
     public static final class ExceptionHandler extends Site {
 
-        private static final long serialVersionUID = 4897339464722665281L;
         public final int handlerPos;
 
         ExceptionHandler(int pcOffset, int handlerPos) {
@@ -468,7 +446,6 @@
      */
     public static final class Mark extends Site {
 
-        private static final long serialVersionUID = 3612943150662354844L;
         public final Object id;
 
         public Mark(int pcOffset, Object id) {
@@ -625,11 +602,10 @@
     }
 
     /**
-     * Gets a fixed-size {@linkplain Arrays#asList(Object...) view} of the assumptions made during
-     * compilation.
+     * Gets the assumptions made during compilation.
      */
-    public Collection<Assumption> getAssumptions() {
-        return assumptions == null ? Collections.emptyList() : Arrays.asList(assumptions);
+    public Assumption[] getAssumptions() {
+        return assumptions;
     }
 
     /**
@@ -664,15 +640,14 @@
     }
 
     /**
-     * Gets a fixed-size {@linkplain Arrays#asList(Object...) view} of the methods whose bytecodes
-     * were used as input to the compilation.
+     * Gets the methods whose bytecodes were used as input to the compilation.
      *
      * @return {@code null} if the compilation did not record method dependencies otherwise the
      *         methods whose bytecodes were used as input to the compilation with the first element
      *         being the root method of the compilation
      */
-    public Collection<ResolvedJavaMethod> getMethods() {
-        return methods == null ? null : Arrays.asList(methods);
+    public ResolvedJavaMethod[] getMethods() {
+        return methods;
     }
 
     public DataSection getDataSection() {

--- a/graal/com.oracle.graal.api.code/src/com/oracle/graal/api/code/DataSection.java	Thu May 28 16:54:14 2015 +0200
+++ b/graal/com.oracle.graal.api.code/src/com/oracle/graal/api/code/DataSection.java	Thu May 28 17:44:05 2015 +0200
@@ -24,7 +24,6 @@
 
 import static com.oracle.graal.api.meta.MetaUtil.*;
 
-import java.io.*;
 import java.nio.*;
 import java.util.*;
 import java.util.function.*;
@@ -34,9 +33,7 @@
 import com.oracle.graal.api.code.DataSection.Data;
 import com.oracle.graal.api.meta.*;
 
-public final class DataSection implements Serializable, Iterable<Data> {
-
-    private static final long serialVersionUID = -1375715553825731716L;
+public final class DataSection implements Iterable<Data> {
 
     @FunctionalInterface
     public interface DataBuilder {
@@ -77,9 +74,7 @@
         }
     }
 
-    public static final class Data implements Serializable {
-
-        private static final long serialVersionUID = -719932751800916080L;
+    public static final class Data {
 
         private int alignment;
         private final int size;

--- a/graal/com.oracle.graal.api.code/src/com/oracle/graal/api/code/InstalledCode.java	Thu May 28 16:54:14 2015 +0200
+++ b/graal/com.oracle.graal.api.code/src/com/oracle/graal/api/code/InstalledCode.java	Thu May 28 17:44:05 2015 +0200
@@ -64,6 +64,13 @@
     }
 
     /**
+     * Returns the name of this code blob.
+     */
+    public String getName() {
+        return name;
+    }
+
+    /**
      * Returns the start address of this installed code if it is {@linkplain #isValid() valid}, 0
      * otherwise.
      */

--- a/graal/com.oracle.graal.api.code/src/com/oracle/graal/api/code/RegisterValue.java	Thu May 28 16:54:14 2015 +0200
+++ b/graal/com.oracle.graal.api.code/src/com/oracle/graal/api/code/RegisterValue.java	Thu May 28 17:44:05 2015 +0200
@@ -32,8 +32,6 @@
  */
 public final class RegisterValue extends AllocatableValue {
 
-    private static final long serialVersionUID = 7999341472196897163L;
-
     private final Register reg;
 
     /**

--- a/graal/com.oracle.graal.api.code/src/com/oracle/graal/api/code/StackLockValue.java	Thu May 28 16:54:14 2015 +0200
+++ b/graal/com.oracle.graal.api.code/src/com/oracle/graal/api/code/StackLockValue.java	Thu May 28 17:44:05 2015 +0200
@@ -31,8 +31,6 @@
  */
 public final class StackLockValue extends AbstractValue implements JavaValue {
 
-    private static final long serialVersionUID = 8241681800464483691L;
-
     private Value owner;
     private StackSlotValue slot;
     private final boolean eliminated;

--- a/graal/com.oracle.graal.api.code/src/com/oracle/graal/api/code/StackSlot.java	Thu May 28 16:54:14 2015 +0200
+++ b/graal/com.oracle.graal.api.code/src/com/oracle/graal/api/code/StackSlot.java	Thu May 28 17:44:05 2015 +0200
@@ -30,8 +30,6 @@
  */
 public final class StackSlot extends StackSlotValue {
 
-    private static final long serialVersionUID = -7725071921307318433L;
-
     private final int offset;
     private final boolean addFrameSize;
 

--- a/graal/com.oracle.graal.api.code/src/com/oracle/graal/api/code/StackSlotValue.java	Thu May 28 16:54:14 2015 +0200
+++ b/graal/com.oracle.graal.api.code/src/com/oracle/graal/api/code/StackSlotValue.java	Thu May 28 17:44:05 2015 +0200
@@ -30,8 +30,6 @@
  */
 public abstract class StackSlotValue extends AllocatableValue {
 
-    private static final long serialVersionUID = 5106407801795483337L;
-
     public StackSlotValue(LIRKind lirKind) {
         super(lirKind);
     }

--- a/graal/com.oracle.graal.api.code/src/com/oracle/graal/api/code/VirtualObject.java	Thu May 28 16:54:14 2015 +0200
+++ b/graal/com.oracle.graal.api.code/src/com/oracle/graal/api/code/VirtualObject.java	Thu May 28 17:44:05 2015 +0200
@@ -33,8 +33,6 @@
  */
 public final class VirtualObject extends AbstractValue implements JavaValue {
 
-    private static final long serialVersionUID = -2907197776426346021L;
-
     private final ResolvedJavaType type;
     private Value[] values;
     private final int id;

--- a/graal/com.oracle.graal.api.code/src/com/oracle/graal/api/code/VirtualStackSlot.java	Thu May 28 16:54:14 2015 +0200
+++ b/graal/com.oracle.graal.api.code/src/com/oracle/graal/api/code/VirtualStackSlot.java	Thu May 28 17:44:05 2015 +0200
@@ -30,7 +30,6 @@
  */
 public abstract class VirtualStackSlot extends StackSlotValue {
 
-    private static final long serialVersionUID = 2823688688873398219L;
     private final int id;
 
     public VirtualStackSlot(int id, LIRKind lirKind) {

--- a/graal/com.oracle.graal.api.meta.test/src/com/oracle/graal/api/meta/test/TestResolvedJavaMethod.java	Thu May 28 16:54:14 2015 +0200
+++ b/graal/com.oracle.graal.api.meta.test/src/com/oracle/graal/api/meta/test/TestResolvedJavaMethod.java	Thu May 28 17:44:05 2015 +0200
@@ -312,6 +312,25 @@
         }
     }
 
+    @Test
+    public void isJavaLangObjectInitTest() throws NoSuchMethodException {
+        ResolvedJavaMethod method = metaAccess.lookupJavaMethod(Object.class.getConstructor());
+        assertTrue(method.isJavaLangObjectInit());
+        for (Map.Entry<Method, ResolvedJavaMethod> e : methods.entrySet()) {
+            ResolvedJavaMethod m = e.getValue();
+            assertFalse(m.isJavaLangObjectInit());
+        }
+        for (Map.Entry<Constructor<?>, ResolvedJavaMethod> e : constructors.entrySet()) {
+            ResolvedJavaMethod m = e.getValue();
+            Constructor<?> key = e.getKey();
+            if (key.getDeclaringClass() == Object.class && key.getParameters().length == 0) {
+                assertTrue(m.isJavaLangObjectInit());
+            } else {
+                assertFalse(m.isJavaLangObjectInit());
+            }
+        }
+    }
+
     private Method findTestMethod(Method apiMethod) {
         String testName = apiMethod.getName() + "Test";
         for (Method m : getClass().getDeclaredMethods()) {

--- a/graal/com.oracle.graal.api.meta/src/com/oracle/graal/api/meta/AbstractJavaProfile.java	Thu May 28 16:54:14 2015 +0200
+++ b/graal/com.oracle.graal.api.meta/src/com/oracle/graal/api/meta/AbstractJavaProfile.java	Thu May 28 17:44:05 2015 +0200
@@ -22,8 +22,6 @@
  */
 package com.oracle.graal.api.meta;
 
-import java.io.*;
-
 /**
  * This object holds probability information for a set of items that were profiled at a specific
  * BCI. The precision of the supplied values may vary, but a runtime that provides this information
@@ -34,9 +32,7 @@
  * @param <U> the class of the items that are profiled at the specific BCI and for which
  *            probabilities are stored. E.g., a ResolvedJavaType or a ResolvedJavaMethod.
  */
-public abstract class AbstractJavaProfile<T extends AbstractProfiledItem<U>, U> implements Serializable {
-
-    private static final long serialVersionUID = 5493379044459116749L;
+public abstract class AbstractJavaProfile<T extends AbstractProfiledItem<U>, U> {
 
     private final double notRecordedProbability;
     private final T[] pitems;

--- a/graal/com.oracle.graal.api.meta/src/com/oracle/graal/api/meta/AbstractProfiledItem.java	Thu May 28 16:54:14 2015 +0200
+++ b/graal/com.oracle.graal.api.meta/src/com/oracle/graal/api/meta/AbstractProfiledItem.java	Thu May 28 17:44:05 2015 +0200
@@ -22,15 +22,11 @@
  */
 package com.oracle.graal.api.meta;
 
-import java.io.*;
-
 /**
  * A profiled type that has a probability. Profiled types are naturally sorted in descending order
  * of their probabilities.
  */
-public abstract class AbstractProfiledItem<T> implements Comparable<AbstractProfiledItem<?>>, Serializable {
-
-    private static final long serialVersionUID = 7838575753661305744L;
+public abstract class AbstractProfiledItem<T> implements Comparable<AbstractProfiledItem<?>> {
 
     protected final T item;
     protected final double probability;

--- a/graal/com.oracle.graal.api.meta/src/com/oracle/graal/api/meta/AbstractValue.java	Thu May 28 16:54:14 2015 +0200
+++ b/graal/com.oracle.graal.api.meta/src/com/oracle/graal/api/meta/AbstractValue.java	Thu May 28 17:44:05 2015 +0200
@@ -22,14 +22,10 @@
  */
 package com.oracle.graal.api.meta;
 
-import java.io.*;
-
 /**
  * Abstract base class for values.
  */
-public abstract class AbstractValue implements Serializable, Value, KindProvider {
-
-    private static final long serialVersionUID = -6909397188697766469L;
+public abstract class AbstractValue implements Value, KindProvider {
 
     public static final AllocatableValue ILLEGAL = Value.ILLEGAL;
 

--- a/graal/com.oracle.graal.api.meta/src/com/oracle/graal/api/meta/AllocatableValue.java	Thu May 28 16:54:14 2015 +0200
+++ b/graal/com.oracle.graal.api.meta/src/com/oracle/graal/api/meta/AllocatableValue.java	Thu May 28 17:44:05 2015 +0200
@@ -28,8 +28,6 @@
  */
 public abstract class AllocatableValue extends AbstractValue implements JavaValue, KindProvider {
 
-    private static final long serialVersionUID = 153019506717492133L;
-
     public static final AllocatableValue[] NONE = {};
 
     public AllocatableValue(LIRKind lirKind) {

--- a/graal/com.oracle.graal.api.meta/src/com/oracle/graal/api/meta/Assumptions.java	Thu May 28 16:54:14 2015 +0200
+++ b/graal/com.oracle.graal.api.meta/src/com/oracle/graal/api/meta/Assumptions.java	Thu May 28 17:44:05 2015 +0200
@@ -22,25 +22,20 @@
  */
 package com.oracle.graal.api.meta;
 
-import java.io.*;
 import java.lang.invoke.*;
 import java.util.*;
 
 /**
  * Class for recording assumptions made during compilation.
  */
-public final class Assumptions implements Serializable, Iterable<Assumptions.Assumption> {
-
-    private static final long serialVersionUID = 5152062717588239131L;
+public final class Assumptions implements Iterable<Assumptions.Assumption> {
 
     /**
      * Abstract base class for assumptions. An assumption assumes a property of the runtime that may
      * be invalidated by subsequent execution (e.g., that a class has no subclasses implementing
      * {@link NoFinalizableSubclass Object.finalize()}).
      */
-    public abstract static class Assumption implements Serializable {
-
-        private static final long serialVersionUID = -1936652569665112915L;
+    public abstract static class Assumption {
     }
 
     /**
@@ -68,6 +63,10 @@
             return result;
         }
 
+        public boolean isAssumptionFree() {
+            return assumptions.length == 0;
+        }
+
         public void add(AssumptionResult<T> other) {
             Assumption[] newAssumptions = Arrays.copyOf(this.assumptions, this.assumptions.length + other.assumptions.length);
             System.arraycopy(other.assumptions, 0, newAssumptions, this.assumptions.length, other.assumptions.length);
@@ -80,8 +79,6 @@
      */
     public static final class NoFinalizableSubclass extends Assumption {
 
-        private static final long serialVersionUID = 6451169735564055081L;
-
         private ResolvedJavaType receiverType;
 
         public NoFinalizableSubclass(ResolvedJavaType receiverType) {
@@ -115,8 +112,6 @@
      */
     public static final class ConcreteSubtype extends Assumption {
 
-        private static final long serialVersionUID = -1457173265437676252L;
-
         /**
          * Type the assumption is made about.
          */
@@ -164,8 +159,6 @@
      */
     public static final class LeafType extends Assumption {
 
-        private static final long serialVersionUID = -1457173265437676252L;
-
         /**
          * Type the assumption is made about.
          */
@@ -203,8 +196,6 @@
      */
     public static final class ConcreteMethod extends Assumption {
 
-        private static final long serialVersionUID = -7636746737947390059L;
-
         /**
          * A virtual (or interface) method whose unique implementation for the receiver type in
          * {@link #context} is {@link #impl}.
@@ -257,8 +248,6 @@
      */
     public static final class CallSiteTargetValue extends Assumption {
 
-        private static final long serialVersionUID = 1732459941784550371L;
-
         public final CallSite callSite;
         public final MethodHandle methodHandle;
 

--- a/graal/com.oracle.graal.api.meta/src/com/oracle/graal/api/meta/ConstantReflectionProvider.java	Thu May 28 16:54:14 2015 +0200
+++ b/graal/com.oracle.graal.api.meta/src/com/oracle/graal/api/meta/ConstantReflectionProvider.java	Thu May 28 17:44:05 2015 +0200
@@ -63,6 +63,14 @@
     JavaConstant readConstantArrayElement(JavaConstant array, int index);
 
     /**
+     * Reads a value from the given array at the given offset if it is a stable array. The offset
+     * will decoded relative to the platform addressing into an index into the array. Returns
+     * {@code null} if the constant is not a stable array, if it is a default value, if the offset
+     * is out of bounds, or if the value is not available at this point.
+     */
+    JavaConstant readConstantArrayElementForOffset(JavaConstant array, long offset);
+
+    /**
      * Gets the constant value of this field. Note that a {@code static final} field may not be
      * considered constant if its declaring class is not yet initialized or if it is a well known
      * field that can be updated via other means (e.g., {@link System#setOut(java.io.PrintStream)}).

--- a/graal/com.oracle.graal.api.meta/src/com/oracle/graal/api/meta/JavaConstant.java	Thu May 28 16:54:14 2015 +0200
+++ b/graal/com.oracle.graal.api.meta/src/com/oracle/graal/api/meta/JavaConstant.java	Thu May 28 17:44:05 2015 +0200
@@ -256,16 +256,18 @@
      */
     static PrimitiveConstant forIntegerKind(Kind kind, long i) {
         switch (kind) {
+            case Boolean:
+                return forBoolean(i != 0);
             case Byte:
-                return new PrimitiveConstant(kind, (byte) i);
+                return forByte((byte) i);
             case Short:
-                return new PrimitiveConstant(kind, (short) i);
+                return forShort((short) i);
             case Char:
-                return new PrimitiveConstant(kind, (char) i);
+                return forChar((char) i);
             case Int:
-                return new PrimitiveConstant(kind, (int) i);
+                return forInt((int) i);
             case Long:
-                return new PrimitiveConstant(kind, i);
+                return forLong(i);
             default:
                 throw new IllegalArgumentException("not an integer kind: " + kind);
         }

--- a/graal/com.oracle.graal.api.meta/src/com/oracle/graal/api/meta/JavaMethodProfile.java	Thu May 28 16:54:14 2015 +0200
+++ b/graal/com.oracle.graal.api.meta/src/com/oracle/graal/api/meta/JavaMethodProfile.java	Thu May 28 17:44:05 2015 +0200
@@ -31,8 +31,6 @@
  */
 public final class JavaMethodProfile extends AbstractJavaProfile<ProfiledMethod, ResolvedJavaMethod> {
 
-    private static final long serialVersionUID = -1440572119913692689L;
-
     public JavaMethodProfile(double notRecordedProbability, ProfiledMethod[] pitems) {
         super(notRecordedProbability, pitems);
     }
@@ -43,8 +41,6 @@
 
     public static class ProfiledMethod extends AbstractProfiledItem<ResolvedJavaMethod> {
 
-        private static final long serialVersionUID = 5418813647187024693L;
-
         public ProfiledMethod(ResolvedJavaMethod method, double probability) {
             super(method, probability);
         }

--- a/graal/com.oracle.graal.api.meta/src/com/oracle/graal/api/meta/JavaTypeProfile.java	Thu May 28 16:54:14 2015 +0200
+++ b/graal/com.oracle.graal.api.meta/src/com/oracle/graal/api/meta/JavaTypeProfile.java	Thu May 28 17:44:05 2015 +0200
@@ -33,7 +33,6 @@
  */
 public final class JavaTypeProfile extends AbstractJavaProfile<ProfiledType, ResolvedJavaType> {
 
-    private static final long serialVersionUID = -6877016333706838441L;
     private static final ProfiledType[] EMPTY_ARRAY = new ProfiledType[0];
 
     private final TriState nullSeen;
@@ -145,8 +144,6 @@
 
     public static class ProfiledType extends AbstractProfiledItem<ResolvedJavaType> {
 
-        private static final long serialVersionUID = 1481773321889860837L;
-
         public ProfiledType(ResolvedJavaType type, double probability) {
             super(type, probability);
             assert type.isArray() || type.isConcrete() : type;
@@ -177,4 +174,22 @@
         }
         return buf.append(String.format("], notRecorded:%.6f>", getNotRecordedProbability())).toString();
     }
+
+    /**
+     * Returns {@code true} if all types seen at this location have been recorded in the profile.
+     */
+    public boolean allTypesRecorded() {
+        return this.getNotRecordedProbability() == 0.0;
+    }
+
+    /**
+     * Returns the single monormorphic type representing this profile or {@code null} if no such
+     * type exists.
+     */
+    public ResolvedJavaType asSingleType() {
+        if (allTypesRecorded() && this.getTypes().length == 1) {
+            return getTypes()[0].getType();
+        }
+        return null;
+    }
 }

--- a/graal/com.oracle.graal.api.meta/src/com/oracle/graal/api/meta/LIRKind.java	Thu May 28 16:54:14 2015 +0200
+++ b/graal/com.oracle.graal.api.meta/src/com/oracle/graal/api/meta/LIRKind.java	Thu May 28 17:44:05 2015 +0200
@@ -22,6 +22,8 @@
  */
 package com.oracle.graal.api.meta;
 
+import java.util.*;
+
 /**
  * Represents the type of values in the LIR. It is composed of a {@link PlatformKind} that gives the
  * low level representation of the value, and a {@link #referenceMask} that describes the location
@@ -133,15 +135,60 @@
      */
     public static LIRKind merge(Value... inputs) {
         assert inputs.length > 0;
-        for (Value input : inputs) {
-            LIRKind kind = input.getLIRKind();
+        ArrayList<LIRKind> kinds = new ArrayList<>(inputs.length);
+        for (int i = 0; i < inputs.length; i++) {
+            kinds.add(inputs[i].getLIRKind());
+        }
+        return merge(kinds);
+    }
+
+    /**
+     * @see #merge(Value...)
+     */
+    public static LIRKind merge(Iterable<LIRKind> kinds) {
+        LIRKind mergeKind = null;
+
+        for (LIRKind kind : kinds) {
+
+            assert mergeKind == null || verifyMoveKinds(mergeKind, kind) : String.format("Input kinds do not match %s vs. %s", mergeKind, kind);
+
             if (kind.isDerivedReference()) {
+                /**
+                 * Kind is a derived reference therefore the result can only be also a derived
+                 * reference.
+                 */
                 return kind;
             }
+            if (mergeKind == null) {
+                mergeKind = kind;
+                continue;
+            }
+
+            if (kind.isValue()) {
+                /* Kind is a value. */
+                if (mergeKind.referenceMask != 0) {
+                    /*
+                     * Inputs consists of values and references. Make the result a derived
+                     * reference.
+                     */
+                    return mergeKind.makeDerivedReference();
+                }
+                /* Check that other inputs are also values. */
+            } else {
+                /* Kind is a reference. */
+                if (mergeKind.referenceMask != kind.referenceMask) {
+                    /*
+                     * Reference maps do not match so the result can only be a derived reference.
+                     */
+                    return mergeKind.makeDerivedReference();
+                }
+            }
+
         }
+        assert mergeKind != null;
 
         // all inputs are values or references, just return one of them
-        return inputs[0].getLIRKind();
+        return mergeKind;
     }
 
     /**
@@ -277,4 +324,26 @@
         LIRKind other = (LIRKind) obj;
         return platformKind == other.platformKind && referenceMask == other.referenceMask;
     }
+
+    public static boolean verifyMoveKinds(LIRKind dst, LIRKind src) {
+        if (src.equals(dst)) {
+            return true;
+        }
+        /*
+         * TODO(je,rs) What we actually want is toStackKind(src.getPlatformKind()).equals(
+         * dst.getPlatformKind()) but due to the handling of sub-integer at the current point
+         * (phi-)moves from e.g. integer to short can happen. Therefore we compare stack kinds.
+         */
+        if (toStackKind(src.getPlatformKind()).equals(toStackKind(dst.getPlatformKind()))) {
+            return !src.isDerivedReference() || dst.isDerivedReference();
+        }
+        return false;
+    }
+
+    private static PlatformKind toStackKind(PlatformKind platformKind) {
+        if (platformKind instanceof Kind) {
+            return ((Kind) platformKind).getStackKind();
+        }
+        return platformKind;
+    }
 }

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.api.meta/src/com/oracle/graal/api/meta/LineNumberTableImpl.java	Thu May 28 17:44:05 2015 +0200
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 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.meta;
+
+public class LineNumberTableImpl implements LineNumberTable {
+
+    private final int[] lineNumbers;
+    private final int[] bci;
+
+    public LineNumberTableImpl(int[] lineNumbers, int[] bci) {
+        this.lineNumbers = lineNumbers;
+        this.bci = bci;
+    }
+
+    @Override
+    public int[] getLineNumberEntries() {
+        return lineNumbers;
+    }
+
+    @Override
+    public int[] getBciEntries() {
+        return bci;
+    }
+
+    @Override
+    public int getLineNumber(@SuppressWarnings("hiding") int bci) {
+        for (int i = 0; i < this.bci.length - 1; i++) {
+            if (this.bci[i] <= bci && bci < this.bci[i + 1]) {
+                return lineNumbers[i];
+            }
+        }
+        return lineNumbers[lineNumbers.length - 1];
+    }
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.api.meta/src/com/oracle/graal/api/meta/LocalImpl.java	Thu May 28 17:44:05 2015 +0200
@@ -0,0 +1,84 @@
+/*
+ * Copyright (c) 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.meta;
+
+public class LocalImpl implements Local {
+
+    private final String name;
+    private final int startBci;
+    private final int endBci;
+    private final int slot;
+    private final JavaType type;
+
+    public LocalImpl(String name, JavaType type, int startBci, int endBci, int slot) {
+        this.name = name;
+        this.startBci = startBci;
+        this.endBci = endBci;
+        this.slot = slot;
+        this.type = type;
+    }
+
+    @Override
+    public int getStartBCI() {
+        return startBci;
+    }
+
+    @Override
+    public int getEndBCI() {
+        return endBci;
+    }
+
+    @Override
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public JavaType getType() {
+        return type;
+    }
+
+    @Override
+    public int getSlot() {
+        return slot;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (!(obj instanceof LocalImpl)) {
+            return false;
+        }
+        LocalImpl that = (LocalImpl) obj;
+        return this.name.equals(that.name) && this.startBci == that.startBci && this.endBci == that.endBci && this.slot == that.slot && this.type.equals(that.type);
+    }
+
+    @Override
+    public int hashCode() {
+        return super.hashCode();
+    }
+
+    @Override
+    public String toString() {
+        return "LocalImpl<name=" + name + ", type=" + type + ", startBci=" + startBci + ", endBci=" + endBci + ", slot=" + slot + ">";
+    }
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.api.meta/src/com/oracle/graal/api/meta/LocalVariableTableImpl.java	Thu May 28 17:44:05 2015 +0200
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 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.meta;
+
+import java.util.*;
+
+public class LocalVariableTableImpl implements LocalVariableTable {
+
+    private final Local[] locals;
+
+    public LocalVariableTableImpl(Local[] locals) {
+        this.locals = locals;
+    }
+
+    @Override
+    public Local getLocal(int slot, int bci) {
+        Local result = null;
+        for (Local local : locals) {
+            if (local.getSlot() == slot && local.getStartBCI() <= bci && local.getEndBCI() >= bci) {
+                if (result == null) {
+                    result = local;
+                } else {
+                    throw new IllegalStateException("Locals overlap!");
+                }
+            }
+        }
+        return result;
+    }
+
+    @Override
+    public Local[] getLocals() {
+        return locals;
+    }
+
+    @Override
+    public Local[] getLocalsAt(int bci) {
+        List<Local> result = new ArrayList<>();
+        for (Local l : locals) {
+            if (l.getStartBCI() <= bci && bci <= l.getEndBCI()) {
+                result.add(l);
+            }
+        }
+        return result.toArray(new Local[result.size()]);
+    }
+
+}

--- a/graal/com.oracle.graal.api.meta/src/com/oracle/graal/api/meta/LocationIdentity.java	Thu May 28 16:54:14 2015 +0200
+++ b/graal/com.oracle.graal.api.meta/src/com/oracle/graal/api/meta/LocationIdentity.java	Thu May 28 17:44:05 2015 +0200
@@ -54,26 +54,18 @@
      */
     public static final LocationIdentity ARRAY_LENGTH_LOCATION = NamedLocationIdentity.immutable("[].length");
 
-    protected final boolean immutable;
-
     public static LocationIdentity any() {
         return ANY_LOCATION;
     }
 
-    protected LocationIdentity(boolean immutable) {
-        this.immutable = immutable;
-    }
-
     /**
      * Denotes a location is unchanging in all cases. Not that this is different than the Java
      * notion of final which only requires definite assignment.
      */
-    public final boolean isImmutable() {
-        return immutable;
-    }
+    public abstract boolean isImmutable();
 
     public final boolean isMutable() {
-        return !immutable;
+        return !isImmutable();
     }
 
     public final boolean isAny() {

--- a/graal/com.oracle.graal.api.meta/src/com/oracle/graal/api/meta/NamedLocationIdentity.java	Thu May 28 16:54:14 2015 +0200
+++ b/graal/com.oracle.graal.api.meta/src/com/oracle/graal/api/meta/NamedLocationIdentity.java	Thu May 28 17:44:05 2015 +0200
@@ -46,11 +46,12 @@
         }
     }
 
-    protected final String name;
+    private final String name;
+    private final boolean immutable;
 
     private NamedLocationIdentity(String name, boolean immutable) {
-        super(immutable);
         this.name = name;
+        this.immutable = immutable;
     }
 
     /**
@@ -87,6 +88,11 @@
     }
 
     @Override
+    public boolean isImmutable() {
+        return immutable;
+    }
+
+    @Override
     public String toString() {
         return name + (isImmutable() ? ":final" : "");
     }

--- a/graal/com.oracle.graal.api.meta/src/com/oracle/graal/api/meta/NullConstant.java	Thu May 28 16:54:14 2015 +0200
+++ b/graal/com.oracle.graal.api.meta/src/com/oracle/graal/api/meta/NullConstant.java	Thu May 28 17:44:05 2015 +0200
@@ -27,8 +27,6 @@
  */
 final class NullConstant extends AbstractValue implements JavaConstant {
 
-    private static final long serialVersionUID = 8906209595800783961L;
-
     protected NullConstant() {
         super(LIRKind.reference(Kind.Object));
     }

--- a/graal/com.oracle.graal.api.meta/src/com/oracle/graal/api/meta/PrimitiveConstant.java	Thu May 28 16:54:14 2015 +0200
+++ b/graal/com.oracle.graal.api.meta/src/com/oracle/graal/api/meta/PrimitiveConstant.java	Thu May 28 17:44:05 2015 +0200
@@ -30,8 +30,6 @@
  */
 public class PrimitiveConstant extends AbstractValue implements JavaConstant, SerializableConstant {
 
-    private static final long serialVersionUID = 8787949721295655376L;
-
     /**
      * The boxed primitive value as a {@code long}. For {@code float} and {@code double} values,
      * this value is the result of {@link Float#floatToRawIntBits(float)} and

--- a/graal/com.oracle.graal.api.meta/src/com/oracle/graal/api/meta/RawConstant.java	Thu May 28 16:54:14 2015 +0200
+++ b/graal/com.oracle.graal.api.meta/src/com/oracle/graal/api/meta/RawConstant.java	Thu May 28 17:44:05 2015 +0200
@@ -23,7 +23,6 @@
 package com.oracle.graal.api.meta;
 
 public class RawConstant extends PrimitiveConstant {
-    private static final long serialVersionUID = -242269518888560348L;
 
     public RawConstant(long rawValue) {
         super(Kind.Int, rawValue);

--- a/graal/com.oracle.graal.api.meta/src/com/oracle/graal/api/meta/ResolvedJavaMethod.java	Thu May 28 16:54:14 2015 +0200
+++ b/graal/com.oracle.graal.api.meta/src/com/oracle/graal/api/meta/ResolvedJavaMethod.java	Thu May 28 17:44:05 2015 +0200
@@ -288,4 +288,11 @@
     default boolean hasReceiver() {
         return !isStatic();
     }
+
+    /**
+     * Determines if this method is {@link java.lang.Object#Object()}.
+     */
+    default boolean isJavaLangObjectInit() {
+        return getDeclaringClass().isJavaLangObject() && getName().equals("<init>");
+    }
 }

--- a/graal/com.oracle.graal.api.meta/src/com/oracle/graal/api/meta/Value.java	Thu May 28 16:54:14 2015 +0200
+++ b/graal/com.oracle.graal.api.meta/src/com/oracle/graal/api/meta/Value.java	Thu May 28 17:44:05 2015 +0200
@@ -28,7 +28,7 @@
  */
 public interface Value extends KindProvider, TrustedInterface {
 
-    @SuppressWarnings("serial") AllocatableValue ILLEGAL = new AllocatableValue(LIRKind.Illegal) {
+    AllocatableValue ILLEGAL = new AllocatableValue(LIRKind.Illegal) {
 
         @Override
         public String toString() {

--- a/graal/com.oracle.graal.api.replacements/src/com/oracle/graal/api/replacements/MethodSubstitution.java	Thu May 28 16:54:14 2015 +0200
+++ b/graal/com.oracle.graal.api.replacements/src/com/oracle/graal/api/replacements/MethodSubstitution.java	Thu May 28 17:44:05 2015 +0200
@@ -56,15 +56,6 @@
     String signature() default "";
 
     /**
-     * Determines if this method should be substituted in all cases, even if inlining thinks it is
-     * not important.
-     *
-     * Note that this is still depending on whether inlining sees the correct call target, so it's
-     * only a hard guarantee for static and special invocations.
-     */
-    boolean forced() default false;
-
-    /**
      * Determines if the substitution is for a method that may not be part of the runtime. For
      * example, a method introduced in a later JDK version. Substitutions for such methods are
      * omitted if the original method cannot be found.

--- a/graal/com.oracle.graal.asm.amd64/src/com/oracle/graal/asm/amd64/AMD64MacroAssembler.java	Thu May 28 16:54:14 2015 +0200
+++ b/graal/com.oracle.graal.asm.amd64/src/com/oracle/graal/asm/amd64/AMD64MacroAssembler.java	Thu May 28 17:44:05 2015 +0200
@@ -27,6 +27,7 @@
 import com.oracle.graal.amd64.*;
 import com.oracle.graal.api.code.*;
 import com.oracle.graal.api.meta.*;
+import com.oracle.graal.asm.*;
 
 /**
  * This class implements commonly used X86 code patterns.
@@ -256,9 +257,14 @@
      * volatile field!
      */
     public final void movlong(AMD64Address dst, long src) {
-        AMD64Address high = new AMD64Address(dst.getBase(), dst.getIndex(), dst.getScale(), dst.getDisplacement() + 4);
-        movl(dst, (int) (src & 0xFFFFFFFF));
-        movl(high, (int) (src >> 32));
+        if (NumUtil.isInt(src)) {
+            AMD64MIOp.MOV.emit(this, OperandSize.QWORD, dst, (int) src);
+        } else {
+            AMD64Address high = new AMD64Address(dst.getBase(), dst.getIndex(), dst.getScale(), dst.getDisplacement() + 4);
+            movl(dst, (int) (src & 0xFFFFFFFF));
+            movl(high, (int) (src >> 32));
+        }
+
     }
 
     public final void flog(Register dest, Register value, boolean base10) {

--- a/graal/com.oracle.graal.asm.test/src/com/oracle/graal/asm/test/AssemblerTest.java	Thu May 28 16:54:14 2015 +0200
+++ b/graal/com.oracle.graal.asm.test/src/com/oracle/graal/asm/test/AssemblerTest.java	Thu May 28 17:44:05 2015 +0200
@@ -63,6 +63,7 @@
             CompilationResult compResult = new CompilationResult();
             byte[] targetCode = test.generateCode(compResult, codeCache.getTarget(), registerConfig, cc);
             compResult.setTargetCode(targetCode, targetCode.length);
+            compResult.setTotalFrameSize(0);
 
             InstalledCode code = codeCache.addMethod(method, compResult, null, null);
 

--- a/graal/com.oracle.graal.asm/src/com/oracle/graal/asm/NumUtil.java	Thu May 28 16:54:14 2015 +0200
+++ b/graal/com.oracle.graal.asm/src/com/oracle/graal/asm/NumUtil.java	Thu May 28 17:44:05 2015 +0200
@@ -82,6 +82,13 @@
         return (short) x == x;
     }
 
+    /**
+     * Determines if a given {@code long} value is the range of signed short values.
+     */
+    public static boolean isShort(long x) {
+        return (short) x == x;
+    }
+
     public static boolean isUShort(int s) {
         return s == (s & 0xFFFF);
     }

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.compiler.amd64.test/src/com/oracle/graal/compiler/amd64/test/ConstantStackMoveTest.java	Thu May 28 17:44:05 2015 +0200
@@ -0,0 +1,213 @@
+/*
+ * Copyright (c) 2015, 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package com.oracle.graal.compiler.amd64.test;
+
+import static org.junit.Assume.*;
+
+import org.junit.*;
+
+import com.oracle.graal.amd64.*;
+import com.oracle.graal.api.code.*;
+import com.oracle.graal.api.meta.*;
+import com.oracle.graal.lir.framemap.*;
+import com.oracle.graal.lir.gen.*;
+import com.oracle.graal.lir.jtt.*;
+
+public class ConstantStackMoveTest extends LIRTest {
+    @Before
+    public void checkAMD64() {
+        assumeTrue("skipping AMD64 specific test", getTarget().arch instanceof AMD64);
+    }
+
+    private static class LoadConstantStackSpec extends LIRTestSpecification {
+        protected final Object primitive;
+
+        public LoadConstantStackSpec(Object primitive) {
+            this.primitive = primitive;
+        }
+
+        @Override
+        public void generate(LIRGeneratorTool gen) {
+            FrameMapBuilder frameMapBuilder = gen.getResult().getFrameMapBuilder();
+            // create slots
+            PrimitiveConstant constantValue = JavaConstant.forBoxedPrimitive(primitive);
+            StackSlotValue s1 = frameMapBuilder.allocateSpillSlot(constantValue.getLIRKind());
+            // move stuff around
+            gen.emitMove(s1, constantValue);
+            gen.emitBlackhole(s1);
+            setResult(gen.emitMove(s1));
+        }
+    }
+
+    private static final class LoadConstantStackSpecByte extends LoadConstantStackSpec {
+        public LoadConstantStackSpecByte(byte primitive) {
+            super(primitive);
+        }
+
+        byte get() {
+            return (Byte) primitive;
+        }
+    }
+
+    private static final class LoadConstantStackSpecShort extends LoadConstantStackSpec {
+        public LoadConstantStackSpecShort(short primitive) {
+            super(primitive);
+        }
+
+        short get() {
+            return (Short) primitive;
+        }
+    }
+
+    private static final class LoadConstantStackSpecInteger extends LoadConstantStackSpec {
+        public LoadConstantStackSpecInteger(int primitive) {
+            super(primitive);
+        }
+
+        int get() {
+            return (Integer) primitive;
+        }
+    }
+
+    private static final class LoadConstantStackSpecLong extends LoadConstantStackSpec {
+        public LoadConstantStackSpecLong(long primitive) {
+            super(primitive);
+        }
+
+        long get() {
+            return (Long) primitive;
+        }
+    }
+
+    private static final class LoadConstantStackSpecFloat extends LoadConstantStackSpec {
+        public LoadConstantStackSpecFloat(float primitive) {
+            super(primitive);
+        }
+
+        float get() {
+            return (Float) primitive;
+        }
+    }
+
+    private static final class LoadConstantStackSpecDouble extends LoadConstantStackSpec {
+        public LoadConstantStackSpecDouble(double primitive) {
+            super(primitive);
+        }
+
+        double get() {
+            return (Double) primitive;
+        }
+    }
+
+    private static final LoadConstantStackSpecByte stackCopyByte = new LoadConstantStackSpecByte(Byte.MAX_VALUE);
+    private static final LoadConstantStackSpecShort stackCopyShort = new LoadConstantStackSpecShort(Short.MAX_VALUE);
+    private static final LoadConstantStackSpecInteger stackCopyInt = new LoadConstantStackSpecInteger(Integer.MAX_VALUE);
+    private static final LoadConstantStackSpecLong stackCopyLong = new LoadConstantStackSpecLong(Long.MAX_VALUE);
+    private static final LoadConstantStackSpecFloat stackCopyFloat = new LoadConstantStackSpecFloat(Float.MAX_VALUE);
+    private static final LoadConstantStackSpecDouble stackCopyDouble = new LoadConstantStackSpecDouble(Double.MAX_VALUE);
+
+    @LIRIntrinsic
+    public static byte testCopyByte(LoadConstantStackSpecByte spec) {
+        return spec.get();
+    }
+
+    public byte testByte() {
+        return testCopyByte(stackCopyByte);
+    }
+
+    @Test
+    public void runByte() throws Throwable {
+        runTest("testByte");
+    }
+
+    @LIRIntrinsic
+    public static short testCopyShort(LoadConstantStackSpecShort spec) {
+        return spec.get();
+    }
+
+    public short testShort() {
+        return testCopyShort(stackCopyShort);
+    }
+
+    @Test
+    public void runShort() throws Throwable {
+        runTest("testShort");
+    }
+
+    @LIRIntrinsic
+    public static int testCopyInt(LoadConstantStackSpecInteger spec) {
+        return spec.get();
+    }
+
+    public int testInt() {
+        return testCopyInt(stackCopyInt);
+    }
+
+    @Test
+    public void runInt() throws Throwable {
+        runTest("testInt");
+    }
+
+    @LIRIntrinsic
+    public static long testCopyLong(LoadConstantStackSpecLong spec) {
+        return spec.get();
+    }
+
+    public long testLong() {
+        return testCopyLong(stackCopyLong);
+    }
+
+    @Test
+    public void runLong() throws Throwable {
+        runTest("testLong");
+    }
+
+    @LIRIntrinsic
+    public static float testCopyFloat(LoadConstantStackSpecFloat spec) {
+        return spec.get();
+    }
+
+    public float testFloat() {
+        return testCopyFloat(stackCopyFloat);
+    }
+
+    @Test
+    public void runFloat() throws Throwable {
+        runTest("testFloat");
+    }
+
+    @LIRIntrinsic
+    public static double testCopyDouble(LoadConstantStackSpecDouble spec) {
+        return spec.get();
+    }
+
+    public double testDouble() {
+        return testCopyDouble(stackCopyDouble);
+    }
+
+    @Test
+    public void runDouble() throws Throwable {
+        runTest("testDouble");
+    }
+
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.compiler.amd64.test/src/com/oracle/graal/compiler/amd64/test/StackStoreTest.java	Thu May 28 17:44:05 2015 +0200
@@ -0,0 +1,130 @@
+/*
+ * Copyright (c) 2015, 2015, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package com.oracle.graal.compiler.amd64.test;
+
+import static org.junit.Assume.*;
+
+import org.junit.*;
+
+import com.oracle.graal.amd64.*;
+import com.oracle.graal.api.code.*;
+import com.oracle.graal.api.meta.*;
+import com.oracle.graal.lir.framemap.*;
+import com.oracle.graal.lir.gen.*;
+import com.oracle.graal.lir.jtt.*;
+
+public class StackStoreTest extends LIRTest {
+    @Before
+    public void checkAMD64() {
+        assumeTrue("skipping AMD64 specific test", getTarget().arch instanceof AMD64);
+    }
+
+    private static final LIRTestSpecification stackCopy0 = new LIRTestSpecification() {
+        @Override
+        public void generate(LIRGeneratorTool gen, Value a) {
+            FrameMapBuilder frameMapBuilder = gen.getResult().getFrameMapBuilder();
+            // create slots
+            StackSlotValue s1 = frameMapBuilder.allocateSpillSlot(a.getLIRKind());
+            StackSlotValue s2 = frameMapBuilder.allocateSpillSlot(LIRKind.value(Kind.Short));
+            // move stuff around
+            gen.emitMove(s1, a);
+            gen.emitMove(s2, JavaConstant.forShort(Short.MIN_VALUE));
+            setResult(gen.emitMove(s1));
+            gen.emitBlackhole(s1);
+            gen.emitBlackhole(s2);
+        }
+    };
+
+    private static final LIRTestSpecification stackCopy1 = new LIRTestSpecification() {
+        @Override
+        public void generate(LIRGeneratorTool gen, Value a) {
+            FrameMapBuilder frameMapBuilder = gen.getResult().getFrameMapBuilder();
+            // create slots
+            StackSlotValue s1 = frameMapBuilder.allocateSpillSlot(a.getLIRKind());
+            StackSlotValue s2 = frameMapBuilder.allocateSpillSlot(LIRKind.value(Kind.Short));
+            // move stuff around
+            gen.emitMove(s1, a);
+            Value v = gen.emitMove(JavaConstant.forShort(Short.MIN_VALUE));
+            gen.emitMove(s2, v);
+            setResult(gen.emitMove(s1));
+            gen.emitBlackhole(s1);
+            gen.emitBlackhole(s2);
+        }
+    };
+
+    private static final LIRTestSpecification stackCopy2 = new LIRTestSpecification() {
+        @Override
+        public void generate(LIRGeneratorTool gen, Value a) {
+            FrameMapBuilder frameMapBuilder = gen.getResult().getFrameMapBuilder();
+            // create slots
+            StackSlotValue s1 = frameMapBuilder.allocateSpillSlot(a.getLIRKind());
+            StackSlotValue s2 = frameMapBuilder.allocateSpillSlot(LIRKind.value(Kind.Short));
+            // move stuff around
+            gen.emitMove(s2, JavaConstant.forShort(Short.MIN_VALUE));
+            gen.emitMove(s1, a);
+            setResult(gen.emitMove(s2));
+            gen.emitBlackhole(s1);
+            gen.emitBlackhole(s2);
+        }
+    };
+
+    @SuppressWarnings("unused")
+    @LIRIntrinsic
+    public static int testShortStackSlot(LIRTestSpecification spec, int a) {
+        return a;
+    }
+
+    @SuppressWarnings("unused")
+    @LIRIntrinsic
+    public static short testShortStackSlot2(LIRTestSpecification spec, int a) {
+        return Short.MIN_VALUE;
+    }
+
+    public int test0(int a) {
+        return testShortStackSlot(stackCopy0, a);
+    }
+
+    @Test
+    public void run0() throws Throwable {
+        runTest("test0", 0xDEADDEAD);
+    }
+
+    public int test1(int a) {
+        return testShortStackSlot(stackCopy1, a);
+    }
+
+    @Test
+    public void run1() throws Throwable {
+        runTest("test1", 0xDEADDEAD);
+    }
+
+    public int test2(int a) {
+        return testShortStackSlot2(stackCopy2, a);
+    }
+
+    @Test
+    public void run2() throws Throwable {
+        runTest("test2", 0xDEADDEAD);
+    }
+
+}

--- a/graal/com.oracle.graal.compiler.amd64/src/com/oracle/graal/compiler/amd64/AMD64LIRGenerator.java	Thu May 28 16:54:14 2015 +0200
+++ b/graal/com.oracle.graal.compiler.amd64/src/com/oracle/graal/compiler/amd64/AMD64LIRGenerator.java	Thu May 28 17:44:05 2015 +0200
@@ -52,6 +52,7 @@
 import com.oracle.graal.compiler.common.*;
 import com.oracle.graal.compiler.common.calc.*;
 import com.oracle.graal.compiler.common.spi.*;
+import com.oracle.graal.compiler.common.util.*;
 import com.oracle.graal.lir.*;
 import com.oracle.graal.lir.StandardOp.JumpOp;
 import com.oracle.graal.lir.amd64.*;
@@ -64,6 +65,7 @@
 import com.oracle.graal.lir.amd64.AMD64ControlFlow.StrategySwitchOp;
 import com.oracle.graal.lir.amd64.AMD64ControlFlow.TableSwitchOp;
 import com.oracle.graal.lir.amd64.AMD64Move.AMD64StackMove;
+import com.oracle.graal.lir.amd64.AMD64Move.CompareAndSwapOp;
 import com.oracle.graal.lir.amd64.AMD64Move.LeaDataOp;
 import com.oracle.graal.lir.amd64.AMD64Move.LeaOp;
 import com.oracle.graal.lir.amd64.AMD64Move.MembarOp;
@@ -81,6 +83,7 @@
 
     private static final RegisterValue RCX_I = AMD64.rcx.asValue(LIRKind.value(Kind.Int));
     private AMD64SpillMoveFactory moveFactory;
+    private Map<PlatformKind.Key, RegisterBackupPair> categorized;
 
     private static class RegisterBackupPair {
         public final Register register;
@@ -93,7 +96,6 @@
     }
 
     private class AMD64SpillMoveFactory implements LIRGeneratorTool.SpillMoveFactory {
-        private Map<PlatformKind.Key, RegisterBackupPair> categorized;
 
         @Override
         public LIRInstruction createMove(AllocatableValue result, Value input) {
@@ -102,34 +104,9 @@
 
         @Override
         public LIRInstruction createStackMove(AllocatableValue result, Value input) {
-            RegisterBackupPair backup = getScratchRegister(input.getPlatformKind());
-            return new AMD64StackMove(result, input, backup.register, backup.backupSlot);
+            return AMD64LIRGenerator.this.createStackMove(result, input);
         }
 
-        private RegisterBackupPair getScratchRegister(PlatformKind kind) {
-            PlatformKind.Key key = kind.getKey();
-            if (categorized == null) {
-                categorized = new HashMap<>();
-            } else if (categorized.containsKey(key)) {
-                return categorized.get(key);
-            }
-
-            FrameMapBuilder frameMapBuilder = getResult().getFrameMapBuilder();
-            RegisterConfig registerConfig = frameMapBuilder.getRegisterConfig();
-
-            Register[] availableRegister = registerConfig.filterAllocatableRegisters(kind, registerConfig.getAllocatableRegisters());
-            assert availableRegister != null && availableRegister.length > 1;
-            Register scratchRegister = availableRegister[0];
-
-            Architecture arch = frameMapBuilder.getCodeCache().getTarget().arch;
-            LIRKind largestKind = LIRKind.value(arch.getLargestStorableKind(scratchRegister.getRegisterCategory()));
-            VirtualStackSlot backupSlot = frameMapBuilder.allocateSpillSlot(largestKind);
-
-            RegisterBackupPair value = new RegisterBackupPair(scratchRegister, backupSlot);
-            categorized.put(key, value);
-
-            return value;
-        }
     }
 
     public AMD64LIRGenerator(LIRKindTool lirKindTool, Providers providers, CallingConvention cc, LIRGenerationResult lirGenRes) {
@@ -155,6 +132,28 @@
         }
     }
 
+    /**
+     * Checks whether the supplied constant can be used without loading it into a register for store
+     * operations, i.e., on the right hand side of a memory access.
+     *
+     * @param c The constant to check.
+     * @return True if the constant can be used directly, false if the constant needs to be in a
+     *         register.
+     */
+    protected final boolean canStoreConstant(JavaConstant c) {
+        // there is no immediate move of 64-bit constants on Intel
+        switch (c.getKind()) {
+            case Long:
+                return Util.isInt(c.asLong()) && !getCodeCache().needsDataPatch(c);
+            case Double:
+                return false;
+            case Object:
+                return c.isNull();
+            default:
+                return true;
+        }
+    }
+
     protected AMD64LIRInstruction createMove(AllocatableValue dst, Value src) {
         if (src instanceof AMD64AddressValue) {
             return new LeaOp(dst, (AMD64AddressValue) src);
@@ -165,6 +164,42 @@
         }
     }
 
+    protected LIRInstruction createStackMove(AllocatableValue result, Value input) {
+        RegisterBackupPair backup = getScratchRegister(input.getPlatformKind());
+        Register scratchRegister = backup.register;
+        StackSlotValue backupSlot = backup.backupSlot;
+        return createStackMove(result, input, scratchRegister, backupSlot);
+    }
+
+    protected LIRInstruction createStackMove(AllocatableValue result, Value input, Register scratchRegister, StackSlotValue backupSlot) {
+        return new AMD64StackMove(result, input, scratchRegister, backupSlot);
+    }
+
+    protected RegisterBackupPair getScratchRegister(PlatformKind kind) {
+        PlatformKind.Key key = kind.getKey();
+        if (categorized == null) {
+            categorized = new HashMap<>();
+        } else if (categorized.containsKey(key)) {
+            return categorized.get(key);
+        }
+
+        FrameMapBuilder frameMapBuilder = getResult().getFrameMapBuilder();
+        RegisterConfig registerConfig = frameMapBuilder.getRegisterConfig();
+
+        Register[] availableRegister = registerConfig.filterAllocatableRegisters(kind, registerConfig.getAllocatableRegisters());
+        assert availableRegister != null && availableRegister.length > 1;
+        Register scratchRegister = availableRegister[0];
+
+        Architecture arch = frameMapBuilder.getCodeCache().getTarget().arch;
+        LIRKind largestKind = LIRKind.value(arch.getLargestStorableKind(scratchRegister.getRegisterCategory()));
+        VirtualStackSlot backupSlot = frameMapBuilder.allocateSpillSlot(largestKind);
+
+        RegisterBackupPair value = new RegisterBackupPair(scratchRegister, backupSlot);
+        categorized.put(key, value);
+
+        return value;
+    }
+
     @Override
     public void emitMove(AllocatableValue dst, Value src) {
         append(createMove(dst, src));
@@ -252,6 +287,183 @@
         return result;
     }
 
+    private static LIRKind toStackKind(LIRKind kind) {
+        if (kind.getPlatformKind() instanceof Kind) {
+            Kind stackKind = ((Kind) kind.getPlatformKind()).getStackKind();
+            return kind.changeType(stackKind);
+        } else {
+            return kind;
+        }
+    }
+
+    @Override
+    public Variable emitLoad(LIRKind kind, Value address, LIRFrameState state) {
+        AMD64AddressValue loadAddress = asAddressValue(address);
+        Variable result = newVariable(toStackKind(kind));
+        switch ((Kind) kind.getPlatformKind()) {
+            case Boolean:
+                append(new AMD64Unary.MemoryOp(MOVZXB, DWORD, result, loadAddress, state));
+                break;
+            case Byte:
+                append(new AMD64Unary.MemoryOp(MOVSXB, DWORD, result, loadAddress, state));
+                break;
+            case Char:
+                append(new AMD64Unary.MemoryOp(MOVZX, DWORD, result, loadAddress, state));
+                break;
+            case Short:
+                append(new AMD64Unary.MemoryOp(MOVSX, DWORD, result, loadAddress, state));
+                break;
+            case Int:
+                append(new AMD64Unary.MemoryOp(MOV, DWORD, result, loadAddress, state));
+                break;
+            case Long:
+            case Object:
+                append(new AMD64Unary.MemoryOp(MOV, QWORD, result, loadAddress, state));
+                break;
+            case Float:
+                append(new AMD64Unary.MemoryOp(MOVSS, SS, result, loadAddress, state));
+                break;
+            case Double:
+                append(new AMD64Unary.MemoryOp(MOVSD, SD, result, loadAddress, state));
+                break;
+            default:
+                throw GraalInternalError.shouldNotReachHere();
+        }
+        return result;
+    }
+
+    protected void emitStoreConst(Kind kind, AMD64AddressValue address, JavaConstant value, LIRFrameState state) {
+        if (value.isNull()) {
+            assert kind == Kind.Int || kind == Kind.Long || kind == Kind.Object;
+            OperandSize size = kind == Kind.Int ? DWORD : QWORD;
+            append(new AMD64BinaryConsumer.MemoryConstOp(AMD64MIOp.MOV, size, address, 0, state));
+        } else {
+            AMD64MIOp op = AMD64MIOp.MOV;
+            OperandSize size;
+            long imm;
+
+            switch (kind) {
+                case Boolean:
+                case Byte:
+                    op = AMD64MIOp.MOVB;
+                    size = BYTE;
+                    imm = value.asInt();
+                    break;
+                case Char:
+                case Short:
+                    size = WORD;
+                    imm = value.asInt();
+                    break;
+                case Int:
+                    size = DWORD;
+                    imm = value.asInt();
+                    break;
+                case Long:
+                    size = QWORD;
+                    imm = value.asLong();
+                    break;
+                case Float:
+                    size = DWORD;
+                    imm = Float.floatToRawIntBits(value.asFloat());
+                    break;
+                case Double:
+                    size = QWORD;
+                    imm = Double.doubleToRawLongBits(value.asDouble());
+                    break;
+                default:
+                    throw GraalInternalError.shouldNotReachHere("unexpected kind " + kind);
+            }
+
+            if (NumUtil.isInt(imm)) {
+                append(new AMD64BinaryConsumer.MemoryConstOp(op, size, address, (int) imm, state));
+            } else {
+                emitStore(kind, address, asAllocatable(value), state);
+            }
+        }
+    }
+
+    protected void emitStore(Kind kind, AMD64AddressValue address, AllocatableValue value, LIRFrameState state) {
+        switch (kind) {
+            case Boolean:
+            case Byte:
+                append(new AMD64BinaryConsumer.MemoryMROp(AMD64MROp.MOVB, BYTE, address, value, state));
+                break;
+            case Char:
+            case Short:
+                append(new AMD64BinaryConsumer.MemoryMROp(AMD64MROp.MOV, WORD, address, value, state));
+                break;
+            case Int:
+                append(new AMD64BinaryConsumer.MemoryMROp(AMD64MROp.MOV, DWORD, address, value, state));
+                break;
+            case Long:
+            case Object:
+                append(new AMD64BinaryConsumer.MemoryMROp(AMD64MROp.MOV, QWORD, address, value, state));
+                break;
+            case Float:
+                append(new AMD64BinaryConsumer.MemoryMROp(AMD64MROp.MOVSS, SS, address, value, state));
+                break;
+            case Double:
+                append(new AMD64BinaryConsumer.MemoryMROp(AMD64MROp.MOVSD, SD, address, value, state));
+                break;
+            default:
+                throw GraalInternalError.shouldNotReachHere();
+        }
+    }
+
+    @Override
+    public void emitStore(LIRKind lirKind, Value address, Value input, LIRFrameState state) {
+        AMD64AddressValue storeAddress = asAddressValue(address);
+        Kind kind = (Kind) lirKind.getPlatformKind();
+        if (isConstant(input)) {
+            emitStoreConst(kind, storeAddress, asConstant(input), state);
+        } else {
+            emitStore(kind, storeAddress, asAllocatable(input), state);
+        }
+    }
+
+    @Override
+    public Variable emitCompareAndSwap(Value address, Value expectedValue, Value newValue, Value trueValue, Value falseValue) {
+        LIRKind kind = newValue.getLIRKind();
+        assert kind.equals(expectedValue.getLIRKind());
+        Kind memKind = (Kind) kind.getPlatformKind();
+
+        AMD64AddressValue addressValue = asAddressValue(address);
+        RegisterValue raxRes = AMD64.rax.asValue(kind);
+        emitMove(raxRes, expectedValue);
+        append(new CompareAndSwapOp(memKind, raxRes, addressValue, raxRes, asAllocatable(newValue)));
+
+        assert trueValue.getLIRKind().equals(falseValue.getLIRKind());
+        Variable result = newVariable(trueValue.getLIRKind());
+        append(new CondMoveOp(result, Condition.EQ, asAllocatable(trueValue), falseValue));
+        return result;
+    }
+
+    @Override
+    public Value emitAtomicReadAndAdd(Value address, Value delta) {
+        LIRKind kind = delta.getLIRKind();
+        Kind memKind = (Kind) kind.getPlatformKind();
+        Variable result = newVariable(kind);
+        AMD64AddressValue addressValue = asAddressValue(address);
+        append(new AMD64Move.AtomicReadAndAddOp(memKind, result, addressValue, asAllocatable(delta)));
+        return result;
+    }
+
+    @Override
+    public Value emitAtomicReadAndWrite(Value address, Value newValue) {
+        LIRKind kind = newValue.getLIRKind();
+        Kind memKind = (Kind) kind.getPlatformKind();
+        Variable result = newVariable(kind);
+        AMD64AddressValue addressValue = asAddressValue(address);
+        append(new AMD64Move.AtomicReadAndWriteOp(memKind, result, addressValue, asAllocatable(newValue)));
+        return result;
+    }
+
+    @Override
+    public void emitNullCheck(Value address, LIRFrameState state) {
+        assert address.getKind() == Kind.Object || address.getKind() == Kind.Long : address + " - " + address.getKind() + " not a pointer!";
+        append(new AMD64Move.NullCheckOp(asAddressValue(address), state));
+    }
+
     @Override
     public void emitJump(LabelRef label) {
         assert label != null;
@@ -1055,16 +1267,39 @@
             return result;
         } else {
             assert inputVal.getKind().getStackKind() == Kind.Int;
-            Variable result = newVariable(LIRKind.derive(inputVal).changeType(Kind.Int));
-            int mask = (int) CodeUtil.mask(fromBits);
-            append(new AMD64Binary.DataOp(AND.getRMOpcode(DWORD), DWORD, result, asAllocatable(inputVal), JavaConstant.forInt(mask)));
+
+            LIRKind resultKind = LIRKind.derive(inputVal);
             if (toBits > 32) {
-                Variable longResult = newVariable(LIRKind.derive(inputVal).changeType(Kind.Long));
-                emitMove(longResult, result);
-                return longResult;
+                resultKind = resultKind.changeType(Kind.Long);
             } else {
-                return result;
+                resultKind = resultKind.changeType(Kind.Int);
             }
+
+            /*
+             * Always emit DWORD operations, even if the resultKind is Long. On AMD64, all DWORD
+             * operations implicitly set the upper half of the register to 0, which is what we want
+             * anyway. Compared to the QWORD oparations, the encoding of the DWORD operations is
+             * sometimes one byte shorter.
+             */
+            switch (fromBits) {
+                case 8:
+                    return emitConvertOp(resultKind, MOVZXB, DWORD, inputVal);
+                case 16:
+                    return emitConvertOp(resultKind, MOVZX, DWORD, inputVal);
+                case 32:
+                    return emitConvertOp(resultKind, MOV, DWORD, inputVal);
+            }
+
+            // odd bit count, fall back on manual masking
+            Variable result = newVariable(resultKind);
+            JavaConstant mask;
+            if (toBits > 32) {
+                mask = JavaConstant.forLong(CodeUtil.mask(fromBits));
+            } else {
+                mask = JavaConstant.forInt((int) CodeUtil.mask(fromBits));
+            }
+            append(new AMD64Binary.DataOp(AND.getRMOpcode(DWORD), DWORD, result, asAllocatable(inputVal), mask));
+            return result;
         }
     }
 

--- a/graal/com.oracle.graal.compiler.amd64/src/com/oracle/graal/compiler/amd64/AMD64NodeLIRBuilder.java	Thu May 28 16:54:14 2015 +0200
+++ b/graal/com.oracle.graal.compiler.amd64/src/com/oracle/graal/compiler/amd64/AMD64NodeLIRBuilder.java	Thu May 28 17:44:05 2015 +0200
@@ -47,6 +47,7 @@
 import com.oracle.graal.nodes.*;
 import com.oracle.graal.nodes.calc.*;
 import com.oracle.graal.nodes.extended.*;
+import com.oracle.graal.nodes.memory.*;
 
 public abstract class AMD64NodeLIRBuilder extends NodeLIRBuilder {
 

--- a/graal/com.oracle.graal.compiler.common/src/com/oracle/graal/compiler/common/FieldIntrospection.java	Thu May 28 16:54:14 2015 +0200
+++ b/graal/com.oracle.graal.compiler.common/src/com/oracle/graal/compiler/common/FieldIntrospection.java	Thu May 28 17:44:05 2015 +0200
@@ -45,4 +45,6 @@
     public Fields getData() {
         return data;
     }
+
+    public abstract Fields[] getAllFields();
 }

--- a/graal/com.oracle.graal.compiler.common/src/com/oracle/graal/compiler/common/Fields.java	Thu May 28 16:54:14 2015 +0200
+++ b/graal/com.oracle.graal.compiler.common/src/com/oracle/graal/compiler/common/Fields.java	Thu May 28 17:44:05 2015 +0200
@@ -48,6 +48,8 @@
      */
     private final Class<?>[] types;
 
+    private final Class<?>[] declaringClasses;
+
     public static Fields forClass(Class<?> clazz, Class<?> endClazz, boolean includeTransient, FieldsScanner.CalcOffset calcOffset) {
         FieldsScanner scanner = new FieldsScanner(calcOffset == null ? new FieldsScanner.DefaultCalcOffset() : calcOffset);
         scanner.scan(clazz, endClazz, includeTransient);
@@ -59,11 +61,13 @@
         this.offsets = new long[fields.size()];
         this.names = new String[offsets.length];
         this.types = new Class[offsets.length];
+        this.declaringClasses = new Class[offsets.length];
         int index = 0;
         for (FieldsScanner.FieldInfo f : fields) {
             offsets[index] = f.offset;
             names[index] = f.name;
             types[index] = f.type;
+            declaringClasses[index] = f.declaringClass;
             index++;
         }
     }
@@ -77,7 +81,7 @@
 
     public static void translateInto(Fields fields, ArrayList<FieldsScanner.FieldInfo> infos) {
         for (int index = 0; index < fields.getCount(); index++) {
-            infos.add(new FieldsScanner.FieldInfo(fields.offsets[index], fields.names[index], fields.types[index]));
+            infos.add(new FieldsScanner.FieldInfo(fields.offsets[index], fields.names[index], fields.types[index], fields.declaringClasses[index]));
         }
     }
 
@@ -217,6 +221,10 @@
         return other.offsets[index] == offsets[index];
     }
 
+    public long[] getOffsets() {
+        return offsets;
+    }
+
     /**
      * Gets the name of a field.
      *
@@ -235,6 +243,10 @@
         return types[index];
     }
 
+    public Class<?> getDeclaringClass(int index) {
+        return declaringClasses[index];
+    }
+
     /**
      * Checks that a given field is assignable from a given value.
      *

--- a/graal/com.oracle.graal.compiler.common/src/com/oracle/graal/compiler/common/FieldsScanner.java	Thu May 28 16:54:14 2015 +0200
+++ b/graal/com.oracle.graal.compiler.common/src/com/oracle/graal/compiler/common/FieldsScanner.java	Thu May 28 17:44:05 2015 +0200
@@ -60,11 +60,13 @@
         public final long offset;
         public final String name;
         public final Class<?> type;
+        public final Class<?> declaringClass;
 
-        public FieldInfo(long offset, String name, Class<?> type) {
+        public FieldInfo(long offset, String name, Class<?> type, Class<?> declaringClass) {
             this.offset = offset;
             this.name = name;
             this.type = type;
+            this.declaringClass = declaringClass;
         }
 
         /**
@@ -117,6 +119,6 @@
     }
 
     protected void scanField(Field field, long offset) {
-        data.add(new FieldsScanner.FieldInfo(offset, field.getName(), field.getType()));
+        data.add(new FieldsScanner.FieldInfo(offset, field.getName(), field.getType(), field.getDeclaringClass()));
     }
 }

--- a/graal/com.oracle.graal.compiler.common/src/com/oracle/graal/compiler/common/GraalOptions.java	Thu May 28 16:54:14 2015 +0200
+++ b/graal/com.oracle.graal.compiler.common/src/com/oracle/graal/compiler/common/GraalOptions.java	Thu May 28 17:44:05 2015 +0200
@@ -286,7 +286,7 @@
     public static final OptionValue<Boolean> OptImplicitNullChecks = new OptionValue<>(true);
 
     @Option(help = "", type = OptionType.Debug)
-    public static final OptionValue<Boolean> OptLivenessAnalysis = new OptionValue<>(true);
+    public static final OptionValue<Boolean> OptClearNonLiveLocals = new OptionValue<>(true);
 
     @Option(help = "", type = OptionType.Debug)
     public static final OptionValue<Boolean> OptLoopTransform = new OptionValue<>(true);

--- a/graal/com.oracle.graal.compiler.common/src/com/oracle/graal/compiler/common/alloc/RegisterAllocationConfig.java	Thu May 28 16:54:14 2015 +0200
+++ b/graal/com.oracle.graal.compiler.common/src/com/oracle/graal/compiler/common/alloc/RegisterAllocationConfig.java	Thu May 28 17:44:05 2015 +0200
@@ -36,6 +36,36 @@
  */
 public class RegisterAllocationConfig {
 
+    public static final class AllocatableRegisters {
+        public final Register[] allocatableRegisters;
+        public final int minRegisterNumber;
+        public final int maxRegisterNumber;
+
+        public AllocatableRegisters(Register[] allocatableRegisters, int minRegisterNumber, int maxRegisterNumber) {
+            this.allocatableRegisters = allocatableRegisters;
+            this.minRegisterNumber = minRegisterNumber;
+            this.maxRegisterNumber = maxRegisterNumber;
+            assert verify(allocatableRegisters, minRegisterNumber, maxRegisterNumber);
+        }
+
+        private static boolean verify(Register[] allocatableRegisters, int minRegisterNumber, int maxRegisterNumber) {
+            int min = Integer.MAX_VALUE;
+            int max = Integer.MIN_VALUE;
+            for (Register reg : allocatableRegisters) {
+                int number = reg.number;
+                if (number < min) {
+                    min = number;
+                }
+                if (number > max) {
+                    max = number;
+                }
+            }
+            assert minRegisterNumber == min;
+            assert maxRegisterNumber == max;
+            return true;
+        }
+    }
+
     public static final String ALL_REGISTERS = "<all>";
 
     private static Register findRegister(String name, Register[] all) {
@@ -47,7 +77,7 @@
         throw new IllegalArgumentException("register " + name + " is not allocatable");
     }
 
-    private static Register[] initAllocatable(Register[] registers) {
+    protected Register[] initAllocatable(Register[] registers) {
         if (RegisterPressure.getValue() != null && !RegisterPressure.getValue().equals(ALL_REGISTERS)) {
             String[] names = RegisterPressure.getValue().split(",");
             Register[] regs = new Register[names.length];
@@ -60,11 +90,12 @@
         return registers;
     }
 
-    private final RegisterConfig registerConfig;
-    private final Map<PlatformKind.Key, Register[]> categorized = new HashMap<>();
+    protected final RegisterConfig registerConfig;
+    private final Map<PlatformKind.Key, AllocatableRegisters> categorized = new HashMap<>();
     private Register[] cachedRegisters;
 
     public RegisterAllocationConfig(RegisterConfig registerConfig) {
+        assert registerConfig != null;
         this.registerConfig = registerConfig;
     }
 
@@ -72,17 +103,19 @@
      * Gets the set of registers that can be used by the register allocator for a value of a
      * particular kind.
      */
-    public Register[] getAllocatableRegisters(PlatformKind kind) {
+    public AllocatableRegisters getAllocatableRegisters(PlatformKind kind) {
         PlatformKind.Key key = kind.getKey();
         if (categorized.containsKey(key)) {
-            Register[] val = categorized.get(key);
+            AllocatableRegisters val = categorized.get(key);
             return val;
         }
-
-        Register[] ret = registerConfig.filterAllocatableRegisters(kind, getAllocatableRegisters());
+        AllocatableRegisters ret = createAllocatableRegisters(registerConfig.filterAllocatableRegisters(kind, getAllocatableRegisters()));
         categorized.put(key, ret);
         return ret;
+    }
 
+    protected AllocatableRegisters createAllocatableRegisters(Register[] registers) {
+        return new AllocatableRegisters(registers, registers[0].number, registers[registers.length - 1].number);
     }
 
     /**

--- a/graal/com.oracle.graal.compiler.common/src/com/oracle/graal/compiler/common/type/AbstractObjectStamp.java	Thu May 28 16:54:14 2015 +0200
+++ b/graal/com.oracle.graal.compiler.common/src/com/oracle/graal/compiler/common/type/AbstractObjectStamp.java	Thu May 28 17:44:05 2015 +0200
@@ -43,6 +43,11 @@
     protected abstract AbstractObjectStamp copyWith(ResolvedJavaType newType, boolean newExactType, boolean newNonNull, boolean newAlwaysNull);
 
     @Override
+    protected final AbstractPointerStamp copyWith(boolean newNonNull, boolean newAlwaysNull) {
+        return copyWith(type, exactType, newNonNull, newAlwaysNull);
+    }
+
+    @Override
     public Stamp unrestricted() {
         return copyWith(null, false, false, false);
     }

--- a/graal/com.oracle.graal.compiler.common/src/com/oracle/graal/compiler/common/type/AbstractPointerStamp.java	Thu May 28 16:54:14 2015 +0200
+++ b/graal/com.oracle.graal.compiler.common/src/com/oracle/graal/compiler/common/type/AbstractPointerStamp.java	Thu May 28 17:44:05 2015 +0200
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014, 2014, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2014, 2015, 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
@@ -45,6 +45,8 @@
         return alwaysNull;
     }
 
+    protected abstract AbstractPointerStamp copyWith(boolean newNonNull, boolean newAlwaysNull);
+
     @Override
     public int hashCode() {
         final int prime = 31;
@@ -55,6 +57,36 @@
     }
 
     @Override
+    public Stamp join(Stamp stamp) {
+        AbstractPointerStamp other = (AbstractPointerStamp) stamp;
+        boolean joinNonNull = this.nonNull || other.nonNull;
+        boolean joinAlwaysNull = this.alwaysNull || other.alwaysNull;
+        if (joinNonNull && joinAlwaysNull) {
+            return empty();
+        } else {
+            return copyWith(joinNonNull, joinAlwaysNull);
+        }
+    }
+
+    @Override
+    public Stamp improveWith(Stamp other) {
+        return join(other);
+    }
+
+    @Override
+    public Stamp meet(Stamp stamp) {
+        AbstractPointerStamp other = (AbstractPointerStamp) stamp;
+        boolean meetNonNull = this.nonNull && other.nonNull;
+        boolean meetAlwaysNull = this.alwaysNull && other.alwaysNull;
+        return copyWith(meetNonNull, meetAlwaysNull);
+    }
+
+    @Override
+    public Stamp unrestricted() {
+        return copyWith(false, false);
+    }
+
+    @Override
     public boolean equals(Object obj) {
         if (this == obj) {
             return true;

--- a/graal/com.oracle.graal.compiler.sparc.test/src/com/oracle/graal/compiler/sparc/test/SPARCAllocatorTest.java	Thu May 28 16:54:14 2015 +0200
+++ b/graal/com.oracle.graal.compiler.sparc.test/src/com/oracle/graal/compiler/sparc/test/SPARCAllocatorTest.java	Thu May 28 17:44:05 2015 +0200
@@ -58,7 +58,7 @@
 
     @Test
     public void test3() {
-        testAllocation("test3snippet", 3, 1, 0);
+        testAllocation("test3snippet", 3, 0, 0);
     }
 
     public static long test3snippet(long x) {

--- a/graal/com.oracle.graal.compiler.sparc/src/com/oracle/graal/compiler/sparc/SPARCLIRGenerator.java	Thu May 28 16:54:14 2015 +0200
+++ b/graal/com.oracle.graal.compiler.sparc/src/com/oracle/graal/compiler/sparc/SPARCLIRGenerator.java	Thu May 28 17:44:05 2015 +0200
@@ -52,15 +52,7 @@
 import com.oracle.graal.lir.sparc.SPARCControlFlow.ReturnOp;
 import com.oracle.graal.lir.sparc.SPARCControlFlow.StrategySwitchOp;
 import com.oracle.graal.lir.sparc.SPARCControlFlow.TableSwitchOp;
-import com.oracle.graal.lir.sparc.SPARCMove.LoadAddressOp;
-import com.oracle.graal.lir.sparc.SPARCMove.LoadDataAddressOp;
-import com.oracle.graal.lir.sparc.SPARCMove.MembarOp;
-import com.oracle.graal.lir.sparc.SPARCMove.MoveFpGp;
-import com.oracle.graal.lir.sparc.SPARCMove.MoveFpGpVIS3;
-import com.oracle.graal.lir.sparc.SPARCMove.MoveFromRegOp;
-import com.oracle.graal.lir.sparc.SPARCMove.MoveToRegOp;
-import com.oracle.graal.lir.sparc.SPARCMove.SPARCStackMove;
-import com.oracle.graal.lir.sparc.SPARCMove.StackLoadAddressOp;
+import com.oracle.graal.lir.sparc.SPARCMove.*;
 import com.oracle.graal.phases.util.*;
 import com.oracle.graal.sparc.*;
 import com.oracle.graal.sparc.SPARC.CPUFeature;
@@ -82,7 +74,7 @@
 
         @Override
         public LIRInstruction createStackMove(AllocatableValue result, Value input) {
-            return new SPARCStackMove(result, input);
+            return SPARCLIRGenerator.this.createStackMove(result, input);
         }
     }
 
@@ -125,6 +117,10 @@
         }
     }
 
+    protected LIRInstruction createStackMove(AllocatableValue result, Value input) {
+        return new SPARCStackMove(result, input);
+    }
+
     @Override
     public void emitMove(AllocatableValue dst, Value src) {
         append(createMove(dst, src));
@@ -158,15 +154,15 @@
                 finalDisp += asConstant(index).asLong() * scale;
                 indexRegister = Value.ILLEGAL;
             } else {
+                Value longIndex = index.getKind() == Kind.Long ? index : emitSignExtend(index, 32, 64);
                 if (scale != 1) {
-                    Value longIndex = index.getKind() == Kind.Long ? index : emitSignExtend(index, 32, 64);
                     if (CodeUtil.isPowerOf2(scale)) {
                         indexRegister = emitShl(longIndex, JavaConstant.forLong(CodeUtil.log2(scale)));
                     } else {
                         indexRegister = emitMul(longIndex, JavaConstant.forLong(scale), false);
                     }
                 } else {
-                    indexRegister = asAllocatable(index);
+                    indexRegister = asAllocatable(longIndex);
                 }
             }
         } else {
@@ -856,9 +852,10 @@
             case F2D:
                 return emitConvert2Op(LIRKind.derive(inputVal).changeType(Kind.Double), F2D, input);
             case I2F: {
-                AllocatableValue convertedFloatReg = newVariable(LIRKind.derive(input).changeType(Kind.Float));
-                moveBetweenFpGp(convertedFloatReg, input);
-                append(new Unary2Op(I2F, convertedFloatReg, convertedFloatReg));
+                AllocatableValue intEncodedFloatReg = newVariable(LIRKind.derive(input).changeType(Kind.Float));
+                moveBetweenFpGp(intEncodedFloatReg, input);
+                AllocatableValue convertedFloatReg = newVariable(intEncodedFloatReg.getLIRKind());
+                append(new Unary2Op(I2F, convertedFloatReg, intEncodedFloatReg));
                 return convertedFloatReg;
             }
             case I2D: {
@@ -871,9 +868,10 @@
                 return convertedDoubleReg;
             }
             case L2D: {
-                AllocatableValue convertedDoubleReg = newVariable(LIRKind.derive(input).changeType(Kind.Double));
-                moveBetweenFpGp(convertedDoubleReg, input);
-                append(new Unary2Op(L2D, convertedDoubleReg, convertedDoubleReg));
+                AllocatableValue longEncodedDoubleReg = newVariable(LIRKind.derive(input).changeType(Kind.Double));
+                moveBetweenFpGp(longEncodedDoubleReg, input);
+                AllocatableValue convertedDoubleReg = newVariable(longEncodedDoubleReg.getLIRKind());
+                append(new Unary2Op(L2D, convertedDoubleReg, longEncodedDoubleReg));
                 return convertedDoubleReg;
             }
             case D2I: {
@@ -1070,4 +1068,16 @@
         append(new ReturnOp(Value.ILLEGAL));
     }
 
+    public Value emitSignExtendLoad(LIRKind kind, Value address, LIRFrameState state) {
+        SPARCAddressValue loadAddress = asAddressValue(address);
+        Variable result = newVariable(kind);
+        append(new LoadOp((Kind) kind.getPlatformKind(), result, loadAddress, state, true));
+        return result;
+    }
+
+    public void emitNullCheck(Value address, LIRFrameState state) {
+        PlatformKind kind = address.getPlatformKind();
+        assert kind == Kind.Object || kind == Kind.Long : address + " - " + kind + " not an object!";
+        append(new NullCheckOp(asAddressValue(address), state));
+    }
 }