C.size_t cgo pointer

[serbaut]

nvm: as I was writing this I realized y should be uint64

I am having trouble with size_t pointers in cgo:

// void foo(int *x)

// void bar(size_t *y)

var x int32

var y int64

foo((*C.int)(&x)) // works

bar((*C.size_t)(&y)) // error: cannot convert &y (type *int64) to type *_Ctype_size_t

This is on 64 bit linux with gcc (GCC) 4.4.6 20120305 (Red Hat 4.4.6-4)

Should y be of some other type?

[minux]

i think it's better to use uintptr for c type size_t.

also note that you need to first convert &y to unsafe.Pointer type

and then convert that to *C.size_t. Go doesn't allow arbitrary

conversion between pointer types, it must go through unsafe.Pointer.

[serbaut]

Not sure what you mean, the following runs fine with go tip:

package main

// #include <stddef.h>

// void foo(int *x) { *x = 17; }

// void bar(size_t *y) { *y = 4711; }

import "C"

import "fmt"

func main() {

    var x int32

    var y uint64

    C.foo((*C.int)(&x))

    C.bar((*C.size_t)(&y))

    fmt.Println(x, y)

}

[bryanturley]

The problem is int is 32bit on 32bit platforms and will soon be 64bit on 64bit platforms.
uintptr also adjusts it's size based on target arch, which probably the reason size_t was created as well.

[serbaut]

How should I rewrite the code above in that case?

[Uli Kunitz]

I would put that more precise: The language specification defines that uint and int might have 32 bit or 64 bit size whereby int and uint must have the same size.

Actually the size of uint and int will change from 32 bit to 64 bit from 1.0.3 to 1.1 on amd64.

[minux]

On Thu, Nov 15, 2012 at 4:23 AM, serbaut <ser...@gmail.com> wrote:

Not sure what you mean, the following runs fine with go tip:

package main

// #include <stddef.h>

// void foo(int *x) { *x = 17; }

// void bar(size_t *y) { *y = 4711; }

import "C"

import "fmt"

func main() {

    var x int32

    var y uint64

    C.foo((*C.int)(&x))

    C.bar((*C.size_t)(&y))

    fmt.Println(x, y)

}

this runs fine simply because size_t is an alias for uint64 on your system.

in general, size_t should correspond to uintptr, and if you declare y as type uintptr, you

need to use unsafe.Pointer to help converting &y to *C.size_t.

[serbaut]

I dont expect my code to be built on anything else than 64 bit linux but thanks for the explanations!

package main

// #include <stddef.h>

// void foo(int *x) { *x = 17; }

// void bar(size_t *y) { *y = 4711; }

import "C"

import (

    "fmt"

    "unsafe"

)

func main() {

    var x int32

    var y uintptr

    C.foo((*C.int)(&x))

    C.bar((*C.size_t)(unsafe.Pointer(&y)))

    fmt.Println(x, y)