cmd/compile: use the builtin clear

To simplify the code a bit.

Change-Id: Ia72f576de59ff161ec389a4992bb635f89783540
GitHub-Last-Rev: eaec8216be964418a085649fcca53a042f28ce1a
GitHub-Pull-Request: golang/go#73411
Reviewed-on: https://go-review.googlesource.com/c/go/+/666117
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Auto-Submit: Keith Randall <khr@golang.org>
Reviewed-by: Michael Pratt <mpratt@google.com>
Reviewed-by: Keith Randall <khr@google.com>
Reviewed-by: Keith Randall <khr@golang.org>

src/cmd/compile/internal/bitvec/bv.go

@@ -196,7 +196,5 @@ func (bv BitVec) String() string {
 }
 
 func (bv BitVec) Clear() {
-	for i := range bv.B {
+	clear(bv.B)
-		bv.B[i] = 0
-	}
 }

src/cmd/compile/internal/liveness/plive.go

@@ -1414,9 +1414,7 @@ func Compute(curfn *ir.Func, f *ssa.Func, stkptrsize int64, pp *objw.Progs, retL
 	{
 		cache := f.Cache.Liveness.(*livenessFuncCache)
 		if cap(lv.be) < 2000 { // Threshold from ssa.Cache slices.
-			for i := range lv.be {
+			clear(lv.be)
-				lv.be[i] = blockEffects{}
-			}
 			cache.be = lv.be
 		}
 		if len(lv.livenessMap.Vals) < 2000 {

src/cmd/compile/internal/objw/prog.go

@@ -116,10 +116,7 @@ func (pp *Progs) Flush() {
 func (pp *Progs) Free() {
 	if base.Ctxt.CanReuseProgs() {
 		// Clear progs to enable GC and avoid abuse.
-		s := pp.Cache[:pp.CacheIndex]
+		clear(pp.Cache[:pp.CacheIndex])
-		for i := range s {
-			s[i] = obj.Prog{}
-		}
 	}
 	// Clear pp to avoid abuse.
 	*pp = Progs{}

src/cmd/compile/internal/reflectdata/reflect.go

@@ -1284,9 +1284,7 @@ func dgcptrmask(t *types.Type, write bool) *obj.LSym {
 // word offsets in t that hold pointers.
 // ptrmask is assumed to fit at least types.PtrDataSize(t)/PtrSize bits.
 func fillptrmask(t *types.Type, ptrmask []byte) {
-	for i := range ptrmask {
+	clear(ptrmask)
-		ptrmask[i] = 0
-	}
 	if !t.HasPointers() {
 		return
 	}

src/cmd/compile/internal/ssa/_gen/allocators.go

@@ -41,7 +41,7 @@ func genAllocators() {
 			capacity: "cap(%s)",
 			mak:      "make([]*Value, %s)",
 			resize:   "%s[:%s]",
-			clear:    "for i := range %[1]s {\n%[1]s[i] = nil\n}",
+			clear:    "clear(%s)",
 			minLog:   5,
 			maxLog:   32,
 		},
@@ -51,7 +51,7 @@ func genAllocators() {
 			capacity: "cap(%s)",
 			mak:      "make([]limit, %s)",
 			resize:   "%s[:%s]",
-			clear:    "for i := range %[1]s {\n%[1]s[i] = limit{}\n}",
+			clear:    "clear(%s)",
 			minLog:   3,
 			maxLog:   30,
 		},

src/cmd/compile/internal/ssa/allocators.go

@@ -31,9 +31,7 @@ func (c *Cache) allocValueSlice(n int) []*Value {
 	return s
 }
 func (c *Cache) freeValueSlice(s []*Value) {
-	for i := range s {
+	clear(s)
-		s[i] = nil
-	}
 	b := bits.Len(uint(cap(s)) - 1)
 	var sp *[]*Value
 	if len(c.hdrValueSlice) == 0 {
@@ -69,9 +67,7 @@ func (c *Cache) allocLimitSlice(n int) []limit {
 	return s
 }
 func (c *Cache) freeLimitSlice(s []limit) {
-	for i := range s {
+	clear(s)
-		s[i] = limit{}
-	}
 	b := bits.Len(uint(cap(s)) - 1)
 	var sp *[]limit
 	if len(c.hdrLimitSlice) == 0 {

src/cmd/compile/internal/ssa/block.go

@@ -264,10 +264,7 @@ func (b *Block) resetWithControl2(kind BlockKind, v, w *Value) {
 // The values in b.Values after i must already have had their args reset,
 // to maintain correct value uses counts.
 func (b *Block) truncateValues(i int) {
-	tail := b.Values[i:]
+	clear(b.Values[i:])
-	for j := range tail {
-		tail[j] = nil
-	}
 	b.Values = b.Values[:i]
 }
 

src/cmd/compile/internal/ssa/cache.go

@@ -39,24 +39,13 @@ type Cache struct {
 
 func (c *Cache) Reset() {
 	nv := sort.Search(len(c.values), func(i int) bool { return c.values[i].ID == 0 })
-	xv := c.values[:nv]
+	clear(c.values[:nv])
-	for i := range xv {
-		xv[i] = Value{}
-	}
 	nb := sort.Search(len(c.blocks), func(i int) bool { return c.blocks[i].ID == 0 })
-	xb := c.blocks[:nb]
+	clear(c.blocks[:nb])
-	for i := range xb {
-		xb[i] = Block{}
-	}
 	nl := sort.Search(len(c.locs), func(i int) bool { return c.locs[i] == nil })
-	xl := c.locs[:nl]
+	clear(c.locs[:nl])
-	for i := range xl {
-		xl[i] = nil
-	}
 
 	// regalloc sets the length of c.regallocValues to whatever it may use,
 	// so clear according to length.
-	for i := range c.regallocValues {
+	clear(c.regallocValues)
-		c.regallocValues[i] = valState{}
-	}
 }

src/cmd/compile/internal/ssa/deadcode.go

@@ -232,10 +232,7 @@ func deadcode(f *Func) {
 			f.NamedValues[*name] = values[:j]
 		}
 	}
-	clearNames := f.Names[i:]
+	clear(f.Names[i:])
-	for j := range clearNames {
-		clearNames[j] = nil
-	}
 	f.Names = f.Names[:i]
 
 	pendingLines := f.cachedLineStarts // Holds statement boundaries that need to be moved to a new value/block
@@ -303,10 +300,7 @@ func deadcode(f *Func) {
 		}
 	}
 	// zero remainder to help GC
-	tail := f.Blocks[i:]
+	clear(f.Blocks[i:])
-	for j := range tail {
-		tail[j] = nil
-	}
 	f.Blocks = f.Blocks[:i]
 }
 

src/cmd/compile/internal/ssa/debug.go

@@ -102,9 +102,7 @@ type stateAtPC struct {
 // reset fills state with the live variables from live.
 func (state *stateAtPC) reset(live abt.T) {
 	slots, registers := state.slots, state.registers
-	for i := range slots {
+	clear(slots)
-		slots[i] = VarLoc{}
-	}
 	for i := range registers {
 		registers[i] = registers[i][:0]
 	}
@@ -242,12 +240,7 @@ func (state *debugState) initializeCache(f *Func, numVars, numSlots int) {
 	if cap(state.blockDebug) < f.NumBlocks() {
 		state.blockDebug = make([]BlockDebug, f.NumBlocks())
 	} else {
-		// This local variable, and the ones like it below, enable compiler
+		clear(state.blockDebug[:f.NumBlocks()])
-		// optimizations. Don't inline them.
-		b := state.blockDebug[:f.NumBlocks()]
-		for i := range b {
-			b[i] = BlockDebug{}
-		}
 	}
 
 	// A list of slots per Value. Reuse the previous child slices.
@@ -285,10 +278,7 @@ func (state *debugState) initializeCache(f *Func, numVars, numSlots int) {
 	if cap(state.pendingSlotLocs) < numPieces {
 		state.pendingSlotLocs = make([]VarLoc, numPieces)
 	} else {
-		psl := state.pendingSlotLocs[:numPieces]
+		clear(state.pendingSlotLocs[:numPieces])
-		for i := range psl {
-			psl[i] = VarLoc{}
-		}
 	}
 	if cap(state.pendingEntries) < numVars {
 		state.pendingEntries = make([]pendingEntry, numVars)
@@ -307,9 +297,7 @@ func (state *debugState) initializeCache(f *Func, numVars, numSlots int) {
 		state.lists = make([][]byte, numVars)
 	} else {
 		state.lists = state.lists[:numVars]
-		for i := range state.lists {
+		clear(state.lists)
-			state.lists[i] = nil
-		}
 	}
 }
 
@@ -1191,9 +1179,7 @@ func (e *pendingEntry) clear() {
 	e.present = false
 	e.startBlock = 0
 	e.startValue = 0
-	for i := range e.pieces {
+	clear(e.pieces)
-		e.pieces[i] = VarLoc{}
-	}
 }
 
 // canMerge reports whether a new location description is a superset

src/cmd/compile/internal/ssa/poset.go

@@ -23,9 +23,7 @@ func newBitset(n int) bitset {
 }
 
 func (bs bitset) Reset() {
-	for i := range bs {
+	clear(bs)
-		bs[i] = 0
-	}
 }
 
 func (bs bitset) Set(idx uint32) {

src/cmd/compile/internal/ssa/regalloc.go

@@ -1301,9 +1301,7 @@ func (s *regAllocState) regalloc(f *Func) {
 			dinfo = make([]dentry, l)
 		} else {
 			dinfo = dinfo[:l]
-			for i := range dinfo {
+			clear(dinfo)
-				dinfo[i] = dentry{}
-			}
 		}
 
 		// Load static desired register info at the end of the block.

src/cmd/compile/internal/ssa/stackalloc.go

@@ -46,15 +46,9 @@ func newStackAllocState(f *Func) *stackAllocState {
 }
 
 func putStackAllocState(s *stackAllocState) {
-	for i := range s.values {
+	clear(s.values)
-		s.values[i] = stackValState{}
+	clear(s.interfere)
-	}
+	clear(s.names)
-	for i := range s.interfere {
-		s.interfere[i] = nil
-	}
-	for i := range s.names {
-		s.names[i] = LocalSlot{}
-	}
 	s.f.Cache.stackAllocState = s
 	s.f = nil
 	s.live = nil

src/cmd/compile/internal/ssa/tighten.go

@@ -85,9 +85,7 @@ func tighten(f *Func) {
 		changed = false
 
 		// Reset target
-		for i := range target {
+		clear(target)
-			target[i] = nil
-		}
 
 		// Compute target locations (for moveable values only).
 		// target location = the least common ancestor of all uses in the dominator tree.

src/cmd/compile/internal/ssa/trim.go

@@ -109,10 +109,7 @@ func trim(f *Func) {
 	}
 	if n < len(f.Blocks) {
 		f.invalidateCFG()
-		tail := f.Blocks[n:]
+		clear(f.Blocks[n:])
-		for i := range tail {
-			tail[i] = nil
-		}
 		f.Blocks = f.Blocks[:n]
 	}
 }

src/cmd/compile/internal/ssagen/ssa.go

@@ -6512,9 +6512,7 @@ func genssa(f *ssa.Func, pp *objw.Progs) {
 			f.Cache.ValueToProgAfter = make([]*obj.Prog, f.NumValues())
 		}
 		valueToProgAfter = f.Cache.ValueToProgAfter[:f.NumValues()]
-		for i := range valueToProgAfter {
+		clear(valueToProgAfter)
-			valueToProgAfter[i] = nil
-		}
 	}
 
 	// If the very first instruction is not tagged as a statement,