j := len(c.Preds)
b.Succs = append(b.Succs, Edge{c, j})
c.Preds = append(c.Preds, Edge{b, i})
+ b.Func.invalidateCFG()
}
// removePred removes the ith input edge from b.
}
b.Preds[n] = Edge{}
b.Preds = b.Preds[:n]
+ b.Func.invalidateCFG()
}
// removeSucc removes the ith output edge from b.
}
b.Succs[n] = Edge{}
b.Succs = b.Succs[:n]
+ b.Func.invalidateCFG()
}
func (b *Block) swapSuccessors() {
if f.RegAlloc == nil {
// Note: regalloc introduces non-dominating args.
// See TODO in regalloc.go.
- idom := dominators(f)
- sdom := newSparseTree(f, idom)
+ sdom := f.sdom()
for _, b := range f.Blocks {
for _, v := range b.Values {
for i, arg := range v.Args {
{name: "opt", fn: opt, required: true}, // TODO: split required rules and optimizing rules
{name: "zero arg cse", fn: zcse, required: true}, // required to merge OpSB values
{name: "opt deadcode", fn: deadcode, required: true}, // remove any blocks orphaned during opt
- {name: "generic domtree", fn: domTree},
{name: "generic cse", fn: cse},
{name: "phiopt", fn: phiopt},
{name: "nilcheckelim", fn: nilcheckelim},
{"opt", "nilcheckelim"},
// tighten should happen before lowering to avoid splitting naturally paired instructions such as CMP/SET
{"tighten", "lower"},
- // cse, phiopt, nilcheckelim, prove and loopbce share idom.
- {"generic domtree", "generic cse"},
- {"generic domtree", "phiopt"},
- {"generic domtree", "nilcheckelim"},
- {"generic domtree", "prove"},
- {"generic domtree", "loopbce"},
// tighten will be most effective when as many values have been removed as possible
{"generic deadcode", "tighten"},
{"generic cse", "tighten"},
}
}
- // Dominator tree (f.sdom) is computed by the generic domtree pass.
+ sdom := f.sdom()
// Compute substitutions we would like to do. We substitute v for w
// if v and w are in the same equivalence class and v dominates w.
rewrite := make([]*Value, f.NumValues())
for _, e := range partition {
- sort.Sort(partitionByDom{e, f.sdom})
+ sort.Sort(partitionByDom{e, sdom})
for i := 0; i < len(e)-1; i++ {
// e is sorted by domorder, so a maximal dominant element is first in the slice
v := e[i]
if w == nil {
continue
}
- if f.sdom.isAncestorEq(v.Block, w.Block) {
+ if sdom.isAncestorEq(v.Block, w.Block) {
rewrite[w.ID] = v
e[j] = nil
} else {
Exit("rstore")))
CheckFunc(fun.f)
- domTree(fun.f)
cse(fun.f)
deadcode(fun.f)
CheckFunc(fun.f)
idom := make([]*Block, f.NumBlocks())
// Compute postorder walk
- post := postorder(f)
+ post := f.postorder()
// Make map from block id to order index (for intersect call)
postnum := make([]int, f.NumBlocks())
}
return b
}
-
-// build immediate dominators.
-func domTree(f *Func) {
- f.idom = dominators(f)
- f.sdom = newSparseTree(f, f.idom)
-}
// Compute the in-register flag value we want at the end of
// each block. This is basically a best-effort live variable
// analysis, so it can be much simpler than a full analysis.
- // TODO: do we really need to keep flag values live across blocks?
- // Could we force the flags register to be unused at basic block
- // boundaries? Then we wouldn't need this computation.
end := make([]*Value, f.NumBlocks())
+ po := f.postorder()
for n := 0; n < 2; n++ {
- // Walk blocks backwards. Poor-man's postorder traversal.
- for i := len(f.Blocks) - 1; i >= 0; i-- {
- b := f.Blocks[i]
+ for _, b := range po {
// Walk values backwards to figure out what flag
// value we want in the flag register at the start
// of the block.
freeValues *Value // free Values linked by argstorage[0]. All other fields except ID are 0/nil.
freeBlocks *Block // free Blocks linked by succstorage[0].b. All other fields except ID are 0/nil.
- idom []*Block // precomputed immediate dominators
- sdom SparseTree // precomputed dominator tree
+ cachedPostorder []*Block // cached postorder traversal
+ cachedIdom []*Block // cached immediate dominators
+ cachedSdom SparseTree // cached dominator tree
+ cachedLoopnest *loopnest // cached loop nest information
constants map[int64][]*Value // constants cache, keyed by constant value; users must check value's Op and Type
}
b.Succs = b.succstorage[:0]
b.Values = b.valstorage[:0]
f.Blocks = append(f.Blocks, b)
+ f.invalidateCFG()
return b
}
func (f *Func) Fatalf(msg string, args ...interface{}) { f.Config.Fatalf(f.Entry.Line, msg, args...) }
func (f *Func) Free() {
+ // Clear cached CFG info.
+ f.invalidateCFG()
+
// Clear values.
n := f.vid.num()
if n > len(f.Config.values) {
f.Config.curFunc = nil
*f = Func{} // just in case
}
+
+// postorder returns the reachable blocks in f in a postorder traversal.
+func (f *Func) postorder() []*Block {
+ if f.cachedPostorder == nil {
+ f.cachedPostorder = postorder(f)
+ }
+ return f.cachedPostorder
+}
+
+// idom returns a map from block ID to the immediate dominator of that block.
+// f.Entry.ID maps to nil. Unreachable blocks map to nil as well.
+func (f *Func) idom() []*Block {
+ if f.cachedIdom == nil {
+ f.cachedIdom = dominators(f)
+ }
+ return f.cachedIdom
+}
+
+// sdom returns a sparse tree representing the dominator relationships
+// among the blocks of f.
+func (f *Func) sdom() SparseTree {
+ if f.cachedSdom == nil {
+ f.cachedSdom = newSparseTree(f, f.idom())
+ }
+ return f.cachedSdom
+}
+
+// loopnest returns the loop nest information for f.
+func (f *Func) loopnest() *loopnest {
+ if f.cachedLoopnest == nil {
+ f.cachedLoopnest = loopnestfor(f)
+ }
+ return f.cachedLoopnest
+}
+
+// invalidateCFG tells f that its CFG has changed.
+func (f *Func) invalidateCFG() {
+ f.cachedPostorder = nil
+ f.cachedIdom = nil
+ f.cachedSdom = nil
+ f.cachedLoopnest = nil
+}
certain := make([]int8, f.NumBlocks()) // In the long run, all outcomes are at least this bad. Mainly for Exit
local := make([]int8, f.NumBlocks()) // for our immediate predecessors.
- nest := loopnestfor(f)
- po := nest.po
+ po := f.postorder()
+ nest := f.loopnest()
b2l := nest.b2l
for _, b := range po {
}
func loopnestfor(f *Func) *loopnest {
- po := postorder(f)
- dom := dominators(f)
- sdom := newSparseTree(f, dom)
+ po := f.postorder()
+ sdom := f.sdom()
b2l := make([]*loop, f.NumBlocks())
loops := make([]*loop, 0)
// TODO: handle 32 bit operations
func findIndVar(f *Func) []indVar {
var iv []indVar
+ sdom := f.sdom()
nextb:
for _, b := range f.Blocks {
// Second condition: b.Succs[entry] dominates nxt so that
// nxt is computed when inc < max, meaning nxt <= max.
- if !f.sdom.isAncestorEq(b.Succs[entry].b, nxt.Block) {
+ if !sdom.isAncestorEq(b.Succs[entry].b, nxt.Block) {
// inc+ind can only be reached through the branch that enters the loop.
continue
}
// removesBoundsChecks remove IsInBounds and IsSliceInBounds based on the induction variables.
func removeBoundsChecks(f *Func, m map[*Value]indVar) {
+ sdom := f.sdom()
for _, b := range f.Blocks {
if b.Kind != BlockIf {
continue
goto skip1
}
- if iv, has := m[ind]; has && f.sdom.isAncestorEq(iv.entry, b) && isNonNegative(iv.min) {
+ if iv, has := m[ind]; has && sdom.isAncestorEq(iv.entry, b) && isNonNegative(iv.min) {
if v.Args[1] == iv.max {
if f.pass.debug > 0 {
f.Config.Warnl(b.Line, "Found redundant %s", v.Op)
goto skip2
}
- if iv, has := m[ind]; has && f.sdom.isAncestorEq(iv.entry, b) && isNonNegative(iv.min) {
+ if iv, has := m[ind]; has && sdom.isAncestorEq(iv.entry, b) && isNonNegative(iv.min) {
if v.Args[1].Op == OpSliceCap && iv.max.Op == OpSliceLen && v.Args[1].Args[0] == iv.max.Args[0] {
if f.pass.debug > 0 {
f.Config.Warnl(b.Line, "Found redundant %s (len promoted to cap)", v.Op)
}
// ind + add >= 0 <-> min + add >= 0 <-> min >= -add
- if iv, has := m[ind]; has && f.sdom.isAncestorEq(iv.entry, b) && isGreaterOrEqualThan(iv.min, -add) {
+ if iv, has := m[ind]; has && sdom.isAncestorEq(iv.entry, b) && isGreaterOrEqualThan(iv.min, -add) {
if !v.Args[1].isGenericIntConst() || !iv.max.isGenericIntConst() {
goto skip3
}
// A nil check is redundant if the same nil check was successful in a
// dominating block. The efficacy of this pass depends heavily on the
// efficacy of the cse pass.
- idom := f.idom
+ idom := f.idom()
domTree := make([][]*Block, f.NumBlocks())
// Create a block ID -> [dominees] mapping
b.ReportAllocs()
for i := 0; i < b.N; i++ {
- domTree(fun.f)
nilcheckelim(fun.f)
}
}
Exit("mem")))
CheckFunc(fun.f)
- domTree(fun.f)
nilcheckelim(fun.f)
// clean up the removed nil check
Goto("exit")))
CheckFunc(fun.f)
- domTree(fun.f)
nilcheckelim(fun.f)
// clean up the removed nil check
Exit("mem")))
CheckFunc(fun.f)
- domTree(fun.f)
nilcheckelim(fun.f)
// clean up the removed nil check
Exit("mem")))
CheckFunc(fun.f)
- domTree(fun.f)
nilcheckelim(fun.f)
// clean up the removed nil check
Exit("mem")))
CheckFunc(fun.f)
- domTree(fun.f)
nilcheckelim(fun.f)
// clean up the removed nil check
Exit("mem")))
CheckFunc(fun.f)
- domTree(fun.f)
nilcheckelim(fun.f)
// clean up the removed nil check
Exit("mem")))
CheckFunc(fun.f)
- domTree(fun.f)
nilcheckelim(fun.f)
// clean up the removed nil check
CheckFunc(fun.f)
// we need the opt here to rewrite the user nilcheck
opt(fun.f)
- domTree(fun.f)
nilcheckelim(fun.f)
// clean up the removed nil check
CheckFunc(fun.f)
// we need the opt here to rewrite the user nilcheck
opt(fun.f)
- domTree(fun.f)
nilcheckelim(fun.f)
// clean up the removed nil check
b.ReportAllocs()
c := NewConfig("amd64", DummyFrontend{b}, nil, true)
fun := Fun(c, "entry", bg(size)...)
- domTree(fun.f)
CheckFunc(fun.f)
b.ResetTimer()
for i := 0; i < b.N; i++ {
b.ReportAllocs()
c := NewConfig("amd64", DummyFrontend{b}, nil, true)
fun := Fun(c, "entry", bg(b.N)...)
- domTree(fun.f)
CheckFunc(fun.f)
b.ResetTimer()
for i := 0; i < passCount; i++ {
//
// In this case we can replace x with a copy of b.
func phiopt(f *Func) {
+ sdom := f.sdom()
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.
// 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) {
+ if tmp := v.Args[1-reverse]; sdom.isAncestorEq(tmp.Block, b) {
v.reset(OpOrB)
v.SetArgs2(b0.Control, tmp)
if f.pass.debug > 0 {
// 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) {
+ if tmp := v.Args[reverse]; sdom.isAncestorEq(tmp.Block, b) {
v.reset(OpAndB)
v.SetArgs2(b0.Control, tmp)
if f.pass.debug > 0 {
})
ft := newFactsTable()
+ idom := f.idom()
+ sdom := f.sdom()
// DFS on the dominator tree.
for len(work) > 0 {
node := work[len(work)-1]
work = work[:len(work)-1]
- parent := f.idom[node.block.ID]
- branch := getBranch(f.sdom, parent, node.block)
+ parent := idom[node.block.ID]
+ branch := getBranch(sdom, parent, node.block)
switch node.state {
case descend:
block: node.block,
state: simplify,
})
- for s := f.sdom.Child(node.block); s != nil; s = f.sdom.Sibling(s) {
+ for s := sdom.Child(node.block); s != nil; s = sdom.Sibling(s) {
work = append(work, bp{
block: s,
state: descend,
// Walk the dominator tree from end to beginning, just once, treating SCC
// components as single blocks, duplicated calculated liveness information
// out to all of them.
- s.loopnest = loopnestfor(f)
- po := s.loopnest.po
+ po := f.postorder()
+ s.loopnest = f.loopnest()
for {
changed := false
// NewSparseTreeHelper returns a SparseTreeHelper for use
// in the gc package, for example in phi-function placement.
func NewSparseTreeHelper(f *Func) *SparseTreeHelper {
- dom := dominators(f)
+ dom := f.idom()
ponums := make([]int32, f.NumBlocks())
po := postorderWithNumbering(f, ponums)
return makeSparseTreeHelper(newSparseTree(f, dom), dom, po, ponums)
// Instead of iterating over f.Blocks, iterate over their postordering.
// Liveness information flows backward, so starting at the end
// increases the probability that we will stabilize quickly.
- po := postorder(s.f)
+ po := s.f.postorder()
for {
changed := false
for _, b := range po {