[GR-4916] Fix problem with move from Constant to StackSlot.

argan · Jul 13, 2017 · a37b749 · a37b749
2 parents 2d4662b + 02b78ce
commit a37b749
Show file tree

Hide file tree

Showing 9 changed files with 95 additions and 6 deletions.
diff --git a/...aalvm.compiler.core.aarch64/src/org/graalvm/compiler/core/aarch64/AArch64MoveFactory.java b/...aalvm.compiler.core.aarch64/src/org/graalvm/compiler/core/aarch64/AArch64MoveFactory.java
@@ -85,6 +85,11 @@ public LIRInstruction createLoad(AllocatableValue dst, Constant src) {
         }
     }
 
+    @Override
+    public LIRInstruction createStackLoad(AllocatableValue result, Constant input) {
+        return createLoad(result, input);
+    }
+
     @Override
     public boolean canInlineConstant(Constant con) {
         if (con instanceof JavaConstant) {

diff --git a/...org.graalvm.compiler.core.amd64/src/org/graalvm/compiler/core/amd64/AMD64MoveFactory.java b/...org.graalvm.compiler.core.amd64/src/org/graalvm/compiler/core/amd64/AMD64MoveFactory.java
@@ -23,16 +23,18 @@
 
 package org.graalvm.compiler.core.amd64;
 
+import static jdk.vm.ci.code.ValueUtil.isRegister;
 import static org.graalvm.compiler.lir.LIRValueUtil.asConstant;
 import static org.graalvm.compiler.lir.LIRValueUtil.isConstantValue;
 import static org.graalvm.compiler.lir.LIRValueUtil.isStackSlotValue;
-import static jdk.vm.ci.code.ValueUtil.isRegister;
 
 import org.graalvm.compiler.core.common.NumUtil;
 import org.graalvm.compiler.core.common.type.DataPointerConstant;
 import org.graalvm.compiler.debug.GraalError;
+import org.graalvm.compiler.lir.LIRInstruction;
 import org.graalvm.compiler.lir.amd64.AMD64AddressValue;
 import org.graalvm.compiler.lir.amd64.AMD64LIRInstruction;
+import org.graalvm.compiler.lir.amd64.AMD64Move;
 import org.graalvm.compiler.lir.amd64.AMD64Move.AMD64StackMove;
 import org.graalvm.compiler.lir.amd64.AMD64Move.LeaDataOp;
 import org.graalvm.compiler.lir.amd64.AMD64Move.LeaOp;
@@ -69,6 +71,17 @@ public boolean canInlineConstant(Constant con) {
         return false;
     }
 
+    @Override
+    public boolean allowConstantToStackMove(Constant constant) {
+        if (constant instanceof DataPointerConstant) {
+            return false;
+        }
+        if (constant instanceof JavaConstant && !AMD64Move.canMoveConst2Stack(((JavaConstant) constant))) {
+            return false;
+        }
+        return true;
+    }
+
     @Override
     public AMD64LIRInstruction createMove(AllocatableValue dst, Value src) {
         if (src instanceof AMD64AddressValue) {
@@ -97,4 +110,13 @@ public AMD64LIRInstruction createLoad(AllocatableValue dst, Constant src) {
             throw GraalError.shouldNotReachHere(String.format("unsupported constant: %s", src));
         }
     }
+
+    @Override
+    public LIRInstruction createStackLoad(AllocatableValue result, Constant input) {
+        if (input instanceof JavaConstant) {
+            return new MoveFromConstOp(result, (JavaConstant) input);
+        } else {
+            throw GraalError.shouldNotReachHere(String.format("unsupported constant for stack load: %s", input));
+        }
+    }
 }
diff --git a/...org.graalvm.compiler.core.sparc/src/org/graalvm/compiler/core/sparc/SPARCMoveFactory.java b/...org.graalvm.compiler.core.sparc/src/org/graalvm/compiler/core/sparc/SPARCMoveFactory.java
@@ -90,6 +90,14 @@ public LIRInstruction createLoad(AllocatableValue dst, Constant src) {
         }
     }
 
+    @Override
+    public LIRInstruction createStackLoad(AllocatableValue result, Constant input) {
+        if (input instanceof DataPointerConstant) {
+            throw GraalError.shouldNotReachHere("unsupported constant for stack load: " + input);
+        }
+        return createLoad(result, input);
+    }
+
     @Override
     public boolean canInlineConstant(Constant con) {
         if (con instanceof JavaConstant) {

diff --git a/...ompiler.hotspot.amd64/src/org/graalvm/compiler/hotspot/amd64/AMD64HotSpotMoveFactory.java b/...ompiler.hotspot.amd64/src/org/graalvm/compiler/hotspot/amd64/AMD64HotSpotMoveFactory.java
@@ -23,6 +23,7 @@
 package org.graalvm.compiler.hotspot.amd64;
 
 import org.graalvm.compiler.core.amd64.AMD64MoveFactory;
+import org.graalvm.compiler.lir.LIRInstruction;
 import org.graalvm.compiler.lir.amd64.AMD64LIRInstruction;
 
 import jdk.vm.ci.hotspot.HotSpotCompressedNullConstant;
@@ -57,7 +58,7 @@ public boolean allowConstantToStackMove(Constant value) {
         if (value instanceof HotSpotConstant) {
             return ((HotSpotConstant) value).isCompressed();
         }
-        return true;
+        return super.allowConstantToStackMove(value);
     }
 
     @Override
@@ -72,4 +73,19 @@ public AMD64LIRInstruction createLoad(AllocatableValue dst, Constant src) {
             return super.createLoad(dst, src);
         }
     }
+
+    @Override
+    public LIRInstruction createStackLoad(AllocatableValue dst, Constant src) {
+        if (HotSpotCompressedNullConstant.COMPRESSED_NULL.equals(src)) {
+            return super.createStackLoad(dst, JavaConstant.INT_0);
+        } else if (src instanceof HotSpotObjectConstant) {
+            assert ((HotSpotConstant) src).isCompressed();
+            return new AMD64HotSpotMove.HotSpotLoadObjectConstantOp(dst, (HotSpotObjectConstant) src);
+        } else if (src instanceof HotSpotMetaspaceConstant) {
+            assert ((HotSpotConstant) src).isCompressed();
+            return new AMD64HotSpotMove.HotSpotLoadMetaspaceConstantOp(dst, (HotSpotMetaspaceConstant) src);
+        } else {
+            return super.createStackLoad(dst, src);
+        }
+    }
 }
diff --git a/...iler/src/org.graalvm.compiler.lir.amd64/src/org/graalvm/compiler/lir/amd64/AMD64Move.java b/...iler/src/org.graalvm.compiler.lir.amd64/src/org/graalvm/compiler/lir/amd64/AMD64Move.java
@@ -669,6 +669,28 @@ public static void const2reg(CompilationResultBuilder crb, AMD64MacroAssembler m
         }
     }
 
