cppCompiler.args '-pthread'
                linker.args '-pthread'

                if (toolChain instanceof Gcc || toolChain instanceof Clang) {
                    // Use C++03 with the old ABIs, as this is what the googletest binaries were built with
                    cppCompiler.args '-std=c++03', '-D_GLIBCXX_USE_CXX11_ABI=0'
                    linker.args '-std=c++03'
                }
            }
        }

# Verify the linker will correctly resolve
# ppc64le objects compiled with gcc's -fno-plt
# option. This inlines PLT calls, and generates
# additional reloc types which the internal linker
# should handle.
#
# Verifies golang.org/issue/53345
#
# Note, older gcc/clang may accept this option, but
# ignore it if binutils does not support the relocs.
[!compiler:gc] skip
[!cgo] skip
[!GOARCH:ppc64le] skip

env CGO_CFLAGS='-fno-plt -O2 -g'

[short] skip

# In the remaining tests below we do actual builds (without -n) to
# verify that the Go linker is going the right thing in addition to the
# Go command. Here the idea is to pass "-tmpdir" to the linker, then
# check after the link is done for the presence of the file
# <tmpdir>/go.o, which the Go linker creates prior to kicking off the
# external linker.

mkdir tmp1
mkdir tmp2
mkdir tmp3
mkdir tmp4
mkdir tmp5

        tools.put(ToolType.CPP_COMPILER, instantiator.newInstance(DefaultCommandLineToolConfiguration.class, ToolType.CPP_COMPILER));
        tools.put(ToolType.LINKER, instantiator.newInstance(DefaultCommandLineToolConfiguration.class, ToolType.LINKER));
        tools.put(ToolType.STATIC_LIB_ARCHIVER, instantiator.newInstance(DefaultCommandLineToolConfiguration.class, ToolType.STATIC_LIB_ARCHIVER));

// Checking of compiler and linker flags.
// We must avoid flags like -fplugin=, which can allow
// arbitrary code execution during the build.
// Do not make changes here without carefully
// considering the implications.
// (That's why the code is isolated in a file named security.go.)
//
// Note that -Wl,foo means split foo on commas and pass to
// the linker, so that -Wl,-foo,bar means pass -foo bar to

    }

    @ToBeFixedForConfigurationCache
    def "fails when required linker tool is not available but language tool is available"() {
        when:
        buildFile << """
model {
    toolChains {
        ${toolChain.id} {
            eachPlatform {
                linker.executable = 'does-not-exist'
            }
        }
    }
}
"""
        fails "mainExecutable"

        tr.appendChild(td);
        td.appendChild(document.createTextNode("Description"));

        for (PropertyDoc propDoc : properties) {
            // <tr>
            //   <td><link linkend="$id"><literal>$name</literal></link</td>
            //   <td>$description</td>
            // </tr>
            tr = document.createElement("tr");
            parent.appendChild(tr);

        tr.appendChild(td);
        td.appendChild(document.createTextNode("Description"));

        for (BlockDoc blockDoc : blocks) {
            // <tr>
            //   <td><link linkend="$id"><literal>$name</literal></link</td>
            //   <td>$description</td>
            // </tr>
            tr = document.createElement("tr");
            parent.appendChild(tr);

[short] skip

# Set up fresh GOCACHE.
env GOCACHE=$WORK/gocache
mkdir $GOCACHE

# Building a main package should run the compiler and linker ...
go build -o $devnull -x main.go
stderr '(compile|gccgo)( |\.exe).*main\.go'
stderr '(link|gccgo)( |\.exe)'

# ... and then the linker again ...
go build -o $devnull -x main.go
! stderr '(compile|gccgo)( |\.exe).*main\.go'
stderr '(link|gccgo)( |\.exe)'

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

package base

import (
	"cmd/internal/obj"
)

// ReservedImports are import paths used internally for generated
// symbols by the compiler.
//
// The linker uses the magic symbol prefixes "go:" and "type:".
// Avoid potential confusion between import paths and symbols
// by rejecting these reserved imports for now. Also, people