cmd.Dir = godir
	output, err := cmd.CombinedOutput()

	// The build should fail, but we want it to fail because we
	// detected the error, not because we passed a bad flag to the
	// C linker.

	if err == nil {
		t.Errorf("go build succeeded unexpectedly")
	}

	t.Logf("%s", output)

	for _, line := range bytes.Split(output, []byte("\n")) {

// run

// Copyright 2016 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// The linker can prune methods that are not directly called or
// assigned to interfaces, but only if reflect.Value.Method is
// never used. Test it here.

package main

import "reflect"

var called = false

type M int

func (m M) UniqueMethodName() {

func (b *Builder) LinkAction(mode, depMode BuildMode, p *load.Package) *Action {
	// Construct link action.
	a := b.cacheAction("link", p, func() *Action {
		a := &Action{
			Mode:    "link",
			Package: p,
		}

		a1 := b.CompileAction(ModeBuild, depMode, p)
		a.Actor = ActorFunc((*Builder).link)
		a.Deps = []*Action{a1}
		a.Objdir = a1.Objdir

// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// See issue 2241 and issue 1878: dwarf include stack size
// issues in linker.

plugins {
    id 'windows-resources'
}

// tag::resource-only-library[]
model {
    components {
        helloRes(NativeLibrarySpec) {
            binaries.all {
                rcCompiler.args "/v"
                linker.args "/noentry", "/machine:x86"
            }
            // tag::windows-resource-set[]
            sources {
                rc {
                    source {
                        srcDirs "src/hello/rc"

// runindir

// Copyright 2021 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Test to verify compiler and linker handling of multiple
// competing map.zero symbol definitions.

        return links == null ? Collections.<MutableModelNode>emptyList() : Iterables.filter(links.values(), predicate);
    }

    @Override
    public int getLinkCount() {
        return links == null ? 0 : links.size();
    }

    @Override
    public boolean hasLink(String name, Predicate<? super MutableModelNode> predicate) {
        ModelNodeInternal linked = getLink(name);

	"fmt"
	"io"

	"cmd/compile/internal/base"
	"cmd/internal/bio"
)

func WriteExports(out *bio.Writer) {
	var data bytes.Buffer

	data.WriteByte('u')
	writeUnifiedExport(&data)

	// The linker also looks for the $$ marker - use char after $$ to distinguish format.
	out.WriteString("\n$$B\n") // indicate binary export format
	io.Copy(out, &data)
	out.WriteString("\n$$\n")

	if base.Debug.Export != 0 {

	}
	testDWARF(t, linktype)
}

func TestDefaultLinkerDWARF(t *testing.T) {
	testCgoDWARF(t, linkCgoDefault)
}

func TestInternalLinkerDWARF(t *testing.T) {
	if runtime.GOARCH == "arm64" {
		t.Skip("internal linker disabled on windows/arm64")
	}
	testCgoDWARF(t, linkCgoInternal)
}

func TestExternalLinkerDWARF(t *testing.T) {
	testCgoDWARF(t, linkCgoExternal)

	Shared     = flag.Bool("shared", false, "generate code that can be linked into a shared library")
	Dynlink    = flag.Bool("dynlink", false, "support references to Go symbols defined in other shared libraries")
	Linkshared = flag.Bool("linkshared", false, "generate code that will be linked against Go shared libraries")
	AllErrors  = flag.Bool("e", false, "no limit on number of errors reported")