+    public static boolean canMoveConst2Stack(JavaConstant input) {
+        switch (input.getJavaKind().getStackKind()) {
+            case Int:
+                break;
+            case Long:
+                break;
+            case Float:
+                break;
+            case Double:
+                break;
+            case Object:
+                if (input.isNull()) {
+                    return true;
+                } else {
+                    return false;
+                }
+            default:
+                return false;
+        }
+        return true;
+    }
+
     public static void const2stack(CompilationResultBuilder crb, AMD64MacroAssembler masm, Value result, JavaConstant input) {
         AMD64Address dest = (AMD64Address) crb.asAddress(result);
         final long imm;

diff --git a/...er/src/org.graalvm.compiler.lir/src/org/graalvm/compiler/lir/alloc/lsra/MoveResolver.java b/...er/src/org.graalvm.compiler.lir/src/org/graalvm/compiler/lir/alloc/lsra/MoveResolver.java
@@ -37,8 +37,9 @@
 import org.graalvm.compiler.lir.LIRInstruction;
 import org.graalvm.compiler.lir.LIRValueUtil;
 import org.graalvm.compiler.lir.gen.LIRGenerationResult;
-import org.graalvm.util.Equivalence;
 import org.graalvm.util.EconomicSet;
+import org.graalvm.util.Equivalence;
+
 import jdk.vm.ci.meta.AllocatableValue;
 import jdk.vm.ci.meta.Constant;
 import jdk.vm.ci.meta.Value;
@@ -296,7 +297,12 @@ private LIRInstruction insertMove(Constant fromOpr, Interval toInterval) {
         assert insertIdx != -1 : "must setup insert position first";
 
         AllocatableValue toOpr = toInterval.operand;
-        LIRInstruction move = getAllocator().getSpillMoveFactory().createLoad(toOpr, fromOpr);
+        LIRInstruction move;
+        if (LIRValueUtil.isStackSlotValue(toInterval.location())) {
+            move = getAllocator().getSpillMoveFactory().createStackLoad(toOpr, fromOpr);
+        } else {
+            move = getAllocator().getSpillMoveFactory().createLoad(toOpr, fromOpr);
+        }
         insertionBuffer.append(insertIdx, move);
 
         DebugContext debug = allocator.getDebug();
@@ -482,7 +488,8 @@ public void addMapping(Interval fromInterval, Interval toInterval) {
         }
 
         assert !fromInterval.operand.equals(toInterval.operand) : "from and to interval equal: " + fromInterval;
-        assert LIRKind.verifyMoveKinds(toInterval.kind(), fromInterval.kind(), allocator.getRegisterAllocationConfig()) : String.format("Kind mismatch: %s vs. %s, from=%s, to=%s", fromInterval.kind(),
+        assert LIRKind.verifyMoveKinds(toInterval.kind(), fromInterval.kind(), allocator.getRegisterAllocationConfig()) : String.format("Kind mismatch: %s vs. %s, from=%s, to=%s",
+                        fromInterval.kind(),
                         toInterval.kind(), fromInterval, toInterval);
         mappingFrom.add(fromInterval);
         mappingFromOpr.add(null);

diff --git a/...c/org.graalvm.compiler.lir/src/org/graalvm/compiler/lir/asm/CompilationResultBuilder.java b/...c/org.graalvm.compiler.lir/src/org/graalvm/compiler/lir/asm/CompilationResultBuilder.java
@@ -482,7 +482,7 @@ private void emitBlock(AbstractBlockBase<?> block) {
                     afterOp.accept(op);
                 }
             } catch (GraalError e) {
-                throw e.addContext("lir instruction", block + "@" + op.id() + " " + op + "\n" + Arrays.toString(lir.codeEmittingOrder()));
+                throw e.addContext("lir instruction", block + "@" + op.id() + " " + op.getClass().getName() + " " + op + "\n" + Arrays.toString(lir.codeEmittingOrder()));
             }
         }
     }

