public override void Visit(PhiInstruction instruction)
{
var type = instruction.Arguments.First().Type;
var arguments = instruction.Arguments.Skip(1);
foreach (var argument in arguments)
{
type = TypeHelper.MergedType(type, argument.Type);
}
instruction.Result.Type = type;
}
public override void Visit(PhiInstruction instruction)
{
SavePreState(instruction, FreshCurrent());
var nstate = FreshCurrent();
var result = instruction.Result;
if (IsConstantType(result.Type))
{
var consargs = instruction.Arguments.Where(v => IsConstantType(v.Type)).ToList();
if (consargs.Count == 0)
{
UpdateStateNotConstant(nstate, result);
}
else if (consargs.All(v => !nstate.Constants(v).IsTop))
{
var cpd = ConstantSetDomain.Bottom;
foreach (var v in consargs)
{
if (!IsConstantType(v.Type))
{
continue;
}
cpd.Join(nstate.Constants(v));
}
nstate.Set(result, cpd);
}
else
{
UpdateStateNotConstant(nstate, result);
}
}
SetCurrent(nstate);
SavePostState(instruction, FreshCurrent());
}
private void InsertPhiInstructions()
{
var defining_nodes = new Dictionary <IVariable, ISet <CFGNode> >();
foreach (var node in cfg.Nodes)
{
foreach (var instruction in node.Instructions)
{
if (instruction is DefinitionInstruction)
{
var definition = instruction as DefinitionInstruction;
if (definition.HasResult)
{
ISet <CFGNode> nodes;
if (defining_nodes.ContainsKey(definition.Result))
{
nodes = defining_nodes[definition.Result];
}
else
{
nodes = new HashSet <CFGNode>();
defining_nodes.Add(definition.Result, nodes);
}
nodes.Add(node);
}
}
}
}
foreach (var entry in defining_nodes)
{
var variable = entry.Key;
var nodes = new Stack <CFGNode>(entry.Value);
while (nodes.Count > 0)
{
var current = nodes.Pop();
foreach (var node in current.DominanceFrontier)
{
if (phi_instructions.ContainsKey(node) && phi_instructions[node].ContainsKey(variable))
{
continue;
}
IDictionary <IVariable, PhiInstruction> node_phi_instructions;
if (phi_instructions.ContainsKey(node))
{
node_phi_instructions = phi_instructions[node];
}
else
{
node_phi_instructions = new Dictionary <IVariable, PhiInstruction>();
phi_instructions.Add(node, node_phi_instructions);
}
var phi = new PhiInstruction(0, variable);
// TODO: Also insert phi instructions into method's body instructions collection.
node.Instructions.Insert(0, phi);
node_phi_instructions.Add(variable, phi);
if (!defining_nodes[variable].Contains(node) && !nodes.Contains(node))
{
nodes.Push(node);
}
}
}
}
}
public override void Visit(PhiInstruction instruction)
{
ptAnalysis.ProcessCopy(State, instruction.Result, instruction.Arguments);
}
public virtual void Visit(PhiInstruction instruction)
{
}
public virtual void Visit(PhiInstruction instruction)
{
Default(instruction);
}
