--- a/.hgtags	Tue Jun 09 18:48:06 2015 -0700
+++ b/.hgtags	Tue Jun 09 19:07:39 2015 -0700
@@ -547,6 +547,8 @@
 28b50d07f6f8c5a567b6a25e95a423948114a004 jdk8u25-b17
 639abc668bfe995dba811dd35411b9ea8a9041cd jdk8u25-b18
 c3528699fb33fe3eb1d117504184ae7ab2507aa1 jdk8u25-b31
+631f0c7b49c091c6865d79d248d6551a270ac22f jdk8u25-b32
+4e1f52384f9ffa803838acad545cd63de48a7b35 jdk8u25-b33
 5bb683bbe2c74876d585b5c3232fc3aab7b23e97 jdk8u31-b00
 5bb686ae3b89f8aa1c74331b2d24e2a5ebd43448 jdk8u31-b01
 087678da96603c9705b38b6cc4a6569ac7b4420a jdk8u31-b02
@@ -561,6 +563,8 @@
 9906d432d6dbd2cda242e3f3cfde7cf6c90245bf jdk8u31-b11
 e13839545238d1ecf17f0489bb6fb765de46719a jdk8u31-b12
 4206e725d584be942c25ff46ff23d8e299ca4a4c jdk8u31-b13
+b517d3a9aebf0fee64808f9a7c0ef8e0b82d5ed3 jdk8u31-b31
+15d8108258cb60a58bdd03b9ff8e77dd6727a804 jdk8u31-b32
 1b3abbeee961dee49780c0e4af5337feb918c555 jdk8u40-b10
 f10fe402dfb1543723b4b117a7cba3ea3d4159f1 hs25.40-b15
 99372b2fee0eb8b3452f47230e84aa6e97003184 jdk8u40-b11
@@ -587,12 +591,20 @@
 0ee548a1cda08c884eccd563e2d5fdb6ee769b5a jdk8u40-b22
 0e67683b700174eab71ea205d1cfa4f1cf4523ba jdk8u40-b23
 fa4e797f61e6dda1a60e06944018213bff2a1b76 jdk8u40-b24
-b124e22eb772806c13d942cc110de38da0108147 graal-0.1
-483d05bf77a7c2a762aca1e06c4191bc06647176 graal-0.2
-9535eccd2a115f6c6f0b15efb508b11ff74cc0d3 graal-0.3
-7d4f630172a16e983212d46c0f1ad6cdb826dfce graal-0.4
-ae5b662550836e851c39e4fbb5c80517fc62488f graal-0.5
-3b60f720b955c466d913abb0113af9b38962950b graal-0.6
-1b0ef9634252c422b6f9839fc62eebc112545486 gpu-0.1
-9a12234da10cfa6934617274c203672389a1bbdd baseline-0.1
-754f2b20d8bc43053d254826e6b9f09db3f3c992 graal-0.7
+698dd28ecc785ffc43e3f12266b13e85382c26a8 jdk8u40-b25
+f39b6944ad447269b81e06ca5da9edff9e9e67c8 jdk8u40-b26
+6824e2475e0432e27f9cc51838bc34ea5fbf5113 jdk8u40-b27
+b95f13f05f553309cd74d6ccf8fcedb259c6716c jdk8u45-b00
+41c3c456e326185053f0654be838f4b0bfb38078 jdk8u45-b01
+626fd8c2eec63e2a2dff3839bfe12c0431bf00a4 jdk8u45-b02
+f41aa01b0a043611ee0abcb81a40f7d80085ec27 jdk8u45-b03
+2f586e3c4b6db807ac6036b485b2890ff82f7bfd jdk8u45-b04
+344ff6e45a1e2960ac4a583f63ebfb54cd52e6b4 jdk8u45-b05
+3afa9cc6e8d537ee456b8e12d1abb1da520b5ddc jdk8u45-b06
+5871f3dd9b4a2c4b44e7da2184f4430323e0c04b jdk8u45-b07
+35c7330b68e21d0dfaaedaaf74b794fd10606e9c jdk8u45-b08
+35d8318de0b6d4e68e2e0a04f6e20cafd113ca54 jdk8u45-b09
+a9f5786079202b74b3651e1097c0b2341b2178b9 jdk8u45-b10
+f4822d12204179e6a3e7aaf98991b6171670cbf2 jdk8u45-b11
+dc29108bcbcbfcd49eaa9135368306dc85db73a6 jdk8u45-b12
+efbf340fc7f56e49735111c23cef030413146409 jdk8u45-b13

--- a/THIRD_PARTY_README	Tue Jun 09 18:48:06 2015 -0700
+++ b/THIRD_PARTY_README	Tue Jun 09 19:07:39 2015 -0700
@@ -1250,7 +1250,7 @@
 
 -------------------------------------------------------------------------------
 
-%% This notice is provided with respect to libpng 1.5.4, which may be 
+%% This notice is provided with respect to libpng 1.6.16, which may be
 included with JRE 8, JDK 8, and OpenJDK 8.
 
 --- begin of LICENSE ---
@@ -1266,8 +1266,8 @@
 
 This code is released under the libpng license.
 
-libpng versions 1.2.6, August 15, 2004, through 1.5.4, July 7, 2011, are
-Copyright (c) 2004, 2006-2011 Glenn Randers-Pehrson, and are
+libpng versions 1.2.6, August 15, 2004, through 1.6.16, December 22, 2014, are
+Copyright (c) 2004, 2006-2014 Glenn Randers-Pehrson, and are
 distributed according to the same disclaimer and license as libpng-1.2.5
 with the following individual added to the list of Contributing Authors
 
@@ -1364,7 +1364,7 @@
 
 Glenn Randers-Pehrson
 glennrp at users.sourceforge.net
-July 7, 2011
+December 22, 2014
 
 --- end of LICENSE ---
 

--- a/graal/com.oracle.graal.asm.amd64/src/com/oracle/graal/asm/amd64/AMD64Address.java	Tue Jun 09 18:48:06 2015 -0700
+++ b/graal/com.oracle.graal.asm.amd64/src/com/oracle/graal/asm/amd64/AMD64Address.java	Tue Jun 09 19:07:39 2015 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2010, 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
@@ -113,6 +113,21 @@
                     return null;
             }
         }
