Repository: mmcloughlin/avo
Pull request #74 (2019-03-31 21:06:15)

reg: rename Bytes() to Size()
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.

codecov-io: # [Codecov](https://codecov.io/gh/mmcloughlin/avo/pull/74?src=pr&el=h1) Report
> Merging [#74](https://codecov.io/gh/mmcloughlin/avo/pull/74?src=pr&el=desc) into [master](https://codecov.io/gh/mmcloughlin/avo/commit/7a0eb66183daac7566e9a52ee83c2c9359577f6a?src=pr&el=desc) will **not change** coverage.
> The diff coverage is `95.23%`.

[![Impacted file tree graph](https://codecov.io/gh/mmcloughlin/avo/pull/74/graphs/tree.svg?width=650&token=DaOLKxzdQS&height=150&src=pr)](https://codecov.io/gh/mmcloughlin/avo/pull/74?src=pr&el=tree)

```diff
@@           Coverage Diff           @@
##           master      #74   +/-   ##
=======================================
  Coverage   76.01%   76.01%           
=======================================
  Files          51       51           
  Lines       31136    31136           
=======================================
  Hits        23669    23669           
  Misses       7367     7367           
  Partials      100      100
```

| Flag | Coverage Δ | |
|---|---|---|
| #integration | `6.08% <85.71%> (ø)` | :arrow_up: |
| #unittests | `74.15% <66.66%> (ø)` | :arrow_up: |

| [Impacted Files](https://codecov.io/gh/mmcloughlin/avo/pull/74?src=pr&el=tree) | Coverage Δ | |
|---|---|---|
| [operand/checks.go](https://codecov.io/gh/mmcloughlin/avo/pull/74/diff?src=pr&el=tree#diff-b3BlcmFuZC9jaGVja3MuZ28=) | `97.97% <100%> (ø)` | :arrow_up: |
| [build/pseudo.go](https://codecov.io/gh/mmcloughlin/avo/pull/74/diff?src=pr&el=tree#diff-YnVpbGQvcHNldWRvLmdv) | `80% <100%> (ø)` | :arrow_up: |
| [reg/collection.go](https://codecov.io/gh/mmcloughlin/avo/pull/74/diff?src=pr&el=tree#diff-cmVnL2NvbGxlY3Rpb24uZ28=) | `93.75% <100%> (ø)` | :arrow_up: |
| [reg/types.go](https://codecov.io/gh/mmcloughlin/avo/pull/74/diff?src=pr&el=tree#diff-cmVnL3R5cGVzLmdv) | `90.58% <92.85%> (ø)` | :arrow_up: |

------

[Continue to review full report at Codecov](https://codecov.io/gh/mmcloughlin/avo/pull/74?src=pr&el=continue).
> **Legend** - [Click here to learn more](https://docs.codecov.io/docs/codecov-delta)
> `Δ = absolute <relative> (impact)`, `ø = not affected`, `? = missing data`
> Powered by [Codecov](https://codecov.io/gh/mmcloughlin/avo/pull/74?src=pr&el=footer). Last update [7a0eb66...b6d0ead](https://codecov.io/gh/mmcloughlin/avo/pull/74?src=pr&el=lastupdated). Read the [comment docs](https://docs.codecov.io/docs/pull-request-comments).

mmcloughlin: > Jumped the gun slightly, but a couple of documentation nits. Overall seems fine though.

Thanks for the review, nits and all :)

Patch:
diff --git a/build/pseudo.go b/build/pseudo.go
index a728bb8..83a570e 100644
--- a/build/pseudo.go
+++ b/build/pseudo.go
@@ -39,7 +39,7 @@ func (c *Context) Load(src gotypes.Component, dst reg.Register) reg.Register {
 		c.adderror(err)
 		return dst
 	}
-	c.mov(b.Addr, dst, int(gotypes.Sizes.Sizeof(b.Type)), int(dst.Bytes()), b.Type)
+	c.mov(b.Addr, dst, int(gotypes.Sizes.Sizeof(b.Type)), int(dst.Size()), b.Type)
 	return dst
 }
 
@@ -51,7 +51,7 @@ func (c *Context) Store(src reg.Register, dst gotypes.Component) {
 		c.adderror(err)
 		return
 	}
-	c.mov(src, b.Addr, int(src.Bytes()), int(gotypes.Sizes.Sizeof(b.Type)), b.Type)
+	c.mov(src, b.Addr, int(src.Size()), int(gotypes.Sizes.Sizeof(b.Type)), b.Type)
 }
 
 // Dereference loads a pointer and returns its element type.
diff --git a/operand/checks.go b/operand/checks.go
index 77b304c..a05dda8 100644
--- a/operand/checks.go
+++ b/operand/checks.go
@@ -132,7 +132,7 @@ func IsYMM(op Op) bool {
 // IsRegisterKindSize returns true if op is a register of the given kind and size in bytes.
 func IsRegisterKindSize(op Op, k reg.Kind, n uint) bool {
 	r, ok := op.(reg.Register)
-	return ok && r.Kind() == k && r.Bytes() == n
+	return ok && r.Kind() == k && r.Size() == n
 }
 
 // IsRegisterKind returns true if op is a register of the given kind.
diff --git a/reg/collection.go b/reg/collection.go
index 548d61c..5c85104 100644
--- a/reg/collection.go
+++ b/reg/collection.go
@@ -13,11 +13,11 @@ func NewCollection() *Collection {
 	}
 }
 
-// VirtualRegister allocates and returns a new virtual register of the given kind and size.
-func (c *Collection) VirtualRegister(k Kind, s Size) Virtual {
+// VirtualRegister allocates and returns a new virtual register of the given kind and width.
+func (c *Collection) VirtualRegister(k Kind, w Width) Virtual {
 	vid := c.vid[k]
 	c.vid[k]++
-	return NewVirtual(vid, k, s)
+	return NewVirtual(vid, k, w)
 }
 
 // GP8 allocates and returns a general-purpose 8-bit register.
@@ -32,8 +32,8 @@ func (c *Collection) GP32() GPVirtual { return c.GP(B32) }
 // GP64 allocates and returns a general-purpose 64-bit register.
 func (c *Collection) GP64() GPVirtual { return c.GP(B64) }
 
-// GP allocates and returns a general-purpose register of the given size.
-func (c *Collection) GP(s Size) GPVirtual { return newgpv(c.VirtualRegister(KindGP, s)) }
+// GP allocates and returns a general-purpose register of the given width.
+func (c *Collection) GP(w Width) GPVirtual { return newgpv(c.VirtualRegister(KindGP, w)) }
 
 // XMM allocates and returns a 128-bit vector register.
 func (c *Collection) XMM() VecVirtual { return c.Vec(B128) }
@@ -44,5 +44,5 @@ func (c *Collection) YMM() VecVirtual { return c.Vec(B256) }
 // ZMM allocates and returns a 512-bit vector register.
 func (c *Collection) ZMM() VecVirtual { return c.Vec(B512) }
 
-// Vec allocates and returns a vector register of the given size.
-func (c *Collection) Vec(s Size) VecVirtual { return newvecv(c.VirtualRegister(KindVector, s)) }
+// Vec allocates and returns a vector register of the given width.
+func (c *Collection) Vec(w Width) VecVirtual { return newvecv(c.VirtualRegister(KindVector, w)) }
diff --git a/reg/types.go b/reg/types.go
index e111139..cd9f32a 100644
--- a/reg/types.go
+++ b/reg/types.go
@@ -5,12 +5,12 @@ import (
 	"fmt"
 )
 
-// Size is a register size.
-type Size uint
+// Width is a register width.
+type Width uint
 
-// Typical register sizes.
+// Typical register width values.
 const (
-	B8 Size = 1 << iota
+	B8 Width = 1 << iota
 	B16
 	B32
 	B64
@@ -19,8 +19,8 @@ const (
 	B512
 )
 
-// Bytes returns the register size in bytes.
-func (s Size) Bytes() uint { return uint(s) }
+// Size returns the register width in bytes.
+func (w Width) Size() uint { return uint(w) }
 
 // Kind is a class of registers.
 type Kind uint8
@@ -47,8 +47,8 @@ func (f *Family) add(r Physical) {
 }
 
 // Virtual returns a virtual register from this family's kind.
-func (f *Family) Virtual(id VID, s Size) Virtual {
-	return NewVirtual(id, f.Kind, s)
+func (f *Family) Virtual(id VID, w Width) Virtual {
+	return NewVirtual(id, f.Kind, w)
 }
 
 // Registers returns the registers in this family.
@@ -78,7 +78,7 @@ func (f *Family) Lookup(id PID, s Spec) Physical {
 // Register represents a virtual or physical register.
 type Register interface {
 	Kind() Kind
-	Bytes() uint
+	Size() uint
 	Asm() string
 	as(Spec) Register
 	register()
@@ -105,16 +105,16 @@ func ToVirtual(r Register) Virtual {
 type virtual struct {
 	id   VID
 	kind Kind
-	Size
+	Width
 	mask uint16
 }
 
 // NewVirtual builds a Virtual register.
-func NewVirtual(id VID, k Kind, s Size) Virtual {
+func NewVirtual(id VID, k Kind, w Width) Virtual {
 	return virtual{
-		id:   id,
-		kind: k,
-		Size: s,
+		id:    id,
+		kind:  k,
+		Width: w,
 	}
 }
 
@@ -123,19 +123,19 @@ 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.id, v.Kind(), v.Bytes())
+	return fmt.Sprintf("<virtual:%v:%v:%v>", v.id, v.Kind(), v.Size())
 }
 
 func (v virtual) SatisfiedBy(p Physical) bool {
-	return v.Kind() == p.Kind() && v.Bytes() == p.Bytes() && (v.mask == 0 || v.mask == p.Mask())
+	return v.Kind() == p.Kind() && v.Size() == p.Size() && (v.mask == 0 || v.mask == p.Mask())
 }
 
 func (v virtual) as(s Spec) Register {
 	return virtual{
-		id:   v.id,
-		kind: v.kind,
-		Size: Size(s.Bytes()),
-		mask: s.Mask(),
+		id:    v.id,
+		kind:  v.kind,
+		Width: Width(s.Size()),
+		mask:  s.Mask(),
 	}
 }
 
@@ -229,8 +229,8 @@ func (s Spec) Mask() uint16 {
 	return uint16(s)
 }
 
-// Bytes returns the register size in bytes.
-func (s Spec) Bytes() uint {
+// Size returns the register width in bytes.
+func (s Spec) Size() uint {
 	x := uint(s)
 	return (x >> 1) + (x & 1)
 }


Test patch:
diff --git a/reg/reg_test.go b/reg/reg_test.go
index 4fe784e..5f5281e 100644
--- a/reg/reg_test.go
+++ b/reg/reg_test.go
@@ -2,10 +2,10 @@ package reg
 
 import "testing"
 
-func TestSpecBytes(t *testing.T) {
+func TestSpecSize(t *testing.T) {
 	cases := []struct {
-		Spec  Spec
-		Bytes uint
+		Spec Spec
+		Size uint
 	}{
 		{S0, 0},
 		{S8L, 1},
@@ -18,8 +18,8 @@ func TestSpecBytes(t *testing.T) {
 		{S512, 64},
 	}
 	for _, c := range cases {
-		if c.Spec.Bytes() != c.Bytes {
-			t.Errorf("%v.Bytes() = %d; expect = %d", c.Spec, c.Spec.Bytes(), c.Bytes)
+		if c.Spec.Size() != c.Size {
+			t.Errorf("%v.Size() = %d; expect = %d", c.Spec, c.Spec.Size(), c.Size)
 		}
 	}
 }