Track register allocations

pass/alloc.go

@@ -2,8 +2,10 @@ package pass
 
 import (
 	"errors"
+	"fmt"
 	"math"
 	"sort"
+	"strings"
 
 	"github.com/mmcloughlin/avo/reg"
 )
@@ -182,7 +184,17 @@ func (a *Allocator) discardconflicting(v, p reg.ID) {
 func (a *Allocator) alloc(v reg.ID) error {
 	ps := a.possible[v]
 	if len(ps) == 0 {
-		return errors.New("failed to allocate registers")
+		var allocs []string
+		for i, v := range a.allocation {
+			if ai, ok := i.(reg.AllocInfoer); ok {
+				allocs = append(allocs, fmt.Sprintf("%02d: %s (type:%T, kind:%v%d)", v.PhysicalID(), ai.AllocInfo(), i, i.Kind(), i.Size()*8))
+			} else {
+				allocs = append(allocs, fmt.Sprintf("%02d: No alloc info. (type:%T, kind:%v%d)", v.PhysicalID(), i, i.Kind(), i.Size()*8))
+			}
+		}
+		sort.Strings(allocs)
+		err := fmt.Sprintf("failed to allocate registers. %d virtual:\n%s", len(a.allocation), strings.Join(allocs, "\n"))
+		return errors.New(err)
 	}
 	p := ps[0]
 	a.allocation[v] = p

reg/func.go

@@ -0,0 +1,28 @@
+package reg
+
+import (
+	"fmt"
+	"runtime"
+	"strings"
+)
+
+// getFnNameFile returns the first file+function in the call stack that is not avo.
+func getFnNameFile(depth int) string {
+	caller := [100]uintptr{0}
+	runtime.Callers(1+depth, caller[:])
+	frames := runtime.CallersFrames(caller[:])
+	for {
+		f, more := frames.Next()
+		file := f.File
+		line := f.Line
+		fnName := f.Func.Name()
+
+		if !strings.Contains(file, "github.com/mmcloughlin/avo") {
+			return fmt.Sprintf("%s:%d %s()", file, line, fnName)
+		}
+		if !more {
+			break
+		}
+	}
+	return ""
+}

reg/types.go

@@ -106,36 +106,54 @@
 type virtual struct {
 	idx  Index
 	kind Kind
-	Spec
+	Width
+	mask    uint16
+	allocAt string
 }
 
 // NewVirtual builds a Virtual register.
 func NewVirtual(idx Index, k Kind, s Spec) Virtual {
 	return virtual{
-		idx:  idx,
-		kind: k,
-		Spec: s,
+		allocAt: getFnNameFile(1),
+		idx:     idx,
+		kind:    k,
+		Spec:    s,
 	}
 }
 
 func (v virtual) ID() ID              { return newid(1, v.kind, v.idx) }
 func (v virtual) VirtualIndex() Index { return v.idx }
 func (v virtual) Kind() Kind          { return v.kind }
 
+// AllocInfoer allows to track where resources were allocated.
+type AllocInfoer interface {
+	AllocInfo() string
+}
+
+// AllocInfo returns allocation info.
+func (v virtual) AllocInfo() string {
+	return v.allocAt
+}
+
+func (v virtual) VirtualID() VID { return v.id }
+func (v virtual) Kind() Kind     { return v.kind }
+
 func (v virtual) Asm() string {
 	// TODO(mbm): decide on virtual register syntax
 	return fmt.Sprintf("<virtual:%v:%v:%v>", v.idx, v.Kind(), v.Size())
 }
 
 func (v virtual) as(s Spec) Register {
 	return virtual{
 		idx:  v.idx,
 		kind: v.kind,
 		Spec: s,
+		// Non-breaking space for sorting.
+		allocAt: fmt.Sprintf("\u00A0- As%v() %s", s.String(), getFnNameFile(2)),
 	}
 }
 
 func (v virtual) spec() Spec { return v.Spec }
 func (v virtual) register()  {}
 
 // Info is a bitmask of register properties.
@@ -248,6 +266,21 @@
 	return LookupPhysical(id.Kind(), id.Index(), s)
 }
 
+// Size returns the register width in bytes.
+func (s Spec) String() string {
+	switch s {
+	case S8H:
+		return "8H"
+	default:
+		return fmt.Sprint(s.Size() * 8)
+	}
+}
+
+// AreConflicting returns whether registers conflict with each other.
+func AreConflicting(x, y Physical) bool {
+	return x.Kind() == y.Kind() && x.PhysicalID() == y.PhysicalID() && (x.Mask()&y.Mask()) != 0
+}
+
 // Allocation records a register allocation.
 type Allocation map[ID]ID
 

reg/x86.go

@@ -23,6 +23,20 @@ var (
 	}
 )
 
+// String returns a human readable representation of the Kind.
+func (k Kind) String() string {
+	switch k {
+	case KindPseudo:
+		return "pseudo"
+	case KindGP:
+		return "gpr"
+	case KindVector:
+		return "vector"
+	default:
+		return "invalid"
+	}
+}
+
 var familiesByKind = map[Kind]*Family{}
 
 func init() {
@@ -81,9 +95,30 @@ type GPVirtual interface {
 
 type gpv struct {
 	Virtual
+	GP
+	allocAt string
 }
 
-func newgpv(v Virtual) GPVirtual { return gpv{Virtual: v} }
+func newgpv(v Virtual) GPVirtual {
+	g := gpv{
+		Virtual: v,
+		//GP:      gpcasts{v},
+		allocAt: getFnNameFile(1),
+	}
+	if ai, ok := v.(AllocInfoer); ok {
+		parent := ai.AllocInfo()
+		if g.allocAt != parent {
+			// Only add ourself if different from parent.
+			g.allocAt = parent + " -> " + g.allocAt
+		}
+	}
+	return g
+}
+
+// AllocInfo returns allocation info.
+func (g gpv) AllocInfo() string {
+	return g.allocAt
+}
 
 func (v gpv) As8() Register  { return newgpv(v.as(S8).(Virtual)) }
 func (v gpv) As8L() Register { return newgpv(v.as(S8L).(Virtual)) }