+
+        public static Scale fromShift(int shift) {
+            switch (shift) {
+                case 0:
+                    return Times1;
+                case 1:
+                    return Times2;
+                case 2:
+                    return Times4;
+                case 3:
+                    return Times8;
+                default:
+                    return null;
+            }
+        }
     }
 
     @Override

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.compiler.amd64/src/com/oracle/graal/compiler/amd64/AMD64AddressLowering.java	Tue Jun 09 19:07:39 2015 -0700
@@ -0,0 +1,153 @@
+/*
+ * 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;
+
+import com.oracle.graal.asm.*;
+import com.oracle.graal.asm.amd64.AMD64Address.Scale;
+import com.oracle.graal.compiler.common.type.*;
+import com.oracle.graal.nodes.*;
+import com.oracle.graal.nodes.calc.*;
+import com.oracle.graal.nodes.memory.address.*;
+import com.oracle.graal.phases.common.AddressLoweringPhase.AddressLowering;
+import com.oracle.jvmci.code.*;
+import com.oracle.jvmci.meta.*;
+
+public class AMD64AddressLowering extends AddressLowering {
+
+    private final CodeCacheProvider codeCache;
+
+    public AMD64AddressLowering(CodeCacheProvider codeCache) {
+        this.codeCache = codeCache;
+    }
+
+    @Override
+    public AddressNode lower(ValueNode address) {
+        return lower(address, null);
+    }
+
+    @Override
+    public AddressNode lower(ValueNode base, ValueNode offset) {
+        AMD64AddressNode ret = new AMD64AddressNode(base, offset);
+        boolean changed;
+        do {
+            changed = improve(ret);
+        } while (changed);
+        return base.graph().unique(ret);
+    }
+
+    protected boolean improve(AMD64AddressNode ret) {
+        ValueNode newBase = improveInput(ret, ret.getBase(), 0);
+        if (newBase != ret.getBase()) {
+            ret.setBase(newBase);
+            return true;
+        }
+
+        ValueNode newIdx = improveInput(ret, ret.getIndex(), ret.getScale().log2);
+        if (newIdx != ret.getIndex()) {
+            ret.setIndex(newIdx);
+            return true;
+        }
+
+        if (ret.getIndex() instanceof LeftShiftNode) {
+            LeftShiftNode shift = (LeftShiftNode) ret.getIndex();
+            if (shift.getY().isConstant()) {
+                int amount = ret.getScale().log2 + shift.getY().asJavaConstant().asInt();
+                Scale scale = Scale.fromShift(amount);
+                if (scale != null) {
+                    ret.setIndex(shift.getX());
+                    ret.setScale(scale);
+                    return true;
+                }
+            }
+        }
+
+        if (ret.getScale() == Scale.Times1) {
+            if (ret.getBase() == null || ret.getIndex() == null) {
+                if (ret.getBase() instanceof AddNode) {
+                    AddNode add = (AddNode) ret.getBase();
+                    ret.setBase(add.getX());
+                    ret.setIndex(add.getY());
+                    return true;
+                } else if (ret.getIndex() instanceof AddNode) {
+                    AddNode add = (AddNode) ret.getIndex();
+                    ret.setBase(add.getX());
+                    ret.setIndex(add.getY());
+                    return true;
+                }
+            }
+
+            if (ret.getBase() instanceof LeftShiftNode && !(ret.getIndex() instanceof LeftShiftNode)) {
+                ValueNode tmp = ret.getBase();
+                ret.setBase(ret.getIndex());
+                ret.setIndex(tmp);
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private ValueNode improveInput(AMD64AddressNode address, ValueNode node, int shift) {
+        if (node == null) {
+            return null;
+        }
+
+        if (node.isConstant()) {
+            return improveConstDisp(address, node, node.asJavaConstant(), null, shift);
+        } else {
+            if (node.stamp() instanceof IntegerStamp && ((IntegerStamp) node.stamp()).getBits() == 64) {
+                if (node instanceof ZeroExtendNode) {
+                    if (((ZeroExtendNode) node).getInputBits() == 32) {
+                        /*
+                         * We can just swallow a zero-extend from 32 bit to 64 bit because the upper
+                         * half of the register will always be zero.
+                         */
+                        return ((ZeroExtendNode) node).getValue();
+                    }
+                } else if (node instanceof AddNode) {
+                    AddNode add = (AddNode) node;
+                    if (add.getX().isConstant()) {
+                        return improveConstDisp(address, node, add.getX().asJavaConstant(), add.getY(), shift);
+                    } else if (add.getY().isConstant()) {
+                        return improveConstDisp(address, node, add.getY().asJavaConstant(), add.getX(), shift);
+                    }
+                }
+            }
+        }
+
+        return node;
+    }
+
+    private ValueNode improveConstDisp(AMD64AddressNode address, ValueNode original, JavaConstant c, ValueNode other, int shift) {
+        if (c.getKind().isNumericInteger() && !codeCache.needsDataPatch(c)) {
+            long disp = address.getDisplacement();
+            disp += c.asLong() << shift;
+            if (NumUtil.isInt(disp)) {
+                address.setDisplacement((int) disp);
+                return other;
+            }
+        }
+        return original;
+    }
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.compiler.amd64/src/com/oracle/graal/compiler/amd64/AMD64AddressNode.java	Tue Jun 09 19:07:39 2015 -0700
@@ -0,0 +1,111 @@
+/*
+ * 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;
+
+import com.oracle.graal.asm.amd64.AMD64Address.Scale;
+import com.oracle.graal.graph.*;
+import com.oracle.graal.lir.amd64.*;
+import com.oracle.graal.nodeinfo.*;
+import com.oracle.graal.nodes.*;
+import com.oracle.graal.nodes.memory.address.*;
+import com.oracle.graal.nodes.spi.*;
+import com.oracle.jvmci.meta.*;
+
+/**
+ * Represents an address of the form [base + index*scale + displacement]. Both base and index are
+ * optional.
+ */
+@NodeInfo
+public class AMD64AddressNode extends AddressNode implements LIRLowerable {
+
+    public static final NodeClass<AMD64AddressNode> TYPE = NodeClass.create(AMD64AddressNode.class);
+
+    @OptionalInput private ValueNode base;
+
+    @OptionalInput private ValueNode index;
+    private Scale scale;
+
+    private int displacement;
+
+    public AMD64AddressNode(ValueNode base) {
+        this(base, null);
+    }
+
+    public AMD64AddressNode(ValueNode base, ValueNode index) {
+        super(TYPE);
+        this.base = base;
+        this.index = index;
+        this.scale = Scale.Times1;
+    }
+
+    public void generate(NodeLIRBuilderTool gen) {
+        AMD64LIRGenerator tool = (AMD64LIRGenerator) gen.getLIRGeneratorTool();
+
+        AllocatableValue baseValue = base == null ? Value.ILLEGAL : tool.asAllocatable(gen.operand(base));
+        AllocatableValue indexValue = index == null ? Value.ILLEGAL : tool.asAllocatable(gen.operand(index));
+
+        LIRKind kind = tool.getLIRKind(stamp());
+        gen.setResult(this, new AMD64AddressValue(kind, baseValue, indexValue, scale, displacement));
+    }
+
+    public ValueNode getBase() {
+        return base;
+    }
+
+    public void setBase(ValueNode base) {
+        // allow modification before inserting into the graph
+        if (isAlive()) {
+            updateUsages(this.base, base);
+        }
+        this.base = base;
+    }
+
+    public ValueNode getIndex() {
+        return index;
+    }
+
+    public void setIndex(ValueNode index) {
+        // allow modification before inserting into the graph
+        if (isAlive()) {
+            updateUsages(this.index, index);
+        }
+        this.index = index;
+    }
+
+    public Scale getScale() {
+        return scale;
+    }
+
+    public void setScale(Scale scale) {
+        this.scale = scale;
+    }
+
+    public int getDisplacement() {
+        return displacement;
+    }
+
+    public void setDisplacement(int displacement) {
+        this.displacement = displacement;
+    }
+}

