< prev index next >
src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.java/src/org/graalvm/compiler/java/BytecodeParser.java
Print this page
rev 56282 : [mq]: graal
@@ -269,10 +269,11 @@
import jdk.internal.vm.compiler.collections.EconomicMap;
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;
import org.graalvm.compiler.bytecode.BytecodeLookupSwitch;
import org.graalvm.compiler.bytecode.BytecodeProvider;
@@ -361,16 +362,17 @@
import org.graalvm.compiler.nodes.calc.FloatConvertNode;
import org.graalvm.compiler.nodes.calc.FloatDivNode;
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;
import org.graalvm.compiler.nodes.calc.RightShiftNode;
import org.graalvm.compiler.nodes.calc.SignExtendNode;
@@ -808,12 +810,13 @@
this.intrinsicContext = intrinsicContext;
this.entryBCI = entryBCI;
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();
}
@@ -1329,11 +1332,15 @@
protected ValueNode genXor(ValueNode x, ValueNode y) {
return XorNode.create(x, y, NodeView.DEFAULT);
}
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) {
return FloatConvertNode.create(op, input, NodeView.DEFAULT);
}
@@ -2480,11 +2487,12 @@
try (InliningScope s = parsingIntrinsic() ? null
: (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]);
}
startFrameState.initializeFromArgumentsArray(args);
parser.build(this.lastInstr, startFrameState);
@@ -2943,11 +2951,21 @@
/*
* This is the first time we see this block as a branch target. Create and return a
* 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 {
setFirstInstruction(block, graph.add(new BeginNode()));
}
@@ -4003,16 +4021,22 @@
throw shouldNotReachHere();
}
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)));
}
@@ -5083,15 +5107,15 @@
case L2I : genNarrow(JavaKind.Long, JavaKind.Int); break;
case I2L : genSignExtend(JavaKind.Int, JavaKind.Long); break;
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;
case IFGE : genIfZero(Condition.GE); break;
case IFGT : genIfZero(Condition.GT); break;
< prev index next >