CFRelease(url_ref);
	if (!res) {
		fprintf(stderr, "runtime/cgo: cannot get URL string\n");
		return;
	}

	// url is of the form "file:///path/to/Info.plist".
	// strip it down to the working directory "/path/to".
	int url_len = strlen(buf);
	if (url_len < sizeof("file://")+sizeof("/Info.plist")) {
		fprintf(stderr, "runtime/cgo: bad URL: %s\n", buf);
		return;
	}
	buf[url_len-sizeof("/Info.plist")+1] = 0;

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build cgo

// Test that we can have two identical cgo packages in a single binary.
// No runtime test; just make sure it compiles.

package cgotest

import (
	_ "cmd/cgo/internal/test/issue23555a"
	_ "cmd/cgo/internal/test/issue23555b"

# Issue #7573
# cmd/cgo: undefined reference when linking a C-library using gccgo

[!cgo] skip
[!exec:gccgo] skip
[cross] skip  # gccgo can't necessarily cross-compile, so don't assume it will reach the step where we expect it to fail

! go build -x -compiler gccgo
stderr 'gccgo.*\-L [^ ]*alibpath \-lalib' # make sure that Go-inline "#cgo LDFLAGS:" ("-L alibpath -lalib") passed to gccgo linking stage

// license that can be found in the LICENSE file.

//go:build cgo && !((ppc64 || ppc64le) && internal)

// Test that we can link together two different cgo packages that both
// use the same libgcc function.

package cgotest

import (
	"runtime"
	"testing"

	"cmd/cgo/internal/test/issue9510a"
	"cmd/cgo/internal/test/issue9510b"
)

func test9510(t *testing.T) {
	if runtime.GOARCH == "arm" {

# Check that second vet reuses cgo-derived inputs.
# The first command could be build instead of vet,
# except that if the cache is empty and there's a net.a
# in GOROOT/pkg, the build will not bother to regenerate
# and cache the cgo outputs, whereas vet always will.

go vet -x os/user
! stderr '^(clang|gcc)'  # should not have run compiler

# such that the .syso file only works when linked against the .a file.
# Package a has #cgo LDFLAGS to make this happen.
#
# Package c imports package a, and uses cgo itself.
# The generation of the _cgo_import.go for package c will fail,
# because it won't know that it has to link against a/libb.a
# (because we don't gather the #cgo LDFLAGS from all transitively
# imported packages).
#

	ret = mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &port);
	if (ret) {
		fprintf(stderr, "runtime/cgo: mach_port_allocate failed: %d\n", ret);
		abort();
	}
	ret = mach_port_insert_right(
		mach_task_self(),
		port,
		port,
		MACH_MSG_TYPE_MAKE_SEND);
	if (ret) {
		fprintf(stderr, "runtime/cgo: mach_port_insert_right failed: %d\n", ret);
		abort();
	}

	ret = thread_set_exception_ports(

# Test automatic setting of CGO_ENABLED based on $CC and what's in $PATH.

[!cgo] skip
[cross] skip

# Assume we're on a system that can enable cgo normally.
env CGO_ENABLED=
go env CGO_ENABLED
stdout 1

# Clearing CC and removing everything but Go from the PATH should usually
# disable cgo: no C compiler anymore (unless the baked-in defaultCC is an
# absolute path and exists.
env CC=
env PATH=$GOROOT/bin
go env CGO_ENABLED

# For reproducibility and easier cross-compilation,
# nothing in std is supposed to use cgo on macOS.
# Check that cgo does not appear as a dependency
# of cmd/go, which imports approximately everything
# in std (certainly everything relevant).
[!GOOS:darwin] skip
go list -deps cmd/go

[!cgo] skip

env GO111MODULE=on

go get rsc.io/CGO
[short] stop

go build rsc.io/CGO

-- go.mod --