// This needs to be linked in to any program that wants to execute any of the
  // expressions in `cpp_shims`.
  string object_file_data;
};

// Describes a protocol buffer to embed into an object file.
struct ProtobufToEmbed {
  // `symbol_prefix` is prefix that is guaranteed to be unique across the binary
  // or DSO the generated object file will be linked into.
  string symbol_prefix;

        def inputFile = targetDir.file("input.txt")
        def linkedDir = file("linked-dir").createLink(targetDir)

        inputFile.text = "original"

        buildFile << """
            task myTask {
                def outputFile = file("build/output.txt")
                inputs.file("linked-dir/input.txt")
                outputs.file(outputFile)

                doLast {

		}
	}
}

func TestElfBindNow(t *testing.T) {
	t.Parallel()
	testenv.MustHaveGoBuild(t)

	const (
		prog = `package main; func main() {}`
		// with default buildmode code compiles in a statically linked binary, hence CGO
		progC = `package main; import "C"; func main() {}`
	)

	// Notes:
	// - for linux/amd64 and linux/arm64, for relro we'll always see a

# controls the default behavior of the linker's -linkmode option.  The
# default value depends on the system.
#
# GO_LDSO: Sets the default dynamic linker/loader (ld.so) to be used
# by the internal linker.
#
# CC: Command line to run to compile C code for GOHOSTARCH.
# Default is "gcc". Also supported: "clang".
#
# CC_FOR_TARGET: Command line to run to compile C code for GOARCH.
# This is used by cgo. Default is CC.
#

	// Just make sure this runs without crashing for now.
	// See issue 15879.
	Glob(`\\?\C:\*`)
}

var globSymlinkTests = []struct {
	path, dest string
	brokenLink bool
}{
	{"test1", "link1", false},
	{"test2", "link2", true},
}

func TestGlobSymlink(t *testing.T) {
	testenv.MustHaveSymlink(t)

	tmpDir := t.TempDir()
	for _, tt := range globSymlinkTests {
		path := Join(tmpDir, tt.path)

 */

package org.gradle.caching.internal.controller.service;

import org.gradle.internal.scan.UsedByScanPlugin;

import java.util.Locale;

@UsedByScanPlugin("values are expected (type is not linked), see BuildCacheStoreBuildOperationType and friends")
public enum BuildCacheServiceRole {
    LOCAL,
    REMOTE;

    private final String displayName;

    BuildCacheServiceRole() {

// THE SOFTWARE.

package arm64

import (
	"cmd/internal/objabi"
	"cmd/internal/sys"
	"cmd/link/internal/ld"
	"cmd/link/internal/loader"
	"cmd/link/internal/sym"
	"debug/elf"
	"fmt"
	"log"
)

func gentext(ctxt *ld.Link, ldr *loader.Loader) {
	initfunc, addmoduledata := ld.PrepareAddmoduledata(ctxt)
	if initfunc == nil {
		return
	}

	o := func(op uint32) {

	// exercising https://golang.org/issues/17594
	reflect.TypeOf(os.Stdout).Elem()
	return 10
}

func F() int {
	defer func() {}()
	return V
}

func H() {
	// Issue 67635: deadcoded closures causes linker crash.
	func() { F() }()

# Tests that the linker implements the PPC64 ELFv2 ABI
# register save and restore functions as defined in
# section 2.3.3.1 of the PPC64 ELFv2 ABI when linking
# external objects most likely compiled with gcc's
# -Os option.
#
# Verifies golang.org/issue/52366 for linux/ppc64le
[!GOOS:linux] skip
[!compiler:gc] skip
[!cgo] skip
[!GOARCH:ppc64le] skip

go build -ldflags='-linkmode=internal'
exec ./abitest
stdout success

	c := cache.Default()

	// Cache output from compile/link, even if we don't do the rest.
	switch a.Mode {
	case "build":
		cache.PutBytes(c, cache.Subkey(a.actionID, "stdout"), a.output)
	case "link":
		// Even though we don't cache the binary, cache the linker text output.
		// We might notice that an installed binary is up-to-date but still
		// want to pretend to have run the linker.
		// Store it under the main package's action ID