mirror of https://github.com/icsharpcode/ILSpy.git
Daniel Grunwald
9 years ago
34 changed files with 1469 additions and 134 deletions
@ -0,0 +1,195 @@
@@ -0,0 +1,195 @@
|
||||
// Copyright (c) 2012 AlphaSierraPapa for the SharpDevelop Team
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a copy of this
|
||||
// software and associated documentation files (the "Software"), to deal in the Software
|
||||
// without restriction, including without limitation the rights to use, copy, modify, merge,
|
||||
// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
|
||||
// to whom the Software is furnished to do so, subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be included in all copies or
|
||||
// substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
|
||||
// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
|
||||
// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
||||
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
||||
// DEALINGS IN THE SOFTWARE.
|
||||
|
||||
using ICSharpCode.Decompiler.TypeSystem; |
||||
using ICSharpCode.Decompiler.Util; |
||||
using System; |
||||
using System.Collections.Generic; |
||||
using System.Diagnostics; |
||||
using System.Linq; |
||||
using System.Text; |
||||
using System.Threading.Tasks; |
||||
|
||||
namespace ICSharpCode.Decompiler.IL.ControlFlow |
||||
{ |
||||
enum StateRangeAnalysisMode |
||||
{ |
||||
IteratorMoveNext, |
||||
IteratorDispose, |
||||
AsyncMoveNext |
||||
} |
||||
|
||||
/// <summary>
|
||||
/// Symbolically executes code to determine which blocks are reachable for which values
|
||||
/// of the 'state' field.
|
||||
/// </summary>
|
||||
/// <remarks>
|
||||
/// Assumption: there are no loops/backward jumps
|
||||
/// We 'run' the code, with "state" being a symbolic variable
|
||||
/// so it can form expressions like "state + x" (when there's a sub instruction)
|
||||
///
|
||||
/// For each block, we maintain the set of values for state for which the block is reachable.
|
||||
/// This is (int.MinValue, int.MaxValue) for the first instruction.
|
||||
/// These ranges are propagated depending on the conditional jumps performed by the code.
|
||||
/// </remarks>
|
||||
class StateRangeAnalysis |
||||
{ |
||||
readonly StateRangeAnalysisMode mode; |
||||
readonly IField stateField; |
||||
readonly SymbolicEvaluationContext evalContext; |
||||
|
||||
readonly Dictionary<Block, LongSet> ranges = new Dictionary<Block, LongSet>(); |
||||
readonly internal Dictionary<IMethod, LongSet> finallyMethodToStateRange; // used only for IteratorDispose
|
||||
|
||||
public StateRangeAnalysis(StateRangeAnalysisMode mode, IField stateField, ILVariable cachedStateVar = null) |
||||
{ |
||||
this.mode = mode; |
||||
this.stateField = stateField; |
||||
if (mode == StateRangeAnalysisMode.IteratorDispose) { |
||||
finallyMethodToStateRange = new Dictionary<IMethod, LongSet>(); |
||||
} |
||||
|
||||
evalContext = new SymbolicEvaluationContext(stateField); |
||||
if (cachedStateVar != null) |
||||
evalContext.AddStateVariable(cachedStateVar); |
||||
} |
||||
|
||||
/// <summary>
|
||||
/// Assign state ranges for all blocks within 'inst'.
|
||||
/// </summary>
|
||||
/// <returns>
|
||||
/// The set of states for which the exit point of the instruction is reached.
|
||||
/// This must be a subset of the input set.
|
||||
///
|
||||
/// Returns an empty set for unsupported instructions.
|
||||
/// </returns>
|
||||
public LongSet AssignStateRanges(ILInstruction inst, LongSet stateRange) |
||||
{ |
||||
switch (inst) { |
||||
case BlockContainer blockContainer: |
||||
AddStateRange(blockContainer.EntryPoint, stateRange); |
||||
foreach (var block in blockContainer.Blocks) { |
||||
// We assume that there are no jumps to blocks already processed.
|
||||
// TODO: is SortBlocks() guaranteeing this, even if the user code has loops?
|
||||
if (ranges.TryGetValue(block, out stateRange)) { |
||||
AssignStateRanges(block, stateRange); |
||||
} |
||||
} |
||||
// Since we don't track 'leave' edges, we can only conservatively
|
||||
// return LongSet.Empty.
|
||||
return LongSet.Empty; |
||||
case Block block: |
||||
foreach (var instInBlock in block.Instructions) { |
||||
if (stateRange.IsEmpty) |
||||
break; |
||||
var oldStateRange = stateRange; |
||||
stateRange = AssignStateRanges(instInBlock, stateRange); |
||||
// End-point can only be reachable in a subset of the states where the start-point is reachable.
|
||||
Debug.Assert(stateRange.IsSubsetOf(oldStateRange)); |
||||
// If the end-point is unreachable, it must be reachable in no states.
|
||||
Debug.Assert(stateRange.IsEmpty || !instInBlock.HasFlag(InstructionFlags.EndPointUnreachable)); |
||||
} |
||||
return stateRange; |
||||
case TryFinally tryFinally: |
||||
var afterTry = AssignStateRanges(tryFinally.TryBlock, stateRange); |
||||
// really finally should start with 'stateRange.UnionWith(afterTry)', but that's
|
||||
// equal to 'stateRange'.
|
||||
Debug.Assert(afterTry.IsSubsetOf(stateRange)); |
||||
var afterFinally = AssignStateRanges(tryFinally.FinallyBlock, stateRange); |
||||
return afterTry.IntersectWith(afterFinally); |
||||
case SwitchInstruction switchInst: |
||||
SymbolicValue val = evalContext.Eval(switchInst.Value); |
||||
if (val.Type != SymbolicValueType.State) |
||||
goto default; |
||||
List<LongInterval> allSectionLabels = new List<LongInterval>(); |
||||
List<LongInterval> exitIntervals = new List<LongInterval>(); |
||||
foreach (var section in switchInst.Sections) { |
||||
// switch (state + Constant)
|
||||
// matches 'case VALUE:'
|
||||
// iff (state + Constant == value)
|
||||
// iff (state == value - Constant)
|
||||
var effectiveLabels = section.Labels.AddOffset(unchecked(-val.Constant)); |
||||
allSectionLabels.AddRange(effectiveLabels.Intervals); |
||||
var result = AssignStateRanges(section.Body, stateRange.IntersectWith(effectiveLabels)); |
||||
exitIntervals.AddRange(result.Intervals); |
||||
} |
||||
var defaultSectionLabels = stateRange.ExceptWith(new LongSet(allSectionLabels)); |
||||
exitIntervals.AddRange(AssignStateRanges(switchInst.DefaultBody, defaultSectionLabels).Intervals); |
||||
// exitIntervals = union of exits of all sections
|
||||
return new LongSet(exitIntervals); |
||||
case IfInstruction ifInst: |
||||
val = evalContext.Eval(ifInst.Condition).AsBool(); |
||||
LongSet trueRanges; |
||||
LongSet falseRanges; |
||||
if (val.Type == SymbolicValueType.StateEquals) { |
||||
trueRanges = stateRange.IntersectWith(new LongSet(val.Constant)); |
||||
falseRanges = stateRange.ExceptWith(new LongSet(val.Constant)); |
||||
} else if (val.Type == SymbolicValueType.StateInEquals) { |
||||
trueRanges = stateRange.ExceptWith(new LongSet(val.Constant)); |
||||
falseRanges = stateRange.IntersectWith(new LongSet(val.Constant)); |
||||
} else { |
||||
goto default; |
||||
} |
||||
var afterTrue = AssignStateRanges(ifInst.TrueInst, trueRanges); |
||||
var afterFalse = AssignStateRanges(ifInst.FalseInst, falseRanges); |
||||
return afterTrue.UnionWith(afterFalse); |
||||
case Branch br: |
||||
AddStateRange(br.TargetBlock, stateRange); |
||||
return LongSet.Empty; |
||||
case Nop nop: |
||||
return stateRange; |
||||
case StLoc stloc when stloc.Variable.IsSingleDefinition: |
||||
val = evalContext.Eval(stloc.Value); |
||||
if (val.Type == SymbolicValueType.State && val.Constant == 0) { |
||||
evalContext.AddStateVariable(stloc.Variable); |
||||
return stateRange; |
||||
} else { |
||||
goto default; // user code
|
||||
} |
||||
case Call call when mode == StateRangeAnalysisMode.IteratorDispose: |
||||
// Call to finally method.
|
||||
// Usually these are in finally blocks, but sometimes (e.g. foreach over array),
|
||||
// the C# compiler puts the call to a finally method outside the try-finally block.
|
||||
finallyMethodToStateRange.Add((IMethod)call.Method.MemberDefinition, stateRange); |
||||
return LongSet.Empty; // return Empty since we executed user code (the finally method)
|
||||
default: |
||||
// User code - abort analysis
|
||||
if (mode == StateRangeAnalysisMode.IteratorDispose && inst.OpCode != OpCode.Return) { |
||||
throw new SymbolicAnalysisFailedException("Unexpected instruction in Iterator.Dispose()"); |
||||
} |
||||
return LongSet.Empty; |
||||
} |
||||
} |
||||
|
||||
private void AddStateRange(Block block, LongSet stateRange) |
||||
{ |
||||
if (ranges.TryGetValue(block, out var existingRange)) |
||||
ranges[block] = stateRange.UnionWith(existingRange); |
||||
else |
||||
ranges.Add(block, stateRange); |
||||
} |
||||
|
||||
public IEnumerable<(Block, LongSet)> GetBlockStateSetMapping(BlockContainer container) |
||||
{ |
||||
foreach (var block in container.Blocks) { |
||||
if (ranges.TryGetValue(block, out var stateSet)) |
||||
yield return (block, stateSet); |
||||
} |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,161 @@
@@ -0,0 +1,161 @@
|
||||
// Copyright (c) 2011 AlphaSierraPapa for the SharpDevelop Team
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a copy of this
|
||||
// software and associated documentation files (the "Software"), to deal in the Software
|
||||
// without restriction, including without limitation the rights to use, copy, modify, merge,
|
||||
// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
|
||||
// to whom the Software is furnished to do so, subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be included in all copies or
|
||||
// substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
|
||||
// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
|
||||
// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
||||
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
||||
// DEALINGS IN THE SOFTWARE.
|
||||
|
||||
using ICSharpCode.Decompiler.TypeSystem; |
||||
using System; |
||||
using System.Collections.Generic; |
||||
using System.Linq; |
||||
using System.Text; |
||||
using System.Threading.Tasks; |
||||
|
||||
namespace ICSharpCode.Decompiler.IL.ControlFlow |
||||
{ |
||||
/// <summary>
|
||||
/// This exception is thrown when we find something else than we expect from the C# compiler.
|
||||
/// This aborts the analysis and makes the whole transform fail.
|
||||
/// </summary>
|
||||
class SymbolicAnalysisFailedException : Exception |
||||
{ |
||||
public SymbolicAnalysisFailedException() { } |
||||
public SymbolicAnalysisFailedException(string message) : base(message) { } |
||||
} |
||||
|
||||
enum SymbolicValueType |
||||
{ |
||||
/// <summary>
|
||||
/// Unknown value
|
||||
/// </summary>
|
||||
Unknown, |
||||
/// <summary>
|
||||
/// int: Constant (result of ldc.i4)
|
||||
/// </summary>
|
||||
IntegerConstant, |
||||
/// <summary>
|
||||
/// int: State + Constant
|
||||
/// </summary>
|
||||
State, |
||||
/// <summary>
|
||||
/// This pointer (result of ldarg.0)
|
||||
/// </summary>
|
||||
This, |
||||
/// <summary>
|
||||
/// bool: State == Constant
|
||||
/// </summary>
|
||||
StateEquals, |
||||
/// <summary>
|
||||
/// bool: State != Constant
|
||||
/// </summary>
|
||||
StateInEquals |
||||
} |
||||
|
||||
struct SymbolicValue |
||||
{ |
||||
public readonly int Constant; |
||||
public readonly SymbolicValueType Type; |
||||
|
||||
public SymbolicValue(SymbolicValueType type, int constant = 0) |
||||
{ |
||||
this.Type = type; |
||||
this.Constant = constant; |
||||
} |
||||
|
||||
public SymbolicValue AsBool() |
||||
{ |
||||
if (Type == SymbolicValueType.State) { |
||||
// convert state integer to bool:
|
||||
// if (state + c) = if (state + c != 0) = if (state != -c)
|
||||
return new SymbolicValue(SymbolicValueType.StateInEquals, unchecked(-Constant)); |
||||
} |
||||
return this; |
||||
} |
||||
public override string ToString() |
||||
{ |
||||
return string.Format("[SymbolicValue {0}: {1}]", this.Type, this.Constant); |
||||
} |
||||
} |
||||
|
||||
class SymbolicEvaluationContext |
||||
{ |
||||
readonly IField stateField; |
||||
readonly List<ILVariable> stateVariables = new List<ILVariable>(); |
||||
|
||||
public SymbolicEvaluationContext(IField stateField) |
||||
{ |
||||
this.stateField = stateField; |
||||
} |
||||
|
||||
public void AddStateVariable(ILVariable v) |
||||
{ |
||||
if (!stateVariables.Contains(v)) |
||||
stateVariables.Add(v); |
||||
} |
||||
|
||||
static readonly SymbolicValue Failed = new SymbolicValue(SymbolicValueType.Unknown); |
||||
|
||||
public SymbolicValue Eval(ILInstruction inst) |
||||
{ |
||||
if (inst is BinaryNumericInstruction bni && bni.Operator == BinaryNumericOperator.Sub && !bni.CheckForOverflow) { |
||||
var left = Eval(bni.Left); |
||||
var right = Eval(bni.Right); |
||||
if (left.Type != SymbolicValueType.State && left.Type != SymbolicValueType.IntegerConstant) |
||||
return Failed; |
||||
if (right.Type != SymbolicValueType.IntegerConstant) |
||||
return Failed; |
||||
return new SymbolicValue(left.Type, unchecked(left.Constant - right.Constant)); |
||||
} else if (inst.MatchLdFld(out var target, out var field)) { |
||||
if (Eval(target).Type != SymbolicValueType.This) |
||||
return Failed; |
||||
if (field.MemberDefinition != stateField) |
||||
return Failed; |
||||
return new SymbolicValue(SymbolicValueType.State); |
||||
} else if (inst.MatchLdLoc(out var loadedVariable)) { |
||||
if (stateVariables.Contains(loadedVariable)) |
||||
return new SymbolicValue(SymbolicValueType.State); |
||||
else if (loadedVariable.Kind == VariableKind.Parameter && loadedVariable.Index < 0) |
||||
return new SymbolicValue(SymbolicValueType.This); |
||||
else |
||||
return Failed; |
||||
} else if (inst.MatchLdcI4(out var value)) { |
||||
return new SymbolicValue(SymbolicValueType.IntegerConstant, value); |
||||
} else if (inst is Comp comp) { |
||||
var left = Eval(comp.Left); |
||||
var right = Eval(comp.Right); |
||||
if (left.Type != SymbolicValueType.State || right.Type != SymbolicValueType.IntegerConstant) |
||||
return Failed; |
||||
// bool: (state + left.Constant == right.Constant)
|
||||
// bool: (state == right.Constant - left.Constant)
|
||||
if (comp.Kind == ComparisonKind.Equality) |
||||
return new SymbolicValue(SymbolicValueType.StateEquals, unchecked(right.Constant - left.Constant)); |
||||
else if (comp.Kind == ComparisonKind.Inequality) |
||||
return new SymbolicValue(SymbolicValueType.StateInEquals, unchecked(right.Constant - left.Constant)); |
||||
else |
||||
return Failed; |
||||
} else if (inst is LogicNot logicNot) { |
||||
SymbolicValue val = Eval(logicNot.Argument).AsBool(); |
||||
if (val.Type == SymbolicValueType.StateEquals) |
||||
return new SymbolicValue(SymbolicValueType.StateInEquals, val.Constant); |
||||
else if (val.Type == SymbolicValueType.StateInEquals) |
||||
return new SymbolicValue(SymbolicValueType.StateEquals, val.Constant); |
||||
else |
||||
return Failed; |
||||
} else { |
||||
return Failed; |
||||
} |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,585 @@
@@ -0,0 +1,585 @@
|
||||
// Copyright (c) 2011 AlphaSierraPapa for the SharpDevelop Team
|
||||
//
|
||||
// Permission is hereby granted, free of charge, to any person obtaining a copy of this
|
||||
// software and associated documentation files (the "Software"), to deal in the Software
|
||||
// without restriction, including without limitation the rights to use, copy, modify, merge,
|
||||
// publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons
|
||||
// to whom the Software is furnished to do so, subject to the following conditions:
|
||||
//
|
||||
// The above copyright notice and this permission notice shall be included in all copies or
|
||||
// substantial portions of the Software.
|
||||
//
|
||||
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
|
||||
// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
|
||||
// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
|
||||
// FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
||||
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
||||
// DEALINGS IN THE SOFTWARE.
|
||||
|
||||
using ICSharpCode.Decompiler.CSharp; |
||||
using ICSharpCode.Decompiler.IL.Transforms; |
||||
using ICSharpCode.Decompiler.TypeSystem; |
||||
using ICSharpCode.Decompiler.Util; |
||||
using Mono.Cecil; |
||||
using System; |
||||
using System.Collections.Generic; |
||||
using System.Diagnostics; |
||||
using System.Linq; |
||||
using System.Text; |
||||
using System.Threading.Tasks; |
||||
|
||||
namespace ICSharpCode.Decompiler.IL.ControlFlow |
||||
{ |
||||
class YieldReturnDecompiler : IILTransform |
||||
{ |
||||
// For a description on the code generated by the C# compiler for yield return:
|
||||
// http://csharpindepth.com/Articles/Chapter6/IteratorBlockImplementation.aspx
|
||||
|
||||
// The idea here is:
|
||||
// - Figure out whether the current method is instanciating an enumerator
|
||||
// - Figure out which of the fields is the state field
|
||||
// - Construct an exception table based on states. This allows us to determine, for each state, what the parent try block is.
|
||||
|
||||
// See http://community.sharpdevelop.net/blogs/danielgrunwald/archive/2011/03/06/ilspy-yield-return.aspx
|
||||
// for a description of this step.
|
||||
|
||||
ILTransformContext context; |
||||
|
||||
/// <summary>The type that contains the function being decompiled.</summary>
|
||||
TypeDefinition currentType; |
||||
|
||||
/// <summary>The compiler-generated enumerator class.</summary>
|
||||
/// <remarks>Set in MatchEnumeratorCreationPattern()</remarks>
|
||||
TypeDefinition enumeratorType; |
||||
|
||||
/// <summary>The constructor of the compiler-generated enumerator class.</summary>
|
||||
/// <remarks>Set in MatchEnumeratorCreationPattern()</remarks>
|
||||
MethodDefinition enumeratorCtor; |
||||
|
||||
/// <summary>The dispose method of the compiler-generated enumerator class.</summary>
|
||||
/// <remarks>Set in ConstructExceptionTable()</remarks>
|
||||
MethodDefinition disposeMethod; |
||||
|
||||
/// <summary>The field in the compiler-generated class holding the current state of the state machine</summary>
|
||||
/// <remarks>Set in AnalyzeCtor()</remarks>
|
||||
IField stateField; |
||||
|
||||
/// <summary>The backing field of the 'Current' property in the compiler-generated class</summary>
|
||||
/// <remarks>Set in AnalyzeCurrentProperty()</remarks>
|
||||
IField currentField; |
||||
|
||||
/// <summary>Maps the fields of the compiler-generated class to the original parameters.</summary>
|
||||
/// <remarks>Set in MatchEnumeratorCreationPattern() and ResolveIEnumerableIEnumeratorFieldMapping()</remarks>
|
||||
readonly Dictionary<IField, ILVariable> fieldToParameterMap = new Dictionary<IField, ILVariable>(); |
||||
|
||||
/// <summary>This dictionary stores the information extracted from the Dispose() method:
|
||||
/// for each "Finally Method", it stores the set of states for which the method is being called.</summary>
|
||||
/// <remarks>Set in ConstructExceptionTable()</remarks>
|
||||
Dictionary<IMethod, LongSet> finallyMethodToStateRange; |
||||
|
||||
/// <summary>
|
||||
/// List of blocks that change the iterator state on block entry.
|
||||
/// </summary>
|
||||
readonly List<(int state, Block block)> stateChanges = new List<(int state, Block block)>(); |
||||
|
||||
#region Run() method
|
||||
public void Run(ILFunction function, ILTransformContext context) |
||||
{ |
||||
if (!context.Settings.YieldReturn) |
||||
return; // abort if enumerator decompilation is disabled
|
||||
this.context = context; |
||||
this.currentType = function.Method.DeclaringType; |
||||
this.enumeratorType = null; |
||||
this.enumeratorCtor = null; |
||||
this.stateField = null; |
||||
this.currentField = null; |
||||
this.fieldToParameterMap.Clear(); |
||||
this.finallyMethodToStateRange = null; |
||||
this.stateChanges.Clear(); |
||||
if (!MatchEnumeratorCreationPattern(function)) |
||||
return; |
||||
BlockContainer newBody; |
||||
try { |
||||
AnalyzeCtor(); |
||||
AnalyzeCurrentProperty(); |
||||
ResolveIEnumerableIEnumeratorFieldMapping(); |
||||
ConstructExceptionTable(); |
||||
newBody = AnalyzeMoveNext(); |
||||
} catch (SymbolicAnalysisFailedException) { |
||||
return; |
||||
} |
||||
|
||||
context.Step("Replacing body with MoveNext() body", function); |
||||
function.IsIterator = true; |
||||
function.Body = newBody; |
||||
// register any locals used in newBody
|
||||
function.Variables.AddRange(newBody.Descendants.OfType<IInstructionWithVariableOperand>().Select(inst => inst.Variable).Distinct()); |
||||
function.CheckInvariant(ILPhase.Normal); |
||||
|
||||
PrintFinallyMethodStateRanges(newBody); |
||||
|
||||
context.Step("Delete unreachable blocks", function); |
||||
// Note: because this only deletes blocks outright, the 'stateChanges' entries remain valid
|
||||
// (though some may point to now-deleted blocks)
|
||||
newBody.SortBlocks(deleteUnreachableBlocks: true); |
||||
|
||||
context.Step("Reconstruct try-finally blocks", function); |
||||
ReconstructTryFinallyBlocks(newBody); |
||||
|
||||
context.Step("Translate fields to local accesses", function); |
||||
TranslateFieldsToLocalAccess(function, function, fieldToParameterMap); |
||||
|
||||
// Re-run control flow simplification over the newly constructed set of gotos,
|
||||
// and inlining because TranslateFieldsToLocalAccess() might have opened up new inlining opportunities.
|
||||
function.RunTransforms(CSharpDecompiler.EarlyILTransforms(), context); |
||||
} |
||||
#endregion
|
||||
|
||||
#region Match the enumerator creation pattern
|
||||
bool MatchEnumeratorCreationPattern(ILFunction function) |
||||
{ |
||||
Block body = SingleBlock(function.Body); |
||||
if (body == null || body.Instructions.Count == 0) { |
||||
return false; |
||||
} |
||||
|
||||
ILInstruction newObj; |
||||
if (body.Instructions.Count == 1) { |
||||
// No parameters passed to enumerator (not even 'this'):
|
||||
// ret(newobj(...))
|
||||
if (body.Instructions[0].MatchReturn(out newObj)) |
||||
return MatchEnumeratorCreationNewObj(newObj); |
||||
else |
||||
return false; |
||||
} |
||||
|
||||
// If there's parameters passed to the helper class, the class instance is first
|
||||
// stored in a variable, then the parameters are copied over, then the instance is returned.
|
||||
|
||||
// stloc(var_1, newobj(..))
|
||||
if (!body.Instructions[0].MatchStLoc(out var var1, out newObj)) |
||||
return false; |
||||
if (!MatchEnumeratorCreationNewObj(newObj)) |
||||
return false; |
||||
|
||||
int i; |
||||
for (i = 1; i < body.Instructions.Count; i++) { |
||||
// stfld(..., ldloc(var_1), ldloc(parameter))
|
||||
if (!body.Instructions[i].MatchStFld(out var ldloc, out var storedField, out var loadParameter)) |
||||
break; |
||||
if (ldloc.MatchLdLoc(var1) |
||||
&& loadParameter.MatchLdLoc(out var parameter) |
||||
&& parameter.Kind == VariableKind.Parameter) { |
||||
fieldToParameterMap[(IField)storedField.MemberDefinition] = parameter; |
||||
} else { |
||||
return false; |
||||
} |
||||
} |
||||
|
||||
// In debug builds, the compiler may copy the var1 into another variable (var2) before returning it.
|
||||
if (i < body.Instructions.Count |
||||
&& body.Instructions[i].MatchStLoc(out var var2, out var ldlocForStloc2) |
||||
&& ldlocForStloc2.MatchLdLoc(var1)) { |
||||
// stloc(var_2, ldloc(var_1))
|
||||
i++; |
||||
} else { |
||||
// in release builds, var1 is returned directly
|
||||
var2 = var1; |
||||
} |
||||
if (i < body.Instructions.Count |
||||
&& body.Instructions[i].MatchReturn(out var retVal) |
||||
&& retVal.MatchLdLoc(var2)) { |
||||
// ret(ldloc(var_2))
|
||||
return true; |
||||
} else { |
||||
return false; |
||||
} |
||||
} |
||||
|
||||
/// <summary>
|
||||
/// Matches the body of a method as a single basic block.
|
||||
/// </summary>
|
||||
static Block SingleBlock(ILInstruction body) |
||||
{ |
||||
var block = body as Block; |
||||
if (body is BlockContainer blockContainer && blockContainer.Blocks.Count == 1) { |
||||
block = blockContainer.Blocks.Single() as Block; |
||||
} |
||||
return block; |
||||
} |
||||
|
||||
/// <summary>
|
||||
/// Matches the newobj instruction that creates an instance of the compiler-generated enumerator helper class.
|
||||
/// </summary>
|
||||
bool MatchEnumeratorCreationNewObj(ILInstruction inst) |
||||
{ |
||||
// newobj(CurrentType/...::.ctor, ldc.i4(-2))
|
||||
if (!(inst is NewObj newObj)) |
||||
return false; |
||||
if (newObj.Arguments.Count != 1) |
||||
return false; |
||||
if (!newObj.Arguments[0].MatchLdcI4(out int initialState)) |
||||
return false; |
||||
if (!(initialState == -2 || initialState == 0)) |
||||
return false; |
||||
enumeratorCtor = context.TypeSystem.GetCecil(newObj.Method) as MethodDefinition; |
||||
enumeratorType = enumeratorCtor?.DeclaringType; |
||||
return enumeratorType?.DeclaringType == currentType |
||||
&& IsCompilerGeneratorEnumerator(enumeratorType); |
||||
} |
||||
|
||||
public static bool IsCompilerGeneratorEnumerator(TypeDefinition type) |
||||
{ |
||||
if (!(type?.DeclaringType != null && type.IsCompilerGenerated())) |
||||
return false; |
||||
foreach (var i in type.Interfaces) { |
||||
var tr = i.InterfaceType; |
||||
if (tr.Namespace == "System.Collections" && tr.Name == "IEnumerator") |
||||
return true; |
||||
} |
||||
return false; |
||||
} |
||||
#endregion
|
||||
|
||||
#region Figure out what the 'state' field is (analysis of .ctor())
|
||||
/// <summary>
|
||||
/// Looks at the enumerator's ctor and figures out which of the fields holds the state.
|
||||
/// </summary>
|
||||
void AnalyzeCtor() |
||||
{ |
||||
Block body = SingleBlock(CreateILAst(enumeratorCtor).Body); |
||||
if (body == null) |
||||
throw new SymbolicAnalysisFailedException("Missing enumeratorCtor.Body"); |
||||
foreach (var inst in body.Instructions) { |
||||
if (inst.MatchStFld(out var target, out var field, out var value) |
||||
&& target.MatchLdThis() |
||||
&& value.MatchLdLoc(out var arg) |
||||
&& arg.Kind == VariableKind.Parameter && arg.Index == 0) { |
||||
stateField = (IField)field.MemberDefinition; |
||||
} |
||||
} |
||||
if (stateField == null) |
||||
throw new SymbolicAnalysisFailedException("Could not find stateField"); |
||||
} |
||||
|
||||
/// <summary>
|
||||
/// Creates ILAst for the specified method, optimized up to before the 'YieldReturn' step.
|
||||
/// </summary>
|
||||
ILFunction CreateILAst(MethodDefinition method) |
||||
{ |
||||
if (method == null || !method.HasBody) |
||||
throw new SymbolicAnalysisFailedException(); |
||||
|
||||
var il = new ILReader(context.TypeSystem).ReadIL(method.Body, context.CancellationToken); |
||||
il.RunTransforms(CSharpDecompiler.EarlyILTransforms(), new ILTransformContext { |
||||
Settings = context.Settings, |
||||
CancellationToken = context.CancellationToken, |
||||
TypeSystem = context.TypeSystem |
||||
}); |
||||
return il; |
||||
} |
||||
#endregion
|
||||
|
||||
#region Figure out what the 'current' field is (analysis of get_Current())
|
||||
/// <summary>
|
||||
/// Looks at the enumerator's get_Current method and figures out which of the fields holds the current value.
|
||||
/// </summary>
|
||||
void AnalyzeCurrentProperty() |
||||
{ |
||||
MethodDefinition getCurrentMethod = enumeratorType.Methods.FirstOrDefault( |
||||
m => m.Name.StartsWith("System.Collections.Generic.IEnumerator", StringComparison.Ordinal) |
||||
&& m.Name.EndsWith(".get_Current", StringComparison.Ordinal)); |
||||
Block body = SingleBlock(CreateILAst(getCurrentMethod).Body); |
||||
if (body == null) |
||||
throw new SymbolicAnalysisFailedException(); |
||||
if (body.Instructions.Count == 1) { |
||||
// release builds directly return the current field
|
||||
// ret(ldfld F(ldloc(this)))
|
||||
if (body.Instructions[0].MatchReturn(out var retVal) |
||||
&& retVal.MatchLdFld(out var target, out var field) |
||||
&& target.MatchLdThis()) { |
||||
currentField = (IField)field.MemberDefinition; |
||||
} |
||||
} else if (body.Instructions.Count == 2) { |
||||
// debug builds store the return value in a temporary
|
||||
// stloc V = ldfld F(ldloc(this))
|
||||
// ret(ldloc V)
|
||||
if (body.Instructions[0].MatchStLoc(out var v, out var ldfld) |
||||
&& ldfld.MatchLdFld(out var target, out var field) |
||||
&& target.MatchLdThis() |
||||
&& body.Instructions[1].MatchReturn(out var retVal) |
||||
&& retVal.MatchLdLoc(v)) { |
||||
currentField = (IField)field.MemberDefinition; |
||||
} |
||||
} |
||||
if (currentField == null) |
||||
throw new SymbolicAnalysisFailedException("Could not find currentField"); |
||||
} |
||||
#endregion
|
||||
|
||||
#region Figure out the mapping of IEnumerable fields to IEnumerator fields (analysis of GetEnumerator())
|
||||
void ResolveIEnumerableIEnumeratorFieldMapping() |
||||
{ |
||||
MethodDefinition getEnumeratorMethod = enumeratorType.Methods.FirstOrDefault( |
||||
m => m.Name.StartsWith("System.Collections.Generic.IEnumerable", StringComparison.Ordinal) |
||||
&& m.Name.EndsWith(".GetEnumerator", StringComparison.Ordinal)); |
||||
if (getEnumeratorMethod == null) |
||||
return; // no mappings (maybe it's just an IEnumerator implementation?)
|
||||
var function = CreateILAst(getEnumeratorMethod); |
||||
foreach (var block in function.Descendants.OfType<Block>()) { |
||||
foreach (var inst in block.Instructions) { |
||||
// storeTarget.storeField = this.loadField;
|
||||
if (inst.MatchStFld(out var storeTarget, out var storeField, out var storeValue) |
||||
&& storeValue.MatchLdFld(out var loadTarget, out var loadField) |
||||
&& loadTarget.MatchLdThis()) { |
||||
storeField = (IField)storeField.MemberDefinition; |
||||
loadField = (IField)loadField.MemberDefinition; |
||||
if (fieldToParameterMap.TryGetValue(loadField, out var mappedParameter)) |
||||
fieldToParameterMap[storeField] = mappedParameter; |
||||
} |
||||
} |
||||
} |
||||
} |
||||
#endregion
|
||||
|
||||
#region Construction of the exception table (analysis of Dispose())
|
||||
// We construct the exception table by analyzing the enumerator's Dispose() method.
|
||||
|
||||
void ConstructExceptionTable() |
||||
{ |
||||
disposeMethod = enumeratorType.Methods.FirstOrDefault(m => m.Name == "System.IDisposable.Dispose"); |
||||
var function = CreateILAst(disposeMethod); |
||||
|
||||
var rangeAnalysis = new StateRangeAnalysis(StateRangeAnalysisMode.IteratorDispose, stateField); |
||||
rangeAnalysis.AssignStateRanges(function.Body, LongSet.Universe); |
||||
finallyMethodToStateRange = rangeAnalysis.finallyMethodToStateRange; |
||||
} |
||||
|
||||
[Conditional("DEBUG")] |
||||
void PrintFinallyMethodStateRanges(BlockContainer bc) |
||||
{ |
||||
foreach (var (method, stateRange) in finallyMethodToStateRange) { |
||||
bc.Blocks[0].Instructions.Insert(0, new Nop { |
||||
Comment = method.Name + " in " + stateRange |
||||
}); |
||||
} |
||||
} |
||||
#endregion
|
||||
|
||||
#region Analyze MoveNext() and generate new body
|
||||
BlockContainer AnalyzeMoveNext() |
||||
{ |
||||
MethodDefinition moveNextMethod = enumeratorType.Methods.FirstOrDefault(m => m.Name == "MoveNext"); |
||||
ILFunction moveNextFunction = CreateILAst(moveNextMethod); |
||||
|
||||
var body = (BlockContainer)moveNextFunction.Body; |
||||
if (body.Blocks.Count == 1 && body.Blocks[0].Instructions.Count == 1 && body.Blocks[0].Instructions[0] is TryFault tryFault) { |
||||
body = (BlockContainer)tryFault.TryBlock; |
||||
var faultBlockContainer = tryFault.FaultBlock as BlockContainer; |
||||
if (faultBlockContainer?.Blocks.Count != 1) |
||||
throw new SymbolicAnalysisFailedException("Unexpected number of blocks in MoveNext() fault block"); |
||||
var faultBlock = faultBlockContainer.Blocks.Single(); |
||||
if (!(faultBlock.Instructions.Count == 2 |
||||
&& faultBlock.Instructions[0] is Call call |
||||
&& context.TypeSystem.GetCecil(call.Method) == disposeMethod |
||||
&& call.Arguments.Count == 1 |
||||
&& call.Arguments[0].MatchLdThis() |
||||
&& faultBlock.Instructions[1].MatchLeave(faultBlockContainer))) { |
||||
throw new SymbolicAnalysisFailedException("Unexpected fault block contents in MoveNext()"); |
||||
} |
||||
} |
||||
|
||||
// Note: body may contain try-catch or try-finally statements that have nested block containers,
|
||||
// but those cannot contain any yield statements.
|
||||
// So for reconstructing the control flow, we only need at the blocks directly within body.
|
||||
|
||||
var rangeAnalysis = new StateRangeAnalysis(StateRangeAnalysisMode.IteratorMoveNext, stateField); |
||||
rangeAnalysis.AssignStateRanges(body, LongSet.Universe); |
||||
|
||||
var newBody = ConvertBody(body, rangeAnalysis.GetBlockStateSetMapping(body)); |
||||
moveNextFunction.Variables.Clear(); |
||||
// release references from old moveNextFunction to instructions that were moved over to newBody
|
||||
moveNextFunction.ReleaseRef(); |
||||
return newBody; |
||||
} |
||||
|
||||
/// <summary>
|
||||
/// Convert the old body (of MoveNext function) to the new body (of decompiled iterator method).
|
||||
///
|
||||
/// * Replace the sequence
|
||||
/// this.currentField = expr;
|
||||
/// this.state = N;
|
||||
/// return true;
|
||||
/// with:
|
||||
/// yield return expr;
|
||||
/// goto blockForState(N);
|
||||
/// * Replace the sequence:
|
||||
/// this._finally2();
|
||||
/// this._finally1();
|
||||
/// return false;
|
||||
/// with:
|
||||
/// yield break;
|
||||
/// * Reconstruct try-finally blocks from
|
||||
/// (on enter) this.state = N;
|
||||
/// (on exit) this._finallyX();
|
||||
/// </summary>
|
||||
private BlockContainer ConvertBody(BlockContainer oldBody, IEnumerable<(Block, LongSet)> blockStateSets) |
||||
{ |
||||
BlockContainer newBody = new BlockContainer(); |
||||
// create all new blocks so that they can be referenced by gotos
|
||||
for (int blockIndex = 0; blockIndex < oldBody.Blocks.Count; blockIndex++) { |
||||
newBody.Blocks.Add(new Block { ILRange = oldBody.Blocks[blockIndex].ILRange }); |
||||
} |
||||
// convert contents of blocks
|
||||
var ssaDefs = new Dictionary<ILVariable, ILInstruction>(); |
||||
|
||||
for (int i = 0; i < oldBody.Blocks.Count; i++) { |
||||
var oldBlock = oldBody.Blocks[i]; |
||||
var newBlock = newBody.Blocks[i]; |
||||
foreach (var oldInst in oldBlock.Instructions) { |
||||
if (oldInst.MatchStFld(out var target, out var field, out var value) && target.MatchLdThis()) { |
||||
if (field.MemberDefinition.Equals(stateField)) { |
||||
if (value.MatchLdcI4(out int newState)) { |
||||
// On state change, break up the block (if necessary):
|
||||
if (newBlock.Instructions.Count > 0) { |
||||
var newBlock2 = new Block(); |
||||
newBlock2.ILRange = new Interval(oldInst.ILRange.Start, oldInst.ILRange.Start); |
||||
newBody.Blocks.Add(newBlock2); |
||||
newBlock.Instructions.Add(new Branch(newBlock2)); |
||||
newBlock = newBlock2; |
||||
} |
||||
#if DEBUG
|
||||
newBlock.Instructions.Add(new Nop { Comment = "iterator._state = " + newState }); |
||||
#endif
|
||||
stateChanges.Add((newState, newBlock)); |
||||
} else { |
||||
newBlock.Instructions.Add(new InvalidExpression("Assigned non-constant to iterator.state field") { |
||||
ILRange = oldInst.ILRange |
||||
}); |
||||
} |
||||
continue; // don't copy over this instruction, but continue with the basic block
|
||||
} else if (field.MemberDefinition.Equals(currentField)) { |
||||
// create yield return
|
||||
newBlock.Instructions.Add(new YieldReturn(value) { ILRange = oldInst.ILRange }); |
||||
ConvertBranchAfterYieldReturn(newBlock, oldBlock, oldInst.ChildIndex); |
||||
break; // we're done with this basic block
|
||||
} |
||||
} else if (oldInst.MatchReturn(out value)) { |
||||
if (value.MatchLdLoc(out var v)) { |
||||
ssaDefs.TryGetValue(v, out value); |
||||
} |
||||
if (value.MatchLdcI4(0)) { |
||||
// yield break
|
||||
newBlock.Instructions.Add(new Leave(newBody) { ILRange = oldInst.ILRange }); |
||||
} else { |
||||
newBlock.Instructions.Add(new InvalidBranch("Unexpected return in MoveNext()")); |
||||
} |
||||
break; // we're done with this basic block
|
||||
} else if (oldInst.MatchStLoc(out var v, out value) && v.IsSingleDefinition) { |
||||
ssaDefs.Add(v, value); |
||||
} |
||||
// copy over the instruction to the new block
|
||||
UpdateBranchTargets(oldInst); |
||||
newBlock.Instructions.Add(oldInst); |
||||
} |
||||
} |
||||
|
||||
// Insert new artificial block as entry point, and jump to state 0.
|
||||
// This causes the method to start directly at the first user code,
|
||||
// and the whole compiler-generated state-dispatching logic becomes unreachable code
|
||||
// and gets deleted.
|
||||
newBody.Blocks.Insert(0, new Block { |
||||
Instructions = { MakeGoTo(0) } |
||||
}); |
||||
return newBody; |
||||
|
||||
void ConvertBranchAfterYieldReturn(Block newBlock, Block oldBlock, int i) |
||||
{ |
||||
if (!(oldBlock.Instructions[i + 1].MatchStFld(out var target, out var field, out var value) |
||||
&& target.MatchLdThis() |
||||
&& field.MemberDefinition == stateField |
||||
&& value.MatchLdcI4(out int newState))) { |
||||
newBlock.Instructions.Add(new InvalidBranch("Unable to find new state assignment for yield return")); |
||||
return; |
||||
} |
||||
if (!(oldBlock.Instructions[i + 2].MatchReturn(out var retVal) |
||||
&& retVal.MatchLdcI4(1))) { |
||||
newBlock.Instructions.Add(new InvalidBranch("Unable to find 'return true' for yield return")); |
||||
return; |
||||
} |
||||
newBlock.Instructions.Add(MakeGoTo(newState)); |
||||
} |
||||
|
||||
ILInstruction MakeGoTo(int v) |
||||
{ |
||||
Block targetBlock = null; |
||||
foreach (var (block, stateSet) in blockStateSets) { |
||||
if (stateSet.Contains(v)) |
||||
targetBlock = block; |
||||
} |
||||
if (targetBlock != null) |
||||
return new Branch(newBody.Blocks[targetBlock.ChildIndex]); |
||||
else |
||||
return new InvalidBranch("Could not find block for state " + v); |
||||
} |
||||
|
||||
void UpdateBranchTargets(ILInstruction inst) |
||||
{ |
||||
switch (inst) { |
||||
case Branch branch: |
||||
if (branch.TargetContainer == oldBody) { |
||||
branch.TargetBlock = newBody.Blocks[branch.TargetBlock.ChildIndex]; |
||||
} |
||||
break; |
||||
case Leave leave: |
||||
if (leave.TargetContainer == oldBody) { |
||||
leave.TargetContainer = newBody; |
||||
} |
||||
break; |
||||
} |
||||
foreach (var child in inst.Children) { |
||||
UpdateBranchTargets(child); |
||||
} |
||||
} |
||||
} |
||||
#endregion
|
||||
|
||||
#region TranslateFieldsToLocalAccess
|
||||
/// <summary>
|
||||
/// Translates all field accesses in `function` to local variable accesses.
|
||||
/// </summary>
|
||||
internal static void TranslateFieldsToLocalAccess(ILFunction function, ILInstruction inst, Dictionary<IField, ILVariable> fieldToVariableMap) |
||||
{ |
||||
if (inst is LdFlda ldflda && ldflda.Target.MatchLdThis()) { |
||||
var fieldDef = (IField)ldflda.Field.MemberDefinition; |
||||
if (!fieldToVariableMap.TryGetValue(fieldDef, out var v)) { |
||||
string name = null; |
||||
if (!string.IsNullOrEmpty(fieldDef.Name) && fieldDef.Name[0] == '<') { |
||||
int pos = fieldDef.Name.IndexOf('>'); |
||||
if (pos > 1) |
||||
name = fieldDef.Name.Substring(1, pos - 1); |
||||
} |
||||
v = function.RegisterVariable(VariableKind.Local, ldflda.Field.ReturnType, name); |
||||
fieldToVariableMap.Add(fieldDef, v); |
||||
} |
||||
inst.ReplaceWith(new LdLoca(v)); |
||||
} else if (inst.MatchLdThis()) { |
||||
inst.ReplaceWith(new InvalidExpression("iterator") { ExpectedResultType = inst.ResultType }); |
||||
} else { |
||||
foreach (var child in inst.Children) { |
||||
TranslateFieldsToLocalAccess(function, child, fieldToVariableMap); |
||||
} |
||||
} |
||||
} |
||||
#endregion
|
||||
|
||||
#region Reconstruct try-finally blocks
|
||||
|
||||
private void ReconstructTryFinallyBlocks(BlockContainer newBody) |
||||
{ |
||||
// TODO
|
||||
} |
||||
|
||||
#endregion
|
||||
} |
||||
} |
||||
Loading…
Reference in new issue