--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graal/com.oracle.graal.nodes/src/com/oracle/graal/nodes/MemoryState.java	Sat Sep 21 08:20:09 2013 +0200
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package com.oracle.graal.nodes;
+
+import com.oracle.graal.graph.*;
+
+public class MemoryState extends VirtualState {
+
+    private MemoryMap memoryMap;
+    @Input private Node object;
+
+    public MemoryState(MemoryMap memoryMap, FixedNode object) {
+        this.memoryMap = memoryMap;
+        this.object = object;
+    }
+
+    public Node object() {
+        return object;
+    }
+
+    public MemoryMap getMemoryMap() {
+        return memoryMap;
+    }
+
+    @Override
+    public VirtualState duplicateWithVirtualState() {
+        throw new GraalInternalError("should not reach here");
+    }
+
+    @Override
+    public void applyToNonVirtual(NodeClosure<? super ValueNode> closure) {
+        throw new GraalInternalError("should not reach here");
+    }
+
+    @Override
+    public void applyToVirtual(VirtualClosure closure) {
+        throw new GraalInternalError("should not reach here");
+    }
+
+    @Override
+    public boolean isPartOfThisState(VirtualState state) {
+        throw new GraalInternalError("should not reach here");
+    }
+}

--- a/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/FloatingReadPhase.java	Thu Sep 19 21:53:20 2013 +0200
+++ b/graal/com.oracle.graal.phases.common/src/com/oracle/graal/phases/common/FloatingReadPhase.java	Sat Sep 21 08:20:09 2013 +0200
@@ -27,7 +27,6 @@
 import java.util.*;
 
 import com.oracle.graal.api.meta.*;
-import com.oracle.graal.graph.*;
 import com.oracle.graal.nodes.*;
 import com.oracle.graal.nodes.PhiNode.PhiType;
 import com.oracle.graal.nodes.extended.*;
@@ -76,11 +75,21 @@
         }
     }
 
+    private final boolean makeReadsFloating;
+
+    public FloatingReadPhase() {
+        this(true);
+    }
+
+    public FloatingReadPhase(boolean makeReadsFloating) {
+        this.makeReadsFloating = makeReadsFloating;
+    }
+
     @Override
     protected void run(StructuredGraph graph) {
         Map<LoopBeginNode, Set<LocationIdentity>> modifiedInLoops = new IdentityHashMap<>();
         ReentrantNodeIterator.apply(new CollectMemoryCheckpointsClosure(modifiedInLoops), graph.start(), new HashSet<LocationIdentity>(), null);
-        ReentrantNodeIterator.apply(new FloatingReadClosure(modifiedInLoops), graph.start(), new MemoryMapImpl(graph.start()), null);
+        ReentrantNodeIterator.apply(new FloatingReadClosure(modifiedInLoops, makeReadsFloating), graph.start(), new MemoryMapImpl(graph.start()), null);
     }
 
     private static class CollectMemoryCheckpointsClosure extends NodeIteratorClosure<Set<LocationIdentity>> {
@@ -138,14 +147,16 @@
     private static class FloatingReadClosure extends NodeIteratorClosure<MemoryMapImpl> {
 
         private final Map<LoopBeginNode, Set<LocationIdentity>> modifiedInLoops;
+        private final boolean makeReadsFloating;
 
-        public FloatingReadClosure(Map<LoopBeginNode, Set<LocationIdentity>> modifiedInLoops) {
+        public FloatingReadClosure(Map<LoopBeginNode, Set<LocationIdentity>> modifiedInLoops, boolean makeFloating) {
             this.modifiedInLoops = modifiedInLoops;
+            this.makeReadsFloating = makeFloating;
         }
 
         @Override
         protected MemoryMapImpl processNode(FixedNode node, MemoryMapImpl state) {
-            if (node instanceof FloatableAccessNode) {
+            if (node instanceof FloatableAccessNode && makeReadsFloating) {
                 processFloatable((FloatableAccessNode) node, state);
             } else if (node instanceof MemoryCheckpoint.Single) {
                 processCheckpoint((MemoryCheckpoint.Single) node, state);
@@ -154,6 +165,9 @@
             }
             assert MemoryCheckpoint.TypeAssertion.correctType(node) : node;
 
+            if (!makeReadsFloating && node instanceof ReturnNode) {
+                node.graph().add(new MemoryState(new MemoryMapImpl(state), node));
+            }
             return state;
         }