Type conversion from byte slice to struct with unsafe

Question

I'm trying to understand why my code in Go doesn't work the way I thought it would. When I execute this test, it fails:

func TestConversion(t *testing.T) {
    type myType struct {
        a     uint8
        value uint64
    }
    myVar1 := myType{a: 1, value: 12345}

    var copyFrom []byte
    copyFromHeader := (*reflect.SliceHeader)(unsafe.Pointer(&copyFrom))
    copyFromHeader.Data = uintptr(unsafe.Pointer(&myVar1))
    copyFromHeader.Cap = 9
    copyFromHeader.Len = 9

    copyTo := make([]byte, len(copyFrom))

    for i := range copyFrom {
        copyTo[i] = copyFrom[i]
    }

    myVar2 := (*myType)(unsafe.Pointer(&copyFrom[0]))
    myVar3 := (*myType)(unsafe.Pointer(&copyTo[0]))

    if myVar2.value != myVar3.value {
        t.Fatalf("Expected myVar3.value to be %d, but it is %d", myVar2.value, myVar3.value)
    }
}

The output will be:

slab_test.go:67: Expected myVar3.value to be 12345, but it is 57

However, if I increase copyFromHeader.Data by 1 before the copying of the data, then it all works fine. Like this:

copyFromHeader.Data = uintptr(unsafe.Pointer(&myVar1)) + 1

I don't understand why it seems to shift the underlying data by one byte.

Answer 1

There are 7 padding bytes between a and value. You're only getting the least significant byte of 12345 (57) in value. When you move copyFrom down by one byte, the values of myVar2.value and myVar3.value are both 48 (the second byte of 12345), so your test passes. It should work if you change 9 to 16.

Is there some particular reason you're copying the struct that way?