Moved register state to scopes

src/build/cpu/CPU.go

@@ -2,59 +2,9 @@ package cpu
 
 // CPU represents the processor.
 type CPU struct {
-	All      []Register
-	General  []Register
-	Syscall  []Register
-	Input    []Register
-	Output   []Register
-	Reserved uint64
-	Used     uint64
-}
-
-// Free will reset the reserved and used status which means the register can be allocated again.
-func (c *CPU) Free(reg Register) {
-	c.Used &= ^(1 << reg)
-	c.Reserved &= ^(1 << reg)
-}
-
-// IsReserved returns true if the register was marked for future use.
-func (c *CPU) IsReserved(reg Register) bool {
-	return c.Reserved&(1<<reg) != 0
-}
-
-// IsUsed returns true if the register is currently in use and holds a value.
-func (c *CPU) IsUsed(reg Register) bool {
-	return c.Used&(1<<reg) != 0
-}
-
-// Reserve reserves a register for future use.
-func (c *CPU) Reserve(reg Register) {
-	c.Reserved |= (1 << reg)
-}
-
-// Use marks a register to be currently in use which means it must be preserved across function calls.
-func (c *CPU) Use(reg Register) {
-	c.Used |= (1 << reg)
-}
-
-// FindFree tries to find a free register in the given slice of registers.
-func (c *CPU) FindFree(registers []Register) (Register, bool) {
-	for _, reg := range registers {
-		if !c.IsReserved(reg) {
-			return reg, true
-		}
-	}
-
-	return 0, false
-}
-
-// MustFindFree tries to find a free register and panics if it could not be found.
-func (c *CPU) MustFindFree(registers []Register) Register {
-	register, exists := c.FindFree(registers)
-
-	if !exists {
-		panic("no free registers")
-	}
-
-	return register
+	All     []Register
+	General []Register
+	Syscall []Register
+	Input   []Register
+	Output  []Register
 }

src/build/cpu/State.go

@@ -0,0 +1,55 @@
+package cpu
+
+// State contains information about which registers are currently in use.
+type State struct {
+	Reserved uint64
+	Used     uint64
+}
+
+// Free will reset the reserved and used status which means the register can be allocated again.
+func (s *State) Free(reg Register) {
+	s.Reserved &= ^(1 << reg)
+	s.Used &= ^(1 << reg)
+}
+
+// IsReserved returns true if the register was marked for future use.
+func (s *State) IsReserved(reg Register) bool {
+	return s.Reserved&(1<<reg) != 0
+}
+
+// IsUsed returns true if the register is currently in use and holds a value.
+func (s *State) IsUsed(reg Register) bool {
+	return s.Used&(1<<reg) != 0
+}
+
+// Reserve reserves a register for future use.
+func (s *State) Reserve(reg Register) {
+	s.Reserved |= (1 << reg)
+}
+
+// Use marks a register to be currently in use which means it must be preserved across function calls.
+func (s *State) Use(reg Register) {
+	s.Used |= (1 << reg)
+}
+
+// FindFree tries to find a free register in the given slice of registers.
+func (s *State) FindFree(registers []Register) (Register, bool) {
+	for _, reg := range registers {
+		if !s.IsReserved(reg) {
+			return reg, true
+		}
+	}
+
+	return 0, false
+}
+
+// MustFindFree tries to find a free register and panics if it could not be found.
+func (s *State) MustFindFree(registers []Register) Register {
+	register, exists := s.FindFree(registers)
+
+	if !exists {
+		panic("no free registers")
+	}
+
+	return register
+}