138eaf8dc3
It was pointed out #73 that Bytes() is a poor name for the size of the register in bytes. In idiomatic Go you would probably expect a Bytes() method to return []byte. This diff changes the Bytes() to Size(). As a result the Size type also needed to be renamed, and Width seemed a reasonable choice. Fixes #73
138 lines
2.9 KiB
Go
138 lines
2.9 KiB
Go
package reg
|
|
|
|
import "testing"
|
|
|
|
func TestSpecSize(t *testing.T) {
|
|
cases := []struct {
|
|
Spec Spec
|
|
Size uint
|
|
}{
|
|
{S0, 0},
|
|
{S8L, 1},
|
|
{S8H, 1},
|
|
{S16, 2},
|
|
{S32, 4},
|
|
{S64, 8},
|
|
{S128, 16},
|
|
{S256, 32},
|
|
{S512, 64},
|
|
}
|
|
for _, c := range cases {
|
|
if c.Spec.Size() != c.Size {
|
|
t.Errorf("%v.Size() = %d; expect = %d", c.Spec, c.Spec.Size(), c.Size)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestToVirtual(t *testing.T) {
|
|
v := GeneralPurpose.Virtual(42, B32)
|
|
if ToVirtual(v) != v {
|
|
t.Errorf("ToVirtual(v) != v for virtual register")
|
|
}
|
|
if ToVirtual(ECX) != nil {
|
|
t.Errorf("ToVirtual should be nil for physical registers")
|
|
}
|
|
}
|
|
|
|
func TestToPhysical(t *testing.T) {
|
|
v := GeneralPurpose.Virtual(42, B32)
|
|
if ToPhysical(v) != nil {
|
|
t.Errorf("ToPhysical should be nil for virtual registers")
|
|
}
|
|
if ToPhysical(ECX) != ECX {
|
|
t.Errorf("ToPhysical(p) != p for physical register")
|
|
}
|
|
}
|
|
|
|
func TestAreConflicting(t *testing.T) {
|
|
cases := []struct {
|
|
X, Y Physical
|
|
Expect bool
|
|
}{
|
|
{ECX, X3, false},
|
|
{AL, AH, false},
|
|
{AL, AX, true},
|
|
{AL, BX, false},
|
|
{X3, Y4, false},
|
|
{X3, Y3, true},
|
|
{Y3, Z4, false},
|
|
{Y3, Z3, true},
|
|
}
|
|
for _, c := range cases {
|
|
if AreConflicting(c.X, c.Y) != c.Expect {
|
|
t.Errorf("AreConflicting(%s, %s) != %v", c.X, c.Y, c.Expect)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestFamilyLookup(t *testing.T) {
|
|
cases := []struct {
|
|
Family *Family
|
|
ID PID
|
|
Spec Spec
|
|
Expect Physical
|
|
}{
|
|
{GeneralPurpose, 0, S8, AL},
|
|
{GeneralPurpose, 1, S8L, CL},
|
|
{GeneralPurpose, 2, S8H, DH},
|
|
{GeneralPurpose, 3, S16, BX},
|
|
{GeneralPurpose, 9, S32, R9L},
|
|
{GeneralPurpose, 13, S64, R13},
|
|
{GeneralPurpose, 13, S512, nil},
|
|
{GeneralPurpose, 133, S64, nil},
|
|
{Vector, 1, S128, X1},
|
|
{Vector, 13, S256, Y13},
|
|
{Vector, 27, S512, Z27},
|
|
{Vector, 1, S16, nil},
|
|
{Vector, 299, S256, nil},
|
|
}
|
|
for _, c := range cases {
|
|
got := c.Family.Lookup(c.ID, c.Spec)
|
|
if got != c.Expect {
|
|
t.Errorf("pid=%v spec=%v: lookup got %v expect %v", c.ID, c.Spec, got, c.Expect)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestPhysicalAs(t *testing.T) {
|
|
cases := []struct {
|
|
Register Physical
|
|
Spec Spec
|
|
Expect Physical
|
|
}{
|
|
{DX, S8L, DL},
|
|
{DX, S8H, DH},
|
|
{DX, S8, DL},
|
|
{DX, S16, DX},
|
|
{DX, S32, EDX},
|
|
{DX, S64, RDX},
|
|
{DX, S256, nil},
|
|
}
|
|
for _, c := range cases {
|
|
got := c.Register.as(c.Spec)
|
|
if got != c.Expect {
|
|
t.Errorf("%s.as(%v) = %v; expect %v", c.Register.Asm(), c.Spec, got, c.Expect)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestVirtualAs(t *testing.T) {
|
|
cases := []struct {
|
|
Virtual Register
|
|
Physical Physical
|
|
Match bool
|
|
}{
|
|
{GeneralPurpose.Virtual(0, B8), CL, true},
|
|
{GeneralPurpose.Virtual(0, B8), CH, true},
|
|
{GeneralPurpose.Virtual(0, B32).as(S8L), CL, true},
|
|
{GeneralPurpose.Virtual(0, B32).as(S8L), CH, false},
|
|
{GeneralPurpose.Virtual(0, B16).as(S32), R9L, true},
|
|
{GeneralPurpose.Virtual(0, B16).as(S32), R9, false},
|
|
}
|
|
for _, c := range cases {
|
|
if c.Virtual.(Virtual).SatisfiedBy(c.Physical) != c.Match {
|
|
t.Errorf("%s.SatisfiedBy(%v) != %v", c.Virtual.Asm(), c.Physical, c.Match)
|
|
}
|
|
}
|
|
}
|