use of org.graalvm.compiler.nodes.virtual.VirtualObjectNode in project graal by oracle.
the class VirtualFrameSetNode method virtualize.
@Override
public void virtualize(VirtualizerTool tool) {
ValueNode tagAlias = tool.getAlias(frame.virtualFrameTagArray);
ValueNode dataAlias = tool.getAlias(TruffleCompilerRuntime.getRuntime().getJavaKindForFrameSlotKind(accessTag) == JavaKind.Object ? frame.virtualFrameObjectArray : frame.virtualFramePrimitiveArray);
if (tagAlias instanceof VirtualObjectNode && dataAlias instanceof VirtualObjectNode) {
VirtualObjectNode tagVirtual = (VirtualObjectNode) tagAlias;
VirtualObjectNode dataVirtual = (VirtualObjectNode) dataAlias;
if (frameSlotIndex < tagVirtual.entryCount() && frameSlotIndex < dataVirtual.entryCount()) {
tool.setVirtualEntry(tagVirtual, frameSlotIndex, getConstant(accessTag));
ValueNode dataEntry = tool.getEntry(dataVirtual, frameSlotIndex);
if (dataEntry.getStackKind() == value.getStackKind()) {
if (tool.setVirtualEntry(dataVirtual, frameSlotIndex, value, value.getStackKind(), -1)) {
tool.delete();
return;
}
}
}
}
/*
* Deoptimization is our only option here. We cannot go back to a UnsafeStoreNode because we
* do not have a FrameState to use for the memory store.
*/
insertDeoptimization(tool);
}
use of org.graalvm.compiler.nodes.virtual.VirtualObjectNode in project graal by oracle.
the class AssertTypeStateNode method virtualize.
@Override
public void virtualize(VirtualizerTool tool) {
ValueNode alias = tool.getAlias(getInput());
if (alias instanceof VirtualObjectNode) {
Set<ResolvedJavaType> ourTypes = new HashSet<>();
addAllTypes(ourTypes, typeState);
if (!ourTypes.contains(StampTool.typeOrNull(alias))) {
throw shouldNotReachHere("Virtual object not compatible with type state: " + this + " : " + getTypeState() + ", " + alias.stamp(NodeView.DEFAULT));
}
tool.replaceWith(alias);
}
}
use of org.graalvm.compiler.nodes.virtual.VirtualObjectNode in project graal by oracle.
the class ObjectEqualsNode method virtualize.
@Override
public void virtualize(VirtualizerTool tool) {
ValueNode xAlias = tool.getAlias(getX());
ValueNode yAlias = tool.getAlias(getY());
VirtualObjectNode xVirtual = xAlias instanceof VirtualObjectNode ? (VirtualObjectNode) xAlias : null;
VirtualObjectNode yVirtual = yAlias instanceof VirtualObjectNode ? (VirtualObjectNode) yAlias : null;
if (xVirtual != null && yVirtual == null) {
virtualizeNonVirtualComparison(xVirtual, yAlias, tool);
} else if (xVirtual == null && yVirtual != null) {
virtualizeNonVirtualComparison(yVirtual, xAlias, tool);
} else if (xVirtual != null && yVirtual != null) {
if (xVirtual.hasIdentity() ^ yVirtual.hasIdentity()) {
/*
* One of the two objects has identity, the other doesn't. In code, this looks like
* "Integer.valueOf(a) == new Integer(b)", which is always false.
*
* In other words: an object created via valueOf can never be equal to one created
* by new in the same compilation unit.
*/
tool.replaceWithValue(LogicConstantNode.contradiction(graph()));
} else if (!xVirtual.hasIdentity() && !yVirtual.hasIdentity()) {
ResolvedJavaType type = xVirtual.type();
if (type.equals(yVirtual.type())) {
MetaAccessProvider metaAccess = tool.getMetaAccessProvider();
if (type.equals(metaAccess.lookupJavaType(Integer.class)) || type.equals(metaAccess.lookupJavaType(Long.class))) {
// both are virtual without identity: check contents
assert xVirtual.entryCount() == 1 && yVirtual.entryCount() == 1;
assert xVirtual.entryKind(0).getStackKind() == JavaKind.Int || xVirtual.entryKind(0) == JavaKind.Long;
IntegerEqualsNode equals = new IntegerEqualsNode(tool.getEntry(xVirtual, 0), tool.getEntry(yVirtual, 0));
tool.addNode(equals);
tool.replaceWithValue(equals);
}
}
} else {
// both are virtual with identity: check if they refer to the same object
tool.replaceWithValue(LogicConstantNode.forBoolean(xVirtual == yVirtual, graph()));
}
}
}
use of org.graalvm.compiler.nodes.virtual.VirtualObjectNode in project graal by oracle.
the class UnboxNode method virtualize.
@Override
public void virtualize(VirtualizerTool tool) {
ValueNode alias = tool.getAlias(getValue());
if (alias instanceof VirtualObjectNode) {
VirtualObjectNode virtual = (VirtualObjectNode) alias;
ResolvedJavaType objectType = virtual.type();
ResolvedJavaType expectedType = tool.getMetaAccessProvider().lookupJavaType(boxingKind.toBoxedJavaClass());
if (objectType.equals(expectedType)) {
tool.replaceWithValue(tool.getEntry(virtual, 0));
}
}
}
use of org.graalvm.compiler.nodes.virtual.VirtualObjectNode in project graal by oracle.
the class GraphUtil method virtualizeArrayCopy.
/**
* Virtualize an array copy.
*
* @param tool the virtualization tool
* @param source the source array
* @param sourceLength the length of the source array
* @param newLength the length of the new array
* @param from the start index in the source array
* @param newComponentType the component type of the new array
* @param elementKind the kind of the new array elements
* @param graph the node graph
* @param virtualArrayProvider a functional provider that returns a new virtual array given the
* component type and length
*/
public static void virtualizeArrayCopy(VirtualizerTool tool, ValueNode source, ValueNode sourceLength, ValueNode newLength, ValueNode from, ResolvedJavaType newComponentType, JavaKind elementKind, StructuredGraph graph, BiFunction<ResolvedJavaType, Integer, VirtualArrayNode> virtualArrayProvider) {
ValueNode sourceAlias = tool.getAlias(source);
ValueNode replacedSourceLength = tool.getAlias(sourceLength);
ValueNode replacedNewLength = tool.getAlias(newLength);
ValueNode replacedFrom = tool.getAlias(from);
if (!replacedNewLength.isConstant() || !replacedFrom.isConstant() || !replacedSourceLength.isConstant()) {
return;
}
assert newComponentType != null : "An array copy can be virtualized only if the real type of the resulting array is known statically.";
int fromInt = replacedFrom.asJavaConstant().asInt();
int newLengthInt = replacedNewLength.asJavaConstant().asInt();
int sourceLengthInt = replacedSourceLength.asJavaConstant().asInt();
if (sourceAlias instanceof VirtualObjectNode) {
VirtualObjectNode sourceVirtual = (VirtualObjectNode) sourceAlias;
assert sourceLengthInt == sourceVirtual.entryCount();
}
if (fromInt < 0 || newLengthInt < 0 || fromInt > sourceLengthInt) {
/* Illegal values for either from index, the new length or the source length. */
return;
}
if (newLengthInt >= tool.getMaximumEntryCount()) {
/* The new array size is higher than maximum allowed size of virtualized objects. */
return;
}
ValueNode[] newEntryState = new ValueNode[newLengthInt];
int readLength = Math.min(newLengthInt, sourceLengthInt - fromInt);
if (sourceAlias instanceof VirtualObjectNode) {
/* The source array is virtualized, just copy over the values. */
VirtualObjectNode sourceVirtual = (VirtualObjectNode) sourceAlias;
for (int i = 0; i < readLength; i++) {
newEntryState[i] = tool.getEntry(sourceVirtual, fromInt + i);
}
} else {
/* The source array is not virtualized, emit index loads. */
for (int i = 0; i < readLength; i++) {
LoadIndexedNode load = new LoadIndexedNode(null, sourceAlias, ConstantNode.forInt(i + fromInt, graph), elementKind);
tool.addNode(load);
newEntryState[i] = load;
}
}
if (readLength < newLengthInt) {
/* Pad the copy with the default value of its elment kind. */
ValueNode defaultValue = ConstantNode.defaultForKind(elementKind, graph);
for (int i = readLength; i < newLengthInt; i++) {
newEntryState[i] = defaultValue;
}
}
/* Perform the replacement. */
VirtualArrayNode newVirtualArray = virtualArrayProvider.apply(newComponentType, newLengthInt);
tool.createVirtualObject(newVirtualArray, newEntryState, Collections.<MonitorIdNode>emptyList(), false);
tool.replaceWithVirtual(newVirtualArray);
}
Aggregations