diff options
Diffstat (limited to 'ICSharpCode.Decompiler/ILAst/ILAstBuilder.cs')
| -rw-r--r-- | ICSharpCode.Decompiler/ILAst/ILAstBuilder.cs | 839 |
1 files changed, 839 insertions, 0 deletions
diff --git a/ICSharpCode.Decompiler/ILAst/ILAstBuilder.cs b/ICSharpCode.Decompiler/ILAst/ILAstBuilder.cs new file mode 100644 index 00000000..21b2b150 --- /dev/null +++ b/ICSharpCode.Decompiler/ILAst/ILAstBuilder.cs @@ -0,0 +1,839 @@ +// 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 System; +using System.Collections.Concurrent; +using System.Collections.Generic; +using System.Linq; +using System.Text; + +using Mono.Cecil; +using Mono.Cecil.Cil; +using Cecil = Mono.Cecil; + +namespace ICSharpCode.Decompiler.ILAst +{ + /// <summary> + /// Converts stack-based bytecode to variable-based bytecode by calculating use-define chains + /// </summary> + public class ILAstBuilder + { + /// <summary> Immutable </summary> + struct StackSlot + { + public readonly ByteCode[] Definitions; // Reaching definitions of this stack slot + public readonly ILVariable LoadFrom; // Variable used for storage of the value + + public StackSlot(ByteCode[] definitions, ILVariable loadFrom) + { + Definitions = definitions; + LoadFrom = loadFrom; + } + + public static StackSlot[] ModifyStack(StackSlot[] stack, int popCount, int pushCount, ByteCode pushDefinition) + { + StackSlot[] newStack = new StackSlot[stack.Length - popCount + pushCount]; + Array.Copy(stack, newStack, stack.Length - popCount); + for (int i = stack.Length - popCount; i < newStack.Length; i++) { + newStack[i] = new StackSlot(new [] { pushDefinition }, null); + } + return newStack; + } + } + + /// <summary> Immutable </summary> + struct VariableSlot + { + public readonly ByteCode[] Definitions; // Reaching deinitions of this variable + public readonly bool UnknownDefinition; // Used for initial state and exceptional control flow + + static readonly VariableSlot UnknownInstance = new VariableSlot(new ByteCode[0], true); + + public VariableSlot(ByteCode[] definitions, bool unknownDefinition) + { + Definitions = definitions; + UnknownDefinition = unknownDefinition; + } + + public static VariableSlot[] CloneVariableState(VariableSlot[] state) + { + VariableSlot[] clone = new VariableSlot[state.Length]; + Array.Copy(state, clone, state.Length); + return clone; + } + + public static VariableSlot[] MakeUknownState(int varCount) + { + VariableSlot[] unknownVariableState = new VariableSlot[varCount]; + for (int i = 0; i < unknownVariableState.Length; i++) { + unknownVariableState[i] = UnknownInstance; + } + return unknownVariableState; + } + } + + sealed class ByteCode + { + public ILLabel Label; // Non-null only if needed + public int Offset; + public int EndOffset; + public ILCode Code; + public object Operand; + public int? PopCount; // Null means pop all + public int PushCount; + public string Name { get { return "IL_" + Offset.ToString("X2"); } } + public ByteCode Next; + public Instruction[] Prefixes; // Non-null only if needed + public StackSlot[] StackBefore; // Unique per bytecode; not shared + public VariableSlot[] VariablesBefore; // Unique per bytecode; not shared + public List<ILVariable> StoreTo; // Store result of instruction to those AST variables + + public bool IsVariableDefinition { + get { + return (Code == ILCode.Stloc) || (Code == ILCode.Ldloca && Next != null && Next.Code == ILCode.Initobj); + } + } + + public override string ToString() + { + StringBuilder sb = new StringBuilder(); + + // Label + sb.Append(Name); + sb.Append(':'); + if (Label != null) + sb.Append('*'); + + // Name + sb.Append(' '); + if (Prefixes != null) { + foreach (var prefix in Prefixes) { + sb.Append(prefix.OpCode.Name); + sb.Append(' '); + } + } + sb.Append(Code.GetName()); + + if (Operand != null) { + sb.Append(' '); + if (Operand is Instruction) { + sb.Append("IL_" + ((Instruction)Operand).Offset.ToString("X2")); + } else if (Operand is Instruction[]) { + foreach(Instruction inst in (Instruction[])Operand) { + sb.Append("IL_" + inst.Offset.ToString("X2")); + sb.Append(" "); + } + } else if (Operand is ILLabel) { + sb.Append(((ILLabel)Operand).Name); + } else if (Operand is ILLabel[]) { + foreach(ILLabel label in (ILLabel[])Operand) { + sb.Append(label.Name); + sb.Append(" "); + } + } else { + sb.Append(Operand.ToString()); + } + } + + if (StackBefore != null) { + sb.Append(" StackBefore={"); + bool first = true; + foreach (StackSlot slot in StackBefore) { + if (!first) sb.Append(","); + bool first2 = true; + foreach(ByteCode defs in slot.Definitions) { + if (!first2) sb.Append("|"); + sb.AppendFormat("IL_{0:X2}", defs.Offset); + first2 = false; + } + first = false; + } + sb.Append("}"); + } + + if (StoreTo != null && StoreTo.Count > 0) { + sb.Append(" StoreTo={"); + bool first = true; + foreach (ILVariable stackVar in StoreTo) { + if (!first) sb.Append(","); + sb.Append(stackVar.Name); + first = false; + } + sb.Append("}"); + } + + if (VariablesBefore != null) { + sb.Append(" VarsBefore={"); + bool first = true; + foreach (VariableSlot varSlot in VariablesBefore) { + if (!first) sb.Append(","); + if (varSlot.UnknownDefinition) { + sb.Append("?"); + } else { + bool first2 = true; + foreach (ByteCode storedBy in varSlot.Definitions) { + if (!first2) sb.Append("|"); + sb.AppendFormat("IL_{0:X2}", storedBy.Offset); + first2 = false; + } + } + first = false; + } + sb.Append("}"); + } + + return sb.ToString(); + } + } + + MethodDefinition methodDef; + bool optimize; + + // Virtual instructions to load exception on stack + Dictionary<ExceptionHandler, ByteCode> ldexceptions = new Dictionary<ExceptionHandler, ByteCode>(); + + DecompilerContext context; + + public List<ILNode> Build(MethodDefinition methodDef, bool optimize, DecompilerContext context) + { + this.methodDef = methodDef; + this.optimize = optimize; + this.context = context; + + if (methodDef.Body.Instructions.Count == 0) return new List<ILNode>(); + + List<ByteCode> body = StackAnalysis(methodDef); + + List<ILNode> ast = ConvertToAst(body, new HashSet<ExceptionHandler>(methodDef.Body.ExceptionHandlers)); + + return ast; + } + + static int offsetIdx; + List<ByteCode> StackAnalysis(MethodDefinition methodDef) + { + Dictionary<Instruction, ByteCode> instrToByteCode = new Dictionary<Instruction, ByteCode>(); + + // Create temporary structure for the stack analysis + List<ByteCode> body = new List<ByteCode>(methodDef.Body.Instructions.Count); + List<Instruction> prefixes = null; + foreach(Instruction inst in methodDef.Body.Instructions) { + if (inst.OpCode.OpCodeType == OpCodeType.Prefix) { + if (prefixes == null) + prefixes = new List<Instruction>(1); + prefixes.Add(inst); + continue; + } + ILCode code = (ILCode)inst.OpCode.Code; + object operand = inst.Operand; + ILCodeUtil.ExpandMacro(ref code, ref operand, methodDef.Body); + ByteCode byteCode = new ByteCode() { + Offset = inst.Offset, + EndOffset = inst.Next != null ? inst.Next.Offset : methodDef.Body.CodeSize, + Code = code, + Operand = operand, + PopCount = inst.GetPopDelta(methodDef), + PushCount = inst.GetPushDelta() + }; + if (prefixes != null) { + instrToByteCode[prefixes[0]] = byteCode; + byteCode.Offset = prefixes[0].Offset; + byteCode.Prefixes = prefixes.ToArray(); + prefixes = null; + } else { + instrToByteCode[inst] = byteCode; + } + body.Add(byteCode); + } + for (int i = 0; i < body.Count - 1; i++) { + body[i].Next = body[i + 1]; + } + + Stack<ByteCode> agenda = new Stack<ByteCode>(); + + int varCount = methodDef.Body.Variables.Count; + + var exceptionHandlerStarts = new HashSet<ByteCode>(methodDef.Body.ExceptionHandlers.Select(eh => instrToByteCode[eh.HandlerStart])); + + // Add known states + if(methodDef.Body.HasExceptionHandlers) { + foreach(ExceptionHandler ex in methodDef.Body.ExceptionHandlers) { + ByteCode handlerStart = instrToByteCode[ex.HandlerStart]; + handlerStart.StackBefore = new StackSlot[0]; + handlerStart.VariablesBefore = VariableSlot.MakeUknownState(varCount); + if (ex.HandlerType == ExceptionHandlerType.Catch || ex.HandlerType == ExceptionHandlerType.Filter) { + // Catch and Filter handlers start with the exeption on the stack + ByteCode ldexception = new ByteCode() { + Code = ILCode.Ldexception, + Operand = ex.CatchType, + PopCount = 0, + PushCount = 1 + }; + ldexceptions[ex] = ldexception; + handlerStart.StackBefore = new StackSlot[] { new StackSlot(new [] { ldexception }, null) }; + } + agenda.Push(handlerStart); + + if (ex.HandlerType == ExceptionHandlerType.Filter) + { + ByteCode filterStart = instrToByteCode[ex.FilterStart]; + ByteCode ldexception = new ByteCode() { + Code = ILCode.Ldexception, + Operand = ex.CatchType, + PopCount = 0, + PushCount = 1 + }; + // TODO: ldexceptions[ex] = ldexception; + filterStart.StackBefore = new StackSlot[] { new StackSlot(new [] { ldexception }, null) }; + filterStart.VariablesBefore = VariableSlot.MakeUknownState(varCount); + agenda.Push(filterStart); + } + } + } + + body[0].StackBefore = new StackSlot[0]; + body[0].VariablesBefore = VariableSlot.MakeUknownState(varCount); + agenda.Push(body[0]); + + // Process agenda + while(agenda.Count > 0) { + ByteCode byteCode = agenda.Pop(); + + // Calculate new stack + StackSlot[] newStack = StackSlot.ModifyStack(byteCode.StackBefore, byteCode.PopCount ?? byteCode.StackBefore.Length, byteCode.PushCount, byteCode); + + // Calculate new variable state + VariableSlot[] newVariableState = VariableSlot.CloneVariableState(byteCode.VariablesBefore); + if (byteCode.IsVariableDefinition) { + newVariableState[((VariableReference)byteCode.Operand).Index] = new VariableSlot(new [] { byteCode }, false); + } + + // After the leave, finally block might have touched the variables + if (byteCode.Code == ILCode.Leave) { + newVariableState = VariableSlot.MakeUknownState(varCount); + } + + // Find all successors + List<ByteCode> branchTargets = new List<ByteCode>(); + if (!byteCode.Code.IsUnconditionalControlFlow()) { + if (exceptionHandlerStarts.Contains(byteCode.Next)) { + // Do not fall though down to exception handler + // It is invalid IL as per ECMA-335 §12.4.2.8.1, but some obfuscators produce it + } else { + branchTargets.Add(byteCode.Next); + } + } + if (byteCode.Operand is Instruction[]) { + foreach(Instruction inst in (Instruction[])byteCode.Operand) { + ByteCode target = instrToByteCode[inst]; + branchTargets.Add(target); + // The target of a branch must have label + if (target.Label == null) { + target.Label = new ILLabel() { Name = target.Name }; + } + } + } else if (byteCode.Operand is Instruction) { + ByteCode target = instrToByteCode[(Instruction)byteCode.Operand]; + branchTargets.Add(target); + // The target of a branch must have label + if (target.Label == null) { + target.Label = new ILLabel() { Name = target.Name }; + } + } + + // Apply the state to successors + foreach (ByteCode branchTarget in branchTargets) { + if (branchTarget.StackBefore == null && branchTarget.VariablesBefore == null) { + if (branchTargets.Count == 1) { + branchTarget.StackBefore = newStack; + branchTarget.VariablesBefore = newVariableState; + } else { + // Do not share data for several bytecodes + branchTarget.StackBefore = StackSlot.ModifyStack(newStack, 0, 0, null); + branchTarget.VariablesBefore = VariableSlot.CloneVariableState(newVariableState); + } + agenda.Push(branchTarget); + } else { + if (branchTarget.StackBefore.Length != newStack.Length) { + throw new Exception("Inconsistent stack size at " + byteCode.Name); + } + + // Be careful not to change our new data - it might be reused for several branch targets. + // In general, be careful that two bytecodes never share data structures. + + bool modified = false; + + // Merge stacks - modify the target + for (int i = 0; i < newStack.Length; i++) { + ByteCode[] oldDefs = branchTarget.StackBefore[i].Definitions; + ByteCode[] newDefs = oldDefs.Union(newStack[i].Definitions); + if (newDefs.Length > oldDefs.Length) { + branchTarget.StackBefore[i] = new StackSlot(newDefs, null); + modified = true; + } + } + + // Merge variables - modify the target + for (int i = 0; i < newVariableState.Length; i++) { + VariableSlot oldSlot = branchTarget.VariablesBefore[i]; + VariableSlot newSlot = newVariableState[i]; + if (!oldSlot.UnknownDefinition) { + if (newSlot.UnknownDefinition) { + branchTarget.VariablesBefore[i] = newSlot; + modified = true; + } else { + ByteCode[] oldDefs = oldSlot.Definitions; + ByteCode[] newDefs = oldDefs.Union(newSlot.Definitions); + if (newDefs.Length > oldDefs.Length) { + branchTarget.VariablesBefore[i] = new VariableSlot(newDefs, false); + modified = true; + } + } + } + } + + if (modified) { + agenda.Push(branchTarget); + } + } + } + } + + // Occasionally the compilers or obfuscators generate unreachable code (which might be intentionally invalid) + // I believe it is safe to just remove it + body.RemoveAll(b => b.StackBefore == null); + + // Generate temporary variables to replace stack + foreach(ByteCode byteCode in body) { + int argIdx = 0; + int popCount = byteCode.PopCount ?? byteCode.StackBefore.Length; + for (int i = byteCode.StackBefore.Length - popCount; i < byteCode.StackBefore.Length; i++) { + var offset = byteCode.Offset != 0 ? byteCode.Offset : offsetIdx++; + ILVariable tmpVar = new ILVariable() { Name = string.Format("arg_{0:X2}_{1}", offset, argIdx), IsGenerated = true }; + byteCode.StackBefore[i] = new StackSlot(byteCode.StackBefore[i].Definitions, tmpVar); + foreach(ByteCode pushedBy in byteCode.StackBefore[i].Definitions) { + if (pushedBy.StoreTo == null) { + pushedBy.StoreTo = new List<ILVariable>(1); + } + pushedBy.StoreTo.Add(tmpVar); + } + argIdx++; + } + } + + // Try to use single temporary variable insted of several if possilbe (especially useful for dup) + // This has to be done after all temporary variables are assigned so we know about all loads + foreach(ByteCode byteCode in body) { + if (byteCode.StoreTo != null && byteCode.StoreTo.Count > 1) { + var locVars = byteCode.StoreTo; + // For each of the variables, find the location where it is loaded - there should be preciesly one + var loadedBy = locVars.Select(locVar => body.SelectMany(bc => bc.StackBefore).Single(s => s.LoadFrom == locVar)).ToList(); + // We now know that all the variables have a single load, + // Let's make sure that they have also a single store - us + if (loadedBy.All(slot => slot.Definitions.Length == 1 && slot.Definitions[0] == byteCode)) { + // Great - we can reduce everything into single variable + var offset = byteCode.Offset != 0 ? byteCode.Offset : offsetIdx++; + ILVariable tmpVar = new ILVariable() { Name = string.Format("expr_{0:X2}", offset), IsGenerated = true }; + byteCode.StoreTo = new List<ILVariable>() { tmpVar }; + foreach(ByteCode bc in body) { + for (int i = 0; i < bc.StackBefore.Length; i++) { + // Is it one of the variable to be merged? + if (locVars.Contains(bc.StackBefore[i].LoadFrom)) { + // Replace with the new temp variable + bc.StackBefore[i] = new StackSlot(bc.StackBefore[i].Definitions, tmpVar); + } + } + } + } + } + } + + // Split and convert the normal local variables + ConvertLocalVariables(body); + + // Convert branch targets to labels + foreach(ByteCode byteCode in body) { + if (byteCode.Operand is Instruction[]) { + List<ILLabel> newOperand = new List<ILLabel>(); + foreach(Instruction target in (Instruction[])byteCode.Operand) { + newOperand.Add(instrToByteCode[target].Label); + } + byteCode.Operand = newOperand.ToArray(); + } else if (byteCode.Operand is Instruction) { + byteCode.Operand = instrToByteCode[(Instruction)byteCode.Operand].Label; + } + } + + // Convert parameters to ILVariables + ConvertParameters(body); + + return body; + } + + static bool IsDeterministicLdloca(ByteCode b) + { + var v = b.Operand; + b = b.Next; + if (b.Code == ILCode.Initobj) return true; + + // instance method calls on value types use the variable ref deterministically + int stack = 1; + while (true) { + if (b.PopCount == null) return false; + stack -= b.PopCount.GetValueOrDefault(); + if (stack == 0) break; + if (stack < 0) return false; + if (b.Code.IsConditionalControlFlow() || b.Code.IsUnconditionalControlFlow()) return false; + switch (b.Code) { + case ILCode.Ldloc: + case ILCode.Ldloca: + case ILCode.Stloc: + if (b.Operand == v) return false; + break; + } + stack += b.PushCount; + b = b.Next; + if (b == null) return false; + } + if (b.Code == ILCode.Ldfld || b.Code == ILCode.Stfld) + return true; + return (b.Code == ILCode.Call || b.Code == ILCode.Callvirt) && ((MethodReference)b.Operand).HasThis; + } + + sealed class VariableInfo + { + public ILVariable Variable; + public List<ByteCode> Defs; + public List<ByteCode> Uses; + } + + /// <summary> + /// If possible, separates local variables into several independent variables. + /// It should undo any compilers merging. + /// </summary> + void ConvertLocalVariables(List<ByteCode> body) + { + foreach(VariableDefinition varDef in methodDef.Body.Variables) { + + // Find all definitions and uses of this variable + var defs = body.Where(b => b.Operand == varDef && b.IsVariableDefinition).ToList(); + var uses = body.Where(b => b.Operand == varDef && !b.IsVariableDefinition).ToList(); + + List<VariableInfo> newVars; + + // If the variable is pinned, use single variable. + // If any of the uses is from unknown definition, use single variable + // If any of the uses is ldloca with a nondeterministic usage pattern, use single variable + if (!optimize || varDef.IsPinned || uses.Any(b => b.VariablesBefore[varDef.Index].UnknownDefinition || (b.Code == ILCode.Ldloca && !IsDeterministicLdloca(b)))) { + newVars = new List<VariableInfo>(1) { new VariableInfo() { + Variable = new ILVariable() { + Name = string.IsNullOrEmpty(varDef.Name) ? "var_" + varDef.Index : varDef.Name, + Type = varDef.IsPinned ? ((PinnedType)varDef.VariableType).ElementType : varDef.VariableType, + OriginalVariable = varDef + }, + Defs = defs, + Uses = uses + }}; + } else { + // Create a new variable for each definition + newVars = defs.Select(def => new VariableInfo() { + Variable = new ILVariable() { + Name = (string.IsNullOrEmpty(varDef.Name) ? "var_" + varDef.Index : varDef.Name) + "_" + def.Offset.ToString("X2"), + Type = varDef.VariableType, + OriginalVariable = varDef + }, + Defs = new List<ByteCode>() { def }, + Uses = new List<ByteCode>() + }).ToList(); + + // VB.NET uses the 'init' to allow use of uninitialized variables. + // We do not really care about them too much - if the original variable + // was uninitialized at that point it means that no store was called and + // thus all our new variables must be uninitialized as well. + // So it does not matter which one we load. + + // TODO: We should add explicit initialization so that C# code compiles. + // Remember to handle cases where one path inits the variable, but other does not. + + // Add loads to the data structure; merge variables if necessary + foreach(ByteCode use in uses) { + ByteCode[] useDefs = use.VariablesBefore[varDef.Index].Definitions; + if (useDefs.Length == 1) { + VariableInfo newVar = newVars.Single(v => v.Defs.Contains(useDefs[0])); + newVar.Uses.Add(use); + } else { + List<VariableInfo> mergeVars = newVars.Where(v => v.Defs.Intersect(useDefs).Any()).ToList(); + VariableInfo mergedVar = new VariableInfo() { + Variable = mergeVars[0].Variable, + Defs = mergeVars.SelectMany(v => v.Defs).ToList(), + Uses = mergeVars.SelectMany(v => v.Uses).ToList() + }; + mergedVar.Uses.Add(use); + newVars = newVars.Except(mergeVars).ToList(); + newVars.Add(mergedVar); + } + } + } + + // Set bytecode operands + foreach(VariableInfo newVar in newVars) { + foreach(ByteCode def in newVar.Defs) { + def.Operand = newVar.Variable; + } + foreach(ByteCode use in newVar.Uses) { + use.Operand = newVar.Variable; + } + } + } + } + + public List<ILVariable> Parameters = new List<ILVariable>(); + + void ConvertParameters(List<ByteCode> body) + { + ILVariable thisParameter = null; + if (methodDef.HasThis) { + TypeReference type = methodDef.DeclaringType; + thisParameter = new ILVariable(); + thisParameter.Type = type.IsValueType ? new ByReferenceType(type) : type; + thisParameter.Name = "this"; + thisParameter.OriginalParameter = methodDef.Body.ThisParameter; + } + foreach (ParameterDefinition p in methodDef.Parameters) { + Parameters.Add(new ILVariable { Type = p.ParameterType, Name = p.Name, OriginalParameter = p }); + } + if (Parameters.Count > 0 && (methodDef.IsSetter || methodDef.IsAddOn || methodDef.IsRemoveOn)) { + // last parameter must be 'value', so rename it + Parameters.Last().Name = "value"; + } + foreach (ByteCode byteCode in body) { + ParameterDefinition p; + switch (byteCode.Code) { + case ILCode.__Ldarg: + p = (ParameterDefinition)byteCode.Operand; + byteCode.Code = ILCode.Ldloc; + byteCode.Operand = p.Index < 0 ? thisParameter : Parameters[p.Index]; + break; + case ILCode.__Starg: + p = (ParameterDefinition)byteCode.Operand; + byteCode.Code = ILCode.Stloc; + byteCode.Operand = p.Index < 0 ? thisParameter : Parameters[p.Index]; + break; + case ILCode.__Ldarga: + p = (ParameterDefinition)byteCode.Operand; + byteCode.Code = ILCode.Ldloca; + byteCode.Operand = p.Index < 0 ? thisParameter : Parameters[p.Index]; + break; + } + } + if (thisParameter != null) + Parameters.Add(thisParameter); + } + + List<ILNode> ConvertToAst(List<ByteCode> body, HashSet<ExceptionHandler> ehs) + { + List<ILNode> ast = new List<ILNode>(); + + while (ehs.Any()) { + ILTryCatchBlock tryCatchBlock = new ILTryCatchBlock(); + + // Find the first and widest scope + int tryStart = ehs.Min(eh => eh.TryStart.Offset); + int tryEnd = ehs.Where(eh => eh.TryStart.Offset == tryStart).Max(eh => eh.TryEnd.Offset); + var handlers = ehs.Where(eh => eh.TryStart.Offset == tryStart && eh.TryEnd.Offset == tryEnd).ToList(); + + // Remember that any part of the body migt have been removed due to unreachability + + // Cut all instructions up to the try block + { + int tryStartIdx = 0; + while (tryStartIdx < body.Count && body[tryStartIdx].Offset < tryStart) tryStartIdx++; + ast.AddRange(ConvertToAst(body.CutRange(0, tryStartIdx))); + } + + // Cut the try block + { + HashSet<ExceptionHandler> nestedEHs = new HashSet<ExceptionHandler>(ehs.Where(eh => (tryStart <= eh.TryStart.Offset && eh.TryEnd.Offset < tryEnd) || (tryStart < eh.TryStart.Offset && eh.TryEnd.Offset <= tryEnd))); + ehs.ExceptWith(nestedEHs); + int tryEndIdx = 0; + while (tryEndIdx < body.Count && body[tryEndIdx].Offset < tryEnd) tryEndIdx++; + tryCatchBlock.TryBlock = new ILBlock(ConvertToAst(body.CutRange(0, tryEndIdx), nestedEHs)); + } + + // Cut all handlers + tryCatchBlock.CatchBlocks = new List<ILTryCatchBlock.CatchBlock>(); + foreach(ExceptionHandler eh in handlers) { + int handlerEndOffset = eh.HandlerEnd == null ? methodDef.Body.CodeSize : eh.HandlerEnd.Offset; + int startIdx = 0; + while (startIdx < body.Count && body[startIdx].Offset < eh.HandlerStart.Offset) startIdx++; + int endIdx = 0; + while (endIdx < body.Count && body[endIdx].Offset < handlerEndOffset) endIdx++; + HashSet<ExceptionHandler> nestedEHs = new HashSet<ExceptionHandler>(ehs.Where(e => (eh.HandlerStart.Offset <= e.TryStart.Offset && e.TryEnd.Offset < handlerEndOffset) || (eh.HandlerStart.Offset < e.TryStart.Offset && e.TryEnd.Offset <= handlerEndOffset))); + ehs.ExceptWith(nestedEHs); + List<ILNode> handlerAst = ConvertToAst(body.CutRange(startIdx, endIdx - startIdx), nestedEHs); + if (eh.HandlerType == ExceptionHandlerType.Catch) { + ILTryCatchBlock.CatchBlock catchBlock = new ILTryCatchBlock.CatchBlock() { + ExceptionType = eh.CatchType, + Body = handlerAst + }; + // Handle the automatically pushed exception on the stack + ByteCode ldexception = ldexceptions[eh]; + if (ldexception.StoreTo == null || ldexception.StoreTo.Count == 0) { + // Exception is not used + catchBlock.ExceptionVariable = null; + } else if (ldexception.StoreTo.Count == 1) { + ILExpression first = catchBlock.Body[0] as ILExpression; + if (first != null && + first.Code == ILCode.Pop && + first.Arguments[0].Code == ILCode.Ldloc && + first.Arguments[0].Operand == ldexception.StoreTo[0]) + { + // The exception is just poped - optimize it all away; + if (context.Settings.AlwaysGenerateExceptionVariableForCatchBlocks) + catchBlock.ExceptionVariable = new ILVariable() { Name = "ex_" + eh.HandlerStart.Offset.ToString("X2"), IsGenerated = true }; + else + catchBlock.ExceptionVariable = null; + catchBlock.Body.RemoveAt(0); + } else { + catchBlock.ExceptionVariable = ldexception.StoreTo[0]; + } + } else { + ILVariable exTemp = new ILVariable() { Name = "ex_" + eh.HandlerStart.Offset.ToString("X2"), IsGenerated = true }; + catchBlock.ExceptionVariable = exTemp; + foreach(ILVariable storeTo in ldexception.StoreTo) { + catchBlock.Body.Insert(0, new ILExpression(ILCode.Stloc, storeTo, new ILExpression(ILCode.Ldloc, exTemp))); + } + } + tryCatchBlock.CatchBlocks.Add(catchBlock); + } else if (eh.HandlerType == ExceptionHandlerType.Finally) { + tryCatchBlock.FinallyBlock = new ILBlock(handlerAst); + } else if (eh.HandlerType == ExceptionHandlerType.Fault) { + tryCatchBlock.FaultBlock = new ILBlock(handlerAst); + } else { + // TODO: ExceptionHandlerType.Filter + } + } + + ehs.ExceptWith(handlers); + + ast.Add(tryCatchBlock); + } + + // Add whatever is left + ast.AddRange(ConvertToAst(body)); + + return ast; + } + + List<ILNode> ConvertToAst(List<ByteCode> body) + { + List<ILNode> ast = new List<ILNode>(); + + // Convert stack-based IL code to ILAst tree + foreach(ByteCode byteCode in body) { + ILRange ilRange = new ILRange(byteCode.Offset, byteCode.EndOffset); + + if (byteCode.StackBefore == null) { + // Unreachable code + continue; + } + + ILExpression expr = new ILExpression(byteCode.Code, byteCode.Operand); + expr.ILRanges.Add(ilRange); + if (byteCode.Prefixes != null && byteCode.Prefixes.Length > 0) { + ILExpressionPrefix[] prefixes = new ILExpressionPrefix[byteCode.Prefixes.Length]; + for (int i = 0; i < prefixes.Length; i++) { + prefixes[i] = new ILExpressionPrefix((ILCode)byteCode.Prefixes[i].OpCode.Code, byteCode.Prefixes[i].Operand); + } + expr.Prefixes = prefixes; + } + + // Label for this instruction + if (byteCode.Label != null) { + ast.Add(byteCode.Label); + } + + // Reference arguments using temporary variables + int popCount = byteCode.PopCount ?? byteCode.StackBefore.Length; + for (int i = byteCode.StackBefore.Length - popCount; i < byteCode.StackBefore.Length; i++) { + StackSlot slot = byteCode.StackBefore[i]; + expr.Arguments.Add(new ILExpression(ILCode.Ldloc, slot.LoadFrom)); + } + + // Store the result to temporary variable(s) if needed + if (byteCode.StoreTo == null || byteCode.StoreTo.Count == 0) { + ast.Add(expr); + } else if (byteCode.StoreTo.Count == 1) { + ast.Add(new ILExpression(ILCode.Stloc, byteCode.StoreTo[0], expr)); + } else { + var offset = byteCode.Offset != 0 ? byteCode.Offset : offsetIdx++; + ILVariable tmpVar = new ILVariable() { Name = "expr_" + offset.ToString("X2"), IsGenerated = true }; + ast.Add(new ILExpression(ILCode.Stloc, tmpVar, expr)); + foreach(ILVariable storeTo in byteCode.StoreTo.AsEnumerable().Reverse()) { + ast.Add(new ILExpression(ILCode.Stloc, storeTo, new ILExpression(ILCode.Ldloc, tmpVar))); + } + } + } + + return ast; + } + } + + public static class ILAstBuilderExtensionMethods + { + public static List<T> CutRange<T>(this List<T> list, int start, int count) + { + List<T> ret = new List<T>(count); + for (int i = 0; i < count; i++) { + ret.Add(list[start + i]); + } + list.RemoveRange(start, count); + return ret; + } + + public static T[] Union<T>(this T[] a, T b) + { + if (a.Length == 0) + return new[] { b }; + if (Array.IndexOf(a, b) >= 0) + return a; + var res = new T[a.Length + 1]; + Array.Copy(a, 0, res, 0, a.Length); + res[res.Length - 1] = b; + return res; + } + + public static T[] Union<T>(this T[] a, T[] b) + { + if (a == b) + return a; + if (a.Length == 0) + return b; + if (b.Length == 0) + return a; + if (a.Length == 1) { + if (b.Length == 1) + return a[0].Equals(b[0]) ? a : new[] { a[0], b[0] }; + return b.Union(a[0]); + } + if (b.Length == 1) + return a.Union(b[0]); + return Enumerable.Union(a, b).ToArray(); + } + } +} |