env CGO_LDFLAGS=-Wno-such-warning -Wno-unknown-warning-option
cd ../ok
go build

# Build a main program that actually uses LDFLAGS.
cd ..
go build -ldflags=-v

# Because we passed -v the Go linker should print the external linker
# command which should include the flag we passed in CGO_LDFLAGS.
stderr no-such-warning

-- go.mod --
module ldflag

-- bad/bad.go --
package bad

env GO111MODULE=off

# check for linker name in error message about linker crash
[!compiler:gc] skip
! go build -ldflags=-crash_for_testing x.go
stderr [\\/]tool[\\/].*[\\/]link

-- x.go --

    BuildOperationQueue queue = Mock(BuildOperationQueue)
    WorkerLeaseService workerLeaseService = new TestWorkerLeaseService()

    GccLinker linker = new GccLinker(buildOperationExecutor, commandLineTool, invocationContext, false, workerLeaseService)

    def "links all object files in a single execution"() {
        given:
        def testDir = tmpDirProvider.testDirectory
        def outputFile = testDir.file("output/lib")

            if (targetPlatform.operatingSystem.linux) {
                cppCompiler.args '-pthread'
                linker.args '-pthread'
            }
        }
        all {
            if (toolChain instanceof Gcc) {
                cppCompiler.args '-std=c++03', '-D_GLIBCXX_USE_CXX11_ABI=0'
                linker.args '-std=c++03'
            }
        }
    }

            if (targetPlatform.operatingSystem.macOsX) {
                linker.args "-framework", "Foundation"
            } else {
                objcCompiler.args "-I/usr/include/GNUstep", "-fconstant-string-class=NSConstantString", "-D_NATIVE_OBJC_EXCEPTIONS"
                linker.args "-lgnustep-base", "-lobjc"
            }
        }
    }
}

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

// This test case contains two static temps (the array literals)
// with same contents but different sizes. The linker should not
// report a hash collision. The linker can (and actually does)
// dedup the two symbols, by keeping the larger symbol. The dedup
// is not a requirement for correctness and not checked in this test.

# The _cgo_import.go file is only needed for internal linking.
# When generating _cgo_import.go for package c fails, an ordinary
# external link should still work. But an internal link is expected
# to fail, because the failure to create _cgo_import.go should cause
# the linker to report an inability to internally link.

[short] skip
[!cgo] skip
[!exec:ar] skip

cc -c -o a/b.syso b/b.c
cc -c -o b/lib.o b/lib.c
exec ar rc a/libb.a b/lib.o

package dep3

// The point of this test file is that it references a type from
// depBase that is also referenced in dep2, but dep2 is loaded by the
// linker before depBase (because it is earlier in the import list).
// There was a bug in the linker where it would not correctly read out
// the type data in this case and later crash.

import (
	"testshared/dep2"
	"testshared/depBase"
)

type Dep3 struct {
	dep  depBase.Dep
	dep2 dep2.Dep2

				return true
			}
		}

		switch goos {
		case "android":
			return true
		case "dragonfly":
			// It seems that on Dragonfly thread local storage is
			// set up by the dynamic linker, so internal cgo linking
			// doesn't work. Test case is "go test runtime/cgo".
			return true
		}
	}

	switch goos {
	case "android":
		if goarch != "arm64" {
			return true
		}

    OBJECTIVECPP_COMPILER("Objective-C++ compiler"),
    OBJECTIVEC_COMPILER("Objective-C compiler"),
    WINDOW_RESOURCES_COMPILER("Windows resources compiler"),
    ASSEMBLER("Assembler"),
    LINKER("Linker"),
    STATIC_LIB_ARCHIVER("Static library archiver"),
    SWIFT_COMPILER("Swift compiler"),
    SYMBOL_EXTRACTOR("Symbol extractor"),
    STRIPPER("Stripper");

    private final String toolName;