private void AdjustConstForType(ReferenceNode node, TypeInfo type)
{
DAGNode n = node;
while (n is ReferenceNode)
{
n = n.NextNodes[0];
}
if (n is LeafNode && n.Data.Length > 0 && (char.IsDigit(n.Data[0]) || n.Data[0] == '.' || n.Data[0] == '-'))
{
long v = 0;
double dv = 0.0;
if (n.Data.IndexOf('.') >= 0)
{
dv = ConstUtility.ParseDouble(n.Data);
v = (long)dv;
}
else
{
v = ConstUtility.ParseLong(n.Data);
dv = (double)v;
}
n.Data = ConstUtility.ConstToString(type, v, dv);
}
}
private DAGNode Clone(Dictionary <DAGNode, DAGNode> pairs)
{
if (pairs.ContainsKey(this))
{
return(pairs[this]);
}
DAGNode node = NewNode();
pairs[this] = node;
node.data = data;
node.otherOperators.AddRange(otherOperators);
node.identifier = identifier;
node.idTypeInfo = idTypeInfo;
node.isStatement = isStatement;
node.isComment = isComment;
node.isConst = isConst;
node.accessed = accessed;
node.exp = exp;
foreach (DAGNode n in nextNodes)
{
DAGNode nn = n.Clone(pairs);
node.AddNext(nn);
}
return(node);
}
/// <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));
}
}
}
}
private DAGNode AdjustGoto(IlIns il, DAGNode node, bool isDecompile)
{
string label = AdjustGoto(il, isDecompile);
if (label != null)
{
node.IsComment = true;
il.Csharps.Add(node);
if (node is UnaryNode)
{
DAGNode newNode = DAGNode.CreateUnary(true, "goto", DAGNode.CreateLeaf(label));
return(newNode);
}
else if (node is BinaryNode)
{
DAGNode newNode = DAGNode.CreateBinary(true, "if", node.NextNodes[0], DAGNode.CreateLeaf(label));
if (node.OtherOperators.Count > 0)
{
newNode.OtherOperators.Add(node.OtherOperators[0]);
}
return(newNode);
}
else if (node is TernaryNode)
{
DAGNode newNode = DAGNode.CreateTernary(true, "if", node.NextNodes[0], node.NextNodes[1], DAGNode.CreateLeaf(label));
newNode.OtherOperators.Add(node.OtherOperators[0]);
return(newNode);
}
}
return(node);
}
public static DAGNode CreateNodeRef(bool isStatement, DAGNode refedNode)
{
ReferenceNode node = new ReferenceNode();
node.isStatement = isStatement;
node.AddNext(refedNode);
return(node);
}
public static DAGNode CreateBinary(bool isStatement, string op, DAGNode v1, DAGNode v2)
{
BinaryNode node = new BinaryNode();
node.isStatement = isStatement;
node.Operator = op;
node.AddNext(v1, v2);
return(node);
}
public static DAGNode CreateUnary(bool isStatement, string op, DAGNode v)
{
UnaryNode node = new UnaryNode();
node.isStatement = isStatement;
node.Operator = op;
node.AddNext(v);
return(node);
}
public static DAGNode GetOriginalNode(DAGNode refedNode)
{
DAGNode node = refedNode;
while (node is ReferenceNode)
{
node = node.NextNodes[0];
}
return(node);
}
/// <summary>
/// 取一个结点的ID，如果结点引用链上都没有ID，则返回原始叶结点的Data，如果也没原始叶结点，则返回空串。
/// </summary>
/// <param name="refedNode"></param>
/// <returns></returns>
/// <remarks>注意：此方法假定结点一定代表一个变量，调用方应确保此假设成立</remarks>
public static string GetID(DAGNode refedNode)
{
DAGNode node = refedNode;
while (node is ReferenceNode && node.Identifier.Length <= 0)
{
node = node.NextNodes[0];
}
if (node.Identifier.Length <= 0 && node is LeafNode)
{
return(node.Data);
}
return(node.Identifier);
}
/// <summary>
/// 变量值改变则迫使原变量引用采用别名。
/// </summary>
/// <param name="name"></param>
private void VarChanged(string name, TypeInfo type, DAGNode newNode)
{
if (semanticStack.Contains(name) && varReferences.ContainsKey(name))
{
DAGNode node = varReferences[name];
if (!type.IsReference)//引用变量是否进栈不影响对它的操作（栈不缓存引用变量的实际值）
{
if (node.Identifier.Length <= 0 || node.Identifier == name)
{
node.SetID(NewAlias(type), type);
}
}
}
varReferences[name] = newNode;
}
private DAGNode GetVarReference(string name, bool create)
{
if (varReferences.ContainsKey(name))
{
return(varReferences[name]);
}
if (create)
{
DAGNode node = DAGNode.CreateLeaf(name);
varReferences[name] = node;
return(node);
}
else
{
return(null);
}
}
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);
}
/// <summary>
/// 构造将值强制转为指定类型的表达式。
/// </summary>
/// <param name="type"></param>
/// <param name="v"></param>
/// <returns></returns>
private DAGNode BuildCastExpression(TypeInfo ti, SemanticValue _v, bool forArg)
{
SemanticValue v = _v.Clone();
DAGNode node = _v.Node;
if (v.Type == BasicTypeInfo.IntPtrInfo)
{
v.Node = DAGNode.CreateUnary("ToInt32", _v.Node);
}
else if (v.Type == BasicTypeInfo.UIntPtrInfo)
{
v.Node = DAGNode.CreateUnary("ToUInt32", _v.Node);
}
if (v.IsConst && ti.IsBoolean)
{
node = DAGNode.CreateLeaf(v.ConstToString(ti));
}
else if (v.IsConst && v.IntegerVal == 0 && ti.IsRef)
{
node = DAGNode.CreateBinary("()", DAGNode.CreateLeaf(ti.TypeDefClause), DAGNode.CreateLeaf("nullptr"));
}
else if (v.IsConst && ti.IsSimple)
{
node = DAGNode.CreateLeaf(v.ConstToString(ti));
if (forArg)
{
node = DAGNode.CreateBinary("()", DAGNode.CreateLeaf(ti.TypeDefClause), node);
}
}
else if (ti != v.Type)
{
node = DAGNode.CreateBinary("()", DAGNode.CreateLeaf(ti.TypeDefClause), v.Node);
}
return(node);
}
static SemanticValue()
{
nullValue.Node = DAGNode.CreateLeaf("null_stack");
}
public static DAGNode CreateNodeRef(DAGNode refedNode)
{
return(CreateNodeRef(false, refedNode));
}
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++;
}
}
}
}
}
}
}
/// <summary>
/// 为两个值构造强制转换表达式，使得两个值可以进行比较操作。
/// </summary>
/// <param name="v1"></param>
/// <param name="v2"></param>
/// <param name="node1"></param>
/// <param name="node2"></param>
/// <returns>
/// true --- 可以生成判大小的比较表达式
/// false --- 不可以生成判大小的比较表达式，需要转为判等表达式（此情形为有一个操作数为0，另一个为对象引用）
/// </returns>
private bool BuildCastExpression(SemanticValue _v1, SemanticValue _v2, out DAGNode node1, out DAGNode node2)
{
bool ret = true;
node1 = _v1.Node;
node2 = _v2.Node;
SemanticValue v1 = _v1.Clone();
SemanticValue v2 = _v2.Clone();
if (v1.Type == BasicTypeInfo.IntPtrInfo)
{
v1.Node = DAGNode.CreateUnary("ToInt32", _v1.Node);
}
else if (v1.Type == BasicTypeInfo.UIntPtrInfo)
{
v1.Node = DAGNode.CreateUnary("ToUInt32", _v1.Node);
}
if (v2.Type == BasicTypeInfo.IntPtrInfo)
{
v2.Node = DAGNode.CreateUnary("ToInt32", _v2.Node);
}
else if (v2.Type == BasicTypeInfo.UIntPtrInfo)
{
v2.Node = DAGNode.CreateUnary("ToUInt32", _v2.Node);
}
if (v1.Type.IsBoolean && v2.IsConst)
{
node2 = DAGNode.CreateLeaf(v2.ConstToString(v1.Type));
}
else if (v2.Type.IsBoolean && v1.IsConst)
{
node1 = DAGNode.CreateLeaf(v1.ConstToString(v2.Type));
}
else if (v1.Type.IsRef && v2.IsConst && v2.IntegerVal == 0)
{
node2 = DAGNode.CreateBinary("()", DAGNode.CreateLeaf(v1.Type.TypeDefClause), DAGNode.CreateLeaf("nullptr"));
ret = false;
}
else if (v2.Type.IsRef && v1.IsConst && v1.IntegerVal == 0)
{
node1 = DAGNode.CreateBinary("()", DAGNode.CreateLeaf(v2.Type.TypeDefClause), DAGNode.CreateLeaf("nullptr"));
ret = false;
}
else if (v1.Type != v2.Type)
{
if (v1.Type.IsSimple && v2.Type.IsSimple)//都是基础类型变量
{
if (v1.IsConst)
{
node1 = DAGNode.CreateLeaf(v1.ConstToString(v2.Type));
}
else if (v2.IsConst)
{
node2 = DAGNode.CreateLeaf(v2.ConstToString(v1.Type));
}
else if (v1.Type.IsCastSimple && !v2.Type.IsCastSimple)
{
node1 = DAGNode.CreateBinary("()", DAGNode.CreateLeaf(v2.Type.TypeClause), v1.Node);
}
else
{
node2 = DAGNode.CreateBinary("()", DAGNode.CreateLeaf(v1.Type.TypeClause), v2.Node);
}
}
else if (v2.Type.IsSimple)//第二个操作数是基础变量，将操作数1强制转为操作数2的类型
{
if (v1.Type.IsRef && v1.IsConst && v1.IntegerVal == 0)
{
node1 = DAGNode.CreateLeaf("0");
}
else
{
node1 = DAGNode.CreateBinary("()", DAGNode.CreateLeaf(v2.Type.TypeDefClause), v1.Node);
}
}
else if (v1.Type.IsSimple)//第一个操作数是基础变量，将操作数2强制转为操作数1的类型
{
if (v2.Type.IsRef && v2.IsConst && v2.IntegerVal == 0)
{
node2 = DAGNode.CreateLeaf("0");
}
else
{
node2 = DAGNode.CreateBinary("()", DAGNode.CreateLeaf(v1.Type.TypeDefClause), v2.Node);
}
}
else//都不是基础变量
{
node2 = DAGNode.CreateBinary("()", DAGNode.CreateLeaf(v1.Type.TypeDefClause), v2.Node);
}
}
return(ret);
}
public static DAGNode CreateUnary(string op, DAGNode v)
{
return(CreateUnary(false, op, v));
}
public static DAGNode CreateBinary(string op, DAGNode v1, DAGNode v2)
{
return(CreateBinary(false, op, v1, v2));
}
