@Override public void update(BigBang bb) { // propagate input state to uses TypeState curState = input.getState(); for (TypeFlow<?> use : getUses()) { use.addState(bb, curState); } notifyObservers(bb); }
protected InvokeTypeFlow(BigBang bb, MethodFlowsGraph methodFlows, InvokeTypeFlow original) { super(original, methodFlows); this.originalInvoke = original; this.location = original.location; this.invoke = original.invoke; actualReturn = original.getActualReturn() != null ? (ActualReturnTypeFlow) methodFlows.lookupCloneOf(bb, original.getActualReturn()) : null; actualParameters = new TypeFlow<?>[original.actualParameters.length]; for (int i = 0; i < original.actualParameters.length; i++) { if (original.getActualParameter(i) != null) { actualParameters[i] = methodFlows.lookupCloneOf(bb, original.getActualParameter(i)); } } }
@Override public void update(BigBang bb) { TypeState curState = getState(); for (TypeFlow<?> use : getUses()) { assert use instanceof FormalReceiverTypeFlow; ((FormalReceiverTypeFlow) use).addReceiverState(bb, curState); } }
@Override public void initClone(BigBang bb) { assert this.isClone(); this.newTypeFlow.addObserver(bb, this); }
@Override public void onObservedUpdate(BigBang bb) { /* * The field type state has changed. Since the type states can only increase, the new filter * will be more coarse, i.e., will let more objects go through. Push the unsafe writes, * collected in the sink, through the new filter. */ addState(bb, unsafeSink.getState()); }
@Override public void update(BigBang bb) { assert checkUsages(); super.update(bb); }
public ArrayCopyTypeFlow(BigBang bb, ArrayCopyTypeFlow original, MethodFlowsGraph methodFlows) { super(original, methodFlows); this.srcArrayFlow = methodFlows.lookupCloneOf(bb, original.srcArrayFlow); this.dstArrayFlow = methodFlows.lookupCloneOf(bb, original.dstArrayFlow); }
@Override public String toString() { return "LoadInstanceFieldTypeFlow<" + getState() + ">"; } }