blob: d6272b4cfc9c3025d59c353fd9bdd284c1ebf543 [file] [log] [blame]
 // Copyright 2016 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package ssa // phiopt eliminates boolean Phis based on the previous if. // // Main use case is to transform: // x := false // if b { // x = true // } // into x = b. // // In SSA code this appears as // // b0 // If b -> b1 b2 // b1 // Plain -> b2 // b2 // x = (OpPhi (ConstBool [true]) (ConstBool [false])) // // In this case we can replace x with a copy of b. func phiopt(f *Func) { for _, b := range f.Blocks { if len(b.Preds) != 2 || len(b.Values) == 0 { // TODO: handle more than 2 predecessors, e.g. a || b || c. continue } pb0, b0 := b, b.Preds[0].b for len(b0.Succs) == 1 && len(b0.Preds) == 1 { pb0, b0 = b0, b0.Preds[0].b } if b0.Kind != BlockIf { continue } pb1, b1 := b, b.Preds[1].b for len(b1.Succs) == 1 && len(b1.Preds) == 1 { pb1, b1 = b1, b1.Preds[0].b } if b1 != b0 { continue } // b0 is the if block giving the boolean value. // reverse is the predecessor from which the truth value comes. var reverse int if b0.Succs[0].b == pb0 && b0.Succs[1].b == pb1 { reverse = 0 } else if b0.Succs[0].b == pb1 && b0.Succs[1].b == pb0 { reverse = 1 } else { b.Fatalf("invalid predecessors\n") } for _, v := range b.Values { if v.Op != OpPhi || !v.Type.IsBoolean() { continue } // Replaces // if a { x = true } else { x = false } with x = a // and // if a { x = false } else { x = true } with x = !a if v.Args[0].Op == OpConstBool && v.Args[1].Op == OpConstBool { if v.Args[reverse].AuxInt != v.Args[1-reverse].AuxInt { ops := [2]Op{OpNot, OpCopy} v.reset(ops[v.Args[reverse].AuxInt]) v.AddArg(b0.Control) if f.pass.debug > 0 { f.Config.Warnl(b.Line, "converted OpPhi to %v", v.Op) } continue } } // Replaces // if a { x = true } else { x = value } with x = a || value. // Requires that value dominates x, meaning that regardless of a, // value is always computed. This guarantees that the side effects // of value are not seen if a is false. if v.Args[reverse].Op == OpConstBool && v.Args[reverse].AuxInt == 1 { if tmp := v.Args[1-reverse]; f.sdom.isAncestorEq(tmp.Block, b) { v.reset(OpOrB) v.SetArgs2(b0.Control, tmp) if f.pass.debug > 0 { f.Config.Warnl(b.Line, "converted OpPhi to %v", v.Op) } continue } } // Replaces // if a { x = value } else { x = false } with x = a && value. // Requires that value dominates x, meaning that regardless of a, // value is always computed. This guarantees that the side effects // of value are not seen if a is false. if v.Args[1-reverse].Op == OpConstBool && v.Args[1-reverse].AuxInt == 0 { if tmp := v.Args[reverse]; f.sdom.isAncestorEq(tmp.Block, b) { v.reset(OpAndB) v.SetArgs2(b0.Control, tmp) if f.pass.debug > 0 { f.Config.Warnl(b.Line, "converted OpPhi to %v", v.Op) } continue } } } } }