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 {
- // 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 {
+ if !a.rematerializeable() {
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)
- }
- }
- }
-}