As far as configurations go, the main ones of interest are:

 * `implementation` - used for compilation, linking and runtime
 * `swiftCompile__Variant__` - for dependencies that are necessary to compile your production code but shouldn’t be part of the linking or runtime process
 * `nativeLink__Variant__` - for dependencies that are necessary to link your code but shouldn’t be part of the compilation or runtime process

[!GOOS:darwin] stop 'not testing -buildmode=pie -race on platform that does not support it'

go build -buildmode=pie -race bytes
! stderr .

[short] stop 'not linking a binary in -short mode'

go build -buildmode=pie -race main.go
! stderr .
exec ./main
stdout 'Hello, 世界'

-- go.mod --
module m

go 1.21
-- main.go --
package main

import "fmt"

			if staticCheck.skip == nil && goos == "linux" && strings.Contains(goexperiment, "boringcrypto") {
				staticCheck.skip = func(*distTest) (string, bool) {
					return "skipping static linking check on Linux when using boringcrypto to avoid C linker warning about getaddrinfo", true
				}
			}

			// Static linking tests
			if goos != "android" && p != "netbsd/arm" {

// misc/cgo to take advantage of the testing framework support for
// when -static is expected to work.

package nocgo

func NoCgo() int {
	c := make(chan int)

	// The test is run with external linking, which means that
	// goroutines will be created via the runtime/cgo package.
	// Make sure that works.
	go func() {
		c <- 42
	}()

	return <-c

	// For internal linking, trampolines are always created for long calls.
	// For external linking, the linker can insert a call stub to handle a long call, but depends on having the TOC address in
	// r2.  For those build modes with external linking where the TOC address is not maintained in r2, trampolines must be created.
	if ctxt.IsExternal() && r2Valid(ctxt) {

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

//go:build !windows && !static && !(darwin && internal)

// Excluded in darwin internal linking PIE (which is the default) mode,
// as dynamic export is not supported.

package cgotest

/*
#include <stdint.h>
#include <dlfcn.h>
#cgo linux LDFLAGS: -ldl

extern uintptr_t dlopen4029(char*, int);

    String getObjectFileExtension();

    String getExecutableName(String executablePath);

    String getSharedLibraryName(String libraryPath);

    /**
     * Does this tool chain produce an import library when linking a shared library?
     */
    boolean producesImportLibrary();

    /**
     * Whether or not this tool chain requires a debuggable binary to be stripped or whether the binary is stripped by default.
     */

 * limitations under the License.
 */

package org.gradle.nativeplatform.toolchain.internal;

import java.io.File;

/**
 * Tools for compiling and linking native languages.
 */
public interface NativeLanguageTools extends ExecutableTools {
    File getCompilerExecutable();

    File getLinkerExecutable();

    File getArchiverExecutable();

# Test case for issue 47993, in which the linker crashes
# on a bad input instead of issuing an error and exiting.

# This test requires external linking, so use cgo as a proxy 
[!cgo] skip

! go build -ldflags='-linkmode=external' .
! stderr 'panic'
stderr '^.*undefined symbol in relocation.*'

-- go.mod --

module issue47993

go 1.16

-- main.go --

package main

type M struct {
	b bool
}

	"path/filepath"
	"syscall"
)

const syscallExecSupported = true

// execArchive invokes the archiver tool with syscall.Exec(), with
// the expectation that this is the last thing that takes place
// in the linking operation.
func (ctxt *Link) execArchive(argv []string) {
	var err error
	argv0 := argv[0]
	if filepath.Base(argv0) == argv0 {
		argv0, err = exec.LookPath(argv0)
		if err != nil {