@Override protected ValueNode cloneAsFieldAccess(Assumptions assumptions, ResolvedJavaField field, boolean volatileAccess) { return new StoreFieldNode(object(), field, value(), stateAfter(), volatileAccess); }
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()); graph.replaceFixedWithFixed(storeField, memoryWrite); if (storeField.isVolatile()) { MembarNode preMembar = graph.add(new MembarNode(JMM_PRE_VOLATILE_WRITE)); graph.addBeforeFixed(memoryWrite, preMembar); MembarNode postMembar = graph.add(new MembarNode(JMM_POST_VOLATILE_WRITE)); graph.addAfterFixed(memoryWrite, postMembar); } }
protected void genStoreField(ValueNode receiver, ResolvedJavaField field, ValueNode value) { StoreFieldNode storeFieldNode = new StoreFieldNode(receiver, field, maskSubWordValue(value, field.getJavaKind())); append(storeFieldNode); storeFieldNode.setStateAfter(this.createFrameState(stream.nextBCI(), storeFieldNode)); }
private boolean processStoreField(StoreFieldNode store, PEReadEliminationBlockState state, GraphEffectList effects) { if (store.isVolatile()) { state.killReadCache(); return false; } JavaKind kind = store.field().getJavaKind(); return processStore(store, store.object(), new FieldLocationIdentity(store.field()), -1, kind, false, store.value(), state, effects); }
@Override public void virtualize(VirtualizerTool tool) { ValueNode alias = tool.getAlias(object()); if (alias instanceof VirtualObjectNode) { VirtualInstanceNode virtual = (VirtualInstanceNode) alias; int fieldIndex = virtual.fieldIndex(field()); if (fieldIndex != -1) { tool.setVirtualEntry(virtual, fieldIndex, value()); tool.delete(); } } }
StoreFieldNode storeFieldNode = (StoreFieldNode) node; PEAppendGraphBuilderContext graphBuilderContext = new PEAppendGraphBuilderContext(methodScope, storeFieldNode); ResolvedJavaField field = storeFieldNode.field(); if (storeFieldNode.isStatic()) { ValueNode value = storeFieldNode.value(); for (NodePlugin nodePlugin : nodePlugins) { if (nodePlugin.handleStoreStaticField(graphBuilderContext, field, value)) { ValueNode object = storeFieldNode.object(); ValueNode value = storeFieldNode.value(); for (NodePlugin nodePlugin : nodePlugins) { if (nodePlugin.handleStoreField(graphBuilderContext, object, field, value)) {
ResolvedJavaField resolvedTarget = lookup(fieldStore.field()); b.add(new StoreFieldNode(lookup(b, methodHandleArguments, fieldStore.object()), resolvedTarget, lookup(b, methodHandleArguments, fieldStore.value())));
public StoreFieldTypeFlow(StoreFieldNode node) { super(node, null); this.field = (AnalysisField) node.field(); }
assert node instanceof StoreFieldNode; StoreFieldNode store = (StoreFieldNode) node; ValueNode value = getScalarAlias(store.value()); if (GraphUtil.unproxify(value) == GraphUtil.unproxify(cachedValue)) { effects.deleteNode(store);
@Override public NodeCycles estimatedNodeCycles() { if (isVolatile()) { return CYCLES_8; } return super.estimatedNodeCycles(); } }
AnalysisField field = (AnalysisField) node.field(); assert field.isWritten(); if (node.value().getStackKind() == JavaKind.Object) { TypeFlowBuilder<?> valueBuilder = state.lookup(node.value()); if (node.isStatic()) { storeFieldBuilder = TypeFlowBuilder.create(bb, node, StoreFieldTypeFlow.class, () -> { FieldTypeFlow fieldFlow = field.getStaticFieldFlow(); storeFieldBuilder.addUseDependency(valueBuilder); } else { TypeFlowBuilder<?> objectBuilder = state.lookup(node.object()); storeFieldBuilder = TypeFlowBuilder.create(bb, node, StoreFieldTypeFlow.class, () -> { StoreInstanceFieldTypeFlow storeFieldFlow = new StoreInstanceFieldTypeFlow(node, valueBuilder.get(), objectBuilder.get());
@Override protected void run(StructuredGraph graph) { for (Node n : graph.getNodes()) { if (n instanceof StoreFieldNode) { StoreFieldNode node = (StoreFieldNode) n; SharedField field = (SharedField) node.field(); if (!field.isAccessed()) { graph.getDebug().log("Remove StoreFieldNode %s to unused field %s", node, field); graph.removeFixed(node); } } } } }
offsetField = valueNodeStoreFieldUsages.first().field(); } else if (valueNodeSignExtendUsages.count() == 1) { SignExtendNode signExtendNode = valueNodeSignExtendUsages.first(); NodeIterable<StoreFieldNode> signExtendFieldStoreUsages = signExtendNode.usages().filter(StoreFieldNode.class); if (signExtendFieldStoreUsages.count() == 1) { offsetField = signExtendFieldStoreUsages.first().field();
ValueNode converted = doImplicitCast(graphKit, valueKind, fieldKind, unboxed); graphKit.append(new StoreFieldNode(receiver, targetField, converted)); graphKit.createReturn(null, JavaKind.Void); graphKit.append(new StoreFieldNode(receiver, targetField, value)); graphKit.createReturn(null, JavaKind.Void); } else { value = doImplicitCast(graphKit, kind, fieldKind, value); graphKit.append(new StoreFieldNode(receiver, targetField, value)); graphKit.createReturn(null, JavaKind.Void);
AnalysisField field = (AnalysisField) node.field(); field.registerAsWritten(methodFlow);
LoadFieldNode load = newGraph.add(LoadFieldNode.create(newGraph.getAssumptions(), param, field)); newGraph.addBeforeFixed(returnNode, load); newGraph.addBeforeFixed(returnNode, newGraph.add(new StoreFieldNode(newInstance, field, load)));