mirror of https://github.com/golang/go.git
cmd/compile/internal/gc: bv.go cleanup
Drive by gardening of bv.go. - Unexport the Bvec type, it is not used outside internal/gc. (machine translated with gofmt -r) - Removed unused constants and functions. (driven by cmd/unused) Change-Id: I3433758ad4e62439f802f4b0ed306e67336d9aba Reviewed-on: https://go-review.googlesource.com/22602 Run-TryBot: Dave Cheney <dave@cheney.net> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
This commit is contained in:
Dave Cheney
parent
94e523cb52
commit
5edcff0134
|
|
@ -7,32 +7,20 @@ package gc
|
|||
import "fmt"
|
||||
|
||||
const (
|
||||
WORDSIZE = 4
|
||||
WORDBITS = 32
|
||||
WORDMASK = WORDBITS - 1
|
||||
WORDSHIFT = 5
|
||||
)
|
||||
|
||||
// A Bvec is a bit vector.
|
||||
type Bvec struct {
|
||||
// A bvec is a bit vector.
|
||||
type bvec struct {
|
||||
n int32 // number of bits in vector
|
||||
b []uint32 // words holding bits
|
||||
}
|
||||
|
||||
func bvsize(n uint32) uint32 {
|
||||
return ((n + WORDBITS - 1) / WORDBITS) * WORDSIZE
|
||||
}
|
||||
|
||||
func bvbits(bv Bvec) int32 {
|
||||
return bv.n
|
||||
}
|
||||
|
||||
func bvwords(bv Bvec) int32 {
|
||||
return (bv.n + WORDBITS - 1) / WORDBITS
|
||||
}
|
||||
|
||||
func bvalloc(n int32) Bvec {
|
||||
return Bvec{n, make([]uint32, bvsize(uint32(n))/4)}
|
||||
func bvalloc(n int32) bvec {
|
||||
nword := (n + WORDBITS - 1) / WORDBITS
|
||||
return bvec{n, make([]uint32, nword)}
|
||||
}
|
||||
|
||||
type bulkBvec struct {
|
||||
|
|
@ -50,20 +38,20 @@ func bvbulkalloc(nbit int32, count int32) bulkBvec {
|
|||
}
|
||||
}
|
||||
|
||||
func (b *bulkBvec) next() Bvec {
|
||||
out := Bvec{b.nbit, b.words[:b.nword]}
|
||||
func (b *bulkBvec) next() bvec {
|
||||
out := bvec{b.nbit, b.words[:b.nword]}
|
||||
b.words = b.words[b.nword:]
|
||||
return out
|
||||
}
|
||||
|
||||
// difference
|
||||
func bvandnot(dst Bvec, src1 Bvec, src2 Bvec) {
|
||||
func bvandnot(dst bvec, src1 bvec, src2 bvec) {
|
||||
for i, x := range src1.b {
|
||||
dst.b[i] = x &^ src2.b[i]
|
||||
}
|
||||
}
|
||||
|
||||
func bveq(bv1 Bvec, bv2 Bvec) bool {
|
||||
func bveq(bv1 bvec, bv2 bvec) bool {
|
||||
if bv1.n != bv2.n {
|
||||
Fatalf("bvequal: lengths %d and %d are not equal", bv1.n, bv2.n)
|
||||
}
|
||||
|
|
@ -75,28 +63,13 @@ func bveq(bv1 Bvec, bv2 Bvec) bool {
|
|||
return true
|
||||
}
|
||||
|
||||
func bvcopy(dst Bvec, src Bvec) {
|
||||
func bvcopy(dst bvec, src bvec) {
|
||||
for i, x := range src.b {
|
||||
dst.b[i] = x
|
||||
}
|
||||
}
|
||||
|
||||
func bvconcat(src1 Bvec, src2 Bvec) Bvec {
|
||||
dst := bvalloc(src1.n + src2.n)
|
||||
for i := int32(0); i < src1.n; i++ {
|
||||
if bvget(src1, i) != 0 {
|
||||
bvset(dst, i)
|
||||
}
|
||||
}
|
||||
for i := int32(0); i < src2.n; i++ {
|
||||
if bvget(src2, i) != 0 {
|
||||
bvset(dst, i+src1.n)
|
||||
}
|
||||
}
|
||||
return dst
|
||||
}
|
||||
|
||||
func bvget(bv Bvec, i int32) int {
|
||||
func bvget(bv bvec, i int32) int {
|
||||
if i < 0 || i >= bv.n {
|
||||
Fatalf("bvget: index %d is out of bounds with length %d\n", i, bv.n)
|
||||
}
|
||||
|
|
@ -105,7 +78,7 @@ func bvget(bv Bvec, i int32) int {
|
|||
|
||||
// bvnext returns the smallest index >= i for which bvget(bv, i) == 1.
|
||||
// If there is no such index, bvnext returns -1.
|
||||
func bvnext(bv Bvec, i int32) int32 {
|
||||
func bvnext(bv bvec, i int32) int32 {
|
||||
if i >= bv.n {
|
||||
return -1
|
||||
}
|
||||
|
|
@ -134,7 +107,7 @@ func bvnext(bv Bvec, i int32) int32 {
|
|||
return i
|
||||
}
|
||||
|
||||
func bvisempty(bv Bvec) bool {
|
||||
func bvisempty(bv bvec) bool {
|
||||
for i := int32(0); i < bv.n; i += WORDBITS {
|
||||
if bv.b[i>>WORDSHIFT] != 0 {
|
||||
return false
|
||||
|
|
@ -143,7 +116,7 @@ func bvisempty(bv Bvec) bool {
|
|||
return true
|
||||
}
|
||||
|
||||
func bvnot(bv Bvec) {
|
||||
func bvnot(bv bvec) {
|
||||
i := int32(0)
|
||||
w := int32(0)
|
||||
for ; i < bv.n; i, w = i+WORDBITS, w+1 {
|
||||
|
|
@ -152,41 +125,33 @@ func bvnot(bv Bvec) {
|
|||
}
|
||||
|
||||
// union
|
||||
func bvor(dst Bvec, src1 Bvec, src2 Bvec) {
|
||||
func bvor(dst bvec, src1 bvec, src2 bvec) {
|
||||
for i, x := range src1.b {
|
||||
dst.b[i] = x | src2.b[i]
|
||||
}
|
||||
}
|
||||
|
||||
// intersection
|
||||
func bvand(dst Bvec, src1 Bvec, src2 Bvec) {
|
||||
func bvand(dst bvec, src1 bvec, src2 bvec) {
|
||||
for i, x := range src1.b {
|
||||
dst.b[i] = x & src2.b[i]
|
||||
}
|
||||
}
|
||||
|
||||
func bvprint(bv Bvec) {
|
||||
func bvprint(bv bvec) {
|
||||
fmt.Printf("#*")
|
||||
for i := int32(0); i < bv.n; i++ {
|
||||
fmt.Printf("%d", bvget(bv, i))
|
||||
}
|
||||
}
|
||||
|
||||
func bvreset(bv Bvec, i int32) {
|
||||
if i < 0 || i >= bv.n {
|
||||
Fatalf("bvreset: index %d is out of bounds with length %d\n", i, bv.n)
|
||||
}
|
||||
mask := uint32(^(1 << uint(i%WORDBITS)))
|
||||
bv.b[i/WORDBITS] &= mask
|
||||
}
|
||||
|
||||
func bvresetall(bv Bvec) {
|
||||
func bvresetall(bv bvec) {
|
||||
for i := range bv.b {
|
||||
bv.b[i] = 0
|
||||
}
|
||||
}
|
||||
|
||||
func bvset(bv Bvec, i int32) {
|
||||
func bvset(bv bvec, i int32) {
|
||||
if i < 0 || i >= bv.n {
|
||||
Fatalf("bvset: index %d is out of bounds with length %d\n", i, bv.n)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -65,9 +65,9 @@ type BasicBlock struct {
|
|||
// uevar: upward exposed variables (used before set in block)
|
||||
// varkill: killed variables (set in block)
|
||||
// avarinit: addrtaken variables set or used (proof of initialization)
|
||||
uevar Bvec
|
||||
varkill Bvec
|
||||
avarinit Bvec
|
||||
uevar bvec
|
||||
varkill bvec
|
||||
avarinit bvec
|
||||
|
||||
// Computed during livenesssolve using control flow information:
|
||||
//
|
||||
|
|
@ -77,10 +77,10 @@ type BasicBlock struct {
|
|||
// (initialized in block or at exit from any predecessor block)
|
||||
// avarinitall: addrtaken variables certainly initialized at block exit
|
||||
// (initialized in block or at exit from all predecessor blocks)
|
||||
livein Bvec
|
||||
liveout Bvec
|
||||
avarinitany Bvec
|
||||
avarinitall Bvec
|
||||
livein bvec
|
||||
liveout bvec
|
||||
avarinitany bvec
|
||||
avarinitall bvec
|
||||
}
|
||||
|
||||
// A collection of global state used by liveness analysis.
|
||||
|
|
@ -92,8 +92,8 @@ type Liveness struct {
|
|||
|
||||
// An array with a bit vector for each safe point tracking live pointers
|
||||
// in the arguments and locals area, indexed by bb.rpo.
|
||||
argslivepointers []Bvec
|
||||
livepointers []Bvec
|
||||
argslivepointers []bvec
|
||||
livepointers []bvec
|
||||
}
|
||||
|
||||
// Constructs a new basic block containing a single instruction.
|
||||
|
|
@ -550,7 +550,7 @@ func isfunny(n *Node) bool {
|
|||
// The avarinit output serves as a signal that the data has been
|
||||
// initialized, because any use of a variable must come after its
|
||||
// initialization.
|
||||
func progeffects(prog *obj.Prog, vars []*Node, uevar Bvec, varkill Bvec, avarinit Bvec) {
|
||||
func progeffects(prog *obj.Prog, vars []*Node, uevar bvec, varkill bvec, avarinit bvec) {
|
||||
bvresetall(uevar)
|
||||
bvresetall(varkill)
|
||||
bvresetall(avarinit)
|
||||
|
|
@ -701,7 +701,7 @@ func newliveness(fn *Node, ptxt *obj.Prog, cfg []*BasicBlock, vars []*Node) *Liv
|
|||
return &result
|
||||
}
|
||||
|
||||
func printeffects(p *obj.Prog, uevar Bvec, varkill Bvec, avarinit Bvec) {
|
||||
func printeffects(p *obj.Prog, uevar bvec, varkill bvec, avarinit bvec) {
|
||||
fmt.Printf("effects of %v", p)
|
||||
fmt.Printf("\nuevar: ")
|
||||
bvprint(uevar)
|
||||
|
|
@ -728,7 +728,7 @@ func printnode(node *Node) {
|
|||
}
|
||||
|
||||
// Pretty print a list of variables. The vars argument is a slice of *Nodes.
|
||||
func printvars(name string, bv Bvec, vars []*Node) {
|
||||
func printvars(name string, bv bvec, vars []*Node) {
|
||||
fmt.Printf("%s:", name)
|
||||
for i, node := range vars {
|
||||
if bvget(bv, int32(i)) != 0 {
|
||||
|
|
@ -864,7 +864,7 @@ func checkptxt(fn *Node, firstp *obj.Prog) {
|
|||
// and then simply copied into bv at the correct offset on future calls with
|
||||
// the same type t. On https://rsc.googlecode.com/hg/testdata/slow.go, onebitwalktype1
|
||||
// accounts for 40% of the 6g execution time.
|
||||
func onebitwalktype1(t *Type, xoffset *int64, bv Bvec) {
|
||||
func onebitwalktype1(t *Type, xoffset *int64, bv bvec) {
|
||||
if t.Align > 0 && *xoffset&int64(t.Align-1) != 0 {
|
||||
Fatalf("onebitwalktype1: invalid initial alignment, %v", t)
|
||||
}
|
||||
|
|
@ -961,7 +961,7 @@ func argswords() int32 {
|
|||
// Generates live pointer value maps for arguments and local variables. The
|
||||
// this argument and the in arguments are always assumed live. The vars
|
||||
// argument is a slice of *Nodes.
|
||||
func onebitlivepointermap(lv *Liveness, liveout Bvec, vars []*Node, args Bvec, locals Bvec) {
|
||||
func onebitlivepointermap(lv *Liveness, liveout bvec, vars []*Node, args bvec, locals bvec) {
|
||||
var xoffset int64
|
||||
|
||||
for i := int32(0); ; i++ {
|
||||
|
|
@ -1158,7 +1158,7 @@ func livenesssolve(lv *Liveness) {
|
|||
|
||||
// This function is slow but it is only used for generating debug prints.
|
||||
// Check whether n is marked live in args/locals.
|
||||
func islive(n *Node, args Bvec, locals Bvec) bool {
|
||||
func islive(n *Node, args bvec, locals bvec) bool {
|
||||
switch n.Class {
|
||||
case PPARAM, PPARAMOUT:
|
||||
for i := 0; int64(i) < n.Type.Width/int64(Widthptr); i++ {
|
||||
|
|
@ -1435,7 +1435,7 @@ const (
|
|||
Hp = 16777619
|
||||
)
|
||||
|
||||
func hashbitmap(h uint32, bv Bvec) uint32 {
|
||||
func hashbitmap(h uint32, bv bvec) uint32 {
|
||||
n := int((bv.n + 31) / 32)
|
||||
for i := 0; i < n; i++ {
|
||||
w := bv.b[i]
|
||||
|
|
@ -1524,8 +1524,8 @@ func livenesscompact(lv *Liveness) {
|
|||
// array so that we can tell where the coalesced bitmaps stop
|
||||
// and so that we don't double-free when cleaning up.
|
||||
for j := uniq; j < n; j++ {
|
||||
lv.livepointers[j] = Bvec{}
|
||||
lv.argslivepointers[j] = Bvec{}
|
||||
lv.livepointers[j] = bvec{}
|
||||
lv.argslivepointers[j] = bvec{}
|
||||
}
|
||||
|
||||
// Rewrite PCDATA instructions to use new numbering.
|
||||
|
|
@ -1539,7 +1539,7 @@ func livenesscompact(lv *Liveness) {
|
|||
}
|
||||
}
|
||||
|
||||
func printbitset(printed bool, name string, vars []*Node, bits Bvec) bool {
|
||||
func printbitset(printed bool, name string, vars []*Node, bits bvec) bool {
|
||||
started := false
|
||||
for i, n := range vars {
|
||||
if bvget(bits, int32(i)) == 0 {
|
||||
|
|
@ -1666,7 +1666,7 @@ func livenessprintdebug(lv *Liveness) {
|
|||
// first word dumped is the total number of bitmaps. The second word is the
|
||||
// length of the bitmaps. All bitmaps are assumed to be of equal length. The
|
||||
// words that are followed are the raw bitmap words.
|
||||
func onebitwritesymbol(arr []Bvec, sym *Sym) {
|
||||
func onebitwritesymbol(arr []bvec, sym *Sym) {
|
||||
off := 4 // number of bitmaps, to fill in later
|
||||
off = duint32(sym, off, uint32(arr[0].n)) // number of bits in each bitmap
|
||||
var i int
|
||||
|
|
|
|||
Loading…
Reference in New Issue