--- a/graal/com.oracle.graal.compiler.amd64/src/com/oracle/graal/compiler/amd64/AMD64LIRGenerator.java	Tue Jun 09 18:48:06 2015 -0700
+++ b/graal/com.oracle.graal.compiler.amd64/src/com/oracle/graal/compiler/amd64/AMD64LIRGenerator.java	Tue Jun 09 19:07:39 2015 -0700
@@ -23,24 +23,6 @@
 
 package com.oracle.graal.compiler.amd64;
 
-import com.oracle.jvmci.amd64.*;
-import com.oracle.jvmci.code.RegisterConfig;
-import com.oracle.jvmci.code.Register;
-import com.oracle.jvmci.code.ForeignCallLinkage;
-import com.oracle.jvmci.code.CodeUtil;
-import com.oracle.jvmci.code.Architecture;
-import com.oracle.jvmci.code.StackSlotValue;
-import com.oracle.jvmci.code.CallingConvention;
-import com.oracle.jvmci.code.RegisterValue;
-import com.oracle.jvmci.code.VirtualStackSlot;
-import com.oracle.jvmci.meta.Kind;
-import com.oracle.jvmci.meta.JavaConstant;
-import com.oracle.jvmci.meta.PlatformKind;
-import com.oracle.jvmci.meta.Value;
-import com.oracle.jvmci.meta.AllocatableValue;
-import com.oracle.jvmci.meta.LIRKind;
-
-import static com.oracle.jvmci.code.ValueUtil.*;
 import static com.oracle.graal.asm.amd64.AMD64Assembler.AMD64BinaryArithmetic.*;
 import static com.oracle.graal.asm.amd64.AMD64Assembler.AMD64MOp.*;
 import static com.oracle.graal.asm.amd64.AMD64Assembler.AMD64RMOp.*;
@@ -48,12 +30,21 @@
 import static com.oracle.graal.asm.amd64.AMD64Assembler.OperandSize.*;
 import static com.oracle.graal.lir.amd64.AMD64Arithmetic.*;
 import static com.oracle.graal.lir.amd64.AMD64MathIntrinsicOp.IntrinsicOpcode.*;
+import static com.oracle.jvmci.code.ValueUtil.*;
 
 import java.util.*;
 
 import com.oracle.graal.asm.*;
-import com.oracle.graal.asm.amd64.AMD64Address.*;
-import com.oracle.graal.asm.amd64.AMD64Assembler.*;
+import com.oracle.graal.asm.amd64.AMD64Assembler.AMD64BinaryArithmetic;
+import com.oracle.graal.asm.amd64.AMD64Assembler.AMD64MIOp;
+import com.oracle.graal.asm.amd64.AMD64Assembler.AMD64MOp;
+import com.oracle.graal.asm.amd64.AMD64Assembler.AMD64MROp;
+import com.oracle.graal.asm.amd64.AMD64Assembler.AMD64RMIOp;
+import com.oracle.graal.asm.amd64.AMD64Assembler.AMD64RMOp;
+import com.oracle.graal.asm.amd64.AMD64Assembler.AMD64Shift;
+import com.oracle.graal.asm.amd64.AMD64Assembler.ConditionFlag;
+import com.oracle.graal.asm.amd64.AMD64Assembler.OperandSize;
+import com.oracle.graal.asm.amd64.AMD64Assembler.SSEOp;
 import com.oracle.graal.compiler.common.calc.*;
 import com.oracle.graal.compiler.common.spi.*;
 import com.oracle.graal.compiler.common.util.*;
@@ -79,7 +70,10 @@
 import com.oracle.graal.lir.framemap.*;
 import com.oracle.graal.lir.gen.*;
 import com.oracle.graal.phases.util.*;
+import com.oracle.jvmci.amd64.*;
+import com.oracle.jvmci.code.*;
 import com.oracle.jvmci.common.*;
