< prev index next >
src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.replacements/src/org/graalvm/compiler/replacements/DefaultJavaLoweringProvider.java
Print this page
*** 31,57 ****
--- 31,60 ----
import static jdk.vm.ci.meta.DeoptimizationReason.NullCheckException;
import static org.graalvm.compiler.nodes.NamedLocationIdentity.ARRAY_LENGTH_LOCATION;
import static org.graalvm.compiler.nodes.java.ArrayLengthNode.readArrayLength;
import static org.graalvm.compiler.nodes.util.GraphUtil.skipPiWhileNonNull;
+ import java.nio.ByteOrder;
import java.util.ArrayList;
import java.util.BitSet;
import java.util.List;
import org.graalvm.compiler.api.directives.GraalDirectives;
import org.graalvm.compiler.api.replacements.Snippet;
import org.graalvm.compiler.api.replacements.SnippetReflectionProvider;
import org.graalvm.compiler.core.common.spi.ForeignCallDescriptor;
import org.graalvm.compiler.core.common.spi.ForeignCallsProvider;
import org.graalvm.compiler.core.common.type.IntegerStamp;
+ import org.graalvm.compiler.core.common.type.ObjectStamp;
import org.graalvm.compiler.core.common.type.Stamp;
import org.graalvm.compiler.core.common.type.StampFactory;
import org.graalvm.compiler.core.common.type.TypeReference;
import org.graalvm.compiler.debug.DebugHandlersFactory;
import org.graalvm.compiler.debug.GraalError;
import org.graalvm.compiler.graph.Node;
import org.graalvm.compiler.nodeinfo.InputType;
+ import org.graalvm.compiler.nodes.CompressionNode.CompressionOp;
import org.graalvm.compiler.nodes.ConstantNode;
import org.graalvm.compiler.nodes.FieldLocationIdentity;
import org.graalvm.compiler.nodes.FixedNode;
import org.graalvm.compiler.nodes.LogicNode;
import org.graalvm.compiler.nodes.NamedLocationIdentity;
*** 67,76 ****
--- 70,80 ----
import org.graalvm.compiler.nodes.calc.LeftShiftNode;
import org.graalvm.compiler.nodes.calc.NarrowNode;
import org.graalvm.compiler.nodes.calc.RightShiftNode;
import org.graalvm.compiler.nodes.calc.SignExtendNode;
import org.graalvm.compiler.nodes.calc.SubNode;
+ import org.graalvm.compiler.nodes.calc.UnpackEndianHalfNode;
import org.graalvm.compiler.nodes.calc.ZeroExtendNode;
import org.graalvm.compiler.nodes.debug.VerifyHeapNode;
import org.graalvm.compiler.nodes.extended.BoxNode;
import org.graalvm.compiler.nodes.extended.FixedValueAnchorNode;
import org.graalvm.compiler.nodes.extended.ForeignCallNode;
*** 148,165 ****
public abstract class DefaultJavaLoweringProvider implements LoweringProvider {
protected final MetaAccessProvider metaAccess;
protected final ForeignCallsProvider foreignCalls;
protected final TargetDescription target;
private BoxingSnippets.Templates boxingSnippets;
private ConstantStringIndexOfSnippets.Templates indexOfSnippets;
! public DefaultJavaLoweringProvider(MetaAccessProvider metaAccess, ForeignCallsProvider foreignCalls, TargetDescription target) {
this.metaAccess = metaAccess;
this.foreignCalls = foreignCalls;
this.target = target;
}
public void initialize(OptionValues options, Iterable<DebugHandlersFactory> factories, SnippetCounter.Group.Factory factory, Providers providers, SnippetReflectionProvider snippetReflection) {
boxingSnippets = new BoxingSnippets.Templates(options, factories, factory, providers, snippetReflection, target);
indexOfSnippets = new ConstantStringIndexOfSnippets.Templates(options, factories, providers, snippetReflection, target);
--- 152,171 ----
public abstract class DefaultJavaLoweringProvider implements LoweringProvider {
protected final MetaAccessProvider metaAccess;
protected final ForeignCallsProvider foreignCalls;
protected final TargetDescription target;
+ private final boolean useCompressedOops;
private BoxingSnippets.Templates boxingSnippets;
private ConstantStringIndexOfSnippets.Templates indexOfSnippets;
! public DefaultJavaLoweringProvider(MetaAccessProvider metaAccess, ForeignCallsProvider foreignCalls, TargetDescription target, boolean useCompressedOops) {
this.metaAccess = metaAccess;
this.foreignCalls = foreignCalls;
this.target = target;
+ this.useCompressedOops = useCompressedOops;
}
public void initialize(OptionValues options, Iterable<DebugHandlersFactory> factories, SnippetCounter.Group.Factory factory, Providers providers, SnippetReflectionProvider snippetReflection) {
boxingSnippets = new BoxingSnippets.Templates(options, factories, factory, providers, snippetReflection, target);
indexOfSnippets = new ConstantStringIndexOfSnippets.Templates(options, factories, providers, snippetReflection, target);
*** 216,230 ****
--- 222,243 ----
lowerUnaryMath((UnaryMathIntrinsicNode) n, tool);
} else if (n instanceof BinaryMathIntrinsicNode) {
lowerBinaryMath((BinaryMathIntrinsicNode) n, tool);
} else if (n instanceof StringIndexOfNode) {
lowerIndexOf((StringIndexOfNode) n);
+ } else if (n instanceof UnpackEndianHalfNode) {
+ lowerSecondHalf((UnpackEndianHalfNode) n);
} else {
throw GraalError.shouldNotReachHere("Node implementing Lowerable not handled: " + n);
}
}
+ private void lowerSecondHalf(UnpackEndianHalfNode n) {
+ ByteOrder byteOrder = target.arch.getByteOrder();
+ n.lower(byteOrder);
+ }
+
private void lowerIndexOf(StringIndexOfNode n) {
if (n.getArgument(3).isConstant()) {
SnippetLowering lowering = new SnippetLowering() {
@Override
public void lower(SnippetLowerableMemoryNode node, LoweringTool tool) {
*** 324,346 ****
} else {
return null;
}
}
protected void lowerLoadFieldNode(LoadFieldNode loadField, LoweringTool tool) {
assert loadField.getStackKind() != JavaKind.Illegal;
StructuredGraph graph = loadField.graph();
ResolvedJavaField field = loadField.field();
ValueNode object = loadField.isStatic() ? staticFieldBase(graph, field) : loadField.object();
object = createNullCheckedValue(object, loadField, tool);
! Stamp loadStamp = loadStamp(loadField.stamp(), field.getJavaKind());
AddressNode address = createFieldAddress(graph, object, field);
assert address != null : "Field that is loaded must not be eliminated: " + field.getDeclaringClass().toJavaName(true) + "." + field.getName();
ReadNode memoryRead = graph.add(new ReadNode(address, fieldLocationIdentity(field), loadStamp, fieldLoadBarrierType(field)));
! ValueNode readValue = implicitLoadConvert(graph, field.getJavaKind(), memoryRead);
loadField.replaceAtUsages(readValue);
graph.replaceFixed(loadField, memoryRead);
if (loadField.isVolatile()) {
MembarNode preMembar = graph.add(new MembarNode(JMM_PRE_VOLATILE_READ));
--- 337,361 ----
} else {
return null;
}
}
+ protected abstract JavaKind getStorageKind(ResolvedJavaField field);
+
protected void lowerLoadFieldNode(LoadFieldNode loadField, LoweringTool tool) {
assert loadField.getStackKind() != JavaKind.Illegal;
StructuredGraph graph = loadField.graph();
ResolvedJavaField field = loadField.field();
ValueNode object = loadField.isStatic() ? staticFieldBase(graph, field) : loadField.object();
object = createNullCheckedValue(object, loadField, tool);
! Stamp loadStamp = loadStamp(loadField.stamp(), getStorageKind(field));
AddressNode address = createFieldAddress(graph, object, field);
assert address != null : "Field that is loaded must not be eliminated: " + field.getDeclaringClass().toJavaName(true) + "." + field.getName();
ReadNode memoryRead = graph.add(new ReadNode(address, fieldLocationIdentity(field), loadStamp, fieldLoadBarrierType(field)));
! ValueNode readValue = implicitLoadConvert(graph, getStorageKind(field), memoryRead);
loadField.replaceAtUsages(readValue);
graph.replaceFixed(loadField, memoryRead);
if (loadField.isVolatile()) {
MembarNode preMembar = graph.add(new MembarNode(JMM_PRE_VOLATILE_READ));
*** 353,363 ****
protected void lowerStoreFieldNode(StoreFieldNode storeField, LoweringTool tool) {
StructuredGraph graph = storeField.graph();
ResolvedJavaField field = storeField.field();
ValueNode object = storeField.isStatic() ? staticFieldBase(graph, field) : storeField.object();
object = createNullCheckedValue(object, storeField, tool);
! ValueNode value = implicitStoreConvert(graph, storeField.field().getJavaKind(), storeField.value());
AddressNode address = createFieldAddress(graph, object, field);
assert address != null;
WriteNode memoryWrite = graph.add(new WriteNode(address, fieldLocationIdentity(field), value, fieldStoreBarrierType(storeField.field())));
memoryWrite.setStateAfter(storeField.stateAfter());
--- 368,378 ----
protected void lowerStoreFieldNode(StoreFieldNode storeField, LoweringTool tool) {
StructuredGraph graph = storeField.graph();
ResolvedJavaField field = storeField.field();
ValueNode object = storeField.isStatic() ? staticFieldBase(graph, field) : storeField.object();
object = createNullCheckedValue(object, storeField, tool);
! ValueNode value = implicitStoreConvert(graph, getStorageKind(storeField.field()), storeField.value());
AddressNode address = createFieldAddress(graph, object, field);
assert address != null;
WriteNode memoryWrite = graph.add(new WriteNode(address, fieldLocationIdentity(field), value, fieldStoreBarrierType(storeField.field())));
memoryWrite.setStateAfter(storeField.stateAfter());
*** 649,661 ****
graph.replaceFixed(read, memoryRead);
}
protected void lowerJavaWriteNode(JavaWriteNode write) {
StructuredGraph graph = write.graph();
! JavaKind valueKind = write.getWriteKind();
! ValueNode value = implicitStoreConvert(graph, valueKind, write.value(), write.isCompressible());
!
WriteNode memoryWrite = graph.add(new WriteNode(write.getAddress(), write.getLocationIdentity(), value, write.getBarrierType()));
memoryWrite.setStateAfter(write.stateAfter());
graph.replaceFixedWithFixed(write, memoryWrite);
memoryWrite.setGuard(write.getGuard());
}
--- 664,674 ----
graph.replaceFixed(read, memoryRead);
}
protected void lowerJavaWriteNode(JavaWriteNode write) {
StructuredGraph graph = write.graph();
! ValueNode value = implicitStoreConvert(graph, write.getWriteKind(), write.value(), write.isCompressible());
WriteNode memoryWrite = graph.add(new WriteNode(write.getAddress(), write.getLocationIdentity(), value, write.getBarrierType()));
memoryWrite.setStateAfter(write.stateAfter());
graph.replaceFixedWithFixed(write, memoryWrite);
memoryWrite.setGuard(write.getGuard());
}
*** 916,929 ****
--- 929,952 ----
public Stamp loadStamp(Stamp stamp, JavaKind kind) {
return loadStamp(stamp, kind, true);
}
+ private boolean useCompressedOops(JavaKind kind, boolean compressible) {
+ return kind == JavaKind.Object && compressible && useCompressedOops;
+ }
+
+ protected abstract Stamp loadCompressedStamp(ObjectStamp stamp);
+
/**
* @param compressible whether the stamp should be compressible
*/
protected Stamp loadStamp(Stamp stamp, JavaKind kind, boolean compressible) {
+ if (useCompressedOops(kind, compressible)) {
+ return loadCompressedStamp((ObjectStamp) stamp);
+ }
+
switch (kind) {
case Boolean:
case Byte:
return IntegerStamp.OPS.getNarrow().foldStamp(32, 8, stamp);
case Char:
*** 947,960 ****
ret = graph.addOrUnique(ret);
}
return ret;
}
/**
! * @param compressible whether the covert should be compressible
*/
protected ValueNode implicitLoadConvert(JavaKind kind, ValueNode value, boolean compressible) {
switch (kind) {
case Byte:
case Short:
return new SignExtendNode(value, 32);
case Boolean:
--- 970,989 ----
ret = graph.addOrUnique(ret);
}
return ret;
}
+ protected abstract ValueNode newCompressionNode(CompressionOp op, ValueNode value);
+
/**
! * @param compressible whether the convert should be compressible
*/
protected ValueNode implicitLoadConvert(JavaKind kind, ValueNode value, boolean compressible) {
+ if (useCompressedOops(kind, compressible)) {
+ return newCompressionNode(CompressionOp.Uncompress, value);
+ }
+
switch (kind) {
case Byte:
case Short:
return new SignExtendNode(value, 32);
case Boolean:
*** 982,991 ****
--- 1011,1024 ----
/**
* @param compressible whether the covert should be compressible
*/
protected ValueNode implicitStoreConvert(JavaKind kind, ValueNode value, boolean compressible) {
+ if (useCompressedOops(kind, compressible)) {
+ return newCompressionNode(CompressionOp.Compress, value);
+ }
+
switch (kind) {
case Boolean:
case Byte:
return new NarrowNode(value, 8);
case Char:
*** 1009,1021 ****
}
LogicNode boundsCheck = IntegerBelowNode.create(n.index(), arrayLength);
if (boundsCheck.isTautology()) {
return null;
- } else {
- return tool.createGuard(n, graph.addOrUniqueWithInputs(boundsCheck), BoundsCheckException, InvalidateReprofile);
}
}
protected GuardingNode createNullCheck(ValueNode object, FixedNode before, LoweringTool tool) {
if (StampTool.isPointerNonNull(object)) {
return null;
--- 1042,1053 ----
}
LogicNode boundsCheck = IntegerBelowNode.create(n.index(), arrayLength);
if (boundsCheck.isTautology()) {
return null;
}
+ return tool.createGuard(n, graph.addOrUniqueWithInputs(boundsCheck), BoundsCheckException, InvalidateReprofile);
}
protected GuardingNode createNullCheck(ValueNode object, FixedNode before, LoweringTool tool) {
if (StampTool.isPointerNonNull(object)) {
return null;
*** 1025,1037 ****
protected ValueNode createNullCheckedValue(ValueNode object, FixedNode before, LoweringTool tool) {
GuardingNode nullCheck = createNullCheck(object, before, tool);
if (nullCheck == null) {
return object;
- } else {
- return before.graph().maybeAddOrUnique(PiNode.create(object, (object.stamp()).join(StampFactory.objectNonNull()), (ValueNode) nullCheck));
}
}
@Override
public ValueNode reconstructArrayIndex(JavaKind elementKind, AddressNode address) {
StructuredGraph graph = address.graph();
--- 1057,1068 ----
protected ValueNode createNullCheckedValue(ValueNode object, FixedNode before, LoweringTool tool) {
GuardingNode nullCheck = createNullCheck(object, before, tool);
if (nullCheck == null) {
return object;
}
+ return before.graph().maybeAddOrUnique(PiNode.create(object, (object.stamp()).join(StampFactory.objectNonNull()), (ValueNode) nullCheck));
}
@Override
public ValueNode reconstructArrayIndex(JavaKind elementKind, AddressNode address) {
StructuredGraph graph = address.graph();
< prev index next >