| // Copyright 2015 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 |
| |
| import "log" |
| |
| // checkFunc checks invariants of f. |
| func checkFunc(f *Func) { |
| blockMark := make([]bool, f.NumBlocks()) |
| valueMark := make([]bool, f.NumValues()) |
| |
| for _, b := range f.Blocks { |
| if blockMark[b.ID] { |
| log.Panicf("block %s appears twice in %s!", b, f.Name) |
| } |
| blockMark[b.ID] = true |
| if b.Func != f { |
| log.Panicf("%s.Func=%s, want %s", b, b.Func.Name, f.Name) |
| } |
| |
| for i, c := range b.Succs { |
| for j, d := range b.Succs { |
| if i != j && c == d { |
| log.Panicf("%s.Succs has duplicate block %s", b, c) |
| } |
| } |
| } |
| // Note: duplicate successors are hard in the following case: |
| // if(...) goto x else goto x |
| // x: v = phi(a, b) |
| // If the conditional is true, does v get the value of a or b? |
| // We could solve this other ways, but the easiest is just to |
| // require (by possibly adding empty control-flow blocks) that |
| // all successors are distinct. They will need to be distinct |
| // anyway for register allocation (duplicate successors implies |
| // the existence of critical edges). |
| |
| for _, p := range b.Preds { |
| var found bool |
| for _, c := range p.Succs { |
| if c == b { |
| found = true |
| break |
| } |
| } |
| if !found { |
| log.Panicf("block %s is not a succ of its pred block %s", b, p) |
| } |
| } |
| |
| switch b.Kind { |
| case BlockExit: |
| if len(b.Succs) != 0 { |
| log.Panicf("exit block %s has successors", b) |
| } |
| if b.Control == nil { |
| log.Panicf("exit block %s has no control value", b) |
| } |
| if b.Control.Type != TypeMem { |
| log.Panicf("exit block %s has non-memory control value %s", b, b.Control.LongString()) |
| } |
| case BlockPlain: |
| if len(b.Succs) != 1 { |
| log.Panicf("plain block %s len(Succs)==%d, want 1", b, len(b.Succs)) |
| } |
| if b.Control != nil { |
| log.Panicf("plain block %s has non-nil control %s", b, b.Control.LongString()) |
| } |
| case BlockIf: |
| if len(b.Succs) != 2 { |
| log.Panicf("if block %s len(Succs)==%d, want 2", b, len(b.Succs)) |
| } |
| if b.Control == nil { |
| log.Panicf("if block %s has no control value", b) |
| } |
| if b.Control.Type != TypeBool { |
| log.Panicf("if block %s has non-bool control value %s", b, b.Control.LongString()) |
| } |
| case BlockCall: |
| if len(b.Succs) != 2 { |
| log.Panicf("call block %s len(Succs)==%d, want 2", b, len(b.Succs)) |
| } |
| if b.Control == nil { |
| log.Panicf("call block %s has no control value", b) |
| } |
| if b.Control.Type != TypeMem { |
| log.Panicf("call block %s has non-memory control value %s", b, b.Control.LongString()) |
| } |
| if b.Succs[1].Kind != BlockExit { |
| log.Panicf("exception edge from call block %s does not go to exit but %s", b, b.Succs[1]) |
| } |
| } |
| |
| for _, v := range b.Values { |
| if valueMark[v.ID] { |
| log.Panicf("value %s appears twice!", v.LongString()) |
| } |
| valueMark[v.ID] = true |
| |
| if v.Block != b { |
| log.Panicf("%s.block != %s", v, b) |
| } |
| if v.Op == OpPhi && len(v.Args) != len(b.Preds) { |
| log.Panicf("phi length %s does not match pred length %d for block %s", v.LongString(), len(b.Preds), b) |
| } |
| |
| // TODO: check for cycles in values |
| // TODO: check type |
| } |
| } |
| |
| for _, id := range f.bid.free { |
| if blockMark[id] { |
| log.Panicf("used block b%d in free list", id) |
| } |
| } |
| for _, id := range f.vid.free { |
| if valueMark[id] { |
| log.Panicf("used value v%d in free list", id) |
| } |
| } |
| } |