+import com.oracle.jvmci.meta.*;
 
 /**
  * This class implements the AMD64 specific portion of the LIR generator.
@@ -214,74 +208,17 @@
         append(new LeaDataOp(dst, data));
     }
 
-    @Override
-    public AMD64AddressValue emitAddress(Value base, long displacement, Value index, int scale) {
-        AllocatableValue baseRegister;
-        long finalDisp = displacement;
-        if (isConstant(base)) {
-            if (asConstant(base).isNull()) {
-                baseRegister = Value.ILLEGAL;
-            } else if (asConstant(base).getKind() != Kind.Object && !getCodeCache().needsDataPatch(asConstant(base))) {
-                finalDisp += asConstant(base).asLong();
-                baseRegister = Value.ILLEGAL;
-            } else {
-                baseRegister = load(base);
-            }
-        } else {
-            baseRegister = asAllocatable(base);
-        }
-
-        AllocatableValue indexRegister;
-        Scale scaleEnum;
-        if (!index.equals(Value.ILLEGAL) && scale != 0) {
-            scaleEnum = Scale.fromInt(scale);
-            if (isConstant(index)) {
-                finalDisp += asConstant(index).asLong() * scale;
-                indexRegister = Value.ILLEGAL;
-
-            } else if (scaleEnum == null) {
-                /* Scale value that architecture cannot handle, so scale manually. */
-                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);
-                }
-                scaleEnum = Scale.Times1;
-
-            } else {
-                indexRegister = asAllocatable(index);
-            }
-        } else {
-            indexRegister = Value.ILLEGAL;
-            scaleEnum = Scale.Times1;
-        }
-
-        int displacementInt;
-        if (NumUtil.isInt(finalDisp)) {
-            displacementInt = (int) finalDisp;
-        } else {
-            displacementInt = 0;
-            AllocatableValue displacementRegister = load(JavaConstant.forLong(finalDisp));
-            if (baseRegister.equals(Value.ILLEGAL)) {
-                baseRegister = displacementRegister;
-            } else if (indexRegister.equals(Value.ILLEGAL)) {
-                indexRegister = displacementRegister;
-                scaleEnum = Scale.Times1;
-            } else {
-                baseRegister = emitAdd(baseRegister, displacementRegister, false);
-            }
-        }
-
-        LIRKind resultKind = getAddressKind(base, displacement, index);
-        return new AMD64AddressValue(resultKind, baseRegister, indexRegister, scaleEnum, displacementInt);
-    }
-
     public AMD64AddressValue asAddressValue(Value address) {
         if (address instanceof AMD64AddressValue) {
             return (AMD64AddressValue) address;
         } else {
-            return emitAddress(address, 0, Value.ILLEGAL, 0);
+            if (address instanceof JavaConstant) {
+                long displacement = ((JavaConstant) address).asLong();
+                if (NumUtil.isInt(displacement)) {
+                    return new AMD64AddressValue(address.getLIRKind(), Value.ILLEGAL, (int) displacement);
+                }
+            }
+            return new AMD64AddressValue(address.getLIRKind(), asAllocatable(address), 0);
         }
     }
 

--- a/graal/com.oracle.graal.compiler.amd64/src/com/oracle/graal/compiler/amd64/AMD64NodeLIRBuilder.java	Tue Jun 09 18:48:06 2015 -0700
+++ b/graal/com.oracle.graal.compiler.amd64/src/com/oracle/graal/compiler/amd64/AMD64NodeLIRBuilder.java	Tue Jun 09 19:07:39 2015 -0700
@@ -140,10 +140,6 @@
         }
     }
 
-    protected AMD64AddressValue makeAddress(Access access) {
-        return (AMD64AddressValue) access.accessLocation().generateAddress(this, gen, operand(access.object()));
-    }
-
     protected ValueNode uncast(ValueNode value) {
         if (value instanceof UnsafeCastNode) {
             UnsafeCastNode cast = (UnsafeCastNode) value;
@@ -197,7 +193,8 @@
                     other = operand(value);
                 }
 
-                getLIRGeneratorTool().emitCompareBranchMemory(kind, other, makeAddress(access), getState(access), finalCondition, unorderedIsTrue, trueLabel, falseLabel, trueLabelProbability);
+                AMD64AddressValue address = (AMD64AddressValue) operand(access.getAddress());
+                getLIRGeneratorTool().emitCompareBranchMemory(kind, other, address, getState(access), finalCondition, unorderedIsTrue, trueLabel, falseLabel, trueLabelProbability);
                 return null;
             }
         };
@@ -219,13 +216,15 @@
                 return null;
             }
             return builder -> {
-                gen.append(new AMD64BinaryConsumer.MemoryConstOp(AMD64MIOp.TEST, size, makeAddress(access), (int) constant.asLong(), getState(access)));
+                AMD64AddressValue address = (AMD64AddressValue) operand(access.getAddress());
+                gen.append(new AMD64BinaryConsumer.MemoryConstOp(AMD64MIOp.TEST, size, address, (int) constant.asLong(), getState(access)));
                 gen.append(new BranchOp(Condition.EQ, trueLabel, falseLabel, trueLabelProbability));
                 return null;
             };
         } else {
             return builder -> {
-                gen.append(new AMD64BinaryConsumer.MemoryRMOp(AMD64RMOp.TEST, size, gen.asAllocatable(operand(value)), makeAddress(access), getState(access)));
+                AMD64AddressValue address = (AMD64AddressValue) operand(access.getAddress());
+                gen.append(new AMD64BinaryConsumer.MemoryRMOp(AMD64RMOp.TEST, size, gen.asAllocatable(operand(value)), address, getState(access)));
                 gen.append(new BranchOp(Condition.EQ, trueLabel, falseLabel, trueLabelProbability));
                 return null;
             };
@@ -234,7 +233,7 @@
 
     protected ComplexMatchResult emitConvertMemoryOp(PlatformKind kind, AMD64RMOp op, OperandSize size, Access access) {
         return builder -> {
-            AMD64AddressValue address = makeAddress(access);
+            AMD64AddressValue address = (AMD64AddressValue) operand(access.getAddress());
             LIRFrameState state = getState(access);
             return getLIRGeneratorTool().emitConvertMemoryOp(kind, op, size, address, state);
         };
@@ -288,7 +287,7 @@
     }
 
     private Value emitReinterpretMemory(LIRKind to, Access access) {
-        AMD64AddressValue address = makeAddress(access);
+        AMD64AddressValue address = (AMD64AddressValue) operand(access.getAddress());
         LIRFrameState state = getState(access);
         return getLIRGeneratorTool().emitLoad(to, address, state);
     }
@@ -338,7 +337,7 @@
     }
 
     private ComplexMatchResult binaryRead(AMD64RMOp op, OperandSize size, ValueNode value, Access access) {
-        return builder -> getLIRGeneratorTool().emitBinaryMemory(op, size, getLIRGeneratorTool().asAllocatable(operand(value)), makeAddress(access), getState(access));
+        return builder -> getLIRGeneratorTool().emitBinaryMemory(op, size, getLIRGeneratorTool().asAllocatable(operand(value)), (AMD64AddressValue) operand(access.getAddress()), getState(access));
     }
 
     @MatchRule("(Add value Read=access)")
