public override IStatement Rewrite(ITryCatchFinallyStatement operation) { _log.Info("Rewriting ITryCatchFinallyStatement: " + operation + " Pass: "******"Finally") { tryCatch.FinallyBody = null; } else { tryCatch.CatchClauses.RemoveAt(int.Parse(MutationTarget.PassInfo)); } return tryCatch; }
public override IStatement Rewrite(ITryCatchFinallyStatement operation) { _log.Info("Rewriting ITryCatchFinallyStatement: " + operation + " Pass: " + MutationTarget.PassInfo); var systemException = CurrentMethod.ContainingTypeDefinition.PlatformType.SystemException; var tryCatch = new TryCatchFinallyStatement(operation); tryCatch.CatchClauses.Add(new CatchClause { ExceptionType = systemException, Body = new BlockStatement() { Statements = new List<IStatement>{ new EmptyStatement()}, } }); return tryCatch; }
internal TryCatchReplacer(SourceMethodBody sourceMethodBody, DecompiledBlock block) { Contract.Requires(sourceMethodBody != null); Contract.Requires(block != null); this.host = sourceMethodBody.host; Contract.Assume(sourceMethodBody.host != null); this.gotosThatTarget = sourceMethodBody.gotosThatTarget; Contract.Assume(this.gotosThatTarget != null); this.unconditionalBranchRemover.gotosThatTarget = sourceMethodBody.gotosThatTarget; Contract.Assume(sourceMethodBody.ilMethodBody != null); foreach (var exInfo in sourceMethodBody.ilMethodBody.OperationExceptionInformation) { var tryCatchF = this.tryCatchFinallyMap.Find(exInfo.TryStartOffset, exInfo.TryEndOffset); if (tryCatchF == null) { tryCatchF = new TryCatchFinallyStatement(); this.tryCatchFinallyMap.Add(exInfo.TryStartOffset, exInfo.TryEndOffset, tryCatchF); } if (exInfo.HandlerKind == HandlerKind.Filter) { this.tryCatchFinallyMap.Add(exInfo.FilterDecisionStartOffset, exInfo.HandlerEndOffset, tryCatchF); this.handlerMap.Add(exInfo.FilterDecisionStartOffset, exInfo.HandlerEndOffset, exInfo); } this.tryCatchFinallyMap.Add(exInfo.HandlerStartOffset, exInfo.HandlerEndOffset, tryCatchF); this.handlerMap.Add(exInfo.HandlerStartOffset, exInfo.HandlerEndOffset, exInfo); } }
/// <summary> /// Visits the specified try catch filter finally statement. /// </summary> /// <param name="tryCatchFilterFinallyStatement">The try catch filter finally statement.</param> public override void Visit(ITryCatchFinallyStatement tryCatchFilterFinallyStatement) { TryCatchFinallyStatement mutableTryCatchFinallyStatement = new TryCatchFinallyStatement(tryCatchFilterFinallyStatement); this.resultStatement = this.myCodeCopier.DeepCopy(mutableTryCatchFinallyStatement); }
/// <summary> /// Visits the specified try catch filter finally statement. /// </summary> /// <param name="tryCatchFilterFinallyStatement">The try catch filter finally statement.</param> /// <returns></returns> protected virtual IStatement DeepCopy(TryCatchFinallyStatement tryCatchFilterFinallyStatement) { tryCatchFilterFinallyStatement.TryBody = (IBlockStatement)Substitute(tryCatchFilterFinallyStatement.TryBody); tryCatchFilterFinallyStatement.CatchClauses = this.DeepCopy(tryCatchFilterFinallyStatement.CatchClauses); if (tryCatchFilterFinallyStatement.FinallyBody != null) tryCatchFilterFinallyStatement.FinallyBody = (IBlockStatement)Substitute(tryCatchFilterFinallyStatement.FinallyBody); return tryCatchFilterFinallyStatement; }
private void RemoveUnconditionalBranchesToLabelImmediatelyFollowing(TryCatchFinallyStatement trycf, DecompiledBlock followingBlock) { Contract.Requires(trycf != null); while (followingBlock != null) { if (followingBlock.Statements.Count == 0) return; var label = followingBlock.Statements[0] as LabeledStatement; if (label != null) { this.unconditionalBranchRemover.StopTraversal = false; this.unconditionalBranchRemover.targetLabel = label; this.unconditionalBranchRemover.Traverse(trycf); var gotos = this.gotosThatTarget.Find((uint)label.Label.UniqueKey); if (gotos == null || gotos.Count == 0) { followingBlock.Statements.RemoveAt(0); } return; } followingBlock = followingBlock.Statements[0] as DecompiledBlock; } }
private void DecompileTryBody(BasicBlock b, BasicBlock firstHandler, TryCatchFinallyStatement tryStatement) { tryStatement.TryBody = GetBasicBlockUpto(b, firstHandler.StartOffset); BasicBlock tryBody = tryStatement.TryBody as BasicBlock; int startPoint = 0; if (tryBody != null && tryBody.Statements.Count > 0) { ILabeledStatement labeledStatement = tryBody.Statements[0] as ILabeledStatement; if (labeledStatement != null) { tryBody.Statements.RemoveAt(0); b.Statements.Insert(startPoint, labeledStatement); startPoint++; } } b.Statements.Insert(startPoint, tryStatement); }
private void ConsolidateScopes(TryCatchFinallyStatement trycf) { Contract.Requires(trycf != null); ConsolidateScopes((DecompiledBlock)trycf.TryBody); if (trycf.FaultBody != null) ConsolidateScopes((DecompiledBlock)trycf.FaultBody); if (trycf.FinallyBody != null) ConsolidateScopes((DecompiledBlock)trycf.FinallyBody); foreach (var catchClause in trycf.CatchClauses) { Contract.Assume(catchClause != null); var cb = (DecompiledBlock)catchClause.Body; ConsolidateScopes(cb); } }
private static void DecompileHandler(BasicBlock containingBlock, BasicBlock handlerBlock, TryCatchFinallyStatement tryStatement) { if (handlerBlock.ExceptionInformation.HandlerKind == HandlerKind.Finally) { tryStatement.FinallyBody = handlerBlock; } else if (handlerBlock.ExceptionInformation.HandlerKind == HandlerKind.Fault) { tryStatement.FaultBody = handlerBlock; } else { CatchClause catchClause = new CatchClause(); catchClause.Body = handlerBlock; catchClause.ExceptionType = handlerBlock.ExceptionInformation.ExceptionType; if (handlerBlock.ExceptionInformation.HandlerKind == HandlerKind.Catch) { catchClause.ExceptionContainer = ExtractExceptionContainer(handlerBlock); } else if (handlerBlock.ExceptionInformation.HandlerKind == HandlerKind.Filter) { catchClause.FilterCondition = ExtractFilterCondition(handlerBlock); } tryStatement.CatchClauses.Add(catchClause); } //Remove handler from statements in containing block containingBlock.Statements[containingBlock.Statements.Count-1] = GetBasicBlockStartingAt(handlerBlock, handlerBlock.ExceptionInformation.HandlerEndOffset); RemoveEndFinally(handlerBlock); }
protected override void Traverse(BasicBlock b) { if (b.NumberOfTryBlocksStartingHere > 0) { BasicBlock firstHandler = null; TryCatchFinallyStatement/*?*/ tryStatement = new TryCatchFinallyStatement(); BasicBlock bb = b; while (b.NumberOfTryBlocksStartingHere-- > 0) { if (bb.Statements.Count > 0) { BasicBlock bbb = bb.Statements[bb.Statements.Count-1] as BasicBlock; while (bbb != null) { if (bbb.ExceptionInformation != null) { if (firstHandler == null) firstHandler = bbb; if (firstHandler.ExceptionInformation.TryEndOffset < bbb.ExceptionInformation.TryEndOffset) { DecompileTryBody(b, firstHandler, tryStatement); tryStatement = new TryCatchFinallyStatement(); firstHandler = bbb; } DecompileHandler(bb, bbb, tryStatement); break; } if (bbb.Statements.Count == 0) break; bb = bbb; bbb = bbb.Statements[bbb.Statements.Count-1] as BasicBlock; } } } DecompileTryBody(b, firstHandler, tryStatement); } }
/// <summary> /// Rewrites the children of the try-catch-filter-finally statement. /// </summary> public virtual void RewriteChildren(TryCatchFinallyStatement tryCatchFilterFinallyStatement) { this.RewriteChildren((Statement)tryCatchFilterFinallyStatement); tryCatchFilterFinallyStatement.TryBody = this.Rewrite((BlockStatement)tryCatchFilterFinallyStatement.TryBody); tryCatchFilterFinallyStatement.CatchClauses = this.Rewrite(tryCatchFilterFinallyStatement.CatchClauses); if (tryCatchFilterFinallyStatement.FaultBody != null) tryCatchFilterFinallyStatement.FaultBody = this.Rewrite((BlockStatement)tryCatchFilterFinallyStatement.FaultBody); if (tryCatchFilterFinallyStatement.FinallyBody != null) tryCatchFilterFinallyStatement.FinallyBody = this.Rewrite((BlockStatement)tryCatchFilterFinallyStatement.FinallyBody); }
/// <summary> /// Visits the specified try catch filter finally statement. /// </summary> /// <param name="tryCatchFilterFinallyStatement">The try catch filter finally statement.</param> public override void Visit(ITryCatchFinallyStatement tryCatchFilterFinallyStatement) { TryCatchFinallyStatement mutableTryCatchFinallyStatement = tryCatchFilterFinallyStatement as TryCatchFinallyStatement; if (alwaysMakeACopy || mutableTryCatchFinallyStatement == null) mutableTryCatchFinallyStatement = new TryCatchFinallyStatement(tryCatchFilterFinallyStatement); this.resultStatement = this.myCodeMutator.Visit(mutableTryCatchFinallyStatement); }
/// <summary> /// Visits the specified try catch filter finally statement. /// </summary> /// <param name="tryCatchFilterFinallyStatement">The try catch filter finally statement.</param> /// <returns></returns> public virtual IStatement Visit(TryCatchFinallyStatement tryCatchFilterFinallyStatement) { tryCatchFilterFinallyStatement.TryBody = Visit(tryCatchFilterFinallyStatement.TryBody); tryCatchFilterFinallyStatement.CatchClauses = Visit(tryCatchFilterFinallyStatement.CatchClauses); if (tryCatchFilterFinallyStatement.FinallyBody != null) tryCatchFilterFinallyStatement.FinallyBody = Visit(tryCatchFilterFinallyStatement.FinallyBody); if (tryCatchFilterFinallyStatement.FaultBody != null) tryCatchFilterFinallyStatement.FaultBody = Visit(tryCatchFilterFinallyStatement.FaultBody); return tryCatchFilterFinallyStatement; }