124 lines
2.7 KiB
Go
124 lines
2.7 KiB
Go
package pass
|
|
|
|
import (
|
|
"github.com/mmcloughlin/avo/ir"
|
|
"github.com/mmcloughlin/avo/operand"
|
|
)
|
|
|
|
// PruneJumpToFollowingLabel removes jump instructions that target an
|
|
// immediately following label.
|
|
func PruneJumpToFollowingLabel(fn *ir.Function) error {
|
|
for i := 0; i+1 < len(fn.Nodes); i++ {
|
|
node := fn.Nodes[i]
|
|
next := fn.Nodes[i+1]
|
|
|
|
// This node is an unconditional jump.
|
|
inst, ok := node.(*ir.Instruction)
|
|
if !ok || !inst.IsBranch || inst.IsConditional {
|
|
continue
|
|
}
|
|
|
|
target := inst.TargetLabel()
|
|
if target == nil {
|
|
continue
|
|
}
|
|
|
|
// And the jump target is the immediately following node.
|
|
lbl, ok := next.(ir.Label)
|
|
if !ok || lbl != *target {
|
|
continue
|
|
}
|
|
|
|
// Then the jump is unnecessary and can be removed.
|
|
fn.Nodes = deletenode(fn.Nodes, i)
|
|
i--
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// PruneDanglingLabels removes labels that are not referenced by any branches.
|
|
func PruneDanglingLabels(fn *ir.Function) error {
|
|
// Count label references.
|
|
count := map[ir.Label]int{}
|
|
for _, n := range fn.Nodes {
|
|
i, ok := n.(*ir.Instruction)
|
|
if !ok || !i.IsBranch {
|
|
continue
|
|
}
|
|
|
|
target := i.TargetLabel()
|
|
if target == nil {
|
|
continue
|
|
}
|
|
|
|
count[*target]++
|
|
}
|
|
|
|
// Look for labels with no references.
|
|
for i := 0; i < len(fn.Nodes); i++ {
|
|
node := fn.Nodes[i]
|
|
lbl, ok := node.(ir.Label)
|
|
if !ok {
|
|
continue
|
|
}
|
|
|
|
if count[lbl] == 0 {
|
|
fn.Nodes = deletenode(fn.Nodes, i)
|
|
i--
|
|
}
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// PruneSelfMoves removes move instructions from one register to itself.
|
|
func PruneSelfMoves(fn *ir.Function) error {
|
|
return removeinstructions(fn, func(i *ir.Instruction) bool {
|
|
switch i.Opcode {
|
|
case "MOVB", "MOVW", "MOVL", "MOVQ":
|
|
default:
|
|
return false
|
|
}
|
|
|
|
return operand.IsRegister(i.Operands[0]) && operand.IsRegister(i.Operands[1]) && i.Operands[0] == i.Operands[1]
|
|
})
|
|
}
|
|
|
|
// removeinstructions deletes instructions from the given function which match predicate.
|
|
func removeinstructions(fn *ir.Function, predicate func(*ir.Instruction) bool) error {
|
|
// Removal of instructions has the potential to invalidate CFG structures.
|
|
// Clear them to prevent accidental use of stale structures after this pass.
|
|
invalidatecfg(fn)
|
|
|
|
for i := 0; i < len(fn.Nodes); i++ {
|
|
n := fn.Nodes[i]
|
|
|
|
inst, ok := n.(*ir.Instruction)
|
|
if !ok || !predicate(inst) {
|
|
continue
|
|
}
|
|
|
|
fn.Nodes = deletenode(fn.Nodes, i)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// deletenode deletes node i from nodes and returns the resulting slice.
|
|
func deletenode(nodes []ir.Node, i int) []ir.Node {
|
|
n := len(nodes)
|
|
copy(nodes[i:], nodes[i+1:])
|
|
nodes[n-1] = nil
|
|
return nodes[:n-1]
|
|
}
|
|
|
|
// invalidatecfg clears CFG structures.
|
|
func invalidatecfg(fn *ir.Function) {
|
|
fn.LabelTarget = nil
|
|
for _, i := range fn.Instructions() {
|
|
i.Pred = nil
|
|
i.Succ = nil
|
|
}
|
|
}
|