@@ -407,13 +406,11 @@
         }
     }
 
-    @MatchRule("(Write object location Narrow=narrow)")
+    @MatchRule("(Write object Narrow=narrow)")
     public ComplexMatchResult writeNarrow(WriteNode root, NarrowNode narrow) {
         return builder -> {
             LIRKind writeKind = getLIRGeneratorTool().getLIRKind(root.value().stamp());
-            Value address = root.location().generateAddress(builder, getLIRGeneratorTool(), operand(root.object()));
-            Value v = operand(narrow.getValue());
-            getLIRGeneratorTool().emitStore(writeKind, address, v, state(root));
+            getLIRGeneratorTool().emitStore(writeKind, operand(root.getAddress()), operand(narrow.getValue()), state(root));
             return null;
         };
     }
@@ -436,7 +433,8 @@
              */
             return null;
         }
-        return builder -> getLIRGeneratorTool().emitZeroExtendMemory(memoryKind == Kind.Short ? Kind.Char : memoryKind, root.getResultBits(), makeAddress(access), getState(access));
+        return builder -> getLIRGeneratorTool().emitZeroExtendMemory(memoryKind == Kind.Short ? Kind.Char : memoryKind, root.getResultBits(), (AMD64AddressValue) operand(access.getAddress()),
+                        getState(access));
     }
 
     @MatchRule("(FloatConvert Read=access)")

--- a/graal/com.oracle.graal.compiler.common/src/com/oracle/graal/compiler/common/GraalOptions.java	Tue Jun 09 18:48:06 2015 -0700
+++ b/graal/com.oracle.graal.compiler.common/src/com/oracle/graal/compiler/common/GraalOptions.java	Tue Jun 09 19:07:39 2015 -0700
@@ -128,9 +128,6 @@
     @Option(help = "", type = OptionType.Debug)
     public static final OptionValue<Boolean> VerifyPhases = new OptionValue<>(false);
 
-    @Option(help = "", type = OptionType.Debug)
-    public static final OptionValue<String> PrintFilter = new OptionValue<>(null);
-
     // Debug settings:
     @Option(help = "", type = OptionType.Debug)
     public static final OptionValue<Boolean> BootstrapReplacements = new OptionValue<>(false);
@@ -173,33 +170,16 @@
     public static final OptionValue<Boolean> PrintIdealGraphSchedule = new OptionValue<>(false);
 
     // Other printing settings
-    @Option(help = "", type = OptionType.Debug)
-    public static final OptionValue<Boolean> PrintCompilation = new OptionValue<>(false);
-
-    @Option(help = "", type = OptionType.Debug)
-    public static final OptionValue<Boolean> PrintAfterCompilation = new OptionValue<>(false);
-
     @Option(help = "Print profiling information when parsing a method's bytecode", type = OptionType.Debug)
     public static final OptionValue<Boolean> PrintProfilingInformation = new OptionValue<>(false);
 
     @Option(help = "", type = OptionType.Debug)
     public static final OptionValue<Boolean> PrintCodeBytes = new OptionValue<>(false);
 
-    @Option(help = "", type = OptionType.Debug)
-    public static final OptionValue<Boolean> PrintBailout = new OptionValue<>(false);
 
     @Option(help = "", type = OptionType.Debug)
     public static final StableOptionValue<Boolean> TraceEscapeAnalysis = new StableOptionValue<>(false);
 
-    @Option(help = "", type = OptionType.Debug)
-    public static final OptionValue<Boolean> ExitVMOnBailout = new OptionValue<>(false);
-
-    @Option(help = "", type = OptionType.Debug)
-    public static final OptionValue<Boolean> ExitVMOnException = new OptionValue<>(true);
-
-    @Option(help = "", type = OptionType.Debug)
-    public static final OptionValue<Boolean> PrintStackTraceOnException = new OptionValue<>(false);
-
     // HotSpot command line options
     @Option(help = "Print inlining optimizations", type = OptionType.Debug)
     public static final OptionValue<Boolean> HotSpotPrintInlining = new OptionValue<>(false);

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.compiler.common/src/com/oracle/graal/compiler/common/type/RawPointerStamp.java	Tue Jun 09 19:07:39 2015 -0700
@@ -0,0 +1,108 @@
+/*
+ * 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.common.type;
+
+import com.oracle.graal.compiler.common.spi.*;
+import com.oracle.jvmci.common.*;
+import com.oracle.jvmci.meta.*;
+
+/**
+ * Type describing pointers to raw memory. This stamp is used for example for direct pointers to
+ * fields or array elements.
+ */
+public class RawPointerStamp extends AbstractPointerStamp {
+
+    protected RawPointerStamp() {
+        super(false, false);
+    }
+
+    @Override
+    public LIRKind getLIRKind(LIRKindTool tool) {
+        return tool.getWordKind();
+    }
+
+    @Override
+    protected AbstractPointerStamp copyWith(boolean newNonNull, boolean newAlwaysNull) {
+        // RawPointerStamp is a singleton
+        assert newNonNull == nonNull() && newAlwaysNull == alwaysNull();
+        return this;
+    }
+
+    @Override
+    public Stamp meet(Stamp other) {
+        assert isCompatible(other);
+        return this;
+    }
+
+    @Override
+    public Stamp improveWith(Stamp other) {
+        return this;
+    }
+
+    @Override
+    public Stamp join(Stamp other) {
+        assert isCompatible(other);
+        return this;
+    }
+
+    @Override
+    public Stamp unrestricted() {
+        return this;
+    }
+
+    @Override
+    public Stamp empty() {
+        // there is no empty pointer stamp
+        return this;
+    }
+
+    @Override
+    public boolean hasValues() {
+        return true;
+    }
+
+    @Override
+    public ResolvedJavaType javaType(MetaAccessProvider metaAccess) {
+        throw JVMCIError.shouldNotReachHere("pointer has no Java type");
+    }
+
+    @Override
+    public Stamp constant(Constant c, MetaAccessProvider meta) {
+        return this;
+    }
+
+    @Override
+    public boolean isCompatible(Stamp other) {
+        return other instanceof RawPointerStamp;
+    }
+
+    @Override
+    public Constant readConstant(MemoryAccessProvider provider, Constant base, long displacement) {
+        throw JVMCIError.shouldNotReachHere("can't read raw pointer");
+    }
+
+    @Override
+    public String toString() {
+        return "void*";
+    }
+}

