Thanks for the test case. I don't know how to do much better for this kind of example. The pointer passing rules say that if you pass the address of an element of a slice, the C code is permitted to examine every element of the slice. You are passing the address of a 1000000 slice of pointers, so each call needs to check 1000000 pointers to make sure that they are not Go pointers.

Thanks Ian for the clear description!

Now I think I understand another strange thing: with
s := struct { p C.ub4, q *GoObj }
C.f(&s.p)
does not work, but (!) with
s := struct{ p [1]C.ub4, q *GoObj },
C.f(&s.p[0])
does work - here we encapsulated the referent, so cgo does not check q.

Back to the original issue: this understanding allows a not-too-ugly workaround:

    i := i % int(n)
    carr := arr[i : i+1 : i+1]
    i = (i + 100) % int(n)
    darr := arr[i : i+1 : i+1]
    //C.call(&arr[i%int(n)], &arr[(i+100)%int(n)])
    C.call(&carr[0], &darr[0])

By calling with a one-element-length array (capped), it works:

:tgulacsi@tgulacsi-Aspire-V3-371: ~/src/github.com/tgulacsi/go/cgo22
! GODEBUG=cgocheck=0 go test  -run=X -bench=.
testing: warning: no tests to run
PASS
BenchmarkCGONaive-4      3000000               494 ns/op
BenchmarkCGOSliced-4     3000000               501 ns/op
BenchmarkCGOCapped-4     3000000               507 ns/op
ok      github.com/tgulacsi/go/cgo22    6.400s
:tgulacsi@tgulacsi-Aspire-V3-371: ~/src/github.com/tgulacsi/go/cgo22
$ GODEBUG=cgocheck=1 go test  -run=X -bench=.
testing: warning: no tests to run
PASS
BenchmarkCGONaive-4          100          18490218 ns/op
BenchmarkCGOSliced-4         100          18211666 ns/op
BenchmarkCGOCapped-4     3000000               568 ns/op
ok      github.com/tgulacsi/go/cgo22    6.305s

Here the "Naive" is the old version, the "Sliced" is the carr := arr[i:i+1] version, and the "Capped" is the above carr := arr[i:i+1:i+1] version.

(same repo has the new code).

I think at least we should document it more explicitly, that the cgo checker checks all reachable pointers in the struct/array/slice level.