/// <summary>
/// 结束当前流图结点的反编译，遗传语义值与变量当前引用给未访问后继结点
/// ，处理利用栈传出的语义值。
/// </summary>
/// <param name="node"></param>
/// <param name="il"></param>
private void EndGraphNode(FlowGraphNode node, bool isDecompile)
{
if (semanticStack.Count > 0)
{
if (isDecompile)
{
//将传出块的语义值改为结点引用，并将结点引用设置在块的结束语句上
IlIns il = ilLines[node.EndLabelValue];
foreach (SemanticValue val in semanticStack)
{
DAGNode n = val.Node;
n = DAGNode.CreateNodeRef(n);
if (!il.Csharps.Contains(n))
{
il.Csharps.Insert(0, n);
}
val.IsConst = false;
val.Node = n;
}
}
foreach (FlowGraphNode n in node.NextNodes)
{
n.SemanticStacks.Add(semanticStack.Clone());
if (n.PrevNodes.Count == 1)
{
//只有一个前导块的块将继承其前导块的变量当前引用，有多个前导块的块不能继承变量当前引用
n.VarReferencesList.Add(new Dictionary <string, DAGNode>(varReferences));
}
}
}
}
public FlowGraphNode Split(long labelValue, long prevLabelValue)
{
if (nodes.ContainsKey(labelValue))
{
return(nodes[labelValue]);
}
FlowGraphNode n1 = Find(labelValue);
if (n1 == null)
{
return(null);
}
FlowGraphNode n2 = NewNode(labelValue);
//断开n1与它的后继并将之添加为n2的后继
FlowGraphNode[] n1s = new FlowGraphNode[n1.NextNodes.Count];
n1.NextNodes.CopyTo(n1s, 0);
foreach (FlowGraphNode n in n1s)
{
n1.DelNext(n);
n2.AddNext(n);
}
//将n2添加为n1的后继
n1.AddNext(n2);
//设置n2的结束标签为n1的结束标签，若n1的结束标签不大于n2的开始标签则不调整n2的结束标签
if (n1.EndLabelValue > n2.LabelValue)
{
n2.EndLabelValue = n1.EndLabelValue;
}
//设置n1的结束标签为分离标签的前一个标签
n1.EndLabelValue = prevLabelValue;
return(n2);
}
public bool IsAccessed(FlowGraphNode node)
{
if (accessedNodes.ContainsKey(node))
{
return(accessedNodes[node]);
}
return(false);
}
private void ResetGraphNodeInfo()
{
flowGraph.Reset();
for (; flowGraph.CurNode != null; flowGraph.Next())
{
FlowGraphNode node = flowGraph.CurNode;
node.SemanticStacks.Clear();
node.VarReferencesList.Clear();
}
}
public FlowGraphNode NewNode(long labelValue)
{
if (nodes.ContainsKey(labelValue))
{
return(nodes[labelValue]);
}
else
{
FlowGraphNode node = new FlowGraphNode(labelValue);
nodes[labelValue] = node;
if (startNode == null)
{
startNode = node;
}
return(node);
}
}
public void Next()
{
if (IteratorIsEnd)
{
return;
}
if (IteratorIsBegin)
{
iterateStack.Push(startNode);
PrepareAccessNode(startNode);
}
else if (curNode.NextNodes.Count > 0)
{
//在访问完当前结点后将后继入栈，这样给当前结点调整流图的机会，比如
//遇到if(1<2) goto label;这样的假条件判断时，会将当前结点与假的后继
//断开
for (int i = curNode.NextNodes.Count - 1; i >= 0; i--)
{
FlowGraphNode n = curNode.NextNodes[i];
if (!accessedNodes.ContainsKey(n))
{
iterateStack.Push(n);
PrepareAccessNode(n);
}
}
}
if (iterateStack.Count > 0)
{
curNode = iterateStack.Pop();
AccessNode(curNode);
}
else if (unaccessedNodes.Count > 0)
{
IEnumerator <FlowGraphNode> enumer = unaccessedNodes.Keys.GetEnumerator();
enumer.MoveNext();
curNode = enumer.Current;
PrepareAccessNode(curNode);
AccessNode(curNode);
}
else
{
curNode = null;
}
}
/// <summary>
/// 开始一个流图结点的编译，继承最左前导块的语义与变量当前引用
/// </summary>
/// <param name="node"></param>
/// <param name="il"></param>
private void BeginGraphNode(FlowGraphNode node)
{
if (node.SemanticStacks.Count > 0)
{
semanticStack = node.SemanticStacks[0].Clone();
}
else
{
semanticStack = new SemanticStack();
}
if (node.VarReferencesList.Count > 0)
{
varReferences = new Dictionary <string, DAGNode>(node.VarReferencesList[0]);
}
else
{
varReferences = new Dictionary <string, DAGNode>();
}
}
private string AdjustGoto(IlIns il, bool isDecompile)
{
long lv = IlIns.LabelToValue(il.Value);
string label = null;
if (switchBlocks.ContainsKey(lv))
{
FlowGraphNode gnode = switchBlocks[lv];
DAGNode dnode = switchExpressions[gnode.EndLabelValue];
while (dnode is ReferenceNode)
{
dnode = dnode.NextNodes[0];
}
if (dnode is LeafNode)
{
DAGNode r = GetVarReference(dnode.Data);
if (r != null)
{
int v = (int)ConstUtility.ParseLong(r.Data);
IlIns switchIl = ilLines[gnode.EndLabelValue];
SwitchOperand op = switchIl.Operand as SwitchOperand;
if (v >= 0 && v < op.Labels.Count)
{
label = op.Labels[v];
lv = IlIns.LabelToValue(op.Labels[v]);
}
}
}
}
string label2 = AdjustGoto(il.LabelValue, lv, isDecompile);
if (label2 != null)
{
return(label2);
}
else if (label != null)
{
return(label);
}
return(null);
}
private void IlToCsharps()
{
foreach (long lv in switches)
{
FlowGraphNode n = flowGraph.Find(lv);
if (n != null)
{
switchBlocks[n.LabelValue] = n;
}
}
flowGraph.Reset();
for (; flowGraph.CurNode != null; flowGraph.Next())
{
FlowGraphNode node = flowGraph.CurNode;
int i = ilLines.Keys.IndexOf(node.LabelValue);
for (; i < ilLines.Values.Count; i++)
{
IlIns il = ilLines.Values[i];
if (il.LabelValue == node.LabelValue)
{
BeginGraphNode(node);
}
else if (il.LabelValue != node.LabelValue && flowGraph.IsNode(il.LabelValue))
{
EndGraphNode(node, true);
break;
}
IlOpcode op0 = IlOpcodes.GetEH(il.Opcode);
if (op0 != IlOpcode.Prefixref)
{
EvaluateEH(op0, il, true);
}
else
{
OpCode op = IlOpcodes.Get(il.Opcode);
int type = EvaluateIl(op, il, true);
}
}
}
}
private void CheckSemantic()
{
for (int i = 0; i < ilLines.Values.Count; i++)
{
IlIns il = ilLines.Values[i];
if (flowGraph.IsNode(il.LabelValue))
{
FlowGraphNode node = flowGraph[il.LabelValue];
if (node.SemanticStacks.Count > 0)
{
//检查是否存在多个前导且存在传入的语义栈，这是需要处理跨块共用栈的情形，添加一个警告信息。
if (node.PrevNodes.Count > 1)
{
DAGNode enode = DAGNode.CreateLeaf(true, "warning ! semantic stack doesn't empty at joint !");
enode.IsComment = true;
il.Csharps.Add(enode);
}
//检查多个前导传入的语义栈的语义值数目是否一致，这表明程序或者分析出现了错误。
int n = -1;
bool error = false;
foreach (SemanticStack ss in node.SemanticStacks)
{
if (n <= 0)
{
n = ss.Count;
}
else if (ss.Count != n)
{
DAGNode enode = DAGNode.CreateLeaf(true, "error ! semantic stack doesn't balance at joint !");
enode.IsComment = true;
il.Csharps.Add(enode);
error = true;
break;
}
}
if (!error)
{
//对多个前导传入的语义栈里的语义值统一一个临时变量名。
TypeInfo[] types = new TypeInfo[n];
string[] tvars = new string[n];
SemanticValue[][] vals0 = new SemanticValue[node.SemanticStacks.Count][];
for (int ii = 0; ii < vals0.Length; ii++)
{
vals0[ii] = node.SemanticStacks[ii].ToArray();
}
SemanticValue[][] vals = new SemanticValue[n][];
for (int ii = 0; ii < vals.Length; ii++)
{
vals[ii] = new SemanticValue[node.SemanticStacks.Count];
for (int j = 0; j < vals[ii].Length; j++)
{
vals[ii][j] = vals0[j][ii];
}
}
int ix = 0;
for (; ix < n; ix++)
{
TypeInfo type = GetCompatibleType(vals[ix]);
if (type.IsReference)//仅对非引用值换名
{
types[ix] = type;
tvars[ix] = "";
}
else
{
types[ix] = type;
tvars[ix] = NewAlias(type);
}
}
foreach (SemanticStack ss in node.SemanticStacks)
{
ix = 0;
foreach (SemanticValue val in ss)
{
if (val.Node is ReferenceNode)
{
if (!types[ix].IsReference)//仅对非引用值换名
{
val.Node.SetID(tvars[ix], types[ix]);
AdjustConstForType(val.Node as ReferenceNode, types[ix]);
}
}
else
{
//error
}
ix++;
}
}
}
}
}
}
}
private void AdjustFlowGraph()
{
flowGraph.Reset();
for (; flowGraph.CurNode != null; flowGraph.Next())
{
FlowGraphNode node = flowGraph.CurNode;
int i = ilLines.Keys.IndexOf(node.LabelValue);
for (; i < ilLines.Values.Count; i++)
{
IlIns il = ilLines.Values[i];
if (il.LabelValue == node.LabelValue)
{
BeginGraphNode(node);
}
else if (il.LabelValue != node.LabelValue && flowGraph.IsNode(il.LabelValue))
{
//行进到块的开始语句才发现新开始块是异常构造块或跳转目标倒致的块
EndGraphNode(node, false);
break;
}
IlOpcode op0 = IlOpcodes.GetEH(il.Opcode);
if (op0 != IlOpcode.Prefixref)
{
EvaluateEH(op0, il, false);
}
else
{
OpCode op = IlOpcodes.Get(il.Opcode);
int type = EvaluateIl(op, il, false);
switch (type)
{
case -2: //永不成立的条件跳转，当前结点与分支目标块断开
{
long target = IlIns.LabelToValue(il.Value);
if (flowGraph.IsNode(target))
{
FlowGraphNode n = flowGraph[target];
node.DelNext(n);
}
EndGraphNode(node, false);
}
break;
case -1: //永成立的条件跳转，当前结点与下一条指令开始的块断开
{
if (i + 1 < ilLines.Values.Count)
{
if (flowGraph.IsNode(ilLines.Values[i + 1].LabelValue))
{
FlowGraphNode n = flowGraph[ilLines.Values[i + 1].LabelValue];
node.DelNext(n);
}
}
EndGraphNode(node, false);
}
break;
case 0: //正常指令流
{
}
break;
case 1: //无条件跳转
case 2: //条件跳转
case 3: //switch分支
{
EndGraphNode(node, false);
}
break;
case 4: //结束类语句
{
EndGraphNode(node, false);
}
break;
}
if (type != 0)
{
break;
}
}
}
}
//合并无分支的顺序块
flowGraph.Reset();
for (; flowGraph.CurNode != null; flowGraph.Next())
{
FlowGraphNode node = flowGraph.CurNode;
while (node.NextNodes.Count == 1 && node.NextNodes[0].PrevNodes.Count == 1)
{
FlowGraphNode n = node.NextNodes[0];
int i = ilLines.Keys.IndexOf(node.EndLabelValue);
int j = ilLines.Keys.IndexOf(n.LabelValue);
if (i + 1 == j)
{
flowGraph.Combine(node, n);
}
else
{
break;
}
}
}
}
private void BuildFlowGraph()
{
flowGraph = new FlowGraph();
FlowGraphNode curNode = null;
FlowGraphNode prevNode = null;
bool nextIsBlock = true;
for (int i = 0; i < ilLines.Count; i++)
{
IlIns il = ilLines.Values[i];
if (nextIsBlock)
{
nextIsBlock = false;
FlowGraphNode node = flowGraph.NewNode(il.LabelValue);
curNode = node;
if (prevNode != null)
{
prevNode.AddNext(node);
}
}
else
{
if (flowGraph.IsNode(il.LabelValue))
{
FlowGraphNode node = flowGraph[il.LabelValue];
curNode.EndLabelValue = GetPrevIlLabelValue(il.LabelValue);
curNode.AddNext(node);
curNode = node;
}
}
IlOpcode op0 = IlOpcodes.GetEH(il.Opcode);
if (op0 != IlOpcode.Prefixref)
{
switch (op0)
{
case IlOpcode.TRY:
{
FlowGraphNode node = flowGraph.NewNode(il.LabelValue);
if (curNode != null)
{
curNode.AddNext(node);
}
curNode = node;
}
break;
case IlOpcode.CATCH:
{
FlowGraphNode node = flowGraph.NewNode(il.LabelValue);
curNode = node;
}
break;
case IlOpcode.FINALLY:
{
FlowGraphNode node = flowGraph.NewNode(il.LabelValue);
curNode = node;
}
break;
case IlOpcode.FILTER:
{
FlowGraphNode node = flowGraph.NewNode(il.LabelValue);
curNode = node;
}
break;
case IlOpcode.FAULT:
{
FlowGraphNode node = flowGraph.NewNode(il.LabelValue);
curNode = node;
}
break;
case IlOpcode.ENDTRY:
case IlOpcode.ENDCATCH:
case IlOpcode.ENDFINALLY:
case IlOpcode.ENDFILTER:
case IlOpcode.ENDFAULT:
{
curNode.EndLabelValue = il.LabelValue;
prevNode = null;
nextIsBlock = true;
}
break;
}
}
else
{
OpCode op = IlOpcodes.Get(il.Opcode);
switch ((IlOpcode)op.Value)
{
case IlOpcode.Br:
case IlOpcode.Br_S:
{
long val = IlIns.LabelToValue(il.Value);
FlowGraphNode node = null;
if (val > il.LabelValue)
{
node = flowGraph.NewNode(val);
curNode.AddNext(node);
}
else
{
long prevVal = GetPrevIlLabelValue(val);
FlowGraphNode d = flowGraph.Find(val);
node = flowGraph.Split(val, prevVal);
if (curNode != d)
{
curNode.AddNext(node);
}
else
{
node.AddNext(node);
curNode = node;
}
}
curNode.EndLabelValue = il.LabelValue;
prevNode = null;
nextIsBlock = true;
}
break;
case IlOpcode.Brtrue:
case IlOpcode.Brfalse:
case IlOpcode.Brtrue_S:
case IlOpcode.Brfalse_S:
case IlOpcode.Beq_S:
case IlOpcode.Bge_S:
case IlOpcode.Bgt_S:
case IlOpcode.Ble_S:
case IlOpcode.Blt_S:
case IlOpcode.Bne_Un_S:
case IlOpcode.Bge_Un_S:
case IlOpcode.Bgt_Un_S:
case IlOpcode.Ble_Un_S:
case IlOpcode.Blt_Un_S:
case IlOpcode.Beq:
case IlOpcode.Bge:
case IlOpcode.Bgt:
case IlOpcode.Ble:
case IlOpcode.Blt:
case IlOpcode.Bne_Un:
case IlOpcode.Bge_Un:
case IlOpcode.Bgt_Un:
case IlOpcode.Ble_Un:
case IlOpcode.Blt_Un:
{
long val = IlIns.LabelToValue(il.Value);
FlowGraphNode node = null;
if (val > il.LabelValue)
{
node = flowGraph.NewNode(val);
curNode.AddNext(node);
}
else
{
long prevVal = GetPrevIlLabelValue(val);
FlowGraphNode d = flowGraph.Find(val);
node = flowGraph.Split(val, prevVal);
if (curNode != d)
{
curNode.AddNext(node);
}
else
{
node.AddNext(node);
curNode = node;
}
}
curNode.EndLabelValue = il.LabelValue;
prevNode = curNode;
nextIsBlock = true;
}
break;
case IlOpcode.Switch:
{
SwitchOperand opVal = il.Operand as SwitchOperand;
foreach (string label in opVal.Labels)
{
long val = IlIns.LabelToValue(label);
FlowGraphNode node = null;
if (val > il.LabelValue)
{
node = flowGraph.NewNode(val);
curNode.AddNext(node);
}
else
{
long prevVal = GetPrevIlLabelValue(val);
FlowGraphNode d = flowGraph.Find(val);
node = flowGraph.Split(val, prevVal);
if (curNode != d)
{
curNode.AddNext(node);
}
else
{
node.AddNext(node);
curNode = node;
}
}
}
curNode.EndLabelValue = il.LabelValue;
prevNode = curNode;
nextIsBlock = true;
}
break;
case IlOpcode.Ret:
case IlOpcode.Break:
case IlOpcode.Throw:
case IlOpcode.Rethrow:
case IlOpcode.Leave:
case IlOpcode.Leave_S:
case IlOpcode.Endfilter:
case IlOpcode.Endfinally:
{
curNode.EndLabelValue = il.LabelValue;
prevNode = null;
nextIsBlock = true;
}
break;
}
}
}
}
public void Combine(FlowGraphNode n1, FlowGraphNode n2)
{
if (n1 == null || n2 == null)
{
return;
}
if (n2.PrevNodes.Count == 1 && n2.PrevNodes[0] == n1 && n1.NextNodes.Count == 1 && n1.NextNodes[0] == n2)//合并条件：n2必须是n1的唯一后继，n1必须是n2的唯一前导
{
//断开n1与n2的关联
n1.DelNext(n2);
//断开n2与其后继的关联，并将其后继添加为n1的后继
FlowGraphNode[] n2s = new FlowGraphNode[n2.NextNodes.Count];
n2.NextNodes.CopyTo(n2s, 0);
foreach (FlowGraphNode n in n2s)
{
n2.DelNext(n);
n1.AddNext(n);
}
//n1的结束标签改为n2的结束标签
n1.EndLabelValue = n2.EndLabelValue;
//删除流图对n2的记忆
nodes.Remove(n2.LabelValue);
accessedNodes.Remove(n2);
unaccessedNodes.Remove(n2);
bool inStack = false;
foreach (FlowGraphNode n in iterateStack)
{
if (n == n2)
{
inStack = true;
break;
}
}
if (inStack)
{
FlowGraphNode[] ns = iterateStack.ToArray();
iterateStack.Clear();
for (int i = ns.Length - 1; i >= 0; i--)
{
if (ns[i] != n2)
{
iterateStack.Push(ns[i]);
}
}
}
if (curNode == n2)
{
curNode = n1;
//设置n1为已访问
AccessNode(n1);
//删除迭代器栈里的n1
inStack = false;
foreach (FlowGraphNode n in iterateStack)
{
if (n == n1)
{
inStack = true;
break;
}
}
if (inStack)
{
FlowGraphNode[] ns = iterateStack.ToArray();
iterateStack.Clear();
for (int i = ns.Length - 1; i >= 0; i--)
{
if (ns[i] != n1)
{
iterateStack.Push(ns[i]);
}
}
}
}
}
}
/// <summary>
/// 设定一个结点为已访问结点，已访问结点是已经由迭代过程返回过的结点。
/// </summary>
/// <param name="node"></param>
private void AccessNode(FlowGraphNode node)
{
accessedNodes[node] = true;
}
/// <summary>
/// 设定一个结点为待访问结点，同时从未访问集合中删除此结点。
/// </summary>
/// <param name="node"></param>
private void PrepareAccessNode(FlowGraphNode node)
{
accessedNodes[node] = false;
unaccessedNodes.Remove(node);
}
