# build a tcp-echo binary using the golang container
FROM golang:1.22 as builder
WORKDIR /go/src/istio.io/tcp-echo-server/
COPY main.go .
RUN CGO_ENABLED=0 GOOS=linux go build -ldflags '-extldflags -static -s -w' -o tcp-echo main.go

FROM scratch

WORKDIR /bin/
COPY --from=builder /go/src/istio.io/tcp-echo-server/tcp-echo .
ENTRYPOINT [ "/bin/tcp-echo" ]
CMD [ "9000", "hello" ]

	-dumpdep
		Dump symbol dependency graph.
	-extar ar
		Set the external archive program (default "ar").
		Used only for -buildmode=c-archive.
	-extld linker
		Set the external linker (default "clang" or "gcc").
	-extldflags flags
		Set space-separated flags to pass to the external linker.
	-f
		Ignore version mismatch in the linked archives.
	-g
		Disable Go package data checks.
	-importcfg file
		Read import configuration from file.

)

func init() {
	flag.Var(&rpath, "r", "set the ELF dynamic linker search `path` to dir1:dir2:...")
	flag.Var(&flagExtld, "extld", "use `linker` when linking in external mode")
	flag.Var(&flagExtldflags, "extldflags", "pass `flags` to external linker")
	flag.Var(&flagW, "w", "disable DWARF generation")
}

// Flags used by the linker. The exported flags are used by the architecture-specific packages.
var (

			// This isn't actually a Go buildmode, just a convenient way to tell
			// cgoTest we want static linking.
			gt.buildmode = ""
			if linkmode == "external" {
				ldflags = append(ldflags, `-extldflags "-static -pthread"`)
			} else if linkmode == "auto" {
				gt.env = append(gt.env, "CGO_LDFLAGS=-static -pthread")
			} else {
				panic("unknown linkmode with static build: " + linkmode)
			}

fmt: format-go format-python tidy-go

ifeq ($(DEBUG),1)
# gobuild script uses custom linker flag to set the variables.
RELEASE_LDFLAGS=''
else
RELEASE_LDFLAGS='-extldflags -static -s -w'
endif

# List of all binaries to build
# We split the binaries into "agent" binaries and standard ones. This corresponds to build "agent".

	// even when linking with -static, causing a linker
	// error when using GNU ld. So take out -rdynamic if
	// we added it. We do it in this order, rather than
	// only adding -rdynamic later, so that -extldflags
	// can override -rdynamic without using -static.
	// Similarly for -Wl,--dynamic-linker.
	checkStatic := func(arg string) {
		if ctxt.IsELF && arg == "-static" {
			for i := range argv {

	cmd.Dir = tmpdir

	// Add enough arguments to push cmd/link into creating a response file.
	var sb strings.Builder
	sb.WriteString(`'-ldflags=all="-extldflags=`)
	for i := 0; i < sys.ExecArgLengthLimit/len("-g"); i++ {
		if i > 0 {
			sb.WriteString(" ")
		}
		sb.WriteString("-g")
	}
	sb.WriteString(`"'`)
	cmd = testenv.CleanCmdEnv(cmd)

the host linker. The default value for the host linker is $CC, split
into fields, or else "gcc". The specific host linker command line can
be overridden using command line flags: cmd/link -extld=clang
-extldflags='-ggdb -O3'. If any package in a build includes a .cc or
other file compiled by the C++ compiler, the go tool will use the
-extld option to set the host linker to the C++ compiler.

}

// StartDefaultServerWithClients starts a test server and returns clients for it.
func StartDefaultServerWithClients(t servertesting.Logger, extraFlags ...string) (func(), clientset.Interface, dynamic.Interface, error) {
	tearDown, config, _, err := StartDefaultServer(t, extraFlags...)
	if err != nil {
		return nil, nil, nil, err
	}

	apiExtensionsClient, err := clientset.NewForConfig(config)
	if err != nil {

		// use of lld, which ships with our clang installation.
		extraLDFlags := ""
		if strings.Contains(testenv.Builder(), "clang") {
			extraLDFlags += " -fuse-ld=lld"
		}
		const cflags = "-flto -Wno-lto-type-mismatch -Wno-unknown-warning-option"
		cmd.Env = append(cmd.Environ(),
			"CGO_CFLAGS="+cflags,
			"CGO_CXXFLAGS="+cflags,
			"CGO_LDFLAGS="+cflags+extraLDFlags)
	}
	out, err := cmd.CombinedOutput()
	if string(out) != "OK\n" {