How can I pass function pointers to C code in Go 1.6 given the new restrictions?

Passing Function Pointers to C Code Using cgo: Addressing Runtime Changes in Go 1.6

Introduction

Go 1.6 introduced modifications to the rules for passing pointers to C code via cgo. As a result, previously viable methods for calling dynamic Go callbacks from C code are no longer functional. This article explores the updated guidelines and demonstrates how to effectively pass function pointers to C code in the current Go ecosystem.

Passing Function Pointers in Go 1.6

Starting from Go 1.6, the following rule applies:

Go code may pass a Go pointer to C provided that the Go memory to which it points does not contain any Go pointers.

This restriction stems from runtime checks that monitor for violations and provoke crashes when detected. Setting the environment variable GODEBUG=cgocheck=0 temporarily disables these checks, but their removal in future Go versions is possible.

Consequences and Solutions

The new rule prohibits passing pointers to C code if the pointed-to memory holds Go function/method pointers. Several approaches exist to circumvent this limitation:

Synchronization and ID Correspondence

One strategy involves maintaining a synchronized data structure that maps IDs to actual pointers. By passing IDs to C code instead of direct pointers, you can bypass the restriction while still achieving the desired functionality.

Examplar Code

The following code snippet illustrates how to implement this approach:

<code class="go">import (
    "fmt"
    "sync"
)

var mu sync.Mutex
var index int
var fns = make(map[int]func(C.int))

func register(fn func(C.int)) int {
    mu.Lock()
    defer mu.Unlock()
    index++
    for fns[index] != nil {
        index++
    }
    fns[index] = fn
    return index
}

func lookup(i int) func(C.int) {
    mu.Lock()
    defer mu.Unlock()
    return fns[i]
}</code>

This code defines a registry system that assigns unique IDs to Go functions and stores the mappings in a thread-safe manner. When calling C code, you can pass the ID instead of the function pointer directly.

Conclusion

The changes in Go 1.6 necessitate careful consideration when passing function pointers to C code. By adopting synchronization techniques like the one presented above, you can effectively overcome the new restrictions and ensure compatibility with the latest versions of Go.

The above is the detailed content of How can I pass function pointers to C code in Go 1.6 given the new restrictions?. For more information, please follow other related articles on the PHP Chinese website!