}
func (bv BitVec) Clear() {
- for i := range bv.B {
- bv.B[i] = 0
- }
+ clear(bv.B)
}
{
cache := f.Cache.Liveness.(*livenessFuncCache)
if cap(lv.be) < 2000 { // Threshold from ssa.Cache slices.
- for i := range lv.be {
- lv.be[i] = blockEffects{}
- }
+ clear(lv.be)
cache.be = lv.be
}
if len(lv.livenessMap.Vals) < 2000 {
func (pp *Progs) Free() {
if base.Ctxt.CanReuseProgs() {
// Clear progs to enable GC and avoid abuse.
- s := pp.Cache[:pp.CacheIndex]
- for i := range s {
- s[i] = obj.Prog{}
- }
+ clear(pp.Cache[:pp.CacheIndex])
}
// Clear pp to avoid abuse.
*pp = Progs{}
// 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 {
- ptrmask[i] = 0
- }
+ clear(ptrmask)
if !t.HasPointers() {
return
}
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,
},
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,
},
return s
}
func (c *Cache) freeValueSlice(s []*Value) {
- for i := range s {
- s[i] = nil
- }
+ clear(s)
b := bits.Len(uint(cap(s)) - 1)
var sp *[]*Value
if len(c.hdrValueSlice) == 0 {
return s
}
func (c *Cache) freeLimitSlice(s []limit) {
- for i := range s {
- s[i] = limit{}
- }
+ clear(s)
b := bits.Len(uint(cap(s)) - 1)
var sp *[]limit
if len(c.hdrLimitSlice) == 0 {
// 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:]
- for j := range tail {
- tail[j] = nil
- }
+ clear(b.Values[i:])
b.Values = b.Values[:i]
}
func (c *Cache) Reset() {
nv := sort.Search(len(c.values), func(i int) bool { return c.values[i].ID == 0 })
- xv := c.values[:nv]
- for i := range xv {
- xv[i] = Value{}
- }
+ clear(c.values[:nv])
nb := sort.Search(len(c.blocks), func(i int) bool { return c.blocks[i].ID == 0 })
- xb := c.blocks[:nb]
- for i := range xb {
- xb[i] = Block{}
- }
+ clear(c.blocks[:nb])
nl := sort.Search(len(c.locs), func(i int) bool { return c.locs[i] == nil })
- xl := c.locs[:nl]
- for i := range xl {
- xl[i] = nil
- }
+ clear(c.locs[:nl])
// regalloc sets the length of c.regallocValues to whatever it may use,
// so clear according to length.
- for i := range c.regallocValues {
- c.regallocValues[i] = valState{}
- }
+ clear(c.regallocValues)
}
f.NamedValues[*name] = values[:j]
}
}
- clearNames := f.Names[i:]
- for j := range clearNames {
- clearNames[j] = nil
- }
+ clear(f.Names[i:])
f.Names = f.Names[:i]
pendingLines := f.cachedLineStarts // Holds statement boundaries that need to be moved to a new value/block
}
}
// zero remainder to help GC
- tail := f.Blocks[i:]
- for j := range tail {
- tail[j] = nil
- }
+ clear(f.Blocks[i:])
f.Blocks = f.Blocks[:i]
}
// 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 {
- slots[i] = VarLoc{}
- }
+ clear(slots)
for i := range registers {
registers[i] = registers[i][:0]
}
if cap(state.blockDebug) < f.NumBlocks() {
state.blockDebug = make([]BlockDebug, f.NumBlocks())
} else {
- // This local variable, and the ones like it below, enable compiler
- // optimizations. Don't inline them.
- b := state.blockDebug[:f.NumBlocks()]
- for i := range b {
- b[i] = BlockDebug{}
- }
+ clear(state.blockDebug[:f.NumBlocks()])
}
// A list of slots per Value. Reuse the previous child slices.
if cap(state.pendingSlotLocs) < numPieces {
state.pendingSlotLocs = make([]VarLoc, numPieces)
} else {
- psl := state.pendingSlotLocs[:numPieces]
- for i := range psl {
- psl[i] = VarLoc{}
- }
+ clear(state.pendingSlotLocs[:numPieces])
}
if cap(state.pendingEntries) < numVars {
state.pendingEntries = make([]pendingEntry, numVars)
state.lists = make([][]byte, numVars)
} else {
state.lists = state.lists[:numVars]
- for i := range state.lists {
- state.lists[i] = nil
- }
+ clear(state.lists)
}
}
e.present = false
e.startBlock = 0
e.startValue = 0
- for i := range e.pieces {
- e.pieces[i] = VarLoc{}
- }
+ clear(e.pieces)
}
// canMerge reports whether a new location description is a superset
}
func (bs bitset) Reset() {
- for i := range bs {
- bs[i] = 0
- }
+ clear(bs)
}
func (bs bitset) Set(idx uint32) {
dinfo = make([]dentry, l)
} else {
dinfo = dinfo[:l]
- for i := range dinfo {
- dinfo[i] = dentry{}
- }
+ clear(dinfo)
}
// Load static desired register info at the end of the block.
}
func putStackAllocState(s *stackAllocState) {
- for i := range s.values {
- s.values[i] = stackValState{}
- }
- for i := range s.interfere {
- s.interfere[i] = nil
- }
- for i := range s.names {
- s.names[i] = LocalSlot{}
- }
+ clear(s.values)
+ clear(s.interfere)
+ clear(s.names)
s.f.Cache.stackAllocState = s
s.f = nil
s.live = nil
changed = false
// Reset target
- for i := range target {
- target[i] = nil
- }
+ clear(target)
// Compute target locations (for moveable values only).
// target location = the least common ancestor of all uses in the dominator tree.
}
if n < len(f.Blocks) {
f.invalidateCFG()
- tail := f.Blocks[n:]
- for i := range tail {
- tail[i] = nil
- }
+ clear(f.Blocks[n:])
f.Blocks = f.Blocks[:n]
}
}
f.Cache.ValueToProgAfter = make([]*obj.Prog, f.NumValues())
}
valueToProgAfter = f.Cache.ValueToProgAfter[:f.NumValues()]
- for i := range valueToProgAfter {
- valueToProgAfter[i] = nil
- }
+ clear(valueToProgAfter)
}
// If the very first instruction is not tagged as a statement,