Also, if I forward-declare _GoStringLen and _GoStringPtr to resolve the C compiler errors, I get undefined symbol errors later:

package main

/*
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
size_t _GoStringLen(_GoString_ s);
const char *_GoStringPtr(_GoString_ s);
void dumpGoString(_GoString_ s) {
    size_t len = _GoStringLen(s);
    const char * sp = _GoStringPtr(s); // may not be NULL terminated
    char * str = strndup(sp, len);
    fprintf(stderr, "go string: %s\n", str);
    free(str);
}
*/
import "C"
import "strconv"

//export PrintWithC
func PrintWithC(v int) {
	C.dumpGoString(strconv.Itoa(v))
}

func main() {
	PrintWithC(42)
}

❯ go build -buildmode=c-archive -o gostring.a main.go
# command-line-arguments
Undefined symbols for architecture x86_64:
  "__GoStringLen", referenced from:
      _dumpGoString in _x001.o
  "__GoStringPtr", referenced from:
      _dumpGoString in _x001.o
ld: symbol(s) not found for architecture x86_64
clang: error: linker command failed with exit code 1 (use -v to see invocation)

The cgo docs indicate that these are only available in the C preamble of .go files.

I think that means that no, these symbols will not be available as part of a c-archive build. I'm not sure how you're supposed to make this work, though, or if it's possible at all.

CC @ianlancetaylor @aclements ?

Quoting https://golang.org/cmd/cgo:

Using //export in a file places a restriction on the preamble: since it is copied into two different C output files, it must not contain any definitions, only declarations. If a file contains both definitions and declarations, then the two output files will produce duplicate symbols and the linker will fail. To avoid this, definitions must be placed in preambles in other files, or in C source files.

You have a definition in your C preamble, and that is not supported when using //export. Sorry.

You have a definition in your C preamble, and that is not supported when using //export. Sorry.

Thanks, you are correct.

Ultimately I think I was able to get this work by:

1. Following the advice here about C calling Go calling C
2. Using 'static inline' to be able to define code in the preamble and export at the same time, as demonstrated in the wiki
3. Manually declaring _GoStringLen and _GoStringPtr in the preamble.

Seems like 2 would be good to mention in the cgo documentation, and 3 should be done automatically?

Here is what I ended up with, which allows me to access a Go string from C with no extra allocations:

main.go:

package main

/*
#cgo linux LDFLAGS: -Wl,-unresolved-symbols=ignore-all
#cgo darwin LDFLAGS: -Wl,-undefined,dynamic_lookup
extern void dumpCString(const char *s, size_t length);
size_t _GoStringLen(_GoString_ s);
const char *_GoStringPtr(_GoString_ s);
static inline void dumpGoString(_GoString_ s)
{
    dumpCString(_GoStringPtr(s), _GoStringLen(s));
}
*/
import "C"
import "strconv"

//export PrintWithC
func PrintWithC(v int) {
	C.dumpGoString(strconv.Itoa(v))
}

func main() {
	PrintWithC(42)
}

main.c:

#include <stdio.h>

#include "libgostring.h"

void dumpCString(const char *s, size_t length)
{
    printf("go string: %.*s\n", (int)length, s);
}

int
main(int argc, char** argv)
{
    PrintWithC(42);
}

❯ go build -buildmode=c-archive -o libgostring.a main.go
❯ clang libgostring.a main.c
❯ ./a.out
go string: 42

As far as I can tell _GoStringLen and _GoStringPtr are declared in the preamble--but only if you don't use //export. The static inline trick can often work but there is no intention of officially supporting it.