private bool ReplaceInvocations(ClassesProcessor.ClassNode caller, MethodWrapper
meth, Exprent exprent)
{
bool res = false;
foreach (Exprent expr in exprent.GetAllExprents())
{
res |= ReplaceInvocations(caller, meth, expr);
}
while (true)
{
bool found = false;
foreach (Exprent expr in exprent.GetAllExprents())
{
if (expr.type == Exprent.Exprent_Invocation)
{
Exprent newexpr = ReplaceAccessExprent(caller, meth, (InvocationExprent)expr);
if (newexpr != null)
{
exprent.ReplaceExprent(expr, newexpr);
found = true;
res = true;
break;
}
}
}
if (!found)
{
break;
}
}
return(res);
}
private static Exprent IsSimpleConstructorInvocation(Exprent exprent)
{
List <Exprent> lst = exprent.GetAllExprents();
foreach (Exprent expr in lst)
{
Exprent ret = IsSimpleConstructorInvocation(expr);
if (ret != null)
{
exprent.ReplaceExprent(expr, ret);
}
}
if (exprent.type == Exprent.Exprent_Invocation)
{
InvocationExprent @in = (InvocationExprent)exprent;
if (@in.GetFunctype() == InvocationExprent.Typ_Init && @in.GetInstance().type ==
Exprent.Exprent_New)
{
NewExprent newExpr = (NewExprent)@in.GetInstance();
newExpr.SetConstructor(@in);
@in.SetInstance(null);
return(newExpr);
}
}
return(null);
}
private static bool IsQualifiedNewGetClass(Exprent first, Exprent second)
{
if (first.type == Exprent.Exprent_Invocation)
{
InvocationExprent invocation = (InvocationExprent)first;
if (!invocation.IsStatic() && invocation.GetInstance().type == Exprent.Exprent_Var &&
invocation.GetName().Equals("getClass") && invocation.GetStringDescriptor().
Equals("()Ljava/lang/Class;"))
{
List <Exprent> lstExprents = second.GetAllExprents();
lstExprents.Add(second);
foreach (Exprent expr in lstExprents)
{
if (expr.type == Exprent.Exprent_New)
{
NewExprent newExpr = (NewExprent)expr;
if (newExpr.GetConstructor() != null && !(newExpr.GetConstructor().GetLstParameters
().Count == 0) && newExpr.GetConstructor().GetLstParameters()[0].Equals(invocation
.GetInstance()))
{
string classname = newExpr.GetNewType().value;
ClassesProcessor.ClassNode node = DecompilerContext.GetClassProcessor().GetMapRootClasses
().GetOrNull(classname);
if (node != null && node.type != ClassesProcessor.ClassNode.Class_Root)
{
return(true);
}
}
}
}
}
}
return(false);
}
private static bool ReplaceInvocations(Exprent exprent, ClassWrapper wrapper, MethodWrapper
meth)
{
bool res = false;
while (true)
{
bool found = false;
foreach (Exprent expr in exprent.GetAllExprents())
{
string cl = IsClass14Invocation(expr, wrapper, meth);
if (cl != null)
{
exprent.ReplaceExprent(expr, new ConstExprent(VarType.Vartype_Class, cl.Replace('.'
, '/'), expr.bytecode));
found = true;
res = true;
break;
}
res |= ReplaceInvocations(expr, wrapper, meth);
}
if (!found)
{
break;
}
}
return(res);
}
private static bool IsExprentIndependent(Exprent exprent, MethodWrapper method)
{
List <Exprent> lst = exprent.GetAllExprents(true);
lst.Add(exprent);
foreach (Exprent expr in lst)
{
switch (expr.type)
{
case Exprent.Exprent_Var:
{
VarVersionPair varPair = new VarVersionPair((VarExprent)expr);
if (!method.varproc.GetExternalVars().Contains(varPair))
{
string varName = method.varproc.GetVarName(varPair);
if (!varName.Equals("this") && !varName.EndsWith(".this"))
{
// FIXME: remove direct comparison with strings
return(false);
}
}
break;
}
case Exprent.Exprent_Field:
{
return(false);
}
}
}
return(true);
}
private static Exprent IsLambda(Exprent exprent, StructClass cl)
{
List <Exprent> lst = exprent.GetAllExprents();
foreach (Exprent expr in lst)
{
Exprent ret = IsLambda(expr, cl);
if (ret != null)
{
exprent.ReplaceExprent(expr, ret);
}
}
if (exprent.type == Exprent.Exprent_Invocation)
{
InvocationExprent @in = (InvocationExprent)exprent;
if (@in.GetInvocationTyp() == InvocationExprent.Invoke_Dynamic)
{
string lambda_class_name = cl.qualifiedName + @in.GetInvokeDynamicClassSuffix();
ClassesProcessor.ClassNode lambda_class = DecompilerContext.GetClassProcessor().GetMapRootClasses
().GetOrNull(lambda_class_name);
if (lambda_class != null)
{
// real lambda class found, replace invocation with an anonymous class
NewExprent newExpr = new NewExprent(new VarType(lambda_class_name, true), null, 0
, @in.bytecode);
newExpr.SetConstructor(@in);
// note: we don't set the instance to null with in.setInstance(null) like it is done for a common constructor invocation
// lambda can also be a reference to a virtual method (e.g. String x; ...(x::toString);)
// in this case instance will hold the corresponding object
return(newExpr);
}
}
}
return(null);
}
private static Dictionary <int, HashSet <VarVersionPair> > GetAllVarVersions(VarVersionPair
leftvar, Exprent exprent, SSAUConstructorSparseEx ssau)
{
Dictionary <int, HashSet <VarVersionPair> > map = new Dictionary <int, HashSet <VarVersionPair
> >();
SFormsFastMapDirect mapLiveVars = ssau.GetLiveVarVersionsMap(leftvar);
List <Exprent> lst = exprent.GetAllExprents(true);
lst.Add(exprent);
foreach (Exprent expr in lst)
{
if (expr.type == Exprent.Exprent_Var)
{
int varindex = ((VarExprent)expr).GetIndex();
if (leftvar.var != varindex)
{
if (mapLiveVars.ContainsKey(varindex))
{
HashSet <VarVersionPair> verset = new HashSet <VarVersionPair>();
foreach (int vers in mapLiveVars.Get(varindex))
{
verset.Add(new VarVersionPair(varindex, vers));
}
Sharpen.Collections.Put(map, varindex, verset);
}
else
{
throw new Exception("inkonsistent live map!");
}
}
else
{
Sharpen.Collections.Put(map, varindex, null);
}
}
else if (expr.type == Exprent.Exprent_Field)
{
if (ssau.GetMapFieldVars().ContainsKey(expr.id))
{
int?varindex = ssau.GetMapFieldVars().GetOrNullable(expr.id);
if (mapLiveVars.ContainsKey(varindex.Value))
{
HashSet <VarVersionPair> verset = new HashSet <VarVersionPair>();
foreach (int vers in mapLiveVars.Get(varindex.Value))
{
verset.Add(new VarVersionPair(varindex.Value, vers));
}
Sharpen.Collections.Put(map, varindex.Value, verset);
}
}
}
}
return(map);
}
private static void SetExprentVersionsToNull(Exprent exprent)
{
List <Exprent> lst = exprent.GetAllExprents(true);
lst.Add(exprent);
foreach (Exprent expr in lst)
{
if (expr.type == Exprent.Exprent_Var)
{
((VarExprent)expr).SetVersion(0);
}
}
}
private static HashSet <VarVersionPair> GetAllVersions(Exprent exprent)
{
HashSet <VarVersionPair> res = new HashSet <VarVersionPair>();
List <Exprent> listTemp = new List <Exprent>(exprent.GetAllExprents(true));
listTemp.Add(exprent);
foreach (Exprent expr in listTemp)
{
if (expr.type == Exprent.Exprent_Var)
{
VarExprent var = (VarExprent)expr;
res.Add(new VarVersionPair(var));
}
}
return(res);
}
private bool CheckTypeExprent(Exprent exprent)
{
foreach (Exprent expr in exprent.GetAllExprents())
{
if (!CheckTypeExprent(expr))
{
return(false);
}
}
if (exprent.type == Exprent.Exprent_Const)
{
ConstExprent constExpr = (ConstExprent)exprent;
if (constExpr.GetConstType().typeFamily <= ICodeConstants.Type_Family_Integer)
{
// boolean or integer
VarVersionPair pair = new VarVersionPair(constExpr.id, -1);
if (!mapExprentMinTypes.ContainsKey(pair))
{
Sharpen.Collections.Put(mapExprentMinTypes, pair, constExpr.GetConstType());
}
}
}
CheckTypesResult result = exprent.CheckExprTypeBounds();
bool res = true;
if (result != null)
{
foreach (CheckTypesResult.ExprentTypePair entry in result.GetLstMaxTypeExprents())
{
if (entry.type.typeFamily != ICodeConstants.Type_Family_Object)
{
ChangeExprentType(entry.exprent, entry.type, 1);
}
}
foreach (CheckTypesResult.ExprentTypePair entry in result.GetLstMinTypeExprents())
{
res &= ChangeExprentType(entry.exprent, entry.type, 0);
}
}
return(res);
}
private static object[] IterateChildExprent(Exprent exprent, Exprent parent, Exprent
next, Dictionary <VarVersionPair, Exprent> mapVarValues, SSAUConstructorSparseEx
ssau)
{
bool changed = false;
foreach (Exprent expr in exprent.GetAllExprents())
{
var oldExpr = expr;
while (true)
{
object[] arr = IterateChildExprent(oldExpr, parent, next, mapVarValues, ssau);
Exprent retexpr = (Exprent)arr[0];
changed |= (bool)arr[1];
bool isReplaceable = (bool)arr[2];
if (retexpr != null)
{
if (isReplaceable)
{
ReplaceSingleVar(exprent, (VarExprent)oldExpr, retexpr, ssau);
oldExpr = retexpr;
}
else
{
exprent.ReplaceExprent(oldExpr, retexpr);
}
changed = true;
}
if (!isReplaceable)
{
break;
}
}
}
Exprent dest = IsReplaceableVar(exprent, mapVarValues);
if (dest != null)
{
return(new object[] { dest, true, true });
}
VarExprent left = null;
Exprent right = null;
if (exprent.type == Exprent.Exprent_Assignment)
{
AssignmentExprent @as = (AssignmentExprent)exprent;
if (@as.GetLeft().type == Exprent.Exprent_Var)
{
left = (VarExprent)@as.GetLeft();
right = @as.GetRight();
}
}
if (left == null)
{
return(new object[] { null, changed, false });
}
bool isHeadSynchronized = false;
if (next == null && parent.type == Exprent.Exprent_Monitor)
{
MonitorExprent monexpr = (MonitorExprent)parent;
if (monexpr.GetMonType() == MonitorExprent.Monitor_Enter && exprent.Equals(monexpr
.GetValue()))
{
isHeadSynchronized = true;
}
}
// stack variable or synchronized head exprent
if (!left.IsStack() && !isHeadSynchronized)
{
return(new object[] { null, changed, false });
}
VarVersionPair leftpaar = new VarVersionPair(left);
List <VarVersionNode> usedVers = new List <VarVersionNode>();
bool notdom = GetUsedVersions(ssau, leftpaar, usedVers);
if (!notdom && (usedVers.Count == 0))
{
return(new object[] { right, changed, false });
}
// stack variables only
if (!left.IsStack())
{
return(new object[] { null, changed, false });
}
int useflags = right.GetExprentUse();
if ((useflags & Exprent.Both_Flags) != Exprent.Both_Flags)
{
return(new object[] { null, changed, false });
}
Dictionary <int, HashSet <VarVersionPair> > mapVars = GetAllVarVersions(leftpaar, right
, ssau);
if (mapVars.ContainsKey(leftpaar.var) && notdom)
{
return(new object[] { null, changed, false });
}
Sharpen.Collections.Remove(mapVars, leftpaar.var);
HashSet <VarVersionPair> setAllowedVars = GetAllVersions(parent);
if (next != null)
{
Sharpen.Collections.AddAll(setAllowedVars, GetAllVersions(next));
}
bool vernotreplaced = false;
HashSet <VarVersionPair> setTempUsedVers = new HashSet <VarVersionPair>();
foreach (VarVersionNode usedvar in usedVers)
{
VarVersionPair usedver = new VarVersionPair(usedvar.var, usedvar.version);
if (IsVersionToBeReplaced(usedver, mapVars, ssau, leftpaar) && (right.type == Exprent
.Exprent_Var || setAllowedVars.Contains(usedver)))
{
setTempUsedVers.Add(usedver);
}
else
{
vernotreplaced = true;
}
}
if (!notdom && !vernotreplaced)
{
foreach (VarVersionPair usedver in setTempUsedVers)
{
Exprent copy = right.Copy();
if (right.type == Exprent.Exprent_Field && ssau.GetMapFieldVars().ContainsKey(right
.id))
{
Sharpen.Collections.Put(ssau.GetMapFieldVars(), copy.id, ssau.GetMapFieldVars().GetOrNullable
(right.id));
}
Sharpen.Collections.Put(mapVarValues, usedver, copy);
}
// remove assignment
return(new object[] { right, changed, false });
}
return(new object[] { null, changed, false });
}
private int[] IterateExprent(List <Exprent> lstExprents, int index, Exprent next,
Dictionary <VarVersionPair, Exprent> mapVarValues, SSAUConstructorSparseEx ssau)
{
Exprent exprent = lstExprents[index];
int changed = 0;
foreach (Exprent expr in exprent.GetAllExprents())
{
var oldExpr = expr;
while (true)
{
object[] arr = IterateChildExprent(oldExpr, exprent, next, mapVarValues, ssau);
Exprent retexpr = (Exprent)arr[0];
changed |= (bool)arr[1] ? 1 : 0;
bool isReplaceable = (bool)arr[2];
if (retexpr != null)
{
if (isReplaceable)
{
ReplaceSingleVar(exprent, (VarExprent)oldExpr, retexpr, ssau);
oldExpr = retexpr;
}
else
{
exprent.ReplaceExprent(oldExpr, retexpr);
}
changed = 1;
}
if (!isReplaceable)
{
break;
}
}
}
// no var on the highest level, so no replacing
VarExprent left = null;
Exprent right = null;
if (exprent.type == Exprent.Exprent_Assignment)
{
AssignmentExprent @as = (AssignmentExprent)exprent;
if (@as.GetLeft().type == Exprent.Exprent_Var)
{
left = (VarExprent)@as.GetLeft();
right = @as.GetRight();
}
}
if (left == null)
{
return(new int[] { -1, changed });
}
VarVersionPair leftpaar = new VarVersionPair(left);
List <VarVersionNode> usedVers = new List <VarVersionNode>();
bool notdom = GetUsedVersions(ssau, leftpaar, usedVers);
if (!notdom && (usedVers.Count == 0))
{
if (left.IsStack() && (right.type == Exprent.Exprent_Invocation || right.type ==
Exprent.Exprent_Assignment || right.type == Exprent.Exprent_New))
{
if (right.type == Exprent.Exprent_New)
{
// new Object(); permitted
NewExprent nexpr = (NewExprent)right;
if (nexpr.IsAnonymous() || nexpr.GetNewType().arrayDim > 0 || nexpr.GetNewType().
type != ICodeConstants.Type_Object)
{
return(new int[] { -1, changed });
}
}
lstExprents[index] = right;
return(new int[] { index + 1, 1 });
}
else if (right.type == Exprent.Exprent_Var)
{
lstExprents.RemoveAtReturningValue(index);
return(new int[] { index, 1 });
}
else
{
return(new int[] { -1, changed });
}
}
int useflags = right.GetExprentUse();
// stack variables only
if (!left.IsStack() && (right.type != Exprent.Exprent_Var || ((VarExprent)right).
IsStack()))
{
// special case catch(... ex)
return(new int[] { -1, changed });
}
if ((useflags & Exprent.Multiple_Uses) == 0 && (notdom || usedVers.Count > 1))
{
return(new int[] { -1, changed });
}
Dictionary <int, HashSet <VarVersionPair> > mapVars = GetAllVarVersions(leftpaar, right
, ssau);
bool isSelfReference = mapVars.ContainsKey(leftpaar.var);
if (isSelfReference && notdom)
{
return(new int[] { -1, changed });
}
HashSet <VarVersionPair> setNextVars = next == null ? null : GetAllVersions(next);
// FIXME: fix the entire method!
if (right.type != Exprent.Exprent_Const && right.type != Exprent.Exprent_Var && setNextVars
!= null && mapVars.ContainsKey(leftpaar.var))
{
foreach (VarVersionNode usedvar in usedVers)
{
if (!setNextVars.Contains(new VarVersionPair(usedvar.var, usedvar.version)))
{
return(new int[] { -1, changed });
}
}
}
Sharpen.Collections.Remove(mapVars, leftpaar.var);
bool vernotreplaced = false;
bool verreplaced = false;
HashSet <VarVersionPair> setTempUsedVers = new HashSet <VarVersionPair>();
foreach (VarVersionNode usedvar in usedVers)
{
VarVersionPair usedver = new VarVersionPair(usedvar.var, usedvar.version);
if (IsVersionToBeReplaced(usedver, mapVars, ssau, leftpaar) && (right.type == Exprent
.Exprent_Const || right.type == Exprent.Exprent_Var || right.type == Exprent.Exprent_Field ||
setNextVars == null || setNextVars.Contains(usedver)))
{
setTempUsedVers.Add(usedver);
verreplaced = true;
}
else
{
vernotreplaced = true;
}
}
if (isSelfReference && vernotreplaced)
{
return(new int[] { -1, changed });
}
else
{
foreach (VarVersionPair usedver in setTempUsedVers)
{
Exprent copy = right.Copy();
if (right.type == Exprent.Exprent_Field && ssau.GetMapFieldVars().ContainsKey(right
.id))
{
Sharpen.Collections.Put(ssau.GetMapFieldVars(), copy.id, ssau.GetMapFieldVars().GetOrNullable
(right.id));
}
Sharpen.Collections.Put(mapVarValues, usedver, copy);
}
}
if (!notdom && !vernotreplaced)
{
// remove assignment
lstExprents.RemoveAtReturningValue(index);
return(new int[] { index, 1 });
}
else if (verreplaced)
{
return(new int[] { index + 1, changed });
}
else
{
return(new int[] { -1, changed });
}
}
private void ProcessExprent(Exprent expr, SFormsFastMapDirect[] varmaparr)
{
if (expr == null)
{
return;
}
VarExprent varassign = null;
bool finished = false;
switch (expr.type)
{
case Exprent.Exprent_Assignment:
{
AssignmentExprent assexpr = (AssignmentExprent)expr;
if (assexpr.GetCondType() == AssignmentExprent.Condition_None)
{
Exprent dest = assexpr.GetLeft();
if (dest.type == Exprent.Exprent_Var)
{
varassign = (VarExprent)dest;
}
}
break;
}
case Exprent.Exprent_Function:
{
FunctionExprent func = (FunctionExprent)expr;
switch (func.GetFuncType())
{
case FunctionExprent.Function_Iif:
{
ProcessExprent(func.GetLstOperands()[0], varmaparr);
SFormsFastMapDirect varmapFalse;
if (varmaparr[1] == null)
{
varmapFalse = new SFormsFastMapDirect(varmaparr[0]);
}
else
{
varmapFalse = varmaparr[1];
varmaparr[1] = null;
}
ProcessExprent(func.GetLstOperands()[1], varmaparr);
SFormsFastMapDirect[] varmaparrNeg = new SFormsFastMapDirect[] { varmapFalse, null };
ProcessExprent(func.GetLstOperands()[2], varmaparrNeg);
MergeMaps(varmaparr[0], varmaparrNeg[0]);
varmaparr[1] = null;
finished = true;
break;
}
case FunctionExprent.Function_Cadd:
{
ProcessExprent(func.GetLstOperands()[0], varmaparr);
SFormsFastMapDirect[] varmaparrAnd = new SFormsFastMapDirect[] { new SFormsFastMapDirect
(varmaparr[0]), null };
ProcessExprent(func.GetLstOperands()[1], varmaparrAnd);
// false map
varmaparr[1] = MergeMaps(varmaparr[varmaparr[1] == null ? 0 : 1], varmaparrAnd[varmaparrAnd
[1] == null ? 0 : 1]);
// true map
varmaparr[0] = varmaparrAnd[0];
finished = true;
break;
}
case FunctionExprent.Function_Cor:
{
ProcessExprent(func.GetLstOperands()[0], varmaparr);
SFormsFastMapDirect[] varmaparrOr = new SFormsFastMapDirect[] { new SFormsFastMapDirect
(varmaparr[varmaparr[1] == null ? 0 : 1]), null };
ProcessExprent(func.GetLstOperands()[1], varmaparrOr);
// false map
varmaparr[1] = varmaparrOr[varmaparrOr[1] == null ? 0 : 1];
// true map
varmaparr[0] = MergeMaps(varmaparr[0], varmaparrOr[0]);
finished = true;
break;
}
}
break;
}
}
if (finished)
{
return;
}
List <Exprent> lst = expr.GetAllExprents();
lst.Remove(varassign);
foreach (Exprent ex in lst)
{
ProcessExprent(ex, varmaparr);
}
SFormsFastMapDirect varmap = varmaparr[0];
if (varassign != null)
{
int varindex = varassign.GetIndex();
if (varassign.GetVersion() == 0)
{
// get next version
int nextver = GetNextFreeVersion(varindex);
// set version
varassign.SetVersion(nextver);
SetCurrentVar(varmap, varindex, nextver);
}
else
{
SetCurrentVar(varmap, varindex, varassign.GetVersion());
}
}
else if (expr.type == Exprent.Exprent_Var)
{
VarExprent vardest = (VarExprent)expr;
int varindex = vardest.GetIndex();
FastSparseSetFactory <int> .FastSparseSet <int> vers = varmap.Get(varindex);
int cardinality = vers.GetCardinality();
if (cardinality == 1)
{
// == 1
// set version
int it = new Sharpen.EnumeratorAdapter <int>(vers.GetEnumerator()).Next();
vardest.SetVersion(it);
}
else if (cardinality == 2)
{
// size > 1
int current_vers = vardest.GetVersion();
VarVersionPair currpaar = new VarVersionPair(varindex, current_vers);
if (current_vers != 0 && phi.ContainsKey(currpaar))
{
SetCurrentVar(varmap, varindex, current_vers);
// update phi node
phi.GetOrNull(currpaar).Union(vers);
}
else
{
// increase version
int nextver = GetNextFreeVersion(varindex);
// set version
vardest.SetVersion(nextver);
SetCurrentVar(varmap, varindex, nextver);
// create new phi node
Sharpen.Collections.Put(phi, new VarVersionPair(varindex, nextver), vers);
}
}
}
}
private FinallyProcessor.Record GetFinallyInformation(StructMethod mt, RootStatement
root, CatchAllStatement fstat)
{
Dictionary <BasicBlock, bool> mapLast = new Dictionary <BasicBlock, bool>();
BasicBlockStatement firstBlockStatement = fstat.GetHandler().GetBasichead();
BasicBlock firstBasicBlock = firstBlockStatement.GetBlock();
Instruction instrFirst = firstBasicBlock.GetInstruction(0);
int firstcode = 0;
switch (instrFirst.opcode)
{
case ICodeConstants.opc_pop:
{
firstcode = 1;
break;
}
case ICodeConstants.opc_astore:
{
firstcode = 2;
break;
}
}
ExprProcessor proc = new ExprProcessor(methodDescriptor, varProcessor);
proc.ProcessStatement(root, mt.GetClassStruct());
SSAConstructorSparseEx ssa = new SSAConstructorSparseEx();
ssa.SplitVariables(root, mt);
List <Exprent> lstExprents = firstBlockStatement.GetExprents();
VarVersionPair varpaar = new VarVersionPair((VarExprent)((AssignmentExprent)lstExprents
[firstcode == 2 ? 1 : 0]).GetLeft());
FlattenStatementsHelper flatthelper = new FlattenStatementsHelper();
DirectGraph dgraph = flatthelper.BuildDirectGraph(root);
LinkedList <DirectNode> stack = new LinkedList <DirectNode>();
stack.AddLast(dgraph.first);
HashSet <DirectNode> setVisited = new HashSet <DirectNode>();
while (!(stack.Count == 0))
{
DirectNode node = Sharpen.Collections.RemoveFirst(stack);
if (setVisited.Contains(node))
{
continue;
}
setVisited.Add(node);
BasicBlockStatement blockStatement = null;
if (node.block != null)
{
blockStatement = node.block;
}
else if (node.preds.Count == 1)
{
blockStatement = node.preds[0].block;
}
bool isTrueExit = true;
if (firstcode != 1)
{
isTrueExit = false;
for (int i = 0; i < node.exprents.Count; i++)
{
Exprent exprent = node.exprents[i];
if (firstcode == 0)
{
List <Exprent> lst = exprent.GetAllExprents();
lst.Add(exprent);
bool found = false;
foreach (Exprent expr in lst)
{
if (expr.type == Exprent.Exprent_Var && new VarVersionPair((VarExprent)expr).Equals
(varpaar))
{
found = true;
break;
}
}
if (found)
{
found = false;
if (exprent.type == Exprent.Exprent_Exit)
{
ExitExprent exexpr = (ExitExprent)exprent;
if (exexpr.GetExitType() == ExitExprent.Exit_Throw && exexpr.GetValue().type == Exprent
.Exprent_Var)
{
found = true;
}
}
if (!found)
{
return(null);
}
else
{
isTrueExit = true;
}
}
}
else if (firstcode == 2)
{
// search for a load instruction
if (exprent.type == Exprent.Exprent_Assignment)
{
AssignmentExprent assexpr = (AssignmentExprent)exprent;
if (assexpr.GetRight().type == Exprent.Exprent_Var && new VarVersionPair((VarExprent
)assexpr.GetRight()).Equals(varpaar))
{
Exprent next = null;
if (i == node.exprents.Count - 1)
{
if (node.succs.Count == 1)
{
DirectNode nd = node.succs[0];
if (!(nd.exprents.Count == 0))
{
next = nd.exprents[0];
}
}
}
else
{
next = node.exprents[i + 1];
}
bool found = false;
if (next != null && next.type == Exprent.Exprent_Exit)
{
ExitExprent exexpr = (ExitExprent)next;
if (exexpr.GetExitType() == ExitExprent.Exit_Throw && exexpr.GetValue().type == Exprent
.Exprent_Var && assexpr.GetLeft().Equals(exexpr.GetValue()))
{
found = true;
}
}
if (!found)
{
return(null);
}
else
{
isTrueExit = true;
}
}
}
}
}
}
// find finally exits
if (blockStatement != null && blockStatement.GetBlock() != null)
{
Statement handler = fstat.GetHandler();
foreach (StatEdge edge in blockStatement.GetSuccessorEdges(Statement.Statedge_Direct_All
))
{
if (edge.GetType() != StatEdge.Type_Regular && handler.ContainsStatement(blockStatement
) && !handler.ContainsStatement(edge.GetDestination()))
{
bool?existingFlag = mapLast.GetOrNullable(blockStatement.GetBlock());
// note: the dummy node is also processed!
if (existingFlag == null || !existingFlag.Value)
{
Sharpen.Collections.Put(mapLast, blockStatement.GetBlock(), isTrueExit);
break;
}
}
}
}
Sharpen.Collections.AddAll(stack, node.succs);
}
// empty finally block?
if (fstat.GetHandler().type == Statement.Type_Basicblock)
{
bool isEmpty = false;
bool isFirstLast = mapLast.ContainsKey(firstBasicBlock);
InstructionSequence seq = firstBasicBlock.GetSeq();
switch (firstcode)
{
case 0:
{
isEmpty = isFirstLast && seq.Length() == 1;
break;
}
case 1:
{
isEmpty = seq.Length() == 1;
break;
}
case 2:
{
isEmpty = isFirstLast ? seq.Length() == 3 : seq.Length() == 1;
break;
}
}
if (isEmpty)
{
firstcode = 3;
}
}
return(new FinallyProcessor.Record(firstcode, mapLast));
}
private Exprent ProcessExprentRecursive(Exprent exprent)
{
bool replaced = true;
while (replaced)
{
replaced = false;
foreach (Exprent expr in exprent.GetAllExprents())
{
Exprent retexpr = ProcessExprentRecursive(expr);
if (retexpr != null)
{
exprent.ReplaceExprent(expr, retexpr);
replaced = true;
exprentReplaced = true;
break;
}
}
}
if (exprent.type == Exprent.Exprent_Assignment)
{
AssignmentExprent @as = (AssignmentExprent)exprent;
if (@as.GetRight().type == Exprent.Exprent_Function)
{
FunctionExprent func = (FunctionExprent)@as.GetRight();
VarType midlayer = null;
if (func.GetFuncType() >= FunctionExprent.Function_I2l && func.GetFuncType() <= FunctionExprent
.Function_I2s)
{
midlayer = func.GetSimpleCastType();
if (func.GetLstOperands()[0].type == Exprent.Exprent_Function)
{
func = (FunctionExprent)func.GetLstOperands()[0];
}
else
{
return(null);
}
}
if (func.GetFuncType() == FunctionExprent.Function_Add || func.GetFuncType() == FunctionExprent
.Function_Sub)
{
Exprent econd = func.GetLstOperands()[0];
Exprent econst = func.GetLstOperands()[1];
if (econst.type != Exprent.Exprent_Const && econd.type == Exprent.Exprent_Const &&
func.GetFuncType() == FunctionExprent.Function_Add)
{
econd = econst;
econst = func.GetLstOperands()[0];
}
if (econst.type == Exprent.Exprent_Const && ((ConstExprent)econst).HasValueOne())
{
Exprent left = @as.GetLeft();
VarType condtype = econd.GetExprType();
if (left.Equals(econd) && (midlayer == null || midlayer.Equals(condtype)))
{
FunctionExprent ret = new FunctionExprent(func.GetFuncType() == FunctionExprent.Function_Add
? FunctionExprent.Function_Ppi : FunctionExprent.Function_Mmi, econd, func.bytecode
);
ret.SetImplicitType(condtype);
exprentReplaced = true;
return(ret);
}
}
}
}
}
return(null);
}
private void ProcessExprent(Exprent expr, SFormsFastMapDirect[] varmaparr, Statement
stat, bool calcLiveVars)
{
if (expr == null)
{
return;
}
VarExprent varassign = null;
bool finished = false;
switch (expr.type)
{
case Exprent.Exprent_Assignment:
{
AssignmentExprent assexpr = (AssignmentExprent)expr;
if (assexpr.GetCondType() == AssignmentExprent.Condition_None)
{
Exprent dest = assexpr.GetLeft();
if (dest.type == Exprent.Exprent_Var)
{
varassign = (VarExprent)dest;
}
}
break;
}
case Exprent.Exprent_Function:
{
FunctionExprent func = (FunctionExprent)expr;
switch (func.GetFuncType())
{
case FunctionExprent.Function_Iif:
{
ProcessExprent(func.GetLstOperands()[0], varmaparr, stat, calcLiveVars);
SFormsFastMapDirect varmapFalse;
if (varmaparr[1] == null)
{
varmapFalse = new SFormsFastMapDirect(varmaparr[0]);
}
else
{
varmapFalse = varmaparr[1];
varmaparr[1] = null;
}
ProcessExprent(func.GetLstOperands()[1], varmaparr, stat, calcLiveVars);
SFormsFastMapDirect[] varmaparrNeg = new SFormsFastMapDirect[] { varmapFalse, null };
ProcessExprent(func.GetLstOperands()[2], varmaparrNeg, stat, calcLiveVars);
MergeMaps(varmaparr[0], varmaparrNeg[0]);
varmaparr[1] = null;
finished = true;
break;
}
case FunctionExprent.Function_Cadd:
{
ProcessExprent(func.GetLstOperands()[0], varmaparr, stat, calcLiveVars);
SFormsFastMapDirect[] varmaparrAnd = new SFormsFastMapDirect[] { new SFormsFastMapDirect
(varmaparr[0]), null };
ProcessExprent(func.GetLstOperands()[1], varmaparrAnd, stat, calcLiveVars);
// false map
varmaparr[1] = MergeMaps(varmaparr[varmaparr[1] == null ? 0 : 1], varmaparrAnd[varmaparrAnd
[1] == null ? 0 : 1]);
// true map
varmaparr[0] = varmaparrAnd[0];
finished = true;
break;
}
case FunctionExprent.Function_Cor:
{
ProcessExprent(func.GetLstOperands()[0], varmaparr, stat, calcLiveVars);
SFormsFastMapDirect[] varmaparrOr = new SFormsFastMapDirect[] { new SFormsFastMapDirect
(varmaparr[varmaparr[1] == null ? 0 : 1]), null };
ProcessExprent(func.GetLstOperands()[1], varmaparrOr, stat, calcLiveVars);
// false map
varmaparr[1] = varmaparrOr[varmaparrOr[1] == null ? 0 : 1];
// true map
varmaparr[0] = MergeMaps(varmaparr[0], varmaparrOr[0]);
finished = true;
break;
}
}
break;
}
}
if (!finished)
{
List <Exprent> lst = expr.GetAllExprents();
lst.Remove(varassign);
foreach (Exprent ex in lst)
{
ProcessExprent(ex, varmaparr, stat, calcLiveVars);
}
}
SFormsFastMapDirect varmap = varmaparr[0];
// field access
if (expr.type == Exprent.Exprent_Field)
{
int?index;
if (mapFieldVars.ContainsKey(expr.id))
{
index = mapFieldVars.GetOrNullable(expr.id);
}
else
{
index = fieldvarcounter--;
Sharpen.Collections.Put(mapFieldVars, expr.id, index);
// ssu graph
ssuversions.CreateNode(new VarVersionPair(index, 1));
}
SetCurrentVar(varmap, index, 1);
}
else if (expr.type == Exprent.Exprent_Invocation || (expr.type == Exprent.Exprent_Assignment &&
((AssignmentExprent)expr).GetLeft().type == Exprent.Exprent_Field) || (expr.
type == Exprent.Exprent_New && ((NewExprent)expr).GetNewType().type == ICodeConstants
.Type_Object) || expr.type == Exprent.Exprent_Function)
{
bool ismmpp = true;
if (expr.type == Exprent.Exprent_Function)
{
ismmpp = false;
FunctionExprent fexpr = (FunctionExprent)expr;
if (fexpr.GetFuncType() >= FunctionExprent.Function_Imm && fexpr.GetFuncType() <=
FunctionExprent.Function_Ppi)
{
if (fexpr.GetLstOperands()[0].type == Exprent.Exprent_Field)
{
ismmpp = true;
}
}
}
if (ismmpp)
{
varmap.RemoveAllFields();
}
}
if (varassign != null)
{
int varindex = varassign.GetIndex();
if (varassign.GetVersion() == 0)
{
// get next version
int nextver = GetNextFreeVersion(varindex, stat);
// set version
varassign.SetVersion(nextver);
// ssu graph
ssuversions.CreateNode(new VarVersionPair(varindex, nextver));
SetCurrentVar(varmap, varindex, nextver);
}
else
{
if (calcLiveVars)
{
VarMapToGraph(new VarVersionPair(varindex, varassign.GetVersion()), varmap);
}
SetCurrentVar(varmap, varindex, varassign.GetVersion());
}
}
else if (expr.type == Exprent.Exprent_Function)
{
// MM or PP function
FunctionExprent func_1 = (FunctionExprent)expr;
switch (func_1.GetFuncType())
{
case FunctionExprent.Function_Imm:
case FunctionExprent.Function_Mmi:
case FunctionExprent.Function_Ipp:
case FunctionExprent.Function_Ppi:
{
if (func_1.GetLstOperands()[0].type == Exprent.Exprent_Var)
{
VarExprent var = (VarExprent)func_1.GetLstOperands()[0];
int varindex = var.GetIndex();
VarVersionPair varpaar = new VarVersionPair(varindex, var.GetVersion());
// ssu graph
VarVersionPair phantomver = phantomppnodes.GetOrNull(varpaar);
if (phantomver == null)
{
// get next version
int nextver = GetNextFreeVersion(varindex, null);
phantomver = new VarVersionPair(varindex, nextver);
//ssuversions.createOrGetNode(phantomver);
ssuversions.CreateNode(phantomver);
VarVersionNode vernode = ssuversions.nodes.GetWithKey(varpaar);
FastSparseSetFactory <int> .FastSparseSet <int> vers = factory.SpawnEmptySet();
if (vernode.preds.Count == 1)
{
vers.Add(new Sharpen.EnumeratorAdapter <VarVersionEdge>(vernode.preds.GetEnumerator()).Next().source.version);
}
else
{
foreach (VarVersionEdge edge in vernode.preds)
{
vers.Add(new Sharpen.EnumeratorAdapter <VarVersionEdge>(edge.source.preds.GetEnumerator()).Next().source.version);
}
}
vers.Add(nextver);
CreateOrUpdatePhiNode(varpaar, vers, stat);
Sharpen.Collections.Put(phantomppnodes, varpaar, phantomver);
}
if (calcLiveVars)
{
VarMapToGraph(varpaar, varmap);
}
SetCurrentVar(varmap, varindex, var.GetVersion());
}
break;
}
}
}
else if (expr.type == Exprent.Exprent_Var)
{
VarExprent vardest = (VarExprent)expr;
int varindex = vardest.GetIndex();
int current_vers = vardest.GetVersion();
FastSparseSetFactory <int> .FastSparseSet <int> vers = varmap.Get(varindex);
int cardinality = vers.GetCardinality();
if (cardinality == 1)
{
// size == 1
if (current_vers != 0)
{
if (calcLiveVars)
{
VarMapToGraph(new VarVersionPair(varindex, current_vers), varmap);
}
SetCurrentVar(varmap, varindex, current_vers);
}
else
{
// split last version
int usever = GetNextFreeVersion(varindex, stat);
// set version
vardest.SetVersion(usever);
SetCurrentVar(varmap, varindex, usever);
// ssu graph
int lastver = new Sharpen.EnumeratorAdapter <int>(vers.GetEnumerator()).Next();
VarVersionNode prenode = ssuversions.nodes.GetWithKey(new VarVersionPair(varindex
, lastver));
VarVersionNode usenode = ssuversions.CreateNode(new VarVersionPair(varindex, usever
));
VarVersionEdge edge = new VarVersionEdge(VarVersionEdge.Edge_General, prenode, usenode
);
prenode.AddSuccessor(edge);
usenode.AddPredecessor(edge);
}
}
else if (cardinality == 2)
{
// size > 1
if (current_vers != 0)
{
if (calcLiveVars)
{
VarMapToGraph(new VarVersionPair(varindex, current_vers), varmap);
}
SetCurrentVar(varmap, varindex, current_vers);
}
else
{
// split version
int usever = GetNextFreeVersion(varindex, stat);
// set version
vardest.SetVersion(usever);
// ssu node
ssuversions.CreateNode(new VarVersionPair(varindex, usever));
SetCurrentVar(varmap, varindex, usever);
current_vers = usever;
}
CreateOrUpdatePhiNode(new VarVersionPair(varindex, current_vers), vers, stat);
}
}
}
private static Exprent IdentifySecondaryFunctions(Exprent exprent, bool statement_level
, VarProcessor varProc)
{
if (exprent.type == Exprent.Exprent_Function)
{
FunctionExprent fexpr = (FunctionExprent)exprent;
switch (fexpr.GetFuncType())
{
case FunctionExprent.Function_Bool_Not:
{
Exprent retparam = PropagateBoolNot(fexpr);
if (retparam != null)
{
return(retparam);
}
break;
}
case FunctionExprent.Function_Eq:
case FunctionExprent.Function_Ne:
case FunctionExprent.Function_Gt:
case FunctionExprent.Function_Ge:
case FunctionExprent.Function_Lt:
case FunctionExprent.Function_Le:
{
Exprent expr1 = fexpr.GetLstOperands()[0];
Exprent expr2 = fexpr.GetLstOperands()[1];
if (expr1.type == Exprent.Exprent_Const)
{
expr2 = expr1;
expr1 = fexpr.GetLstOperands()[1];
}
if (expr1.type == Exprent.Exprent_Function && expr2.type == Exprent.Exprent_Const)
{
FunctionExprent funcexpr = (FunctionExprent)expr1;
ConstExprent cexpr = (ConstExprent)expr2;
int functype = funcexpr.GetFuncType();
if (functype == FunctionExprent.Function_Lcmp || functype == FunctionExprent.Function_Fcmpg ||
functype == FunctionExprent.Function_Fcmpl || functype == FunctionExprent.Function_Dcmpg ||
functype == FunctionExprent.Function_Dcmpl)
{
int desttype = -1;
int?[] destcons = mapNumComparisons.GetOrNull(fexpr.GetFuncType());
if (destcons != null)
{
int index = cexpr.GetIntValue() + 1;
if (index >= 0 && index <= 2)
{
int?destcon = destcons[index];
if (destcon != null)
{
desttype = destcon.Value;
}
}
}
if (desttype >= 0)
{
return(new FunctionExprent(desttype, funcexpr.GetLstOperands(), funcexpr.bytecode
));
}
}
}
break;
}
}
}
bool replaced = true;
while (replaced)
{
replaced = false;
foreach (Exprent expr in exprent.GetAllExprents())
{
Exprent retexpr = IdentifySecondaryFunctions(expr, false, varProc);
if (retexpr != null)
{
exprent.ReplaceExprent(expr, retexpr);
replaced = true;
break;
}
}
}
switch (exprent.type)
{
case Exprent.Exprent_Function:
{
FunctionExprent fexpr_1 = (FunctionExprent)exprent;
List <Exprent> lstOperands = fexpr_1.GetLstOperands();
switch (fexpr_1.GetFuncType())
{
case FunctionExprent.Function_Xor:
{
for (int i = 0; i < 2; i++)
{
Exprent operand = lstOperands[i];
VarType operandtype = operand.GetExprType();
if (operand.type == Exprent.Exprent_Const && operandtype.type != ICodeConstants.Type_Boolean)
{
ConstExprent cexpr = (ConstExprent)operand;
long val;
if (operandtype.type == ICodeConstants.Type_Long)
{
val = (long)cexpr.GetValue();
}
else
{
val = (int)cexpr.GetValue();
}
if (val == -1)
{
List <Exprent> lstBitNotOperand = new List <Exprent>();
lstBitNotOperand.Add(lstOperands[1 - i]);
return(new FunctionExprent(FunctionExprent.Function_Bit_Not, lstBitNotOperand, fexpr_1
.bytecode));
}
}
}
break;
}
case FunctionExprent.Function_Eq:
case FunctionExprent.Function_Ne:
{
if (lstOperands[0].GetExprType().type == ICodeConstants.Type_Boolean && lstOperands
[1].GetExprType().type == ICodeConstants.Type_Boolean)
{
for (int i = 0; i < 2; i++)
{
if (lstOperands[i].type == Exprent.Exprent_Const)
{
ConstExprent cexpr = (ConstExprent)lstOperands[i];
int val = (int)cexpr.GetValue();
if ((fexpr_1.GetFuncType() == FunctionExprent.Function_Eq && val == 1) || (fexpr_1
.GetFuncType() == FunctionExprent.Function_Ne && val == 0))
{
return(lstOperands[1 - i]);
}
else
{
List <Exprent> lstNotOperand = new List <Exprent>();
lstNotOperand.Add(lstOperands[1 - i]);
return(new FunctionExprent(FunctionExprent.Function_Bool_Not, lstNotOperand, fexpr_1
.bytecode));
}
}
}
}
break;
}
case FunctionExprent.Function_Bool_Not:
{
if (lstOperands[0].type == Exprent.Exprent_Const)
{
int val = ((ConstExprent)lstOperands[0]).GetIntValue();
if (val == 0)
{
return(new ConstExprent(VarType.Vartype_Boolean, 1, fexpr_1.bytecode));
}
else
{
return(new ConstExprent(VarType.Vartype_Boolean, 0, fexpr_1.bytecode));
}
}
break;
}
case FunctionExprent.Function_Iif:
{
Exprent expr1_1 = lstOperands[1];
Exprent expr2_1 = lstOperands[2];
if (expr1_1.type == Exprent.Exprent_Const && expr2_1.type == Exprent.Exprent_Const)
{
ConstExprent cexpr1 = (ConstExprent)expr1_1;
ConstExprent cexpr2 = (ConstExprent)expr2_1;
if (cexpr1.GetExprType().type == ICodeConstants.Type_Boolean && cexpr2.GetExprType
().type == ICodeConstants.Type_Boolean)
{
if (cexpr1.GetIntValue() == 0 && cexpr2.GetIntValue() != 0)
{
return(new FunctionExprent(FunctionExprent.Function_Bool_Not, lstOperands[0], fexpr_1
.bytecode));
}
else if (cexpr1.GetIntValue() != 0 && cexpr2.GetIntValue() == 0)
{
return(lstOperands[0]);
}
}
}
break;
}
case FunctionExprent.Function_Lcmp:
case FunctionExprent.Function_Fcmpl:
case FunctionExprent.Function_Fcmpg:
case FunctionExprent.Function_Dcmpl:
case FunctionExprent.Function_Dcmpg:
{
int var = DecompilerContext.GetCounterContainer().GetCounterAndIncrement(CounterContainer
.Var_Counter);
VarType type = lstOperands[0].GetExprType();
FunctionExprent iff = new FunctionExprent(FunctionExprent.Function_Iif, Sharpen.Arrays.AsList <Exprent>
(new FunctionExprent(FunctionExprent.Function_Lt, Sharpen.Arrays.AsList <Exprent>(new VarExprent
(var, type, varProc), ConstExprent.GetZeroConstant(type.type)), null), new ConstExprent
(VarType.Vartype_Int, -1, null), new ConstExprent(VarType.Vartype_Int, 1, null))
, null);
FunctionExprent head = new FunctionExprent(FunctionExprent.Function_Eq, Sharpen.Arrays.AsList <Exprent>
(new AssignmentExprent(new VarExprent(var, type, varProc), new FunctionExprent(FunctionExprent
.Function_Sub, Sharpen.Arrays.AsList(lstOperands[0], lstOperands[1]), null), null
), ConstExprent.GetZeroConstant(type.type)), null);
varProc.SetVarType(new VarVersionPair(var, 0), type);
return(new FunctionExprent(FunctionExprent.Function_Iif, Sharpen.Arrays.AsList <Exprent>(head
, new ConstExprent(VarType.Vartype_Int, 0, null), iff), fexpr_1.bytecode));
}
}
break;
}
case Exprent.Exprent_Assignment:
{
// check for conditional assignment
AssignmentExprent asexpr = (AssignmentExprent)exprent;
Exprent right = asexpr.GetRight();
Exprent left = asexpr.GetLeft();
if (right.type == Exprent.Exprent_Function)
{
FunctionExprent func = (FunctionExprent)right;
VarType midlayer = null;
if (func.GetFuncType() >= FunctionExprent.Function_I2l && func.GetFuncType() <= FunctionExprent
.Function_I2s)
{
right = func.GetLstOperands()[0];
midlayer = func.GetSimpleCastType();
if (right.type == Exprent.Exprent_Function)
{
func = (FunctionExprent)right;
}
else
{
return(null);
}
}
List <Exprent> lstFuncOperands = func.GetLstOperands();
Exprent cond = null;
switch (func.GetFuncType())
{
case FunctionExprent.Function_Add:
case FunctionExprent.Function_And:
case FunctionExprent.Function_Or:
case FunctionExprent.Function_Xor:
{
if (left.Equals(lstFuncOperands[1]))
{
cond = lstFuncOperands[0];
break;
}
goto case FunctionExprent.Function_Sub;
}
case FunctionExprent.Function_Sub:
case FunctionExprent.Function_Mul:
case FunctionExprent.Function_Div:
case FunctionExprent.Function_Rem:
case FunctionExprent.Function_Shl:
case FunctionExprent.Function_Shr:
case FunctionExprent.Function_Ushr:
{
if (left.Equals(lstFuncOperands[0]))
{
cond = lstFuncOperands[1];
}
break;
}
}
if (cond != null && (midlayer == null || midlayer.Equals(cond.GetExprType())))
{
asexpr.SetRight(cond);
asexpr.SetCondType(func.GetFuncType());
}
}
break;
}
case Exprent.Exprent_Invocation:
{
if (!statement_level)
{
// simplify if exprent is a real expression. The opposite case is pretty absurd, can still happen however (and happened at least once).
Exprent retexpr = ConcatenationHelper.ContractStringConcat(exprent);
if (!exprent.Equals(retexpr))
{
return(retexpr);
}
}
break;
}
}
return(null);
}