canMove := f.Cache.allocBoolSlice(f.NumValues())
defer f.Cache.freeBoolSlice(canMove)
+
+ // Compute the memory states of each block.
+ startMem := f.Cache.allocValueSlice(f.NumBlocks())
+ defer f.Cache.freeValueSlice(startMem)
+ endMem := f.Cache.allocValueSlice(f.NumBlocks())
+ defer f.Cache.freeValueSlice(endMem)
+ memState(f, startMem, endMem)
+
for _, b := range f.Blocks {
for _, v := range b.Values {
if v.Op.isLoweredGetClosurePtr() {
// SelectN is typically, ultimately, a register.
continue
}
- if v.MemoryArg() != nil {
- // We can't move values which have a memory arg - it might
- // make two memory values live across a block boundary.
- continue
- }
// Count arguments which will need a register.
narg := 0
for _, a := range v.Args {
- if !a.rematerializeable() {
+ // SP and SB are special registers and have no effect on
+ // the allocation of general-purpose registers.
+ if a.needRegister() && a.Op != OpSB && a.Op != OpSP {
narg++
}
}
// v is not moveable, or is already in correct place.
continue
}
+ if mem := v.MemoryArg(); mem != nil {
+ if startMem[t.ID] != mem {
+ // We can't move a value with a memory arg unless the target block
+ // has that memory arg as its starting memory.
+ continue
+ }
+ }
+ if f.pass.debug > 0 {
+ b.Func.Warnl(v.Pos, "%v is moved", v.Op)
+ }
// Move v to the block which dominates its uses.
t.Values = append(t.Values, v)
v.Block = t
}
}
}
+
+// memState computes the memory state at the beginning and end of each block of
+// the function. The memory state is represented by a value of mem type.
+// The returned result is stored in startMem and endMem, and endMem is nil for
+// blocks with no successors (Exit,Ret,RetJmp blocks). This algorithm is not
+// suitable for infinite loop blocks that do not contain any mem operations.
+// For example:
+// b1:
+//
+// (some values)
+//
+// plain -> b2
+// b2: <- b1 b2
+// Plain -> b2
+//
+// Algorithm introduction:
+// 1. The start memory state of a block is InitMem, a Phi node of type mem or
+// an incoming memory value.
+// 2. The start memory state of a block is consistent with the end memory state
+// of its parent nodes. If the start memory state of a block is a Phi value,
+// then the end memory state of its parent nodes is consistent with the
+// corresponding argument value of the Phi node.
+// 3. The algorithm first obtains the memory state of some blocks in the tree
+// in the first step. Then floods the known memory state to other nodes in
+// the second step.
+func memState(f *Func, startMem, endMem []*Value) {
+ // This slice contains the set of blocks that have had their startMem set but this
+ // startMem value has not yet been propagated to the endMem of its predecessors
+ changed := make([]*Block, 0)
+ // First step, init the memory state of some blocks.
+ for _, b := range f.Blocks {
+ for _, v := range b.Values {
+ var mem *Value
+ if v.Op == OpPhi {
+ if v.Type.IsMemory() {
+ mem = v
+ }
+ } else if v.Op == OpInitMem {
+ mem = v // This is actually not needed.
+ } else if a := v.MemoryArg(); a != nil && a.Block != b {
+ // The only incoming memory value doesn't belong to this block.
+ mem = a
+ }
+ if mem != nil {
+ if old := startMem[b.ID]; old != nil {
+ if old == mem {
+ continue
+ }
+ f.Fatalf("func %s, startMem[%v] has different values, old %v, new %v", f.Name, b, old, mem)
+ }
+ startMem[b.ID] = mem
+ changed = append(changed, b)
+ }
+ }
+ }
+
+ // Second step, floods the known memory state of some blocks to others.
+ for len(changed) != 0 {
+ top := changed[0]
+ changed = changed[1:]
+ mem := startMem[top.ID]
+ for i, p := range top.Preds {
+ pb := p.b
+ if endMem[pb.ID] != nil {
+ continue
+ }
+ if mem.Op == OpPhi && mem.Block == top {
+ endMem[pb.ID] = mem.Args[i]
+ } else {
+ endMem[pb.ID] = mem
+ }
+ if startMem[pb.ID] == nil {
+ startMem[pb.ID] = endMem[pb.ID]
+ changed = append(changed, pb)
+ }
+ }
+ }
+}