|
|
|
@ -2,6 +2,7 @@ |
|
|
|
// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
|
|
|
|
// This code is distributed under MIT X11 license (for details please see \doc\license.txt)
|
|
|
|
|
|
|
|
|
|
|
|
using System; |
|
|
|
using System; |
|
|
|
|
|
|
|
using System.Collections.Generic; |
|
|
|
using System.Diagnostics; |
|
|
|
using System.Diagnostics; |
|
|
|
using System.Linq; |
|
|
|
using System.Linq; |
|
|
|
|
|
|
|
|
|
|
|
@ -12,18 +13,70 @@ namespace ICSharpCode.Decompiler.ILAst |
|
|
|
/// </summary>
|
|
|
|
/// </summary>
|
|
|
|
public class ILInlining |
|
|
|
public class ILInlining |
|
|
|
{ |
|
|
|
{ |
|
|
|
|
|
|
|
public static void InlineAllVariables(ILBlock method) |
|
|
|
|
|
|
|
{ |
|
|
|
|
|
|
|
ILInlining i = new ILInlining(method); |
|
|
|
|
|
|
|
foreach (ILBlock block in method.GetSelfAndChildrenRecursive<ILBlock>()) |
|
|
|
|
|
|
|
i.InlineAllInBlock(block); |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
Dictionary<ILVariable, int> numStloc = new Dictionary<ILVariable, int>(); |
|
|
|
|
|
|
|
Dictionary<ILVariable, int> numLdloc = new Dictionary<ILVariable, int>(); |
|
|
|
|
|
|
|
Dictionary<ILVariable, int> numLdloca = new Dictionary<ILVariable, int>(); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
public ILInlining(ILBlock method) |
|
|
|
|
|
|
|
{ |
|
|
|
|
|
|
|
// Analyse the whole method
|
|
|
|
|
|
|
|
foreach(ILExpression expr in method.GetSelfAndChildrenRecursive<ILExpression>()) { |
|
|
|
|
|
|
|
ILVariable locVar = expr.Operand as ILVariable; |
|
|
|
|
|
|
|
if (locVar != null) { |
|
|
|
|
|
|
|
if (expr.Code == ILCode.Stloc) { |
|
|
|
|
|
|
|
numStloc[locVar] = numStloc.GetOrDefault(locVar) + 1; |
|
|
|
|
|
|
|
} else if (expr.Code == ILCode.Ldloc) { |
|
|
|
|
|
|
|
numLdloc[locVar] = numLdloc.GetOrDefault(locVar) + 1; |
|
|
|
|
|
|
|
} else if (expr.Code == ILCode.Ldloca) { |
|
|
|
|
|
|
|
numLdloca[locVar] = numLdloca.GetOrDefault(locVar) + 1; |
|
|
|
|
|
|
|
} else { |
|
|
|
|
|
|
|
throw new NotSupportedException(expr.Code.ToString()); |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
public void InlineAllInBlock(ILBlock block) |
|
|
|
|
|
|
|
{ |
|
|
|
|
|
|
|
List<ILNode> body = block.Body; |
|
|
|
|
|
|
|
for(int i = 0; i < body.Count - 1;) { |
|
|
|
|
|
|
|
ILExpression nextExpr = body[i + 1] as ILExpression; |
|
|
|
|
|
|
|
ILVariable locVar; |
|
|
|
|
|
|
|
ILExpression expr; |
|
|
|
|
|
|
|
ILExpression ldParent; |
|
|
|
|
|
|
|
int ldPos; |
|
|
|
|
|
|
|
if (body[i].Match(ILCode.Stloc, out locVar, out expr) && InlineIfPossible(block, i)) { |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// We are moving the expression evaluation past the other aguments.
|
|
|
|
|
|
|
|
// It is ok to pass ldloc because the expression can not contain stloc and thus the ldloc will still return the same value
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
i = Math.Max(0, i - 1); // Go back one step
|
|
|
|
|
|
|
|
} else { |
|
|
|
|
|
|
|
i++; |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
/// <summary>
|
|
|
|
/// Inlines instructions before pos into block.Body[pos].
|
|
|
|
/// Inlines instructions before pos into block.Body[pos].
|
|
|
|
/// </summary>
|
|
|
|
/// </summary>
|
|
|
|
/// <returns>The number of instructions that were inlined.</returns>
|
|
|
|
/// <returns>The number of instructions that were inlined.</returns>
|
|
|
|
public static int InlineInto(ILBlock block, int pos, ILBlock method) |
|
|
|
public int InlineInto(ILBlock block, int pos) |
|
|
|
{ |
|
|
|
{ |
|
|
|
int count = 0; |
|
|
|
int count = 0; |
|
|
|
while (--pos >= 0) { |
|
|
|
while (--pos >= 0) { |
|
|
|
ILExpression expr = block.Body[pos] as ILExpression; |
|
|
|
ILExpression expr = block.Body[pos] as ILExpression; |
|
|
|
if (expr == null || expr.Code != ILCode.Stloc) |
|
|
|
if (expr == null || expr.Code != ILCode.Stloc) |
|
|
|
break; |
|
|
|
break; |
|
|
|
if (InlineIfPossible(block, pos, method)) |
|
|
|
if (InlineIfPossible(block, pos)) |
|
|
|
count++; |
|
|
|
count++; |
|
|
|
else |
|
|
|
else |
|
|
|
break; |
|
|
|
break; |
|
|
|
@ -34,9 +87,16 @@ namespace ICSharpCode.Decompiler.ILAst |
|
|
|
/// <summary>
|
|
|
|
/// <summary>
|
|
|
|
/// Inlines the stloc instruction at block.Body[pos] into the next instruction, if possible.
|
|
|
|
/// Inlines the stloc instruction at block.Body[pos] into the next instruction, if possible.
|
|
|
|
/// </summary>
|
|
|
|
/// </summary>
|
|
|
|
public static bool InlineIfPossible(ILBlock block, int pos, ILBlock method) |
|
|
|
public bool InlineIfPossible(ILBlock block, int pos) |
|
|
|
{ |
|
|
|
{ |
|
|
|
if (InlineIfPossible((ILExpression)block.Body[pos], block.Body.ElementAtOrDefault(pos+1), method)) { |
|
|
|
ILVariable v; |
|
|
|
|
|
|
|
ILExpression inlinedExpression; |
|
|
|
|
|
|
|
if (block.Body[pos].Match(ILCode.Stloc, out v, out inlinedExpression) |
|
|
|
|
|
|
|
&& InlineIfPossible(v, inlinedExpression, block.Body.ElementAtOrDefault(pos+1))) |
|
|
|
|
|
|
|
{ |
|
|
|
|
|
|
|
// Assign the ranges of the stloc instruction:
|
|
|
|
|
|
|
|
inlinedExpression.ILRanges.AddRange(((ILExpression)block.Body[pos]).ILRanges); |
|
|
|
|
|
|
|
// Remove the stloc instruction:
|
|
|
|
block.Body.RemoveAt(pos); |
|
|
|
block.Body.RemoveAt(pos); |
|
|
|
return true; |
|
|
|
return true; |
|
|
|
} |
|
|
|
} |
|
|
|
@ -46,17 +106,24 @@ namespace ICSharpCode.Decompiler.ILAst |
|
|
|
/// <summary>
|
|
|
|
/// <summary>
|
|
|
|
/// Inlines 'expr' into 'next', if possible.
|
|
|
|
/// Inlines 'expr' into 'next', if possible.
|
|
|
|
/// </summary>
|
|
|
|
/// </summary>
|
|
|
|
public static bool InlineIfPossible(ILExpression expr, ILNode next, ILBlock method) |
|
|
|
bool InlineIfPossible(ILVariable v, ILExpression inlinedExpression, ILNode next) |
|
|
|
{ |
|
|
|
{ |
|
|
|
if (expr.Code != ILCode.Stloc) |
|
|
|
|
|
|
|
throw new ArgumentException("expr must be stloc"); |
|
|
|
|
|
|
|
// ensure the variable is accessed only a single time
|
|
|
|
// ensure the variable is accessed only a single time
|
|
|
|
if (method.GetSelfAndChildrenRecursive<ILExpression>().Count(e => e != expr && e.Operand == expr.Operand) != 1) |
|
|
|
if (!(numStloc.GetOrDefault(v) == 1 && numLdloc.GetOrDefault(v) == 1 && numLdloca.GetOrDefault(v) == 0)) |
|
|
|
return false; |
|
|
|
return false; |
|
|
|
|
|
|
|
HashSet<ILVariable> forbiddenVariables = new HashSet<ILVariable>(); |
|
|
|
|
|
|
|
foreach (ILExpression potentialStore in inlinedExpression.GetSelfAndChildrenRecursive<ILExpression>()) { |
|
|
|
|
|
|
|
if (potentialStore.Code == ILCode.Stloc) |
|
|
|
|
|
|
|
forbiddenVariables.Add((ILVariable)potentialStore.Operand); |
|
|
|
|
|
|
|
} |
|
|
|
ILExpression parent; |
|
|
|
ILExpression parent; |
|
|
|
int pos; |
|
|
|
int pos; |
|
|
|
if (FindLoadInNext(next as ILExpression, (ILVariable)expr.Operand, out parent, out pos) == true) { |
|
|
|
if (FindLoadInNext(next as ILExpression, v, forbiddenVariables, out parent, out pos) == true) { |
|
|
|
parent.Arguments[pos] = expr.Arguments[0]; |
|
|
|
// Assign the ranges of the ldloc instruction:
|
|
|
|
|
|
|
|
inlinedExpression.ILRanges.AddRange(parent.Arguments[pos].ILRanges); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
parent.Arguments[pos] = inlinedExpression; |
|
|
|
|
|
|
|
|
|
|
|
return true; |
|
|
|
return true; |
|
|
|
} |
|
|
|
} |
|
|
|
return false; |
|
|
|
return false; |
|
|
|
@ -66,29 +133,39 @@ namespace ICSharpCode.Decompiler.ILAst |
|
|
|
/// Finds the position to inline to.
|
|
|
|
/// Finds the position to inline to.
|
|
|
|
/// </summary>
|
|
|
|
/// </summary>
|
|
|
|
/// <returns>true = found; false = cannot continue search; null = not found</returns>
|
|
|
|
/// <returns>true = found; false = cannot continue search; null = not found</returns>
|
|
|
|
static bool? FindLoadInNext(ILExpression expr, ILVariable v, out ILExpression parent, out int pos) |
|
|
|
bool? FindLoadInNext(ILExpression expr, ILVariable v, HashSet<ILVariable> forbiddenVariables, out ILExpression parent, out int pos) |
|
|
|
{ |
|
|
|
{ |
|
|
|
parent = null; |
|
|
|
parent = null; |
|
|
|
pos = 0; |
|
|
|
pos = 0; |
|
|
|
if (expr == null) |
|
|
|
if (expr == null) |
|
|
|
return false; |
|
|
|
return false; |
|
|
|
for (int i = 0; i < expr.Arguments.Count; i++) { |
|
|
|
for (int i = 0; i < expr.Arguments.Count; i++) { |
|
|
|
|
|
|
|
// Stop when seeing an opcode that does not guarantee that its operands will be evaluated.
|
|
|
|
|
|
|
|
// Inlining in that case might result in the inlined expresion not being evaluted.
|
|
|
|
|
|
|
|
if (i == 1 && (expr.Code == ILCode.LogicAnd || expr.Code == ILCode.LogicOr || expr.Code == ILCode.TernaryOp)) |
|
|
|
|
|
|
|
return false; |
|
|
|
|
|
|
|
|
|
|
|
ILExpression arg = expr.Arguments[i]; |
|
|
|
ILExpression arg = expr.Arguments[i]; |
|
|
|
|
|
|
|
|
|
|
|
if (arg.Code == ILCode.Ldloc && arg.Operand == v) { |
|
|
|
if (arg.Code == ILCode.Ldloc && arg.Operand == v) { |
|
|
|
parent = expr; |
|
|
|
parent = expr; |
|
|
|
pos = i; |
|
|
|
pos = i; |
|
|
|
return true; |
|
|
|
return true; |
|
|
|
} |
|
|
|
} |
|
|
|
bool? r = FindLoadInNext(arg, v, out parent, out pos); |
|
|
|
bool? r = FindLoadInNext(arg, v, forbiddenVariables, out parent, out pos); |
|
|
|
if (r != null) |
|
|
|
if (r != null) |
|
|
|
return r; |
|
|
|
return r; |
|
|
|
} |
|
|
|
} |
|
|
|
return IsWithoutSideEffects(expr.Code) ? (bool?)null : false; |
|
|
|
if (expr.Code == ILCode.Ldloc) { |
|
|
|
} |
|
|
|
ILVariable loadedVar = (ILVariable)expr.Operand; |
|
|
|
|
|
|
|
if (!forbiddenVariables.Contains(loadedVar) && numLdloca.GetOrDefault(loadedVar) == 0) { |
|
|
|
static bool IsWithoutSideEffects(ILCode code) |
|
|
|
// the expression is loading a non-forbidden variable:
|
|
|
|
{ |
|
|
|
// we're allowed to continue searching
|
|
|
|
return code == ILCode.Ldloc; |
|
|
|
return null; |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
// otherwise: abort, inlining is not possible
|
|
|
|
|
|
|
|
return false; |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
|
Eusebiu Marcu
15 years ago