--- a/graal/com.oracle.graal.compiler.common/src/com/oracle/graal/compiler/common/type/StampFactory.java	Tue Jun 09 18:48:06 2015 -0700
+++ b/graal/com.oracle.graal.compiler.common/src/com/oracle/graal/compiler/common/type/StampFactory.java	Tue Jun 09 19:07:39 2015 -0700
@@ -45,6 +45,7 @@
     private static final Stamp positiveInt = forInteger(Kind.Int, 0, Integer.MAX_VALUE, 0, Integer.MAX_VALUE);
     private static final Stamp booleanTrue = forInteger(Kind.Boolean, -1, -1, 1, 1);
     private static final Stamp booleanFalse = forInteger(Kind.Boolean, 0, 0, 0, 0);
+    private static final Stamp rawPointer = new RawPointerStamp();
 
     private static void setCache(Kind kind, Stamp stamp) {
         stampCache[kind.ordinal()] = stamp;
@@ -350,4 +351,8 @@
 
         return result;
     }
+
+    public static Stamp pointer() {
+        return rawPointer;
+    }
 }

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.compiler.sparc/src/com/oracle/graal/compiler/sparc/SPARCAddressLowering.java	Tue Jun 09 19:07:39 2015 -0700
@@ -0,0 +1,93 @@
+/*
+ * 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.sparc;
+
+import com.oracle.graal.asm.sparc.*;
+import com.oracle.graal.nodes.*;
+import com.oracle.graal.nodes.calc.*;
+import com.oracle.graal.nodes.memory.address.*;
+import com.oracle.graal.phases.common.AddressLoweringPhase.AddressLowering;
+import com.oracle.jvmci.code.*;
+import com.oracle.jvmci.meta.*;
+
+public class SPARCAddressLowering extends AddressLowering {
+
+    private final CodeCacheProvider codeCache;
+
+    public SPARCAddressLowering(CodeCacheProvider codeCache) {
+        this.codeCache = codeCache;
+    }
+
+    @Override
+    public AddressNode lower(ValueNode address) {
+        return lower(address, 0);
+    }
+
+    @Override
+    public AddressNode lower(ValueNode base, ValueNode offset) {
+        JavaConstant immBase = asImmediate(base);
+        if (immBase != null && SPARCAssembler.isSimm13(immBase)) {
+            return lower(offset, immBase.asLong());
+        }
+
+        JavaConstant immOffset = asImmediate(offset);
+        if (immOffset != null && SPARCAssembler.isSimm13(immOffset)) {
+            return lower(base, immOffset.asLong());
+        }
+
+        return base.graph().unique(new SPARCIndexedAddressNode(base, offset));
+    }
+
+    private AddressNode lower(ValueNode base, long displacement) {
+        if (base instanceof AddNode) {
+            AddNode add = (AddNode) base;
+
+            JavaConstant immX = asImmediate(add.getX());
+            if (immX != null && SPARCAssembler.isSimm13(displacement + immX.asLong())) {
+                return lower(add.getY(), displacement + immX.asLong());
+            }
+
+            JavaConstant immY = asImmediate(add.getY());
+            if (immY != null && SPARCAssembler.isSimm13(displacement + immY.asLong())) {
+                return lower(add.getX(), displacement + immY.asLong());
+            }
+
+            if (displacement == 0) {
+                return lower(add.getX(), add.getY());
+            }
+        }
+
+        assert SPARCAssembler.isSimm13(displacement);
+        return base.graph().unique(new SPARCImmediateAddressNode(base, (int) displacement));
+    }
+
+    private JavaConstant asImmediate(ValueNode value) {
+        JavaConstant c = value.asJavaConstant();
+        if (c != null && c.getKind().isNumericInteger() && !codeCache.needsDataPatch(c)) {
+            return c;
+        } else {
+            return null;
+        }
+    }
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.compiler.sparc/src/com/oracle/graal/compiler/sparc/SPARCImmediateAddressNode.java	Tue Jun 09 19:07:39 2015 -0700
@@ -0,0 +1,78 @@
+/*
+ * 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.sparc;
+
+import com.oracle.graal.asm.sparc.*;
+import com.oracle.graal.graph.*;
+import com.oracle.graal.lir.sparc.*;
+import com.oracle.graal.nodeinfo.*;
+import com.oracle.graal.nodes.*;
+import com.oracle.graal.nodes.memory.address.*;
+import com.oracle.graal.nodes.spi.*;
+import com.oracle.jvmci.meta.*;
+
+/**
+ * Represents an address of the form [base + simm13].
+ */
+@NodeInfo
+public class SPARCImmediateAddressNode extends AddressNode implements LIRLowerable {
+
+    public static final NodeClass<SPARCImmediateAddressNode> TYPE = NodeClass.create(SPARCImmediateAddressNode.class);
+
+    @Input private ValueNode base;
+    private int displacement;
+
+    public SPARCImmediateAddressNode(ValueNode base, int displacement) {
+        super(TYPE);
+        assert SPARCAssembler.isSimm13(displacement);
+        this.base = base;
+        this.displacement = displacement;
+    }
+
+    public void generate(NodeLIRBuilderTool gen) {
+        SPARCLIRGenerator tool = (SPARCLIRGenerator) gen.getLIRGeneratorTool();
+
+        AllocatableValue baseValue = tool.asAllocatable(gen.operand(base));
+
+        LIRKind kind = tool.getLIRKind(stamp());
+        gen.setResult(this, new SPARCImmediateAddressValue(kind, baseValue, displacement));
+    }
+
+    public ValueNode getBase() {
+        return base;
+    }
+
+    public void setBase(ValueNode base) {
+        updateUsages(this.base, base);
+        this.base = base;
+    }
+
+    public int getDisplacement() {
+        return displacement;
+    }
+
+    public void setDisplacement(int displacement) {
+        this.displacement = displacement;
+    }
+}

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.compiler.sparc/src/com/oracle/graal/compiler/sparc/SPARCIndexedAddressNode.java	Tue Jun 09 19:07:39 2015 -0700
@@ -0,0 +1,78 @@
+/*
+ * 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.sparc;
+
+import com.oracle.graal.graph.*;
+import com.oracle.graal.lir.sparc.*;
+import com.oracle.graal.nodeinfo.*;
+import com.oracle.graal.nodes.*;
+import com.oracle.graal.nodes.memory.address.*;
+import com.oracle.graal.nodes.spi.*;
+import com.oracle.jvmci.meta.*;
+
+/**
+ * Represents an address of the form [base + index].
+ */
+@NodeInfo
+public class SPARCIndexedAddressNode extends AddressNode implements LIRLowerable {
+
+    public static final NodeClass<SPARCIndexedAddressNode> TYPE = NodeClass.create(SPARCIndexedAddressNode.class);
+
+    @Input private ValueNode base;
+    @Input private ValueNode index;
+
+    public SPARCIndexedAddressNode(ValueNode base, ValueNode index) {
+        super(TYPE);
+        this.base = base;
+        this.index = index;
+    }
+
+    public void generate(NodeLIRBuilderTool gen) {
+        SPARCLIRGenerator tool = (SPARCLIRGenerator) gen.getLIRGeneratorTool();
+
+        AllocatableValue baseValue = tool.asAllocatable(gen.operand(base));
+        AllocatableValue indexValue = tool.asAllocatable(gen.operand(index));
+
+        LIRKind kind = tool.getLIRKind(stamp());
+        gen.setResult(this, new SPARCIndexedAddressValue(kind, baseValue, indexValue));
+    }
+
+    public ValueNode getBase() {
+        return base;
+    }
+
+    public void setBase(ValueNode base) {
+        updateUsages(this.base, base);
+        this.base = base;
+    }
+
+    public ValueNode getIndex() {
+        return index;
+    }
+
+    public void setIndex(ValueNode index) {
+        updateUsages(this.index, index);
+        this.index = index;
+    }
+}

