What causes "wrong number of bytes for register %s (%d)" in go-delve/delve?

Pad/resize the byte slice to exactly 8 bytes (little-endian) before calling SetReg

wrong number of bytes for register %s (%d)

Error message

wrong number of bytes for register %s (%d)

What it means

On FreeBSD (amd64), fbsdutil.SetReg validates that registers backed by an 8-byte field (e.g. Rflags and other general-purpose registers) receive exactly 8 bytes of data; otherwise it returns 'wrong number of bytes for register <name> (<n>)'. This protects against writing a malformed register buffer into the process's register state. It indicates the caller supplied a Regs value with an unexpected byte length.

Source

Thrown at pkg/proc/fbsdutil/regs.go:229

	case regnum.AMD64_R11:
		p = &r.Regs.R11
	case regnum.AMD64_R12:
		p = &r.Regs.R12
	case regnum.AMD64_R13:
		p = &r.Regs.R13
	case regnum.AMD64_R14:
		p = &r.Regs.R14
	case regnum.AMD64_R15:
		p = &r.Regs.R15
	case regnum.AMD64_Rip:
		p = &r.Regs.Rip
	case regnum.AMD64_Rflags:
		p = &r.Regs.Rflags
	}

	if p != nil {
		if reg.Bytes != nil && len(reg.Bytes) != 8 {
			return false, fmt.Errorf("wrong number of bytes for register %s (%d)", regnum.AMD64ToName(regNum), len(reg.Bytes))
		}
		*p = int64(reg.Uint64Val)
		return false, nil
	}

	if r.loadFpRegs != nil {
		if err := r.loadFpRegs(r); err != nil {
			return false, err
		}
		r.loadFpRegs = nil
	}

	if regNum < regnum.AMD64_XMM0 || regNum > regnum.AMD64_XMM0+15 {
		return false, fmt.Errorf("can not set %s", regnum.AMD64ToName(regNum))
	}

	reg.FillBytes()

View on GitHub (pinned to a23773e6c3)

Solutions

Pad/resize the byte slice to exactly 8 bytes (little-endian) before calling SetReg
Use reg.FillBytes()/proper Regs construction so Bytes length matches the register width
Verify you are writing an amd64-width value and not a 32-bit one

Example fix

// before
b := []byte{0x10, 0x00} // 2 bytes
thread.SetReg(regnum.AMD64_Rflags, proc.Regs{Bytes: b})
// after
b := make([]byte, 8)
binary.LittleEndian.PutUint64(b, 0x10)
thread.SetReg(regnum.AMD64_Rflags, proc.Regs{Bytes: b})

Defensive patterns

Strategy: validation

Validate before calling

if len(regBytes) != 8 {
	return fmt.Errorf("GP register write needs 8 bytes, got %d", len(regBytes))
}

Type guard

func isEightBytes(b []byte) bool { return len(b) == 8 }

Try / catch

null

Prevention

Always encode 64-bit little-endian values for amd64 GP registers
Use proc.Regs helper constructors/FillBytes
Test register-write tooling on the target OS before deploying

When it happens

Trigger: Calling SetReg (e.g. via proc.WriteRegister / the RPC SetRegister API) with reg.Bytes of length other than 8 for a GP register; scripted register modification via RPC2 with wrongly sized byte slices.

Common situations: Tooling that pokes registers programmatically passing 4-byte values for a 64-bit register; architecture confusion (32-bit sized writes on amd64); hand-crafted core/debug automation bugs.

Related errors

AI-assisted analysis of go-delve/delve@a23773e6c3 (2026-08-31). Data as JSON: /api/errors/13595e20f199d61c. Report an issue: GitHub.