protected override Entity InternalResolve <TNode>(
GraphStructuredProgram <TNode> program,
ResolvedMethod <TNode> sourceMethod,
Reference reference)
{
var classMethodReference = (ClassMethodReference)reference;
var resolvedOwner = Resolve(program, sourceMethod, classMethodReference.Owner);
if (resolvedOwner is ResolvedClassId owningClassId)
{
var owner = program.FindClassById(owningClassId);
var method = program.GetOrCreateMethod(owner, classMethodReference.Name);
var methodId = program.GetOrCreateMethodId(classMethodReference.Name);
var resolvedReference = new ResolvedClassMethodReference <TNode>(owningClassId, methodId);
resolvedReference.Method = method;
return(resolvedReference);
}
if (resolvedOwner is SecondaryEntity owningEntity)
{
var methodId = program.GetOrCreateMethodId(classMethodReference.Name);
var resolvedReference = new ResolvedObjectMethodReference <TNode>(owningEntity, methodId);
resolvedReference.FindClassMethod = program.FindMethodById;
sourceMethod.StoreAdditionalVariable(resolvedReference);
return(resolvedReference);
}
return(null);
}
private Dictionary <SecondaryEntity, ParameterIndex> AddIntermediateEdgesIfNeeded(
GraphStructuredProgram <TNode> targetProgram,
Dictionary <Entity, ParameterIndex> passedParameters,
TNode currentSource,
Func <TNode> nodeCreator,
Func <SecondaryEntity> variableCreator,
out TNode newSource)
{
var processedParameters = passedParameters.ToDictionary(
pair =>
{
if (!(pair.Key is ResolvedLocalVariable))
{
var newTarget = nodeCreator();
var newVariable = variableCreator();
var statement = new ResolvedAssignmentStatement(null, pair.Key, newVariable);
var edge = new OperationEdge <TNode>(currentSource, statement, newTarget);
targetProgram.AddEdge(edge);
currentSource = newTarget;
return(newVariable);
}
return((SecondaryEntity)pair.Key);
},
pair => pair.Value);
newSource = currentSource;
return(processedParameters);
}
protected abstract bool Step(
GraphStructuredProgram <TNode> targetProgram,
ResolvedMethod <TNode> targetMethod,
TNode source,
Statement statement,
TNode target,
Func <TNode> nodeCreator);
protected override bool Step(
GraphStructuredProgram <TNode> targetProgram,
ResolvedMethod <TNode> targetMethod,
TNode source,
Statement statement,
TNode target,
Func <TNode> nodeCreator)
{
if (statement is AssignmentStatement assignment)
{
var sourceEntity = ReferenceResolver.Resolve(targetProgram, targetMethod, assignment.Source);
var targetEntity = ReferenceResolver.Resolve(targetProgram, targetMethod, assignment.Target);
var targetSecondaryEntity = targetEntity as SecondaryEntity;
Trace.Assert(targetSecondaryEntity != null);
var referencedByThis =
assignment.Target is ClassFieldReference classFieldReference &&
classFieldReference.Owner is ClassReference classReference &&
classReference.ThisClassReference;
var newStatement = new ResolvedAssignmentStatement(
assignment.Location, sourceEntity, targetSecondaryEntity, referencedByThis);
targetProgram.AddEdge(new OperationEdge <TNode>(source, newStatement, target));
return(false);
}
return(true);
}
public static Entity Resolve <TNode>(
GraphStructuredProgram <TNode> program,
ResolvedMethod <TNode> method,
Reference reference)
{
if (reference == null)
{
Console.Error.WriteLine("Null reference");
return(null);
}
var type = reference.GetType();
if (!Resolvers.ContainsKey(type))
{
Console.Error.WriteLine($"Cannot find resolver for reference type {type}");
}
var resolved = Resolvers[type].InternalResolve(program, method, reference);
if (resolved == null)
{
Console.Error.WriteLine($"Reference of type {type} has been resolved as null");
}
return(resolved);
}
protected override InternalStatement RestoreImplementation <TNode>(
GraphStructuredProgram <TNode> program,
ResolvedMethod <TNode> owner,
InternalStatement statement)
{
var invocation = (ResolvedInvocationStatement <TNode>)statement;
var restoredEntity = EntitiesRestorer.Restore(program, owner, invocation.TargetEntity);
var restoredPassedParameters =
invocation.PassedParameters.ToDictionary(
pair => (SecondaryEntity)EntitiesRestorer.Restore(program, owner, pair.Key),
pair => pair.Value);
var restoredReturnedValues =
invocation.ReturnedValues.ToDictionary(
pair => pair.Key,
pair => (SecondaryEntity)EntitiesRestorer.Restore(program, owner, pair.Value));
return(new ResolvedInvocationStatement <TNode>(
invocation,
restoredEntity,
invocation.TargetMethodId,
restoredPassedParameters,
restoredReturnedValues));
}
protected override Entity InternalResolve <TNode>(
GraphStructuredProgram <TNode> program,
ResolvedMethod <TNode> method,
Reference reference)
{
var property = (ClassPropertyReference)reference;
return(Resolve(program, method, new ClassFieldReference(property.Owner, property.Name)));
}
protected override Entity InternalResolve <TNode>(
GraphStructuredProgram <TNode> program,
ResolvedMethod <TNode> method,
Reference reference)
{
var real = (ClassReference)reference;
return(program.GetOrCreateClass(real.ClassId).Id);
}
protected override bool Step(
GraphStructuredProgram <TNode> targetProgram,
ResolvedMethod <TNode> targetMethod,
TNode source, Statement statement, TNode target,
Func <TNode> nodeCreator)
{
targetProgram.AddOperation(source, new Operation <TNode>(statement, target));
return(true);
}
protected override Entity RestoreImplementation <TNode>(
GraphStructuredProgram <TNode> program,
ResolvedMethod <TNode> method,
Entity entity)
{
var localFunctionReference = (ResolvedLocalFunctionReference <TNode>)entity;
method.Methods.TryGetValue(localFunctionReference.MethodId, out var restored);
localFunctionReference.Method = restored;
return(localFunctionReference);
}
protected override Entity RestoreImplementation <TNode>(
GraphStructuredProgram <TNode> program,
ResolvedMethod <TNode> method,
Entity entity)
{
var classField = (ResolvedClassField)entity;
var clazz = program.FindClassById(classField.ClassId);
return(clazz.GetOrCreateField(classField.VariableId));
}
protected override Entity RestoreImplementation <TNode>(
GraphStructuredProgram <TNode> program,
ResolvedMethod <TNode> method,
Entity entity)
{
var classMethodReference = (ResolvedClassMethodReference <TNode>)entity;
classMethodReference.Method =
program.FindMethodById(classMethodReference.OwnerId, classMethodReference.MethodId);
return(classMethodReference);
}
protected PdvmBasedAnalysis(
GraphStructuredProgram <int> program,
IContextProcessor <TState, TStackSymbol, Node, OperationEdge <Node>,
TContext, GssNode <TStackSymbol, TGssData> > contextProcessor,
Func <PDVM <TState, TStackSymbol, Node, OperationEdge <Node>, TContext, TGssData> > pdvmProvider)
: base(program)
{
InternalCacheProvider = new CacheProvider <TState, TStackSymbol, TContext, GssNode <TStackSymbol, TGssData> >();
InternalTransitionProvider = new TransitionProvider(program);
InternalSimulation = new PDVMSimulation <TState, TStackSymbol, int, OperationEdge <int>, TContext, TGssData>(
contextProcessor, InternalCacheProvider, InternalTransitionProvider, pdvmProvider);
}
public static Entity Restore <TNode>(
GraphStructuredProgram <TNode> program,
ResolvedMethod <TNode> method,
Entity entity)
{
var exists = RegisteredRestorers.TryGetValue(entity.GetType(), out var restorer);
if (exists)
{
return(restorer.RestoreImplementation(program, method, entity));
}
return(entity);
}
public static InternalStatement Restore <TNode>(
GraphStructuredProgram <TNode> program,
ResolvedMethod <TNode> method,
InternalStatement statement)
{
var exists = RegisteredRestorers.TryGetValue(statement.InternalType, out var restorer);
if (exists)
{
return(restorer.RestoreImplementation(program, method, statement));
}
return(statement);
}
protected override Entity RestoreImplementation <TNode>(
GraphStructuredProgram <TNode> program,
ResolvedMethod <TNode> method,
Entity entity)
{
var objectMethodReference = (ResolvedObjectMethodReference <TNode>)entity;
var restoredOwner = (SecondaryEntity)Restore(program, method, objectMethodReference.OwningObject);
var restored = new ResolvedObjectMethodReference <TNode>(restoredOwner, objectMethodReference.MethodId)
{
FindClassMethod = program.FindMethodById
};
method.StoreAdditionalVariable(restored);
return(restored);
}
protected override Entity InternalResolve <TNode>(
GraphStructuredProgram <TNode> program,
ResolvedMethod <TNode> sourceMethod,
Reference reference)
{
var localFunctionReference = (LocalFunctionReference)reference;
var methodId = program.GetOrCreateMethodId(localFunctionReference.MethodId.Value);
var method = sourceMethod.Methods[methodId];
var resolvedReference = new ResolvedLocalFunctionReference <TNode>(methodId)
{
Method = method
};
return(resolvedReference);
}
protected override InternalStatement RestoreImplementation <TNode>(
GraphStructuredProgram <TNode> program,
ResolvedMethod <TNode> method,
InternalStatement statement)
{
var assignment = (ResolvedAssignmentStatement)statement;
var source = EntitiesRestorer.Restore(program, method, assignment.Source);
Trace.Assert(assignment.Target != null);
var target = assignment.Target == null ? null : EntitiesRestorer.Restore(program, method, assignment.Target);
Trace.Assert(target is SecondaryEntity);
return(new ResolvedAssignmentStatement(
assignment.Location, source, (SecondaryEntity)target, assignment.TargetReferencedByThis));
}
protected override Entity RestoreImplementation <TNode>(
GraphStructuredProgram <TNode> program,
ResolvedMethod <TNode> method,
Entity entity)
{
var localVariable = (ResolvedLocalVariable)entity;
var exists = method.Variables.TryGetValue(localVariable.LocalId, out var variable);
//Trace.Assert(exists);
if (!exists)
{
method.AddLocalVariable(localVariable);
variable = localVariable;
}
return(variable);
}
private bool InternalStep(
GraphStructuredProgram <TNode> targetProgram,
ResolvedMethod <TNode> targetMethod,
TNode source,
Statement statement,
TNode target,
Func <TNode> nodeCreator)
{
//TODO: Check steps order correctness
var toContinue =
myComposedWith?.InternalStep(targetProgram, targetMethod, source, statement, target, nodeCreator);
if (toContinue == null || toContinue.Value)
{
return(Step(targetProgram, targetMethod, source, statement, target, nodeCreator));
}
return(false);
}
protected override Entity InternalResolve <TNode>(
GraphStructuredProgram <TNode> program,
ResolvedMethod <TNode> method,
Reference reference)
{
var real = (LocalVariableReference)reference;
var exists = method.Variables.TryGetValue(real.Index, out var resolved);
Trace.Assert(exists);
if (!exists)
{
method.AddLocalVariable(new ResolvedLocalVariable(real.Index));
resolved = method.Variables[real.Index];
}
if (resolved.DefaultClassType < 0 && real.DefaultType != null)
{
var defaultType = program.GetOrCreateClass(real.DefaultType);
resolved.DefaultClassType = defaultType.Id.GlobalId;
}
return(resolved);
}
public SourceFilterSink(GraphStructuredProgram <int> program)
: base(program, getPdvmProvider(program))
{
myProgram = program;
}
protected override Entity InternalResolve <TNode>(
GraphStructuredProgram <TNode> program,
ResolvedMethod <TNode> method,
Reference reference)
{
var classFieldReference = (ClassFieldReference)reference;
if (classFieldReference.Owner is ClassReference classReference)
{
var clazz = program.GetOrCreateClass(classReference.ClassId);
var field = program.GetOrCreateClassField(clazz.Id, classFieldReference.Name);
if (classFieldReference.DefaultClassType != null)
{
field.DefaultClassType = program.GetOrCreateClass(classFieldReference.DefaultClassType).Id.GlobalId;
}
return(field);
}
else if (classFieldReference.Owner is LocalVariableReference localVariableReference)
{
var localVariable = method.Variables[localVariableReference.Index];
var fieldId = program.GetOrCreateFieldId(classFieldReference.Name);
var resolvedObjectField = new ResolvedObjectField(localVariable, fieldId)
{
FindClassField = program.FindClassFieldById
};
method.StoreAdditionalVariable(resolvedObjectField);
return(resolvedObjectField);
}
else if (classFieldReference.Owner is ClassFieldReference anotherReference)
{
var resolvedAnotherReference = (SecondaryEntity)Resolve(program, method, anotherReference);
var fieldId = program.GetOrCreateFieldId(classFieldReference.Name);
var resolvedObjectField = new ResolvedObjectField(resolvedAnotherReference, fieldId)
{
FindClassField = program.FindClassFieldById
};
method.StoreAdditionalVariable(resolvedObjectField);
return(resolvedObjectField);
}
else if (classFieldReference.Owner is ClassPropertyReference propertyReference)
{
var resolvedAnotherReference = (SecondaryEntity)Resolve(program, method, propertyReference);
var fieldId = program.GetOrCreateFieldId(classFieldReference.Name);
var resolvedObjectField = new ResolvedObjectField(resolvedAnotherReference, fieldId)
{
FindClassField = program.FindClassFieldById
};
method.StoreAdditionalVariable(resolvedObjectField);
return(resolvedObjectField);
}
Trace.Assert(false);
return(null);
}
public TypePropagation(
GraphStructuredProgram <int> program)
: base(program, new MyContextProcessor(), () => PdvmProvider(program))
{
}
public MyPdvm(
GraphStructuredProgram <int> processingProgram)
{
myProcessingProgram = processingProgram;
}
public SourceFilterSinkPDVM(GraphStructuredProgram <int> processingProgram) : base(processingProgram)
{
mySinkAttributeId = Program.GetOrCreateAttribute(Constants.SinkAttribute);
myFilterAttributeId = Program.GetOrCreateAttribute(Constants.FilterAttribute);
}
protected abstract InternalStatement RestoreImplementation <TNode>(
GraphStructuredProgram <TNode> program,
ResolvedMethod <TNode> method,
InternalStatement statement);
protected abstract Entity RestoreImplementation <TNode>(
GraphStructuredProgram <TNode> program,
ResolvedMethod <TNode> method,
Entity entity);
protected AbstractAnalysis(GraphStructuredProgram <Node> program)
{
Program = program;
}
protected ILProcessingPDVM(GraphStructuredProgram <Node> program)
{
Program = program;
}
