How can I pass function pointers to C code using CGO in Go versions 1.6 and later?

Passing Function Pointers to C Code Using CGO

Introduction

In Go versions prior to 1.6, passing function pointers to C code using CGO was straightforward. However, with the introduction of new rules in Go 1.6, this practice has become more complex.

The Issue

The crux of the issue lies in the updated CGO rules, which stipulate that Go code can only pass Go pointers to C if the memory they refer to doesn't contain any other Go pointers. This creates a problem, as function pointers are stored in Go memory that may contain other Go pointers.

Potential Solutions

Several approaches have emerged to address this issue. One common solution is to abandon the use of direct function pointers altogether. Instead, create a synchronized data structure that maps IDs (integers) to the actual function pointers. This allows you to pass the ID to the C code instead of the pointer itself.

Example Implementation

The following code snippet demonstrates how to implement this approach:

<code class="golang">package gocallback

import (
    "fmt"
    "sync"
)

type Callback func(C.int)

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

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

func lookup(i int) Callback {
    mu.Lock()
    defer mu.Unlock()
    return fns[i]
}

func unregister(i int) {
    mu.Lock()
    defer mu.Unlock()
    delete(fns, i)
}</code>

Usage in C Code

Once the Go data structure is in place, you can call the Go callback from C code by passing the ID rather than the function pointer itself. For example:

<code class="c">extern void go_callback_int(int foo, int p1);

static inline void CallMyFunction(int foo) {
    go_callback_int(foo, 5);
}</code>

Conclusion

While the new CGO rules add some complexity to the process of passing function pointers to C code, the approaches outlined in this article provide effective solutions. By leveraging synchronized data structures and IDs, you can continue to enjoy the benefits of interfacing between Go and C code while adhering to the latest CGO regulations.

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