private void BreakReduceBranch(BasicBlock root, BBLoop loop, BasicBlock breakTarget, BranchBasicBlock branchbb, Seq<BasicBlock> removed, Seq<BasicBlock> added) { var beforeState = branchbb.Block.BeforeState; var afterState = branchbb.Block.AfterState; if (branchbb.Target.Equals(breakTarget) && !branchbb.Fallthrough.Equals(breakTarget)) { var instructions = branchbb.Block.CopyContents(); branchbb.Test.Eval(instructions, afterState, branchbb.Target.Block.BeforeState, BottomPT); var cond = SeparateCondition(beforeState, ref instructions); var lci = new BreakContinueInstruction(NextInstructionId--, BreakContinueOp.Break, loop.Label) { BeforeState = afterState, AfterState = afterState }; var itei = new IfThenElseInstruction(NextInstructionId--, cond, new Instructions(lci), null) { BeforeState = beforeState, AfterState = afterState }; instructions.Add(itei); var newbb = new JumpBasicBlock(nextBlockId++, new Instructions(beforeState, instructions), branchbb.Fallthrough); root.Coalesce(branchbb, new Set<BasicBlock> { branchbb }, newbb); removed.Add(branchbb); added.Add(newbb); } else if (branchbb.Fallthrough.Equals(breakTarget) && !branchbb.Target.Equals(breakTarget)) { var instructions = branchbb.Block.CopyContents(); branchbb.Test.Negate().Eval (instructions, afterState, branchbb.Fallthrough.Block.BeforeState, BottomPT); var cond = SeparateCondition(beforeState, ref instructions); var lci = new BreakContinueInstruction(NextInstructionId--, BreakContinueOp.Break, loop.Label) { BeforeState = afterState, AfterState = afterState }; var itei = new IfThenElseInstruction(NextInstructionId--, cond, new Instructions(lci), null) { BeforeState = beforeState, AfterState = afterState }; instructions.Add(itei); var newbb = new JumpBasicBlock(nextBlockId++, new Instructions(beforeState, instructions), branchbb.Target); root.Coalesce(branchbb, new Set<BasicBlock> { branchbb }, newbb); removed.Add(branchbb); added.Add(newbb); } }
private string TryReduceBranch(BasicBlock root, BranchBasicBlock branchbb) { var beforeState = branchbb.Block.BeforeState; var afterState = branchbb.Block.AfterState; { // While-do var thenbb = branchbb.Target as JumpBasicBlock; var group = new Set<BasicBlock> { branchbb }; if (thenbb != null && thenbb.Target.Equals(branchbb) && thenbb.Sources.Count == 1 && group.Add(thenbb) && !group.Contains(branchbb.Fallthrough)) { var instructions = branchbb.Block.CopyContents(); branchbb.Test.Eval(instructions, afterState, thenbb.Block.BeforeState, BottomPT); var wdi = new WhileDoInstruction (NextInstructionId--, new Instructions(beforeState, instructions), thenbb.Block) { BeforeState = beforeState, AfterState = branchbb.Fallthrough.Block.BeforeState }; var newbb = new JumpBasicBlock(nextBlockId++, new Instructions(wdi), branchbb.Fallthrough); root.Coalesce(branchbb, group, newbb); return String.Format("while-do from B{0}", branchbb.Id); } } { // Flipped while-do var elsebb = branchbb.Fallthrough as JumpBasicBlock; var group = new Set<BasicBlock> { branchbb }; if (elsebb != null && elsebb.Target.Equals(branchbb) && elsebb.Sources.Count == 1 && group.Add(elsebb) && !group.Contains(branchbb.Target)) { var instructions = branchbb.Block.CopyContents(); branchbb.Test.Negate().Eval (instructions, afterState, elsebb.Block.BeforeState, BottomPT); var wdi = new WhileDoInstruction (NextInstructionId--, new Instructions(beforeState, instructions), elsebb.Block) { BeforeState = beforeState, AfterState = branchbb.Target.Block.BeforeState }; var newbb = new JumpBasicBlock(nextBlockId++, new Instructions(wdi), branchbb.Target); root.Coalesce(branchbb, group, newbb); return String.Format("while-do (flipped) from B{0}", branchbb.Id); } } { // Do-while var thenbb = branchbb.Target; if (thenbb.Equals(branchbb) && !branchbb.Fallthrough.Equals(branchbb)) { var instructions = branchbb.Block.CopyContents(); branchbb.Test.Eval(instructions, afterState, beforeState, BottomPT); var cond = SeparateCondition(beforeState, ref instructions); var dwi = new DoWhileInstruction(NextInstructionId--, new Instructions(beforeState, instructions), cond) { BeforeState = beforeState, AfterState = branchbb.Fallthrough.Block.BeforeState }; var newbb = new JumpBasicBlock(nextBlockId++, new Instructions(dwi), branchbb.Fallthrough); root.Coalesce(branchbb, new Set<BasicBlock> { branchbb }, newbb); return String.Format("do-while from B{0}", branchbb.Id); } } { // Flipped Do-while var elsebb = branchbb.Fallthrough; if (elsebb.Equals(branchbb) && !branchbb.Target.Equals(branchbb)) { var instructions = branchbb.Block.CopyContents(); branchbb.Test.Negate().Eval (instructions, afterState, beforeState, BottomPT); var cond = SeparateCondition(beforeState, ref instructions); var dwi = new DoWhileInstruction(NextInstructionId--, new Instructions(beforeState, instructions), cond) { BeforeState = beforeState, AfterState = branchbb.Target.Block.BeforeState }; var newbb = new JumpBasicBlock(nextBlockId++, new Instructions(dwi), branchbb.Target); root.Coalesce(branchbb, new Set<BasicBlock> { branchbb }, newbb); return String.Format("do-while (flipped) from B{0}", branchbb.Id); } } { // If-then, converging control var thenbb = branchbb.Target as JumpBasicBlock; if (thenbb != null && thenbb.Target.Equals(branchbb.Fallthrough) && thenbb.Sources.Count == 1) { var instructions = branchbb.Block.CopyContents(); branchbb.Test.Eval(instructions, afterState, thenbb.Block.BeforeState, BottomPT); var cond = SeparateCondition(beforeState, ref instructions); var itei = new IfThenElseInstruction(NextInstructionId--, cond, thenbb.Block, null) { BeforeState = beforeState, AfterState = thenbb.Block.AfterState }; instructions.Add(itei); var newbb = thenbb.CloneWithInstructions (nextBlockId++, new Instructions(beforeState, instructions)); root.Coalesce(branchbb, new Set<BasicBlock> { branchbb, thenbb }, newbb); return String.Format("if-then with converging control paths from B{0}", branchbb.Id); } } { // Flipped if-then, converging control var elsebb = branchbb.Fallthrough as JumpBasicBlock; if (elsebb != null && elsebb.Target.Equals(branchbb.Target) && elsebb.Sources.Count == 1) { var instructions = branchbb.Block.CopyContents(); branchbb.Test.Negate().Eval (instructions, afterState, elsebb.Block.BeforeState, BottomPT); var cond = SeparateCondition(beforeState, ref instructions); var itei = new IfThenElseInstruction(NextInstructionId--, cond, elsebb.Block, null) { BeforeState = beforeState, AfterState = elsebb.Block.AfterState }; instructions.Add(itei); var newbb = elsebb.CloneWithInstructions (nextBlockId++, new Instructions(beforeState, instructions)); root.Coalesce(branchbb, new Set<BasicBlock> { branchbb, elsebb }, newbb); return String.Format("if-then (flipped) with converging control paths from B{0}", branchbb.Id); } } { // Short-circuited and/or "expression" var thenbb = branchbb.Target as JumpBasicBlock; var elsebb = branchbb.Fallthrough as JumpBasicBlock; var group = new Set<BasicBlock> { branchbb }; if (thenbb != null && elsebb != null && thenbb.Target.Equals(elsebb.Target) && elsebb.Sources.Count == 1 && group.Add(elsebb) && !group.Contains(thenbb) && !group.Contains(thenbb.Target) && !thenbb.Target.Equals(thenbb) && IsLoadBooleanBlock(thenbb.Block)) { var instructions = branchbb.Block.CopyContents(); var test = IsLoadTrueBooleanBlock(thenbb.Block) ? branchbb.Test : branchbb.Test.Negate(); test.Eval(instructions, afterState, thenbb.Block.BeforeState, BottomPT); var left = SeparateCondition(beforeState, ref instructions); var op = IsLoadTrueBooleanBlock(thenbb.Block) ? ShortCircuitingOp.Or : ShortCircuitingOp.And; var sci = new ShortCircuitingInstruction(NextInstructionId--, left, op, elsebb.Block) { BeforeState = beforeState, AfterState = elsebb.Block.AfterState }; instructions.Add(sci); var newbb = new JumpBasicBlock (nextBlockId++, new Instructions(beforeState, instructions), elsebb.Target); if (thenbb.Sources.Count == 1) group.Add(thenbb); root.Coalesce(branchbb, group, newbb); return String.Format("short-circuited and/or expression from B{0}", branchbb.Id); } } { // Flipped short-circuited and/or "expression" var thenbb = branchbb.Target as JumpBasicBlock; var elsebb = branchbb.Fallthrough as JumpBasicBlock; var group = new Set<BasicBlock> { branchbb }; if (thenbb != null && elsebb != null && thenbb.Target.Equals(elsebb.Target) && thenbb.Sources.Count == 1 && group.Add(thenbb) && !group.Contains(elsebb) && !group.Contains(elsebb.Target) && !elsebb.Target.Equals(elsebb) && IsLoadBooleanBlock(elsebb.Block)) { var instructions = branchbb.Block.CopyContents(); var test = IsLoadTrueBooleanBlock(elsebb.Block) ? branchbb.Test.Negate() : branchbb.Test; test.Eval(instructions, afterState, thenbb.Block.BeforeState, BottomPT); var left = SeparateCondition(beforeState, ref instructions); var op = IsLoadTrueBooleanBlock(elsebb.Block) ? ShortCircuitingOp.Or : ShortCircuitingOp.And; var sci = new ShortCircuitingInstruction(NextInstructionId--, left, op, thenbb.Block) { BeforeState = beforeState, AfterState = thenbb.Block.AfterState }; instructions.Add(sci); var newbb = new JumpBasicBlock (nextBlockId++, new Instructions(beforeState, instructions), thenbb.Target); if (elsebb.Sources.Count == 1) group.Add(elsebb); root.Coalesce(branchbb, group, newbb); return String.Format("short-circuited (flipped) and/or expression from B{0}", branchbb.Id); } } { // Short-circuited and/or control flow var group = new Set<BasicBlock> { branchbb }; var thenbb = branchbb.Target as BranchBasicBlock; if (thenbb != null && branchbb.Fallthrough.Equals(thenbb.Fallthrough) && thenbb.Sources.Count == 1 && group.Add(thenbb) && !group.Contains(thenbb.Target) && !group.Contains(branchbb.Fallthrough)) { var instructions = branchbb.Block.CopyContents(); branchbb.Test.Eval(instructions, afterState, thenbb.Block.BeforeState, BottomPT); var left = SeparateCondition(beforeState, ref instructions); var instructions2 = thenbb.Block.CopyContents(); var afterState2 = thenbb.Test.Eval (instructions2, thenbb.Block.AfterState, thenbb.Target.Block.BeforeState, BottomPT); var right = new Instructions(thenbb.Block.BeforeState, instructions2); var sci = new ShortCircuitingInstruction(NextInstructionId--, left, ShortCircuitingOp.And, right) { BeforeState = beforeState, AfterState = afterState2 }; instructions.Add(sci); var newbb = new BranchBasicBlock (nextBlockId++, new Instructions(beforeState, instructions), new Test(TestOp.True, false, methEnv.Global.Int32Ref)) { Target = thenbb.Target, Fallthrough = thenbb.Fallthrough }; root.Coalesce(branchbb, group, newbb); return String.Format ("short-circuited (normal, normal) and/or control flow from B{0}", branchbb.Id); } } { // Short-circuited and/or control flow, flipped first var group = new Set<BasicBlock> { branchbb }; var elsebb = branchbb.Fallthrough as BranchBasicBlock; if (elsebb != null && branchbb.Target.Equals(elsebb.Fallthrough) && elsebb.Sources.Count == 1 && group.Add(elsebb) && !group.Contains(elsebb.Target) && !group.Contains(branchbb.Target)) { var instructions = branchbb.Block.CopyContents(); branchbb.Test.Negate().Eval (instructions, afterState, elsebb.Block.BeforeState, BottomPT); var left = SeparateCondition(beforeState, ref instructions); var instructions2 = elsebb.Block.CopyContents(); var afterState2 = elsebb.Test.Eval (instructions2, elsebb.Block.AfterState, elsebb.Target.Block.BeforeState, BottomPT); var right = new Instructions(elsebb.Block.BeforeState, instructions2); var sci = new ShortCircuitingInstruction(NextInstructionId--, left, ShortCircuitingOp.And, right) { BeforeState = beforeState, AfterState = afterState2 }; instructions.Add(sci); var newbb = new BranchBasicBlock (nextBlockId++, new Instructions(beforeState, instructions), new Test(TestOp.True, false, methEnv.Global.Int32Ref)) { Target = elsebb.Target, Fallthrough = branchbb.Target }; root.Coalesce(branchbb, group, newbb); return String.Format ("short-circuited (flipped, normal) and/or control flow from B{0}", branchbb.Id); } } { // Short-circuited and/or control flow, flipped second var group = new Set<BasicBlock> { branchbb }; var thenbb = branchbb.Target as BranchBasicBlock; if (thenbb != null && branchbb.Fallthrough.Equals(thenbb.Target) && thenbb.Sources.Count == 1 && group.Add(thenbb) && !group.Contains(thenbb.Fallthrough) && !group.Contains(branchbb.Fallthrough)) { var instructions = branchbb.Block.CopyContents(); branchbb.Test.Eval(instructions, afterState, thenbb.Block.BeforeState, BottomPT); var left = SeparateCondition(beforeState, ref instructions); var instructions2 = thenbb.Block.CopyContents(); var afterState2 = thenbb.Test.Negate().Eval (instructions2, thenbb.Block.AfterState, thenbb.Fallthrough.Block.BeforeState, BottomPT); var right = new Instructions(thenbb.Block.BeforeState, instructions2); var sci = new ShortCircuitingInstruction(NextInstructionId--, left, ShortCircuitingOp.And, right) { BeforeState = beforeState, AfterState = afterState2 }; instructions.Add(sci); var newbb = new BranchBasicBlock (nextBlockId++, new Instructions(beforeState, instructions), new Test(TestOp.True, false, methEnv.Global.Int32Ref)) { Target = thenbb.Fallthrough, Fallthrough = branchbb.Fallthrough }; root.Coalesce(branchbb, group, newbb); return String.Format ("short-circuited (normal, flipped) and/or control flow from B{0}", branchbb.Id); } } { // Short-circuited and/or control flow, flipped first and second var group = new Set<BasicBlock> { branchbb }; var elsebb = branchbb.Fallthrough as BranchBasicBlock; if (elsebb != null && branchbb.Target.Equals(elsebb.Target) && elsebb.Sources.Count == 1 && group.Add(elsebb) && !group.Contains(elsebb.Fallthrough) && !group.Contains(branchbb.Target)) { var instructions = branchbb.Block.CopyContents(); branchbb.Test.Negate().Eval (instructions, afterState, elsebb.Block.BeforeState, BottomPT); var left = SeparateCondition(beforeState, ref instructions); var instructions2 = elsebb.Block.CopyContents(); var afterState2 = elsebb.Test.Negate().Eval (instructions2, elsebb.Block.AfterState, elsebb.Fallthrough.Block.BeforeState, BottomPT); var right = new Instructions(elsebb.Block.BeforeState, instructions2); var sci = new ShortCircuitingInstruction(NextInstructionId--, left, ShortCircuitingOp.And, right) { BeforeState = beforeState, AfterState = afterState2 }; instructions.Add(sci); var newbb = new BranchBasicBlock (nextBlockId++, new Instructions(beforeState, instructions), new Test(TestOp.True, false, methEnv.Global.Int32Ref)) { Target = elsebb.Fallthrough, Fallthrough = branchbb.Target }; root.Coalesce(branchbb, group, newbb); return String.Format ("short-circuited (flipped, flipped) and/or control flow from B{0}", branchbb.Id); } } { // If-then-else, neither side returns var thenbb = branchbb.Target as NonReturningBasicBlock; var elsebb = branchbb.Fallthrough as NonReturningBasicBlock; if (thenbb != null && elsebb != null && !branchbb.Equals(thenbb) && !branchbb.Equals(elsebb) && !thenbb.Equals(elsebb) && branchbb.Target.Sources.Count == 1 && branchbb.Fallthrough.Sources.Count == 1) { var instructions = branchbb.Block.CopyContents(); if (thenbb.Block.Size <= elsebb.Block.Size) { branchbb.Test.Eval (instructions, afterState, thenbb.Block.BeforeState, BottomPT); var cond = SeparateCondition(beforeState, ref instructions); var itei = new IfThenElseInstruction(NextInstructionId--, cond, thenbb.Block, null) { BeforeState = beforeState, AfterState = thenbb.Block.AfterState }; instructions.Add(itei); var newbb = new JumpBasicBlock (nextBlockId++, new Instructions(beforeState, instructions), elsebb); root.Coalesce(branchbb, new Set<BasicBlock> { branchbb, thenbb }, newbb); return String.Format("if-then-else, no return, then smaller, from B{0}", branchbb.Id); } else { branchbb.Test.Negate().Eval (instructions, afterState, elsebb.Block.BeforeState, BottomPT); var cond = SeparateCondition(beforeState, ref instructions); var itei = new IfThenElseInstruction(NextInstructionId--, cond, elsebb.Block, null) { BeforeState = beforeState, AfterState = elsebb.Block.AfterState }; instructions.Add(itei); var newbb = new JumpBasicBlock (nextBlockId++, new Instructions(beforeState, instructions), thenbb); root.Coalesce(branchbb, new Set<BasicBlock> { branchbb, elsebb }, newbb); return String.Format("if-then-else, no return, else smaller, from B{0}", branchbb.Id); } } } { // If-then, no-return var thenbb = branchbb.Target as NonReturningBasicBlock; if (thenbb != null && thenbb.Sources.Count == 1) { var instructions = branchbb.Block.CopyContents(); branchbb.Test.Eval(instructions, afterState, thenbb.Block.BeforeState, BottomPT); var cond = SeparateCondition(beforeState, ref instructions); var itei = new IfThenElseInstruction(NextInstructionId--, cond, thenbb.Block, null) { BeforeState = beforeState, AfterState = thenbb.Block.AfterState }; instructions.Add(itei); var newbb = new JumpBasicBlock (nextBlockId++, new Instructions(beforeState, instructions), branchbb.Fallthrough); root.Coalesce(branchbb, new Set<BasicBlock> { branchbb, thenbb }, newbb); return String.Format("if-then, no return, from B{0}", branchbb.Id); } } { // Flipped if-then, no-return var elsebb = branchbb.Fallthrough as NonReturningBasicBlock; if (elsebb != null && elsebb.Sources.Count == 1) { var instructions = branchbb.Block.CopyContents(); branchbb.Test.Negate().Eval (instructions, afterState, elsebb.Block.BeforeState, BottomPT); var cond = SeparateCondition(beforeState, ref instructions); var itei = new IfThenElseInstruction(NextInstructionId--, cond, elsebb.Block, null) { BeforeState = beforeState, AfterState = elsebb.Block.AfterState }; instructions.Add(itei); var newbb = new JumpBasicBlock (nextBlockId++, new Instructions(beforeState, instructions), branchbb.Target); root.Coalesce(branchbb, new Set<BasicBlock> { branchbb, elsebb }, newbb); return String.Format("if-then (flipped), no return, from B{0}", branchbb.Id); } } { // If-then-else var group = new Set<BasicBlock> { branchbb }; if (group.Add(branchbb.Target) && group.Add(branchbb.Fallthrough) && branchbb.Target.Sources.Count == 1 && branchbb.Fallthrough.Sources.Count == 1 && branchbb.Target.HasSameExit(branchbb.Fallthrough)) { var instructions = branchbb.Block.CopyContents(); branchbb.Test.Eval (instructions, afterState, branchbb.Target.Block.BeforeState, BottomPT); var cond = SeparateCondition(beforeState, ref instructions); var itei = new IfThenElseInstruction (NextInstructionId--, cond, branchbb.Target.Block, branchbb.Fallthrough.Block) { BeforeState = beforeState, AfterState = branchbb.Target.Block.AfterState }; instructions.Add(itei); var newbb = branchbb.Fallthrough.CloneWithInstructions (nextBlockId++, new Instructions(beforeState, instructions)); root.Coalesce(branchbb, group, newbb); return String.Format("if-then-else from B{0}", branchbb.Id); } } return null; }
private string ContinueReduceBranch(BasicBlock root, BBLoop loop, BranchBasicBlock branchbb) { var beforeState = branchbb.Block.BeforeState; var afterState = branchbb.Block.AfterState; if (branchbb.Target.Equals(loop.ContinueTarget) && !branchbb.Fallthrough.Equals(loop.ContinueTarget) && loop.ContinueTarget.Sources.Count > 1) { var instructions = branchbb.Block.CopyContents(); branchbb.Test.Eval (instructions, afterState, branchbb.Target.Block.BeforeState, BottomPT); var cond = SeparateCondition(beforeState, ref instructions); var lci = new BreakContinueInstruction(NextInstructionId--, BreakContinueOp.Continue, loop.Label) { BeforeState = afterState, AfterState = afterState }; var ifei = new IfThenElseInstruction(-1, cond, new Instructions(lci), null) { BeforeState = beforeState, AfterState = afterState }; instructions.Add(ifei); var newbb = new JumpBasicBlock (nextBlockId++, new Instructions(beforeState, instructions), branchbb.Fallthrough); root.Coalesce(branchbb, new Set<BasicBlock> { branchbb }, newbb); return String.Format("continue from branch at B{0} within loop from B{1}", branchbb.Id, loop.Head.Id); } if (branchbb.Fallthrough.Equals(loop.ContinueTarget) && !branchbb.Target.Equals(loop.ContinueTarget) && loop.ContinueTarget.Sources.Count > 1) { var instructions = branchbb.Block.CopyContents(); branchbb.Test.Negate().Eval (instructions, afterState, branchbb.Fallthrough.Block.BeforeState, BottomPT); var cond = SeparateCondition(beforeState, ref instructions); var lci = new BreakContinueInstruction(NextInstructionId--, BreakContinueOp.Continue, loop.Label) { BeforeState = afterState, AfterState = afterState }; var ifei = new IfThenElseInstruction(NextInstructionId--, cond, new Instructions(lci), null) { BeforeState = beforeState, AfterState = afterState }; instructions.Add(ifei); var newbb = new JumpBasicBlock(nextBlockId++, new Instructions(beforeState, instructions), branchbb.Target); root.Coalesce(branchbb, new Set<BasicBlock> { branchbb }, newbb); return String.Format ("continue from branch (flipped) at B{0} within loop from B{1}", branchbb.Id, loop.Head.Id); } return null; }