From 9b665b7cbcd3219ef9768608cb0857b871d8ff09 Mon Sep 17 00:00:00 2001 From: Siegfried Pammer Date: Thu, 1 Mar 2018 17:14:11 +0100 Subject: [PATCH] Add AwaitInCatchTransform --- .../CorrectnessTestRunner.cs | 5 +- .../TestCases/Correctness/Async.cs | 29 +++ .../ICSharpCode.Decompiler.csproj | 1 + .../IL/ControlFlow/AsyncAwaitDecompiler.cs | 16 +- .../IL/ControlFlow/AwaitInCatchTransform.cs | 187 ++++++++++++++++++ 5 files changed, 230 insertions(+), 8 deletions(-) create mode 100644 ICSharpCode.Decompiler/IL/ControlFlow/AwaitInCatchTransform.cs diff --git a/ICSharpCode.Decompiler.Tests/CorrectnessTestRunner.cs b/ICSharpCode.Decompiler.Tests/CorrectnessTestRunner.cs index f33ae5515..9a536cc67 100644 --- a/ICSharpCode.Decompiler.Tests/CorrectnessTestRunner.cs +++ b/ICSharpCode.Decompiler.Tests/CorrectnessTestRunner.cs @@ -257,8 +257,11 @@ namespace ICSharpCode.Decompiler.Tests } [Test] - public void Async([Values(CompilerOptions.None, CompilerOptions.Optimize)] CompilerOptions options) + public void Async([ValueSource("defaultOptions")] CompilerOptions options) { + if (options.HasFlag(CompilerOptions.UseMcs)) { + Assert.Ignore("Decompiler bug with mono!"); + } RunCS(options: options); } diff --git a/ICSharpCode.Decompiler.Tests/TestCases/Correctness/Async.cs b/ICSharpCode.Decompiler.Tests/TestCases/Correctness/Async.cs index c6bacb282..d94009270 100644 --- a/ICSharpCode.Decompiler.Tests/TestCases/Correctness/Async.cs +++ b/ICSharpCode.Decompiler.Tests/TestCases/Correctness/Async.cs @@ -123,6 +123,35 @@ namespace ICSharpCode.Decompiler.Tests.TestCases.Correctness } } + public async Task AwaitMultipleCatchBlocks(Task task) + { + try { + Console.WriteLine("Before throw"); + throw new Exception(); + } catch (OutOfMemoryException ex) { + Console.WriteLine(ex.ToString()); + Console.WriteLine(await task); + } catch { + Console.WriteLine(await task); + } + } + + + public async Task AwaitMultipleCatchBlocks2(Task task) + { + try { + Console.WriteLine("Before throw"); + throw new Exception(); + } catch (OutOfMemoryException ex) { + Console.WriteLine(ex.ToString()); + Console.WriteLine(await task); + } catch (InternalBufferOverflowException ex) { + Console.WriteLine(ex.ToString()); + } catch { + Console.WriteLine(await task); + } + } + public async Task AwaitFinally(Task task) { try { diff --git a/ICSharpCode.Decompiler/ICSharpCode.Decompiler.csproj b/ICSharpCode.Decompiler/ICSharpCode.Decompiler.csproj index c9c769e62..fed22d9e8 100644 --- a/ICSharpCode.Decompiler/ICSharpCode.Decompiler.csproj +++ b/ICSharpCode.Decompiler/ICSharpCode.Decompiler.csproj @@ -285,6 +285,7 @@ + diff --git a/ICSharpCode.Decompiler/IL/ControlFlow/AsyncAwaitDecompiler.cs b/ICSharpCode.Decompiler/IL/ControlFlow/AsyncAwaitDecompiler.cs index adc55b685..97ca6be17 100644 --- a/ICSharpCode.Decompiler/IL/ControlFlow/AsyncAwaitDecompiler.cs +++ b/ICSharpCode.Decompiler/IL/ControlFlow/AsyncAwaitDecompiler.cs @@ -126,6 +126,8 @@ namespace ICSharpCode.Decompiler.IL.ControlFlow // 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); + + AwaitInCatchTransform.Run(function, context); } private void CleanUpBodyOfMoveNext(ILFunction function) @@ -513,15 +515,15 @@ namespace ICSharpCode.Decompiler.IL.ControlFlow } } } - #endregion + #endregion - #region AnalyzeStateMachine + #region AnalyzeStateMachine - /// - /// Analyze the the state machine; and replace 'leave IL_0000' with await+jump to block that gets - /// entered on the next MoveNext() call. - /// - void AnalyzeStateMachine(ILFunction function) + /// + /// Analyze the the state machine; and replace 'leave IL_0000' with await+jump to block that gets + /// entered on the next MoveNext() call. + /// + void AnalyzeStateMachine(ILFunction function) { context.Step("AnalyzeStateMachine()", function); smallestAwaiterVarIndex = int.MaxValue; diff --git a/ICSharpCode.Decompiler/IL/ControlFlow/AwaitInCatchTransform.cs b/ICSharpCode.Decompiler/IL/ControlFlow/AwaitInCatchTransform.cs new file mode 100644 index 000000000..9d14a6549 --- /dev/null +++ b/ICSharpCode.Decompiler/IL/ControlFlow/AwaitInCatchTransform.cs @@ -0,0 +1,187 @@ +// Copyright (c) 2018 Siegfried Pammer +// +// 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.Generic; +using System.Linq; +using System.Text; +using ICSharpCode.Decompiler.IL.Transforms; + +namespace ICSharpCode.Decompiler.IL.ControlFlow +{ + class AwaitInCatchTransform + { + public static void Run(ILFunction function, ILTransformContext context) + { + HashSet changedContainers = new HashSet(); + + // analyze all try-catch statements in the function + foreach (var tryCatch in function.Descendants.OfType().ToArray()) { + if (!(tryCatch.Parent?.Parent is BlockContainer container)) + continue; + // Detect all handlers that contain an await expression + AnalyzeHandlers(tryCatch.Handlers, out var transformableCatchBlocks); + var cfg = new ControlFlowGraph(container, context.CancellationToken); + if (transformableCatchBlocks.Count > 0) + changedContainers.Add(container); + foreach (var result in transformableCatchBlocks) { + var node = cfg.GetNode(result.RealCatchBlockEntryPoint); + + context.Step("Inline catch block with await", result.Handler); + + // Remove the IfInstruction from the jump table and eliminate all branches to the block. + var jumpTableBlock = (Block)result.JumpTableEntry.Parent; + jumpTableBlock.Instructions.RemoveAt(result.JumpTableEntry.ChildIndex); + + if (result.NextBlock != null) { + foreach (var branch in tryCatch.Descendants.OfType()) { + if (branch.TargetBlock == jumpTableBlock) + branch.ReplaceWith(new Branch(result.NextBlock)); + } + } + + // Add the real catch block entry-point to the block container + var catchBlockHead = ((BlockContainer)result.Handler.Body).Blocks.Last(); + + result.RealCatchBlockEntryPoint.Remove(); + ((BlockContainer)result.Handler.Body).Blocks.Insert(0, result.RealCatchBlockEntryPoint); + + // Remove the generated catch block + catchBlockHead.Remove(); + + // Inline all blocks that are dominated by the entrypoint of the real catch block + foreach (var n in cfg.cfg) { + if (((Block)n.UserData).Parent == result.Handler.Body) + continue; + if (node.Dominates(n)) { + MoveBlock((Block)n.UserData, (BlockContainer)result.Handler.Body); + } + } + + // Remove all assignments to the common object variable that stores the exception object. + if (result.ObjectVariableStore != null) { + foreach (var load in result.ObjectVariableStore.Variable.LoadInstructions.ToArray()) { + if (load.Parent is CastClass cc && cc.Type == result.Handler.Variable.Type) + cc.ReplaceWith(new LdLoc(result.Handler.Variable)); + else + load.ReplaceWith(new LdLoc(result.Handler.Variable)); + } + } + } + } + + // clean up all modified containers + foreach (var container in changedContainers) + container.SortBlocks(deleteUnreachableBlocks: true); + } + + static void MoveBlock(Block block, BlockContainer target) + { + block.Remove(); + target.Blocks.Add(block); + } + + /// + /// Analyzes all catch handlers and returns every handler that follows the await catch handler pattern. + /// + static bool AnalyzeHandlers(InstructionCollection handlers, out List<(int Id, TryCatchHandler Handler, Block RealCatchBlockEntryPoint, Block NextBlock, IfInstruction JumpTableEntry, StLoc ObjectVariableStore)> transformableCatchBlocks) + { + transformableCatchBlocks = new List<(int Id, TryCatchHandler Handler, Block RealCatchBlockEntryPoint, Block NextBlock, IfInstruction JumpTableEntry, StLoc ObjectVariableStore)>(); + ILVariable catchHandlerIdentifier = null; + foreach (var handler in handlers) { + if (!MatchAwaitCatchHandler((BlockContainer)handler.Body, out int id, out var identifierVariable, out var realEntryPoint, out var nextBlock, out var jumpTableEntry, out var objectVariableStore)) + continue; + if (id < 1 || (catchHandlerIdentifier != null && identifierVariable != catchHandlerIdentifier)) + continue; + catchHandlerIdentifier = identifierVariable; + transformableCatchBlocks.Add((id, handler, realEntryPoint, nextBlock, jumpTableEntry, objectVariableStore)); + } + return transformableCatchBlocks.Count > 0; + } + + /// + /// Matches the await catch handler pattern: + /// stloc V_3(ldloc E_100) - copy exception variable to a temporary + /// stloc V_6(ldloc V_3) - store exception in 'global' object variable + /// stloc V_5(ldc.i4 2) - store id of catch block in 'identifierVariable' + /// br IL_0075 - jump out of catch block to the head of the catch-handler jump table + /// + static bool MatchAwaitCatchHandler(BlockContainer container, out int id, out ILVariable identifierVariable, out Block realEntryPoint, out Block nextBlock, out IfInstruction jumpTableEntry, out StLoc objectVariableStore) + { + id = default(int); + identifierVariable = null; + realEntryPoint = null; + jumpTableEntry = null; + objectVariableStore = null; + nextBlock = null; + var catchBlock = container.EntryPoint; + if (catchBlock.Instructions.Count < 2 || catchBlock.Instructions.Count > 4) + return false; + if (!catchBlock.Instructions.Last().MatchBranch(out var jumpTableStartBlock)) + return false; + if (catchBlock.Instructions.Count > 2) { + objectVariableStore = (StLoc)catchBlock.Instructions[catchBlock.Instructions.Count - 3]; + } + var identifierVariableAssignment = catchBlock.Instructions.SecondToLastOrDefault(); + if (!identifierVariableAssignment.MatchStLoc(out identifierVariable, out var value) || !value.MatchLdcI4(out id)) + return false; + // analyze jump table: + // [stloc identifierVariableCopy(identifierVariable)] + // if (comp(identifierVariable == id)) br realEntryPoint + // br jumpTableEntryBlock + ILVariable identifierVariableCopy; + if (jumpTableStartBlock.Instructions.Count == 3) { + if (!jumpTableStartBlock.Instructions[0].MatchStLoc(out identifierVariableCopy, out var identifierVariableLoad) || !identifierVariableLoad.MatchLdLoc(identifierVariable)) + return false; + } else if (jumpTableStartBlock.Instructions.Count == 2) { + identifierVariableCopy = identifierVariable; + } else return false; + var jumpTableEntryBlock = jumpTableStartBlock; + do { + if (!(jumpTableEntryBlock.Instructions.SecondToLastOrDefault() is IfInstruction ifInst)) + return false; + ILInstruction lastInst = jumpTableEntryBlock.Instructions.Last(); + if (ifInst.Condition.MatchCompEquals(out var left, out var right)) { + if (!ifInst.TrueInst.MatchBranch(out realEntryPoint)) + return false; + if (!lastInst.MatchBranch(out jumpTableEntryBlock)) { + if (!lastInst.MatchLeave((BlockContainer)lastInst.Parent.Parent)) + return false; + } + } else if (ifInst.Condition.MatchCompNotEquals(out left, out right)) { + if (!lastInst.MatchBranch(out realEntryPoint)) + return false; + if (!ifInst.TrueInst.MatchBranch(out jumpTableEntryBlock)) { + if (!ifInst.TrueInst.MatchLeave((BlockContainer)lastInst.Parent.Parent)) + return false; + } + } else { + return false; + } + if (!left.MatchLdLoc(identifierVariableCopy)) + return false; + if (right.MatchLdcI4(id)) { + nextBlock = jumpTableEntryBlock; + jumpTableEntry = ifInst; + return true; + } + } while (jumpTableEntryBlock?.Instructions.Count == 2); + return false; + } + } +}