public StackSymbol(OperationEdge <int> callSite, ResolvedInvocationStatement <Node> invocation)
{
CallSite = callSite;
Owner = null;
if (invocation == null)
{
return;
}
var owner = invocation.TargetEntity;
if (invocation.IsConstructor)
{
var index = new ParameterIndex(-1);
Owner = invocation.ReturnedValues[index] as ResolvedLocalVariable;
}
else if (owner is ResolvedLocalVariable localVariable)
{
Owner = localVariable;
}
else if (owner is SecondaryEntity justSecondary)
{
Owner = Utils.FindClosestLocalOwner(justSecondary);
}
}
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 override void OnFinish(
Head <TState, Node,
PdaExtractingContext <GssNode <TStackSymbol, EmptyGssData>, OperationEdge <Node> >,
GssNode <TStackSymbol, EmptyGssData> > head,
OperationEdge <Node> sourceTransition)
{
OnFinishEvent?.Invoke(head.CurrentContext);
}
private void ProcessInvocation(
State state,
ResolvedInvocationStatement <Node> invocation,
OperationEdge <Node> currentTransition)
{
var targets = CollectPossibleTargets(invocation.TargetEntity, invocation.TargetMethodId);
var passedParameters = invocation.PassedParameters.ToDictionary(
pair => Utils.FindClosestLocalOwner(pair.Key), pair => pair.Value);
if (state is ResolvedLocalVariable localState)
{
if (!passedParameters.ContainsKey(localState))
{
return;
}
var parameterIndex = passedParameters[localState].Value;
foreach (var target in targets)
{
var isSink = false;
var isFilter = false;
if (target is ResolvedMethod <Node> method)
{
isSink = method.HasAttribute(mySinkAttributeId);
isFilter = method.HasAttribute(myFilterAttributeId);
}
if (isSink)
{
Accept(new FinalState());
}
else
{
if (!isFilter)
{
var nextState = target.Variables[parameterIndex];
var frame = new StackSymbol(currentTransition, invocation);
Push(nextState, frame, target.EntryPoint);
}
}
}
}
else
{
foreach (var target in targets)
{
var frame = new StackSymbol(currentTransition, invocation);
Push(state, frame, target.EntryPoint);
}
}
}
public override bool Analyze(IEnumerable <ResolvedMethod <Node> > starts)
{
var initialState = new UnknownEntity();
var emptyInvocation = new OperationEdge <Node>(0, new NopStatement(), 0);
var initialStackData = new MyStackData(emptyInvocation, initialState, false);
var pdvm = (MyPdvm)InternalSimulation.Pdvm;
pdvm.SetForcedExecutor(InternalSimulation.ForceExecute);
var contexts = starts.Select(
start => InternalSimulation.Load(start.Start, initialState, initialStackData)).ToList();
InternalSimulation.Run();
return(true);
}
public override void Step(
State state,
GssNode <StackSymbol, EmptyGssData> stack,
Node position,
OperationEdge <Node> currentTransition)
{
var commonStatement = currentTransition.Statement;
if (commonStatement.Type != StatementType.Internal)
{
return;
}
if ((state is FinalState))
{
return;
}
Skip(state);
var statement = (InternalStatement)commonStatement;
switch (statement.InternalType)
{
case InternalStatementType.ResolvedInvocation:
ProcessInvocation(state, (ResolvedInvocationStatement <Node>)statement, currentTransition);
break;
case InternalStatementType.Return:
ProcessReturn(state, stack, (InternalReturnStatement)statement);
break;
case InternalStatementType.ResolvedAssignment:
ProcessAssignment(state, stack, (ResolvedAssignmentStatement)statement);
break;
}
}
public MyStackData(MyTransition callingEdge, SecondaryEntity trackedEntity, bool trampoline)
{
CallingEdge = callingEdge;
TrackedEntity = trackedEntity;
Trampoline = trampoline;
}
public Node Target(OperationEdge <Node> transition)
{
return(transition.Target);
}
