--- a/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.java/src/org/graalvm/compiler/java/BytecodeParser.java Tue Sep 24 08:54:08 2019 -0700
+++ b/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.java/src/org/graalvm/compiler/java/BytecodeParser.java Tue Sep 24 12:47:15 2019 -0400
@@ -271,6 +271,7 @@
import jdk.internal.vm.compiler.collections.Equivalence;
import jdk.internal.vm.compiler.collections.UnmodifiableEconomicMap;
import org.graalvm.compiler.api.replacements.Fold;
+import org.graalvm.compiler.api.replacements.MethodSubstitution;
import org.graalvm.compiler.api.replacements.Snippet;
import org.graalvm.compiler.bytecode.Bytecode;
import org.graalvm.compiler.bytecode.BytecodeDisassembler;
@@ -363,12 +364,13 @@
import org.graalvm.compiler.nodes.calc.IntegerBelowNode;
import org.graalvm.compiler.nodes.calc.IntegerEqualsNode;
import org.graalvm.compiler.nodes.calc.IntegerLessThanNode;
+import org.graalvm.compiler.nodes.calc.IntegerNormalizeCompareNode;
import org.graalvm.compiler.nodes.calc.IsNullNode;
import org.graalvm.compiler.nodes.calc.LeftShiftNode;
import org.graalvm.compiler.nodes.calc.MulNode;
import org.graalvm.compiler.nodes.calc.NarrowNode;
import org.graalvm.compiler.nodes.calc.NegateNode;
-import org.graalvm.compiler.nodes.calc.NormalizeCompareNode;
+import org.graalvm.compiler.nodes.calc.FloatNormalizeCompareNode;
import org.graalvm.compiler.nodes.calc.ObjectEqualsNode;
import org.graalvm.compiler.nodes.calc.OrNode;
import org.graalvm.compiler.nodes.calc.RemNode;
@@ -810,8 +812,9 @@
this.parent = parent;
ClassInitializationPlugin classInitializationPlugin = graphBuilderConfig.getPlugins().getClassInitializationPlugin();
- if (classInitializationPlugin != null && graphBuilderConfig.eagerResolving()) {
- uninitializedIsError = eagerInitializing = !classInitializationPlugin.supportsLazyInitialization(constantPool);
+ if (classInitializationPlugin != null && graphBuilderConfig.eagerResolving() && classInitializationPlugin.supportsLazyInitialization(constantPool)) {
+ eagerInitializing = false;
+ uninitializedIsError = false;
} else {
eagerInitializing = graphBuilderConfig.eagerResolving();
uninitializedIsError = graphBuilderConfig.unresolvedIsError();
@@ -1331,7 +1334,11 @@
}
protected ValueNode genNormalizeCompare(ValueNode x, ValueNode y, boolean isUnorderedLess) {
- return NormalizeCompareNode.create(x, y, isUnorderedLess, JavaKind.Int, getConstantReflection());
+ return FloatNormalizeCompareNode.create(x, y, isUnorderedLess, JavaKind.Int, getConstantReflection());
+ }
+
+ protected ValueNode genIntegerNormalizeCompare(ValueNode x, ValueNode y) {
+ return IntegerNormalizeCompareNode.create(x, y, false, JavaKind.Int, getConstantReflection());
}
protected ValueNode genFloatConvert(FloatConvert op, ValueNode input) {
@@ -2482,7 +2489,8 @@
: (calleeIntrinsicContext != null ? new IntrinsicScope(this, targetMethod, args)
: new InliningScope(this, targetMethod, args))) {
BytecodeParser parser = graphBuilderInstance.createBytecodeParser(graph, this, targetMethod, INVOCATION_ENTRY_BCI, calleeIntrinsicContext);
- FrameStateBuilder startFrameState = new FrameStateBuilder(parser, parser.code, graph, graphBuilderConfig.retainLocalVariables());
+ boolean targetIsSubstitution = targetMethod.isAnnotationPresent(MethodSubstitution.class);
+ FrameStateBuilder startFrameState = new FrameStateBuilder(parser, parser.code, graph, graphBuilderConfig.retainLocalVariables() && !targetIsSubstitution);
if (!targetMethod.isStatic()) {
args[0] = nullCheckedValue(args[0]);
}
@@ -2945,7 +2953,17 @@
* placeholder that later can be replaced with a MergeNode when we see this block
* again.
*/
- if (canReuseInstruction && (block.getPredecessorCount() == 1 || !controlFlowSplit) && !block.isLoopHeader() && (currentBlock.loops & ~block.loops) == 0) {
+ if (canReuseInstruction && (block.getPredecessorCount() == 1 || !controlFlowSplit) && !block.isLoopHeader() && (currentBlock.loops & ~block.loops) == 0 &&
+ currentBlock.getJsrScope() == block.getJsrScope()) {
+ /*
+ * If we know that no BeginNode is necessary, then we can avoid allocating and
+ * later removing that node. This is strictly a performance optimization:
+ * unnecessary BeginNode are allowed and will be removed later on. We need to be
+ * careful though because the predecessor information is not always enough: when
+ * the loop level changes, we always need a BeginNode. Also, JSR scope changes
+ * required a BeginNode because the predecessors coming from RET bytecodes are
+ * not reflected in the predecessor count.
+ */
setFirstInstruction(block, lastInstr);
lastInstr = null;
} else {
@@ -4005,12 +4023,18 @@
frameState.push(kind, append(v));
}
- private void genCompareOp(JavaKind kind, boolean isUnorderedLess) {
+ private void genFloatCompareOp(JavaKind kind, boolean isUnorderedLess) {
ValueNode y = frameState.pop(kind);
ValueNode x = frameState.pop(kind);
frameState.push(JavaKind.Int, append(genNormalizeCompare(x, y, isUnorderedLess)));
}
+ private void genIntegerCompareOp(JavaKind kind) {
+ ValueNode y = frameState.pop(kind);
+ ValueNode x = frameState.pop(kind);
+ frameState.push(JavaKind.Int, append(genIntegerNormalizeCompare(x, y)));
+ }
+
private void genFloatConvert(FloatConvert op, JavaKind from, JavaKind to) {
ValueNode input = frameState.pop(from);
frameState.push(to, append(genFloatConvert(op, input)));
@@ -5085,11 +5109,11 @@
case I2B : genSignExtend(JavaKind.Byte, JavaKind.Int); break;
case I2S : genSignExtend(JavaKind.Short, JavaKind.Int); break;
case I2C : genZeroExtend(JavaKind.Char, JavaKind.Int); break;
- case LCMP : genCompareOp(JavaKind.Long, false); break;
- case FCMPL : genCompareOp(JavaKind.Float, true); break;
- case FCMPG : genCompareOp(JavaKind.Float, false); break;
- case DCMPL : genCompareOp(JavaKind.Double, true); break;
- case DCMPG : genCompareOp(JavaKind.Double, false); break;
+ case LCMP : genIntegerCompareOp(JavaKind.Long); break;
+ case FCMPL : genFloatCompareOp(JavaKind.Float, true); break;
+ case FCMPG : genFloatCompareOp(JavaKind.Float, false); break;
+ case DCMPL : genFloatCompareOp(JavaKind.Double, true); break;
+ case DCMPG : genFloatCompareOp(JavaKind.Double, false); break;
case IFEQ : genIfZero(Condition.EQ); break;
case IFNE : genIfZero(Condition.NE); break;
case IFLT : genIfZero(Condition.LT); break;