--- a/graal/com.oracle.graal.compiler.sparc/src/com/oracle/graal/compiler/sparc/SPARCLIRGenerator.java	Tue Jun 09 18:48:06 2015 -0700
+++ b/graal/com.oracle.graal.compiler.sparc/src/com/oracle/graal/compiler/sparc/SPARCLIRGenerator.java	Tue Jun 09 19:07:39 2015 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2009, 2014, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2009, 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
@@ -140,74 +140,18 @@
         append(new LoadDataAddressOp(dst, data));
     }
 
-    @Override
-    public SPARCAddressValue emitAddress(Value base, long displacement, Value index, int scale) {
-        AllocatableValue baseRegister;
-        long finalDisp = displacement;
-        if (isConstant(base)) {
-            if (asConstant(base).isNull()) {
-                baseRegister = SPARC.g0.asValue(base.getLIRKind());
-            } else if (asConstant(base).getKind() != Kind.Object) {
-                finalDisp += asConstant(base).asLong();
-                baseRegister = Value.ILLEGAL;
-            } else {
-                baseRegister = load(base);
-            }
-        } else {
-            baseRegister = asAllocatable(base);
-        }
-
-        AllocatableValue indexRegister;
-        if (!index.equals(Value.ILLEGAL) && scale != 0) {
-            if (isConstant(index)) {
-                finalDisp += asConstant(index).asLong() * scale;
-                indexRegister = Value.ILLEGAL;
-            } else {
-                Value longIndex = index.getKind() == Kind.Long ? index : emitSignExtend(index, 32, 64);
-                if (scale != 1) {
-                    if (CodeUtil.isPowerOf2(scale)) {
-                        indexRegister = emitShl(longIndex, JavaConstant.forLong(CodeUtil.log2(scale)));
-                    } else {
-                        indexRegister = emitMul(longIndex, JavaConstant.forLong(scale), false);
-                    }
-                } else {
-                    indexRegister = asAllocatable(longIndex);
-                }
-            }
-        } else {
-            indexRegister = Value.ILLEGAL;
-        }
-
-        int displacementInt;
-
-        // If we don't have an index register we can use a displacement, otherwise load the
-        // displacement into a register and add it to the base.
-        if (indexRegister.equals(Value.ILLEGAL) && SPARCAssembler.isSimm13(finalDisp)) {
-            displacementInt = (int) finalDisp;
-        } else {
-            displacementInt = 0;
-            if (baseRegister.equals(Value.ILLEGAL)) {
-                baseRegister = load(JavaConstant.forLong(finalDisp));
-            } else {
-                if (finalDisp == 0) {
-                    // Nothing to do. Just use the base register.
-                } else {
-                    Variable longBaseRegister = newVariable(LIRKind.derivedReference(Kind.Long));
-                    emitMove(longBaseRegister, baseRegister);
-                    baseRegister = emitAdd(longBaseRegister, JavaConstant.forLong(finalDisp), false);
-                }
-            }
-        }
-
-        LIRKind resultKind = getAddressKind(base, displacement, index);
-        return new SPARCAddressValue(resultKind, baseRegister, indexRegister, displacementInt);
-    }
-
     protected SPARCAddressValue asAddressValue(Value address) {
         if (address instanceof SPARCAddressValue) {
             return (SPARCAddressValue) address;
         } else {
-            return emitAddress(address, 0, Value.ILLEGAL, 0);
+            LIRKind kind = address.getLIRKind();
+            if (address instanceof JavaConstant) {
+                long displacement = ((JavaConstant) address).asLong();
+                if (SPARCAssembler.isSimm13(displacement)) {
+                    return new SPARCImmediateAddressValue(kind, SPARC.g0.asValue(kind), (int) displacement);
+                }
+            }
+            return new SPARCImmediateAddressValue(kind, asAllocatable(address), 0);
         }
     }
 

