< prev index next >
src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.replacements/src/org/graalvm/compiler/replacements/DefaultJavaLoweringProvider.java
Print this page
rev 52509 : [mq]: graal
@@ -29,11 +29,14 @@
import static jdk.vm.ci.code.MemoryBarriers.JMM_PRE_VOLATILE_READ;
import static jdk.vm.ci.code.MemoryBarriers.JMM_PRE_VOLATILE_WRITE;
import static jdk.vm.ci.meta.DeoptimizationAction.InvalidateReprofile;
import static jdk.vm.ci.meta.DeoptimizationReason.BoundsCheckException;
import static jdk.vm.ci.meta.DeoptimizationReason.NullCheckException;
+import static org.graalvm.compiler.core.common.SpeculativeExecutionAttacksMitigations.Options.UseIndexMasking;
import static org.graalvm.compiler.nodes.NamedLocationIdentity.ARRAY_LENGTH_LOCATION;
+import static org.graalvm.compiler.nodes.calc.BinaryArithmeticNode.branchlessMax;
+import static org.graalvm.compiler.nodes.calc.BinaryArithmeticNode.branchlessMin;
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;
@@ -183,10 +186,14 @@
public final TargetDescription getTarget() {
return target;
}
+ public MetaAccessProvider getMetaAccess() {
+ return metaAccess;
+ }
+
@Override
@SuppressWarnings("try")
public void lower(Node n, LoweringTool tool) {
assert n instanceof Lowerable;
StructuredGraph graph = (StructuredGraph) n.graph();
@@ -438,17 +445,18 @@
MembarNode postMembar = graph.add(new MembarNode(JMM_POST_VOLATILE_WRITE));
graph.addAfterFixed(memoryWrite, postMembar);
}
}
+ public static final IntegerStamp POSITIVE_ARRAY_INDEX_STAMP = StampFactory.forInteger(32, 0, Integer.MAX_VALUE - 1);
+
/**
* Create a PiNode on the index proving that the index is positive. On some platforms this is
* important to allow the index to be used as an int in the address mode.
*/
public AddressNode createArrayIndexAddress(StructuredGraph graph, ValueNode array, JavaKind elementKind, ValueNode index, GuardingNode boundsCheck) {
- IntegerStamp indexStamp = StampFactory.forInteger(32, 0, Integer.MAX_VALUE - 1);
- ValueNode positiveIndex = graph.maybeAddOrUnique(PiNode.create(index, indexStamp, boundsCheck != null ? boundsCheck.asNode() : null));
+ ValueNode positiveIndex = graph.maybeAddOrUnique(PiNode.create(index, POSITIVE_ARRAY_INDEX_STAMP, boundsCheck != null ? boundsCheck.asNode() : null));
return createArrayAddress(graph, array, elementKind, positiveIndex);
}
public AddressNode createArrayAddress(StructuredGraph graph, ValueNode array, JavaKind elementKind, ValueNode index) {
ValueNode wordIndex;
@@ -457,14 +465,14 @@
} else {
assert target.wordSize == 4 : "unsupported word size";
wordIndex = index;
}
- int shift = CodeUtil.log2(arrayScalingFactor(elementKind));
+ int shift = CodeUtil.log2(metaAccess.getArrayIndexScale(elementKind));
ValueNode scaledIndex = graph.unique(new LeftShiftNode(wordIndex, ConstantNode.forInt(shift, graph)));
- int base = arrayBaseOffset(elementKind);
+ int base = metaAccess.getArrayBaseOffset(elementKind);
ValueNode offset = graph.unique(new AddNode(scaledIndex, ConstantNode.forIntegerKind(target.wordJavaKind, base, graph)));
return graph.unique(new OffsetAddressNode(array, offset));
}
@@ -474,11 +482,16 @@
array = createNullCheckedValue(array, loadIndexed, tool);
JavaKind elementKind = loadIndexed.elementKind();
Stamp loadStamp = loadStamp(loadIndexed.stamp(NodeView.DEFAULT), elementKind);
GuardingNode boundsCheck = getBoundsCheck(loadIndexed, array, tool);
- AddressNode address = createArrayIndexAddress(graph, array, elementKind, loadIndexed.index(), boundsCheck);
+ ValueNode index = loadIndexed.index();
+ if (UseIndexMasking.getValue(graph.getOptions())) {
+ index = proxyIndex(loadIndexed, index, array, tool);
+ }
+ AddressNode address = createArrayIndexAddress(graph, array, elementKind, index, boundsCheck);
+
ReadNode memoryRead = graph.add(new ReadNode(address, NamedLocationIdentity.getArrayLocation(elementKind), loadStamp, BarrierType.NONE));
memoryRead.setGuard(boundsCheck);
ValueNode readValue = implicitLoadConvert(graph, elementKind, memoryRead);
loadIndexed.replaceAtUsages(readValue);
@@ -798,11 +811,11 @@
if (offset >= 0) {
address = createOffsetAddress(graph, newObject, offset);
barrierType = fieldInitializationBarrier(entryKind);
}
} else {
- address = createOffsetAddress(graph, newObject, arrayBaseOffset(entryKind) + i * arrayScalingFactor(entryKind));
+ address = createOffsetAddress(graph, newObject, metaAccess.getArrayBaseOffset(entryKind) + i * metaAccess.getArrayIndexScale(entryKind));
barrierType = arrayInitializationBarrier(entryKind);
}
if (address != null) {
WriteNode write = new WriteNode(address, LocationIdentity.init(), implicitStoreConvert(graph, entryKind, value), barrierType);
graph.addAfterFixed(newObject, graph.add(write));
@@ -998,15 +1011,10 @@
public abstract ValueNode staticFieldBase(StructuredGraph graph, ResolvedJavaField field);
public abstract int arrayLengthOffset();
- @Override
- public int arrayScalingFactor(JavaKind elementKind) {
- return target.arch.getPlatformKind(elementKind).getSizeInBytes();
- }
-
public Stamp loadStamp(Stamp stamp, JavaKind kind) {
return loadStamp(stamp, kind, true);
}
private boolean useCompressedOops(JavaKind kind, boolean compressible) {
@@ -1108,30 +1116,42 @@
protected abstract ValueNode createReadHub(StructuredGraph graph, ValueNode object, LoweringTool tool);
protected abstract ValueNode createReadArrayComponentHub(StructuredGraph graph, ValueNode arrayHub, FixedNode anchor);
+ protected ValueNode proxyIndex(AccessIndexedNode n, ValueNode index, ValueNode array, LoweringTool tool) {
+ StructuredGraph graph = index.graph();
+ ValueNode arrayLength = readOrCreateArrayLength(n, array, tool, graph);
+ ValueNode lengthMinusOne = SubNode.create(arrayLength, ConstantNode.forInt(1), NodeView.DEFAULT);
+ return branchlessMax(branchlessMin(index, lengthMinusOne, NodeView.DEFAULT), ConstantNode.forInt(0), NodeView.DEFAULT);
+ }
+
protected GuardingNode getBoundsCheck(AccessIndexedNode n, ValueNode array, LoweringTool tool) {
if (n.getBoundsCheck() != null) {
return n.getBoundsCheck();
}
StructuredGraph graph = n.graph();
- ValueNode arrayLength = readArrayLength(array, tool.getConstantReflection());
- if (arrayLength == null) {
- arrayLength = createReadArrayLength(array, n, tool);
- } else {
- arrayLength = arrayLength.isAlive() ? arrayLength : graph.addOrUniqueWithInputs(arrayLength);
- }
+ ValueNode arrayLength = readOrCreateArrayLength(n, array, tool, graph);
LogicNode boundsCheck = IntegerBelowNode.create(n.index(), arrayLength, NodeView.DEFAULT);
if (boundsCheck.isTautology()) {
return null;
}
return tool.createGuard(n, graph.addOrUniqueWithInputs(boundsCheck), BoundsCheckException, InvalidateReprofile);
}
+ private ValueNode readOrCreateArrayLength(AccessIndexedNode n, ValueNode array, LoweringTool tool, StructuredGraph graph) {
+ ValueNode arrayLength = readArrayLength(array, tool.getConstantReflection());
+ if (arrayLength == null) {
+ arrayLength = createReadArrayLength(array, n, tool);
+ } else {
+ arrayLength = arrayLength.isAlive() ? arrayLength : graph.addOrUniqueWithInputs(arrayLength);
+ }
+ return arrayLength;
+ }
+
protected GuardingNode createNullCheck(ValueNode object, FixedNode before, LoweringTool tool) {
if (StampTool.isPointerNonNull(object)) {
return null;
}
return tool.createGuard(before, before.graph().unique(IsNullNode.create(object)), NullCheckException, InvalidateReprofile, SpeculationLog.NO_SPECULATION, true, null);
@@ -1148,13 +1168,13 @@
@Override
public ValueNode reconstructArrayIndex(JavaKind elementKind, AddressNode address) {
StructuredGraph graph = address.graph();
ValueNode offset = ((OffsetAddressNode) address).getOffset();
- int base = arrayBaseOffset(elementKind);
+ int base = metaAccess.getArrayBaseOffset(elementKind);
ValueNode scaledIndex = graph.unique(new SubNode(offset, ConstantNode.forIntegerStamp(offset.stamp(NodeView.DEFAULT), base, graph)));
- int shift = CodeUtil.log2(arrayScalingFactor(elementKind));
+ int shift = CodeUtil.log2(metaAccess.getArrayIndexScale(elementKind));
ValueNode ret = graph.unique(new RightShiftNode(scaledIndex, ConstantNode.forInt(shift, graph)));
return IntegerConvertNode.convert(ret, StampFactory.forKind(JavaKind.Int), graph, NodeView.DEFAULT);
}
}
< prev index next >