< 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,278 ****
--- 269,279 ----
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,376 ****
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.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.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;
--- 362,378 ----
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.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,819 ****
this.intrinsicContext = intrinsicContext;
this.entryBCI = entryBCI;
this.parent = parent;
ClassInitializationPlugin classInitializationPlugin = graphBuilderConfig.getPlugins().getClassInitializationPlugin();
! if (classInitializationPlugin != null && graphBuilderConfig.eagerResolving()) {
! uninitializedIsError = eagerInitializing = !classInitializationPlugin.supportsLazyInitialization(constantPool);
} else {
eagerInitializing = graphBuilderConfig.eagerResolving();
uninitializedIsError = graphBuilderConfig.unresolvedIsError();
}
--- 810,822 ----
this.intrinsicContext = intrinsicContext;
this.entryBCI = entryBCI;
this.parent = parent;
ClassInitializationPlugin classInitializationPlugin = graphBuilderConfig.getPlugins().getClassInitializationPlugin();
! if (classInitializationPlugin != null && graphBuilderConfig.eagerResolving() && classInitializationPlugin.supportsLazyInitialization(constantPool)) {
! eagerInitializing = false;
! uninitializedIsError = false;
} else {
eagerInitializing = graphBuilderConfig.eagerResolving();
uninitializedIsError = graphBuilderConfig.unresolvedIsError();
}
*** 1329,1339 ****
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());
}
protected ValueNode genFloatConvert(FloatConvert op, ValueNode input) {
return FloatConvertNode.create(op, input, NodeView.DEFAULT);
}
--- 1332,1346 ----
protected ValueNode genXor(ValueNode x, ValueNode y) {
return XorNode.create(x, y, NodeView.DEFAULT);
}
protected ValueNode genNormalizeCompare(ValueNode x, ValueNode y, boolean isUnorderedLess) {
! 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,2490 ****
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());
if (!targetMethod.isStatic()) {
args[0] = nullCheckedValue(args[0]);
}
startFrameState.initializeFromArgumentsArray(args);
parser.build(this.lastInstr, startFrameState);
--- 2487,2498 ----
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);
! 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,2953 ****
/*
* 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) {
setFirstInstruction(block, lastInstr);
lastInstr = null;
} else {
setFirstInstruction(block, graph.add(new BeginNode()));
}
--- 2951,2971 ----
/*
* 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 &&
! 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,4018 ****
throw shouldNotReachHere();
}
frameState.push(kind, append(v));
}
! private void genCompareOp(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 genFloatConvert(FloatConvert op, JavaKind from, JavaKind to) {
ValueNode input = frameState.pop(from);
frameState.push(to, append(genFloatConvert(op, input)));
}
--- 4021,4042 ----
throw shouldNotReachHere();
}
frameState.push(kind, append(v));
}
! 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,5097 ****
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 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;
--- 5107,5121 ----
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 : 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 >