diff --git a/compiler/src/org.graalvm.compiler.lir/src/org/graalvm/compiler/lir/gen/LIRGeneratorTool.java b/compiler/src/org.graalvm.compiler.lir/src/org/graalvm/compiler/lir/gen/LIRGeneratorTool.java
@@ -80,6 +80,8 @@ public interface MoveFactory {
         LIRInstruction createStackMove(AllocatableValue result, AllocatableValue input);
 
         LIRInstruction createLoad(AllocatableValue result, Constant input);
+
+        LIRInstruction createStackLoad(AllocatableValue result, Constant input);
     }
 
     abstract class BlockScope implements AutoCloseable {

diff --git a/...r/src/org.graalvm.compiler.lir/src/org/graalvm/compiler/lir/gen/VerifyingMoveFactory.java b/...r/src/org.graalvm.compiler.lir/src/org/graalvm/compiler/lir/gen/VerifyingMoveFactory.java
@@ -80,6 +80,13 @@ public LIRInstruction createLoad(AllocatableValue result, Constant input) {
         return inst;
     }
 
+    @Override
+    public LIRInstruction createStackLoad(AllocatableValue result, Constant input) {
+        LIRInstruction inst = inner.createStackLoad(result, input);
+        assert LoadConstantOp.isLoadConstantOp(inst) && checkResult(inst, result, null);
+        return inst;
+    }
+
     /** Closure for {@link VerifyingMoveFactory#checkResult}. */
     @SuppressWarnings("unused")
     private static class CheckClosure {