protected override void ResetValueTypeInstanceAnalysisData(IOperation operation)
{
if (AnalysisEntityFactory.TryCreate(operation, out AnalysisEntity analysisEntity))
{
ResetValueTypeInstanceAnalysisData(analysisEntity);
}
}
/// <summary>
/// Transfers the analysis data rooted from <paramref name="assignedValueOperation"/> to <paramref name="targetAnalysisEntity"/>, for a value type assignment operation.
/// This involves transfer of data for of all <see cref="AnalysisEntity"/> instances that share the same <see cref="AnalysisEntity.InstanceLocation"/> as the valueAnalysisEntity for the <paramref name="assignedValueOperation"/>
/// to all <see cref="AnalysisEntity"/> instances that share the same <see cref="AnalysisEntity.InstanceLocation"/> as <paramref name="targetAnalysisEntity"/>.
/// </summary>
private void TransferValueTypeInstanceAnalysisDataForAssignment(AnalysisEntity targetAnalysisEntity, IOperation assignedValueOperation)
{
Debug.Assert(HasPointsToAnalysisResult);
Debug.Assert(targetAnalysisEntity.Type.HasValueCopySemantics());
IEnumerable <AnalysisEntity> dependentAnalysisEntities;
if (AnalysisEntityFactory.TryCreate(assignedValueOperation, out AnalysisEntity valueAnalysisEntity))
{
dependentAnalysisEntities = GetChildAnalysisEntities(valueAnalysisEntity);
}
else
{
// For allocations.
PointsToAbstractValue newValueLocation = GetPointsToAbstractValue(assignedValueOperation);
if (newValueLocation.Kind == PointsToAbstractValueKind.NoLocation)
{
return;
}
dependentAnalysisEntities = GetChildAnalysisEntities(newValueLocation);
}
foreach (AnalysisEntity dependentInstance in dependentAnalysisEntities)
{
// Clone the dependent instance but with with target as the root.
AnalysisEntity newAnalysisEntity = AnalysisEntityFactory.CreateWithNewInstanceRoot(dependentInstance, targetAnalysisEntity);
var dependentValue = GetAbstractValue(dependentInstance);
SetAbstractValue(newAnalysisEntity, dependentValue);
}
}
protected override void SetAbstractValueForElementInitializer(IOperation instance, ImmutableArray <AbstractIndex> indices, ITypeSymbol elementType, IOperation initializer, TAbstractAnalysisValue value)
{
if (AnalysisEntityFactory.TryCreateForElementInitializer(instance, indices, elementType, out AnalysisEntity analysisEntity))
{
SetAbstractValueForAssignment(analysisEntity, initializer, value);
}
}
protected override void SetAbstractValueForAssignment(IOperation target, IOperation assignedValueOperation, TAbstractAnalysisValue assignedValue)
{
if (AnalysisEntityFactory.TryCreate(target, out AnalysisEntity targetAnalysisEntity))
{
SetAbstractValueForAssignment(targetAnalysisEntity, assignedValueOperation, assignedValue);
}
}
protected override void SetAbstractValueForSymbolDeclaration(ISymbol symbol, IOperation initializer, TAbstractAnalysisValue initializerValue)
{
if (AnalysisEntityFactory.TryCreateForSymbolDeclaration(symbol, out AnalysisEntity analysisEntity))
{
SetAbstractValueForAssignment(analysisEntity, initializer, initializerValue);
}
}
protected DataFlowOperationVisitor(
AbstractValueDomain <TAbstractAnalysisValue> valueDomain,
ISymbol owningSymbol,
bool pessimisticAnalysis,
DataFlowAnalysisResult <NullBlockAnalysisResult, NullAbstractValue> nullAnalysisResultOpt,
DataFlowAnalysisResult <PointsToBlockAnalysisResult, PointsToAbstractValue> pointsToAnalysisResultOpt)
{
Debug.Assert(owningSymbol != null);
Debug.Assert(owningSymbol.Kind == SymbolKind.Method ||
owningSymbol.Kind == SymbolKind.Field ||
owningSymbol.Kind == SymbolKind.Property ||
owningSymbol.Kind == SymbolKind.Event);
ValueDomain = valueDomain;
OwningSymbol = owningSymbol;
PessimisticAnalysis = pessimisticAnalysis;
_nullAnalysisResultOpt = nullAnalysisResultOpt;
_pointsToAnalysisResultOpt = pointsToAnalysisResultOpt;
_valueCacheBuilder = ImmutableDictionary.CreateBuilder <IOperation, TAbstractAnalysisValue>();
_pendingArgumentsToReset = new List <IArgumentOperation>();
ThisOrMePointsToAbstractValue = GetThisOrMeInstancePointsToValue(owningSymbol.ContainingType);
AnalysisEntityFactory = new AnalysisEntityFactory(
(pointsToAnalysisResultOpt != null || IsPointsToAnalysis) ?
GetPointsToAbstractValue :
(Func <IOperation, PointsToAbstractValue>)null,
owningSymbol.ContainingType);
}
protected override TAbstractAnalysisValue VisitAssignmentOperation(IAssignmentOperation operation, object argument)
{
var value = base.VisitAssignmentOperation(operation, argument);
if (AnalysisEntityFactory.TryCreate(operation.Target, out AnalysisEntity targetEntity))
{
value = GetAbstractValue(targetEntity);
}
return(value);
}
protected AnalysisEntityDataFlowOperationVisitor(
AbstractValueDomain <TAbstractAnalysisValue> valueDomain,
INamedTypeSymbol containingTypeSymbol,
DataFlowAnalysisResult <NullBlockAnalysisResult, NullAbstractValue> nullAnalysisResultOpt,
DataFlowAnalysisResult <PointsToBlockAnalysisResult, PointsToAbstractValue> pointsToAnalysisResultOpt)
: base(valueDomain, containingTypeSymbol, nullAnalysisResultOpt, pointsToAnalysisResultOpt)
{
AnalysisEntityFactory = new AnalysisEntityFactory(
(pointsToAnalysisResultOpt != null || IsPointsToAnalysis) ?
GetPointsToAbstractValue :
(Func <IOperation, PointsToAbstractValue>)null,
containingTypeSymbol);
}
protected sealed override TAbstractAnalysisValue ComputeAnalysisValueForOutArgument(IArgumentOperation operation, TAbstractAnalysisValue defaultValue)
{
if (AnalysisEntityFactory.TryCreate(operation, out AnalysisEntity analysisEntity))
{
var value = ComputeAnalysisValueForOutArgument(analysisEntity, operation, defaultValue);
SetAbstractValue(analysisEntity, value);
return(GetAbstractValue(analysisEntity));
}
else
{
return(defaultValue);
}
}
protected override TAbstractAnalysisValue ComputeAnalysisValueForReferenceOperation(IOperation operation, TAbstractAnalysisValue defaultValue)
{
if (AnalysisEntityFactory.TryCreate(operation, out AnalysisEntity analysisEntity))
{
if (!HasAbstractValue(analysisEntity))
{
SetAbstractValue(analysisEntity, defaultValue);
}
return(GetAbstractValue(analysisEntity));
}
else
{
return(defaultValue);
}
}
protected DataFlowOperationVisitor(
AbstractDomain <TAbstractAnalysisValue> valueDomain,
INamedTypeSymbol containingTypeSymbol,
DataFlowAnalysisResult <NullBlockAnalysisResult, NullAbstractValue> nullAnalysisResultOpt,
DataFlowAnalysisResult <PointsToBlockAnalysisResult, PointsToAbstractValue> pointsToAnalysisResultOpt)
{
ValueDomain = valueDomain;
_nullAnalysisResultOpt = nullAnalysisResultOpt;
_pointsToAnalysisResultOpt = pointsToAnalysisResultOpt;
_valueCacheBuilder = ImmutableDictionary.CreateBuilder <IOperation, TAbstractAnalysisValue>();
_pendingArgumentsToReset = new List <IArgumentOperation>();
ThisOrMePointsToAbstractValue = GetThisOrMeInstancePointsToValue(containingTypeSymbol);
AnalysisEntityFactory = new AnalysisEntityFactory(
HasPointsToAnalysisResult ? GetPointsToAbstractValue : (Func <IOperation, PointsToAbstractValue>)null,
containingTypeSymbol);
}
public void OnEntry(BasicBlock entryBlock, TAnalysisData input)
{
CurrentBasicBlock = entryBlock;
CurrentAnalysisData = input;
if (_lazyParameterEntities == null &&
OwningSymbol is IMethodSymbol method &&
method.Parameters.Length > 0)
{
var builder = ImmutableDictionary.CreateBuilder <IParameterSymbol, AnalysisEntity>();
foreach (var parameter in method.Parameters)
{
var result = AnalysisEntityFactory.TryCreateForSymbolDeclaration(parameter, out AnalysisEntity analysisEntity);
Debug.Assert(result);
builder.Add(parameter, analysisEntity);
SetValueForParameterOnEntry(parameter, analysisEntity);
}
_lazyParameterEntities = builder.ToImmutable();
}
}