--- a/graal/com.oracle.graal.compiler.sparc/src/com/oracle/graal/compiler/sparc/SPARCNodeLIRBuilder.java	Tue Jun 09 18:48:06 2015 -0700
+++ b/graal/com.oracle.graal.compiler.sparc/src/com/oracle/graal/compiler/sparc/SPARCNodeLIRBuilder.java	Tue Jun 09 19:07:39 2015 -0700
@@ -108,8 +108,7 @@
         Kind localFromKind = fromKind;
         Kind localToKind = toKind;
         return builder -> {
-            Value address = access.accessLocation().generateAddress(builder, gen, operand(access.object()));
-            Value v = getLIRGeneratorTool().emitSignExtendLoad(LIRKind.value(localFromKind), address, getState(access));
+            Value v = getLIRGeneratorTool().emitSignExtendLoad(LIRKind.value(localFromKind), operand(access.getAddress()), getState(access));
             return getLIRGeneratorTool().emitReinterpret(LIRKind.value(localToKind), v);
         };
     }

--- a/graal/com.oracle.graal.compiler.test/src/com/oracle/graal/compiler/test/CheckGraalInvariants.java	Tue Jun 09 18:48:06 2015 -0700
+++ b/graal/com.oracle.graal.compiler.test/src/com/oracle/graal/compiler/test/CheckGraalInvariants.java	Tue Jun 09 19:07:39 2015 -0700
@@ -33,8 +33,6 @@
 import org.junit.*;
 
 import com.oracle.graal.api.runtime.*;
-import com.oracle.graal.compiler.*;
-import com.oracle.graal.compiler.CompilerThreadFactory.DebugConfigAccess;
 import com.oracle.graal.compiler.common.type.*;
 import com.oracle.graal.graph.*;
 import com.oracle.graal.graphbuilderconf.*;
@@ -48,11 +46,12 @@
 import com.oracle.graal.phases.tiers.*;
 import com.oracle.graal.phases.util.*;
 import com.oracle.graal.phases.verify.*;
-import com.oracle.graal.printer.*;
 import com.oracle.graal.runtime.*;
 import com.oracle.graal.test.*;
 import com.oracle.jvmci.code.*;
 import com.oracle.jvmci.code.Register.RegisterCategory;
+import com.oracle.jvmci.compiler.*;
+import com.oracle.jvmci.compiler.CompilerThreadFactory.DebugConfigAccess;
 import com.oracle.jvmci.debug.*;
 import com.oracle.jvmci.meta.*;
 
@@ -125,7 +124,7 @@
         String[] filters = property == null ? null : property.split(",");
 
         CompilerThreadFactory factory = new CompilerThreadFactory("CheckInvariantsThread", new DebugConfigAccess() {
-            public GraalDebugConfig getDebugConfig() {
+            public JVMCIDebugConfig getDebugConfig() {
                 return DebugEnvironment.initialize(System.out);
             }
         });

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.compiler.test/src/com/oracle/graal/compiler/test/ConditionalEliminationTest10.java	Tue Jun 09 19:07:39 2015 -0700
@@ -0,0 +1,67 @@
+/*
+ * 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.test;
+
+import org.junit.*;
+
+import com.oracle.graal.api.directives.*;
+import com.oracle.graal.nodes.*;
+import com.oracle.graal.nodes.StructuredGraph.*;
+import com.oracle.graal.nodes.spi.*;
+import com.oracle.graal.phases.common.*;
+import com.oracle.graal.phases.tiers.*;
+
+/**
+ * This test checks the combined action of
+ * {@link com.oracle.graal.phases.common.DominatorConditionalEliminationPhase} and
+ * {@link com.oracle.graal.phases.common.LoweringPhase}. The lowering phase needs to introduce the
+ * null checks at the correct places for the dominator conditional elimination phase to pick them
+ * up.
+ */
+public class ConditionalEliminationTest10 extends ConditionalEliminationTestBase {
+
+    private static class TestClass {
+        int x;
+    }
+
+    @SuppressWarnings("all")
+    public static int testSnippet(int a, TestClass t) {
+        int result = 0;
+        if (a == 0) {
+            GraalDirectives.controlFlowAnchor();
+            result = t.x;
+        }
+        GraalDirectives.controlFlowAnchor();
+        return result + t.x;
+    }
+
+    @Test
+    public void test1() {
+        StructuredGraph graph = parseEager("testSnippet", AllowAssumptions.YES);
+        PhaseContext context = new PhaseContext(getProviders());
+        new LoweringPhase(new CanonicalizerPhase(), LoweringTool.StandardLoweringStage.HIGH_TIER).apply(graph, context);
+        Assert.assertEquals(2, graph.getNodes().filter(GuardNode.class).count());
+        new DominatorConditionalEliminationPhase(true).apply(graph, context);
+        Assert.assertEquals(1, graph.getNodes().filter(GuardNode.class).count());
+    }
+}

--- a/graal/com.oracle.graal.compiler.test/src/com/oracle/graal/compiler/test/GraalCompilerTest.java	Tue Jun 09 18:48:06 2015 -0700
+++ b/graal/com.oracle.graal.compiler.test/src/com/oracle/graal/compiler/test/GraalCompilerTest.java	Tue Jun 09 19:07:39 2015 -0700
@@ -23,9 +23,9 @@
 package com.oracle.graal.compiler.test;
 
 import static com.oracle.graal.compiler.GraalCompiler.*;
-import static com.oracle.graal.compiler.common.GraalOptions.*;
 import static com.oracle.graal.nodes.ConstantNode.*;
 import static com.oracle.jvmci.code.CodeUtil.*;
+import static com.oracle.jvmci.compiler.Compiler.*;
 
 import java.lang.reflect.*;
 import java.util.*;
@@ -33,7 +33,7 @@
 import java.util.function.*;
 
 import org.junit.*;
-import org.junit.internal.*;
+import org.junit.internal.AssumptionViolatedException;
 
 import com.oracle.graal.api.directives.*;
 import com.oracle.graal.api.replacements.*;
@@ -59,7 +59,6 @@
 import com.oracle.graal.phases.schedule.SchedulePhase.SchedulingStrategy;
 import com.oracle.graal.phases.tiers.*;
 import com.oracle.graal.phases.util.*;
-import com.oracle.graal.printer.*;
 import com.oracle.graal.runtime.*;
 import com.oracle.graal.test.*;
 import com.oracle.jvmci.code.*;