/// <summary> /// if (...) br trueBlock; /// -> /// if (...) { trueBlock... } /// /// Only inlines branches that are strictly dominated by this block (incoming edge count == 1) /// </summary> private bool InlineTrueBranch(Block block, IfInstruction ifInst) { if (!CanInline(ifInst.TrueInst)) { if (block.Instructions.SecondToLastOrDefault() == ifInst && ifInst.FalseInst.MatchNop()) { var exitInst = block.Instructions.Last(); if (DetectExitPoints.CompatibleExitInstruction(ifInst.TrueInst, exitInst)) { // if (...) exitInst; exitInst; context.Step("Use empty block as then-branch", ifInst.TrueInst); ifInst.TrueInst = new Nop().WithILRange(ifInst.TrueInst); // false, because we didn't inline a real block // this will cause HandleIfInstruction() to attempt to inline the exitInst. return(false); } } return(false); } context.Step("Inline block as then-branch", ifInst.TrueInst); // The targetBlock was already processed, and is ready to embed var targetBlock = ((Branch)ifInst.TrueInst).TargetBlock; targetBlock.AddRef(); // Peformance: avoid temporarily disconnecting targetBlock targetBlock.Remove(); ifInst.TrueInst = targetBlock; targetBlock.ReleaseRef(); return(true); }
private void HandleSwitchInstruction(ControlFlowNode cfgNode, Block block, SwitchInstruction sw, ref ILInstruction exitInst) { Debug.Assert(sw.DefaultBody is Nop); // First, move blocks into the switch section foreach (var section in sw.Sections) { if (IsUsableBranchToChild(cfgNode, section.Body)) { // case ...: goto targetBlock; var targetBlock = ((Branch)section.Body).TargetBlock; targetBlock.Remove(); section.Body = targetBlock; } } // Move the code following the switch into the default section if (IsUsableBranchToChild(cfgNode, exitInst)) { // switch(...){} goto targetBlock; // ---> switch(..) { default: { targetBlock } } var targetBlock = ((Branch)exitInst).TargetBlock; targetBlock.Remove(); sw.DefaultBody = targetBlock; if (IsBranchOrLeave(targetBlock.Instructions.Last())) { exitInst = block.Instructions[block.Instructions.Count - 1] = targetBlock.Instructions.Last(); targetBlock.Instructions.RemoveAt(targetBlock.Instructions.Count - 1); } else { exitInst = null; block.Instructions.RemoveAt(block.Instructions.Count - 1); } } // Remove compatible exitInsts from switch sections: foreach (var section in sw.Sections) { Block sectionBlock = section.Body as Block; if (sectionBlock != null && exitInst == null && IsBranchOrLeave(sectionBlock.Instructions.Last())) { exitInst = sectionBlock.Instructions.Last(); sectionBlock.Instructions.RemoveAt(sectionBlock.Instructions.Count - 1); block.Instructions.Add(exitInst); } else if (sectionBlock != null && DetectExitPoints.CompatibleExitInstruction(exitInst, sectionBlock.Instructions.Last())) { sectionBlock.Instructions.RemoveAt(sectionBlock.Instructions.Count - 1); } } sw.Sections.ReplaceList(sw.Sections.OrderBy(s => s.Body.ILRange.Start)); }
private void HandleIfInstruction(ControlFlowNode cfgNode, Block block, IfInstruction ifInst, ref ILInstruction exitInst) { if (ShouldSwapIfTargets(ifInst.TrueInst, exitInst)) { // "if (c) goto lateBlock; goto earlierBlock;" // -> "if (!c)" goto earlierBlock; goto lateBlock; // This reordering should make the if structure correspond more closely to the original C# source code context.Step("Negate if", ifInst); block.Instructions[block.Instructions.Count - 1] = ifInst.TrueInst; ifInst.TrueInst = exitInst; exitInst = block.Instructions.Last(); ifInst.Condition = Comp.LogicNot(ifInst.Condition); } ILInstruction trueExitInst; if (IsUsableBranchToChild(cfgNode, ifInst.TrueInst)) { // "if (...) goto targetBlock; exitInst;" // -> "if (...) { targetBlock } exitInst;" context.Step("Inline block as then-branch", ifInst); var targetBlock = ((Branch)ifInst.TrueInst).TargetBlock; // The targetBlock was already processed, we can embed it into the if statement: targetBlock.Remove(); ifInst.TrueInst = targetBlock; ILInstruction nestedCondition, nestedTrueInst; while (targetBlock.Instructions.Count > 0 && targetBlock.Instructions[0].MatchIfInstruction(out nestedCondition, out nestedTrueInst)) { nestedTrueInst = UnpackBlockContainingOnlyBranch(nestedTrueInst); if (DetectExitPoints.CompatibleExitInstruction(exitInst, nestedTrueInst)) { // "if (...) { if (nestedCondition) goto exitPoint; ... } goto exitPoint;" // -> "if (... && !nestedCondition) { ... } goto exitPoint;" context.Step("Combine 'if (cond1 && !cond2)' in then-branch", ifInst); ifInst.Condition = IfInstruction.LogicAnd(ifInst.Condition, Comp.LogicNot(nestedCondition)); targetBlock.Instructions.RemoveAt(0); // Update targetBlock label now that we've removed the first instruction if (targetBlock.Instructions.FirstOrDefault()?.ILRange.IsEmpty == false) { int offset = targetBlock.Instructions[0].ILRange.Start; targetBlock.ILRange = new Interval(offset, offset); } continue; // try to find more nested conditions } if (nestedTrueInst is Block nestedTrueBlock && DetectExitPoints.CompatibleExitInstruction(exitInst, nestedTrueBlock.Instructions.Last()) && targetBlock.HasFlag(InstructionFlags.EndPointUnreachable)) { // "if (...) { if (nestedCondition) { trueInst...; goto exitPoint; } falseInst...; } goto exitPoint;" // -> "if (...) { if (!nestedCondition) { falseInst...; } trueInst... } goto exitPoint;" // (only if end-point of 'falseInst...' is unreachable) context.Step("Invert nested condition to reduce number of gotos", ifInst); var nestedIfInst = (IfInstruction)targetBlock.Instructions[0]; nestedIfInst.Condition = Comp.LogicNot(nestedCondition); nestedTrueBlock.Instructions.RemoveAt(nestedTrueBlock.Instructions.Count - 1); // remove nested goto exitPoint; // remove falseInsts from outer block var falseInsts = targetBlock.Instructions.Skip(1).ToArray(); targetBlock.Instructions.RemoveRange(1, targetBlock.Instructions.Count - 1); // add trueInsts to outer block targetBlock.Instructions.AddRange(nestedTrueBlock.Instructions); // add falseInsts to inner block nestedTrueBlock.Instructions.ReplaceList(falseInsts); nestedIfInst.Condition.AcceptVisitor(new ExpressionTransforms { context = new StatementTransformContext(context) }); } break; } trueExitInst = targetBlock.Instructions.LastOrDefault(); if (DetectExitPoints.CompatibleExitInstruction(exitInst, trueExitInst)) { // "if (...) { ...; goto exitPoint } goto exitPoint;" // -> "if (...) { ... } goto exitPoint;" context.Step("Remove redundant 'goto exitPoint;' in then-branch", ifInst); targetBlock.Instructions.RemoveAt(targetBlock.Instructions.Count - 1); trueExitInst = null; if (targetBlock.Instructions.Count == 1 && targetBlock.Instructions[0].MatchIfInstruction(out nestedCondition, out nestedTrueInst)) { // "if (...) { if (nestedCondition) nestedTrueInst; } exitInst;" // --> "if (... && nestedCondition) nestedTrueInst; } exitInst" context.Step("Combine if conditions into logic.and (in then-branch)", ifInst); ifInst.Condition = IfInstruction.LogicAnd(ifInst.Condition, nestedCondition); ifInst.TrueInst = nestedTrueInst; trueExitInst = (nestedTrueInst as Block)?.Instructions.LastOrDefault(); } } } else { trueExitInst = ifInst.TrueInst; } if (IsUsableBranchToChild(cfgNode, exitInst)) { var targetBlock = ((Branch)exitInst).TargetBlock; var falseExitInst = targetBlock.Instructions.LastOrDefault(); if (DetectExitPoints.CompatibleExitInstruction(trueExitInst, falseExitInst)) { // if (...) { ...; goto exitPoint; } goto nextBlock; nextBlock: ...; goto exitPoint; // -> if (...) { ... } else { ... } goto exitPoint; context.Step("Inline block as else-branch", ifInst); targetBlock.Instructions.RemoveAt(targetBlock.Instructions.Count - 1); targetBlock.Remove(); ifInst.FalseInst = targetBlock; exitInst = block.Instructions[block.Instructions.Count - 1] = falseExitInst; Block trueBlock = ifInst.TrueInst as Block; if (trueBlock != null) { Debug.Assert(trueExitInst == trueBlock.Instructions.Last()); trueBlock.Instructions.RemoveAt(trueBlock.Instructions.Count - 1); } else { Debug.Assert(trueExitInst == ifInst.TrueInst); ifInst.TrueInst = new Nop { ILRange = ifInst.TrueInst.ILRange }; } } } if (IsEmpty(ifInst.TrueInst)) { // prefer empty true-branch to empty-else branch context.Step("Swap empty then-branch with else-branch", ifInst); var oldTrue = ifInst.TrueInst; ifInst.TrueInst = ifInst.FalseInst; ifInst.FalseInst = new Nop { ILRange = oldTrue.ILRange }; ifInst.Condition = Comp.LogicNot(ifInst.Condition); // After swapping, it's possible that we can introduce a short-circuit operator: Block trueBlock = ifInst.TrueInst as Block; ILInstruction nestedCondition, nestedTrueInst; if (trueBlock != null && trueBlock.Instructions.Count == 1 && trueBlock.FinalInstruction is Nop && trueBlock.Instructions[0].MatchIfInstruction(out nestedCondition, out nestedTrueInst)) { // if (cond) if (nestedCond) nestedTrueInst // ==> if (cond && nestedCond) nestedTrueInst context.Step("Combine if conditions into logic.and (after branch swapping)", ifInst); ifInst.Condition = IfInstruction.LogicAnd(ifInst.Condition, nestedCondition); ifInst.TrueInst = nestedTrueInst; } } else if (ifInst.FalseInst.OpCode != OpCode.Nop && ifInst.FalseInst.ILRange.Start < ifInst.TrueInst.ILRange.Start) { // swap true and false branches of if/else construct, // to bring them in the same order as the IL code context.Step("Swap then-branch with else-branch", ifInst); var oldTrue = ifInst.TrueInst; ifInst.TrueInst = ifInst.FalseInst; ifInst.FalseInst = oldTrue; ifInst.Condition = Comp.LogicNot(ifInst.Condition); } }
/// <summary> /// Looks for common exits in the inlined then and else branches of an if instruction /// and performs inversions and simplifications to merge them provided they don't /// isolate a higher priority block exit /// </summary> private void MergeCommonBranches(Block block, IfInstruction ifInst) { var thenExits = new List <ILInstruction>(); AddExits(ifInst.TrueInst, 0, thenExits); if (thenExits.Count == 0) { return; } // if there are any exits from the then branch, then the else is redundant and shouldn't exist Debug.Assert(IsEmpty(ifInst.FalseInst)); Debug.Assert(ifInst.Parent == block); var elseExits = new List <ILInstruction>(); int falseInstIndex = block.Instructions.IndexOf(ifInst) + 1; AddExits(block, falseInstIndex, elseExits); var commonExits = elseExits.Where(e1 => thenExits.Any(e2 => DetectExitPoints.CompatibleExitInstruction(e1, e2))); // find the common exit with the highest block exit priority ILInstruction commonExit = null; foreach (var exit in commonExits) { if (commonExit == null || CompareBlockExitPriority(exit, commonExit) > 0) { commonExit = exit; } } if (commonExit == null) { return; } // if the current block exit has higher priority than the exits to merge, // determine if this merge will isolate the current block exit // that is, no sequence of inversions can restore it to the block exit position var blockExit = block.Instructions.Last(); if (CompareBlockExitPriority(blockExit, commonExit, true) > 0 && !WillShortCircuit(block, ifInst, commonExit)) { return; } // could improve performance by directly implementing the || short-circuit when WillShortCircuit // currently the same general sequence of transformations introduces both operators context.StepStartGroup("Merge common branches " + commonExit, ifInst); ProduceExit(ifInst.TrueInst, 0, commonExit); ProduceExit(block, falseInstIndex, commonExit); // if (...) { ...; blockExit; } ...; blockExit; // -> if (...) { ...; blockExit; } else { ... } blockExit; if (ifInst != block.Instructions.SecondToLastOrDefault()) { context.Step("Embed else-block for goto removal", ifInst); Debug.Assert(IsEmpty(ifInst.FalseInst)); ifInst.FalseInst = ExtractBlock(block, block.Instructions.IndexOf(ifInst) + 1, block.Instructions.Count - 1); } // if (...) { ...; goto blockExit; } blockExit; // -> if (...) { ... } blockExit; // OR // if (...) { ...; goto blockExit; } else { ... } blockExit; // -> if (...) { ... } else { ... } blockExit; context.Step("Remove redundant 'goto blockExit;' in then-branch", ifInst); if (!(ifInst.TrueInst is Block trueBlock) || trueBlock.Instructions.Count == 1) { ifInst.TrueInst = new Nop().WithILRange(ifInst.TrueInst); }