/** Return the state of the receiver object. */ public TypeState getObjectState() { return objectFlow.getState(); }
/** Return the state of the receiver object. */ public TypeState getObjectState() { return objectFlow.getState(); }
public TypeState getObjectState() { return objectFlow.getState(); }
@Override public TypeState getState() { return input.getState(); }
/** Return the state of the receiver object. */ public TypeState getObjectState() { return objectFlow.getState(); }
public TypeState getAllSynchronizedTypeState() { return allSynchronizedTypeFlow.getState(); }
@Override public boolean closeToAllInstantiated(BigBang bb) { if (typesCount > 200 && bb != null) { MultiTypeState allInstState = (MultiTypeState) bb.getAllInstantiatedTypeFlow().getState(); return typesCount * 100L / allInstState.typesCount > 75; } return false; }
public boolean isCloseToAllInstantiated(BigBang bb) { return this.getState().closeToAllInstantiated(bb); }
@Override public void print() { System.out.format("%5d %5d %5d |", numParsedGraphs.get(), getAllInstantiatedTypeFlow().getState().typesCount(), universe.getNextTypeId()); super.print(); System.out.println(); } }
@Override public boolean addUse(BigBang bb, TypeFlow<?> use) { assert use != null; // propagate input state to use if (doAddUse(bb, use, false)) { use.addState(bb, input.getState()); return true; } return false; }
private boolean addUse(BigBang bb, TypeFlow<?> use, boolean propagateTypeState, boolean registerInput) { if (doAddUse(bb, use, registerInput)) { if (propagateTypeState) { use.addState(bb, getState()); } return true; } return false; }
private static void updateFlow(BigBang bb, TypeFlow<?> flow, TypeState newState, List<TypeFlow<?>> changedFlows) { if (!flow.getState().equals(newState)) { flow.setState(bb, newState); if (changedFlows != null && (flow.getUses().size() > 0 || flow.getObservers().size() > 0)) { changedFlows.add(flow); } } }
@Override public String toString() { return "TypeFlow<" + (source instanceof Node ? ((StructuredGraph) ((Node) source).graph()).method().format("%h.%n@") : "") + source + ": " + getState() + ">"; }
@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); }
public void update(BigBang bb) { TypeState curState = getState(); for (TypeFlow<?> use : getUses()) { use.addState(bb, curState); } notifyObservers(bb); }
@Override public void onObservedUpdate(BigBang bb) { /* Only a clone should be updated */ assert this.isClone(); /* The state of the new type provider has changed. */ TypeState newTypeState = newTypeFlow.getState(); TypeState currentTypeState = getState(); /* Generate a heap object for every new incoming type. */ TypeState resultState = newTypeState.typesStream() .filter(t -> !currentTypeState.containsType(t)) .map(type -> TypeState.forAllocation(bb, source, allocationSite, type, allocationContext)) .reduce(TypeState.forEmpty(), (s1, s2) -> TypeState.forUnion(bb, s1, s2)); assert !resultState.canBeNull(); addState(bb, resultState); }
@Override public void onObservedUpdate(BigBang bb) { /* When the all-instantiated changes it will notify the source flow. */ if (bb.getAllInstantiatedTypeFlow().getState().containsType(sourceState.exactType())) { /* The source state type was instantiated. */ /* Now the source flow can be removed from the all-instantiated observers. */ bb.getAllInstantiatedTypeFlow().removeObserver(this); /* Update the state and propagate it to uses. */ addState(bb, sourceState); } }
@Override public void onObservedUpdate(BigBang bb) { /* Only a clone should be updated */ assert this.isClone(); TypeState objectState = objectFlow.getState(); if (objectState.isUnknown()) { bb.reportIllegalUnknownUse(graphRef.getMethod(), source, "Illegal: Unsafe store into UnknownTypeState objects. Store: " + source); return; } /* Iterate over the receiver objects. */ for (AnalysisObject object : objectState.objects()) { AnalysisType objectType = object.type(); assert !objectType.isArray(); handleUnsafeAccessedFields(bb, objectType.unsafeAccessedFields(partitionKind), object); } }
@Override public void initClone(BigBang bb) { /* When the clone is linked check if the all-instantiated contains the source state type. */ if (sourceState.isNull() || sourceState.isEmpty() || bb.getAllInstantiatedTypeFlow().getState().containsType(sourceState.exactType())) { /* If yes, set the state and propagate it to uses. */ addState(bb, sourceState); } else { /* * If no, update the can-be-null state of the source flow and register it as an observer * for all-instantiated. */ addState(bb, sourceState.canBeNull() ? TypeState.forNull() : TypeState.forEmpty()); bb.getAllInstantiatedTypeFlow().addObserver(bb, this); } }
@Override public void forNonNullArrayElement(JavaConstant array, AnalysisType arrayType, JavaConstant elementConstant, AnalysisType elementType, int elementIndex) { assert elementType.isInstantiated(); /* * *ALL* constants are scanned after each analysis iteration, thus the elementType will * eventually be added to the AllInstantiatedTypeFlow and the array elements flow will * eventually be updated. */ if (bb.getAllInstantiatedTypeFlow().getState().containsType(elementType)) { ArrayElementsTypeFlow arrayObjElementsFlow = getArrayElementsFlow(array, arrayType); AnalysisObject constantObject = bb.analysisPolicy().createConstantObject(bb, elementConstant, elementType); if (!arrayObjElementsFlow.getState().isUnknown() && !arrayObjElementsFlow.getState().containsObject(constantObject)) { /* Add the constant element to the constant's array type flow. */ TypeState elementTypeState = TypeState.forNonNullObject(bb, constantObject); arrayObjElementsFlow.addState(bb, elementTypeState); } } }