Mercurial > hg > graal-compiler

changeset 7573:17b6a63fe7c2

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
replace all-default MaterializeNodes with NewObject during lowering, not during PEA (fixes GRAAL-35)
author Lukas Stadler <lukas.stadler@jku.at>
date Thu, 31 Jan 2013 11:32:14 +0100
parents bbb2619857d4
children 3a8b3b03ffa0 3ac7d10a6572 5f3cba05c2fa
files graal/com.oracle.graal.virtual/src/com/oracle/graal/virtual/nodes/MaterializeObjectNode.java graal/com.oracle.graal.virtual/src/com/oracle/graal/virtual/phases/ea/BlockState.java
diffstat 2 files changed, 60 insertions(+), 81 deletions(-) [+]
line wrap: on
line diff
--- a/graal/com.oracle.graal.virtual/src/com/oracle/graal/virtual/nodes/MaterializeObjectNode.java	Thu Jan 31 11:23:55 2013 +0100
+++ b/graal/com.oracle.graal.virtual/src/com/oracle/graal/virtual/nodes/MaterializeObjectNode.java	Thu Jan 31 11:32:14 2013 +0100
@@ -57,21 +57,31 @@
     @Override
     public void lower(LoweringTool tool) {
         StructuredGraph graph = (StructuredGraph) graph();
+
+        boolean defaultEntries = true;
+        if (lockCount > 0) {
+            defaultEntries = false;
+        } else {
+            for (ValueNode value : values) {
+                if (!value.isConstant() || !value.asConstant().isDefaultForKind()) {
+                    defaultEntries = false;
+                    break;
+                }
+            }
+        }
+
         if (virtualObject instanceof VirtualInstanceNode) {
             VirtualInstanceNode virtual = (VirtualInstanceNode) virtualObject;
 
-            NewInstanceNode newInstance = graph.add(new NewInstanceNode(virtual.type(), false, lockCount > 0));
+            NewInstanceNode newInstance = graph.add(new NewInstanceNode(virtual.type(), defaultEntries, lockCount > 0));
             this.replaceAtUsages(newInstance);
-            graph.addAfterFixed(this, newInstance);
+            graph.addBeforeFixed(this, newInstance);
 
-            FixedWithNextNode position = newInstance;
-            for (int i = 0; i < virtual.entryCount(); i++) {
-                StoreFieldNode store = graph.add(new StoreFieldNode(newInstance, virtual.field(i), values.get(i), -1));
-                graph.addAfterFixed(position, store);
-                position = store;
+            if (!defaultEntries) {
+                for (int i = 0; i < virtual.entryCount(); i++) {
+                    graph.addBeforeFixed(this, graph.add(new StoreFieldNode(newInstance, virtual.field(i), values.get(i), -1)));
+                }
             }
-
-            graph.removeFixed(this);
         } else {
             assert virtualObject instanceof VirtualArrayNode;
             VirtualArrayNode virtual = (VirtualArrayNode) virtualObject;
@@ -79,22 +89,20 @@
             ResolvedJavaType element = virtual.componentType();
             NewArrayNode newArray;
             if (element.getKind() == Kind.Object) {
-                newArray = graph.add(new NewObjectArrayNode(element, ConstantNode.forInt(virtual.entryCount(), graph), false, lockCount > 0));
+                newArray = graph.add(new NewObjectArrayNode(element, ConstantNode.forInt(virtual.entryCount(), graph), defaultEntries, lockCount > 0));
             } else {
-                newArray = graph.add(new NewPrimitiveArrayNode(element, ConstantNode.forInt(virtual.entryCount(), graph), false, lockCount > 0));
+                newArray = graph.add(new NewPrimitiveArrayNode(element, ConstantNode.forInt(virtual.entryCount(), graph), defaultEntries, lockCount > 0));
             }
             this.replaceAtUsages(newArray);
-            graph.addAfterFixed(this, newArray);
+            graph.addBeforeFixed(this, newArray);
 
-            FixedWithNextNode position = newArray;
-            for (int i = 0; i < virtual.entryCount(); i++) {
-                StoreIndexedNode store = graph.add(new StoreIndexedNode(newArray, ConstantNode.forInt(i, graph), element.getKind(), values.get(i), -1));
-                graph.addAfterFixed(position, store);
-                position = store;
+            if (!defaultEntries) {
+                for (int i = 0; i < virtual.entryCount(); i++) {
+                    graph.addBeforeFixed(this, graph.add(new StoreIndexedNode(newArray, ConstantNode.forInt(i, graph), element.getKind(), values.get(i), -1)));
+                }
             }
-
-            graph.removeFixed(this);
         }
+        graph.removeFixed(this);
     }
 
     @Override
--- a/graal/com.oracle.graal.virtual/src/com/oracle/graal/virtual/phases/ea/BlockState.java	Thu Jan 31 11:23:55 2013 +0100
+++ b/graal/com.oracle.graal.virtual/src/com/oracle/graal/virtual/phases/ea/BlockState.java	Thu Jan 31 11:32:14 2013 +0100
@@ -30,8 +30,7 @@
 import com.oracle.graal.api.meta.*;
 import com.oracle.graal.graph.*;
 import com.oracle.graal.nodes.*;
-import com.oracle.graal.nodes.java.*;
-import com.oracle.graal.nodes.spi.Virtualizable.*;
+import com.oracle.graal.nodes.spi.Virtualizable.EscapeState;
 import com.oracle.graal.nodes.virtual.*;
 import com.oracle.graal.phases.graph.ReentrantBlockIterator.MergeableBlockState;
 import com.oracle.graal.virtual.nodes.*;
@@ -94,70 +93,42 @@
 
         ValueNode[] fieldState = obj.getEntries();
 
-        // determine if all entries are default constants
-        boolean allDefault = true;
+        // some entries are not default constants - do the materialization
+        virtual.materializeAt(fixed);
+        MaterializeObjectNode materialize = new MaterializeObjectNode(virtual, obj.getLockCount());
+        ValueNode[] values = new ValueNode[obj.getEntries().length];
+        materialize.setProbability(fixed.probability());
+        obj.escape(materialize, state);
+        deferred.add(virtual);
         for (int i = 0; i < fieldState.length; i++) {
-            if (!fieldState[i].isConstant() || !fieldState[i].asConstant().isDefaultForKind()) {
-                allDefault = false;
-                break;
+            ObjectState valueObj = getObjectState(fieldState[i]);
+            if (valueObj != null) {
+                if (valueObj.isVirtual()) {
+                    materializeChangedBefore(fixed, valueObj.virtual, state, deferred, deferredStores, materializeEffects);
+                }
+                if (deferred.contains(valueObj.virtual)) {
+                    Kind fieldKind;
+                    CyclicMaterializeStoreNode store;
+                    if (virtual instanceof VirtualArrayNode) {
+                        store = new CyclicMaterializeStoreNode(materialize, valueObj.getMaterializedValue(), i);
+                        fieldKind = ((VirtualArrayNode) virtual).componentType().getKind();
+                    } else {
+                        VirtualInstanceNode instanceObject = (VirtualInstanceNode) virtual;
+                        store = new CyclicMaterializeStoreNode(materialize, valueObj.getMaterializedValue(), instanceObject.field(i));
+                        fieldKind = instanceObject.field(i).getType().getKind();
+                    }
+                    deferredStores.addFixedNodeBefore(store, fixed);
+                    values[i] = ConstantNode.defaultForKind(fieldKind, fixed.graph());
+                } else {
+                    values[i] = valueObj.getMaterializedValue();
+                }
+            } else {
+                values[i] = fieldState[i];
             }
         }
+        deferred.remove(virtual);
 
-        if (allDefault && obj.getLockCount() == 0) {
-            // create an ordinary NewInstance/NewArray node if all entries are default constants
-            FixedWithNextNode newObject;
-            if (virtual instanceof VirtualInstanceNode) {
-                newObject = new NewInstanceNode(virtual.type(), true, false);
-            } else {
-                assert virtual instanceof VirtualArrayNode;
-                ResolvedJavaType element = ((VirtualArrayNode) virtual).componentType();
-                if (element.getKind() == Kind.Object) {
-                    newObject = new NewObjectArrayNode(element, ConstantNode.forInt(virtual.entryCount(), fixed.graph()), true, false);
-                } else {
-                    newObject = new NewPrimitiveArrayNode(element, ConstantNode.forInt(virtual.entryCount(), fixed.graph()), true, false);
-                }
-            }
-            newObject.setProbability(fixed.probability());
-            obj.escape(newObject, state);
-            materializeEffects.addFixedNodeBefore(newObject, fixed);
-        } else {
-            // some entries are not default constants - do the materialization
-            virtual.materializeAt(fixed);
-            MaterializeObjectNode materialize = new MaterializeObjectNode(virtual, obj.getLockCount());
-            ValueNode[] values = new ValueNode[obj.getEntries().length];
-            materialize.setProbability(fixed.probability());
-            obj.escape(materialize, state);
-            deferred.add(virtual);
-            for (int i = 0; i < fieldState.length; i++) {
-                ObjectState valueObj = getObjectState(fieldState[i]);
-                if (valueObj != null) {
-                    if (valueObj.isVirtual()) {
-                        materializeChangedBefore(fixed, valueObj.virtual, state, deferred, deferredStores, materializeEffects);
-                    }
-                    if (deferred.contains(valueObj.virtual)) {
-                        Kind fieldKind;
-                        CyclicMaterializeStoreNode store;
-                        if (virtual instanceof VirtualArrayNode) {
-                            store = new CyclicMaterializeStoreNode(materialize, valueObj.getMaterializedValue(), i);
-                            fieldKind = ((VirtualArrayNode) virtual).componentType().getKind();
-                        } else {
-                            VirtualInstanceNode instanceObject = (VirtualInstanceNode) virtual;
-                            store = new CyclicMaterializeStoreNode(materialize, valueObj.getMaterializedValue(), instanceObject.field(i));
-                            fieldKind = instanceObject.field(i).getType().getKind();
-                        }
-                        deferredStores.addFixedNodeBefore(store, fixed);
-                        values[i] = ConstantNode.defaultForKind(fieldKind, fixed.graph());
-                    } else {
-                        values[i] = valueObj.getMaterializedValue();
-                    }
-                } else {
-                    values[i] = fieldState[i];
-                }
-            }
-            deferred.remove(virtual);
-
-            materializeEffects.addMaterialization(materialize, fixed, values);
-        }
+        materializeEffects.addMaterialization(materialize, fixed, values);
     }
 
     void addAndMarkAlias(VirtualObjectNode virtual, ValueNode node, NodeBitMap usages) {