29 import org.graalvm.compiler.core.common.type.StampFactory;
  30 import org.graalvm.compiler.graph.Node;
  31 import org.graalvm.compiler.graph.NodeClass;
  32 import org.graalvm.compiler.nodeinfo.InputType;
  33 import org.graalvm.compiler.nodeinfo.NodeInfo;
  34 import org.graalvm.compiler.nodes.FrameState;
  35 import org.graalvm.compiler.nodes.StateSplit;
  36 import org.graalvm.compiler.nodes.ValueNode;
  37 import org.graalvm.compiler.nodes.ValueNodeUtil;
  38 import org.graalvm.compiler.nodes.extended.GuardingNode;
  39 import org.graalvm.compiler.nodes.memory.address.AddressNode;
  40 
  41 @NodeInfo(allowedUsageTypes = {InputType.Memory, InputType.Guard}, cycles = CYCLES_3, size = SIZE_1)
  42 public abstract class AbstractWriteNode extends FixedAccessNode implements StateSplit, MemoryCheckpoint.Single, MemoryAccess, GuardingNode {
  43 
  44     public static final NodeClass<AbstractWriteNode> TYPE = NodeClass.create(AbstractWriteNode.class);
  45     @Input ValueNode value;
  46     @OptionalInput(InputType.State) FrameState stateAfter;
  47     @OptionalInput(InputType.Memory) Node lastLocationAccess;
  48 
  49     protected final boolean initialization;
  50 
  51     @Override
  52     public FrameState stateAfter() {
  53         return stateAfter;
  54     }
  55 
  56     @Override
  57     public void setStateAfter(FrameState x) {
  58         assert x == null || x.isAlive() : "frame state must be in a graph";
  59         updateUsages(stateAfter, x);
  60         stateAfter = x;
  61     }
  62 
  63     @Override
  64     public boolean hasSideEffect() {
  65         return true;
  66     }
  67 
  68     public ValueNode value() {
  69         return value;
  70     }
  71 
  72     /**
  73      * Returns whether this write is the initialization of the written location. If it is true, the
  74      * old value of the memory location is either uninitialized or zero. If it is false, the memory
  75      * location is guaranteed to contain a valid value or zero.
  76      */
  77     public boolean isInitialization() {
  78         return initialization;
  79     }
  80 
  81     protected AbstractWriteNode(NodeClass<? extends AbstractWriteNode> c, AddressNode address, LocationIdentity location, ValueNode value, BarrierType barrierType) {
  82         this(c, address, location, value, barrierType, false);
  83     }
  84 
  85     protected AbstractWriteNode(NodeClass<? extends AbstractWriteNode> c, AddressNode address, LocationIdentity location, ValueNode value, BarrierType barrierType, boolean initialization) {
  86         super(c, address, location, StampFactory.forVoid(), barrierType);
  87         this.value = value;
  88         this.initialization = initialization;
  89     }
  90 
  91     protected AbstractWriteNode(NodeClass<? extends AbstractWriteNode> c, AddressNode address, LocationIdentity location, ValueNode value, BarrierType barrierType, GuardingNode guard,
  92                     boolean initialization) {
  93         super(c, address, location, StampFactory.forVoid(), guard, barrierType, false, null);
  94         this.value = value;
  95         this.initialization = initialization;
  96     }
  97 
  98     @Override
  99     public boolean isAllowedUsageType(InputType type) {
 100         return (type == InputType.Guard && getNullCheck()) ? true : super.isAllowedUsageType(type);
 101     }
 102 
 103     @Override
 104     public MemoryNode getLastLocationAccess() {
 105         return (MemoryNode) lastLocationAccess;
 106     }
 107 
 108     @Override
 109     public void setLastLocationAccess(MemoryNode lla) {
 110         Node newLla = ValueNodeUtil.asNode(lla);
 111         updateUsages(lastLocationAccess, newLla);
 112         lastLocationAccess = newLla;
 113     }
 114 }

  29 import org.graalvm.compiler.core.common.type.StampFactory;
  30 import org.graalvm.compiler.graph.Node;
  31 import org.graalvm.compiler.graph.NodeClass;
  32 import org.graalvm.compiler.nodeinfo.InputType;
  33 import org.graalvm.compiler.nodeinfo.NodeInfo;
  34 import org.graalvm.compiler.nodes.FrameState;
  35 import org.graalvm.compiler.nodes.StateSplit;
  36 import org.graalvm.compiler.nodes.ValueNode;
  37 import org.graalvm.compiler.nodes.ValueNodeUtil;
  38 import org.graalvm.compiler.nodes.extended.GuardingNode;
  39 import org.graalvm.compiler.nodes.memory.address.AddressNode;
  40 
  41 @NodeInfo(allowedUsageTypes = {InputType.Memory, InputType.Guard}, cycles = CYCLES_3, size = SIZE_1)
  42 public abstract class AbstractWriteNode extends FixedAccessNode implements StateSplit, MemoryCheckpoint.Single, MemoryAccess, GuardingNode {
  43 
  44     public static final NodeClass<AbstractWriteNode> TYPE = NodeClass.create(AbstractWriteNode.class);
  45     @Input ValueNode value;
  46     @OptionalInput(InputType.State) FrameState stateAfter;
  47     @OptionalInput(InputType.Memory) Node lastLocationAccess;
  48 


  49     @Override
  50     public FrameState stateAfter() {
  51         return stateAfter;
  52     }
  53 
  54     @Override
  55     public void setStateAfter(FrameState x) {
  56         assert x == null || x.isAlive() : "frame state must be in a graph";
  57         updateUsages(stateAfter, x);
  58         stateAfter = x;
  59     }
  60 
  61     @Override
  62     public boolean hasSideEffect() {
  63         return true;
  64     }
  65 
  66     public ValueNode value() {
  67         return value;
  68     }
  69 









  70     protected AbstractWriteNode(NodeClass<? extends AbstractWriteNode> c, AddressNode address, LocationIdentity location, ValueNode value, BarrierType barrierType) {




  71         super(c, address, location, StampFactory.forVoid(), barrierType);
  72         this.value = value;








  73     }
  74 
  75     @Override
  76     public boolean isAllowedUsageType(InputType type) {
  77         return (type == InputType.Guard && getNullCheck()) ? true : super.isAllowedUsageType(type);
  78     }
  79 
  80     @Override
  81     public MemoryNode getLastLocationAccess() {
  82         return (MemoryNode) lastLocationAccess;
  83     }
  84 
  85     @Override
  86     public void setLastLocationAccess(MemoryNode lla) {
  87         Node newLla = ValueNodeUtil.asNode(lla);
  88         updateUsages(lastLocationAccess, newLla);
  89         lastLocationAccess = newLla;
  90     }
  91 }