"internal/goversion",
	// internal/lazyregexp is provided by Go 1.17, which permits it to
	// be imported by other packages in this list, but is not provided
	// by the Go 1.17 version of gccgo. It's on this list only to
	// support gccgo, and can be removed if we require gccgo 14 or later.
	"internal/lazyregexp",
	"internal/pkgbits",
	"internal/platform",
	"internal/profile",
	"internal/race",
	"internal/saferio",
	"internal/syscall/unix",

[compiler:gccgo] skip # gccgo does not have standard packages
[short] skip

env GOCACHE=$WORK/tmp

# Run go test -json on errors m/empty/pkg and m/skipper
# It would be nice to test that the output is interlaced
# but it seems to be impossible to do that in a short test
# that isn't also flaky. Just check that we get JSON output.
go test -json -short -v errors m/empty/pkg m/skipper

# Check errors for run action
stdout '"Package":"errors"'

	if err != nil {
		t.Fatalf("go list %s: %v\n%s", thePackage, err, out)
	}
	export := strings.TrimSpace(string(out))
	compiler, target, _ := strings.Cut(export, ":")

	if compiler == "gccgo" {
		t.Skip("golang.org/issue/22500")
	}

	fset := token.NewFileSet()

	t.Run("LookupDefault", func(t *testing.T) {
		imp := ForCompiler(fset, compiler, nil)
		pkg, err := imp.Import(thePackage)

	raddr    string

	mu   sync.Mutex // guards conn
	conn serverConn
}

// This interface and the separate syslog_unix.go file exist for
// Solaris support as implemented by gccgo. On Solaris you cannot
// simply open a TCP connection to the syslog daemon. The gccgo
// sources have a syslog_solaris.go file that implements unixSyslog to
// return a type that satisfies this interface and simply calls the C
// library syslog function.

		s = strings.Replace(s, "MKPOSTIFIPAD", "X__ifi_pad", 1)
		s = strings.Replace(s, "MKPOSTSYSINFOTF", "X_f", 1)

		// Force the type of RawSockaddr.Data to [14]int8 to match
		// the existing gccgo API.
		re = regexp.MustCompile("(Data\\s+\\[14\\])uint8")
		s = re.ReplaceAllString(s, "${1}int8")

	case goos == "freebsd":
		// Keep pre-FreeBSD 10 / non-POSIX 2008 names for timespec fields

stdout '^\tbuild\t-ldflags=example\.com/m=-w$'

go build -trimpath
go version -m m$GOEXE
stdout '\tbuild\t-trimpath=true$'

# gccgoflags are not added when gc is used, and vice versa.
# TODO: test gccgo.
go build -gccgoflags=all=UNUSED
go version -m m$GOEXE
! stdout gccgoflags

# Build and tool tags are added but not release tags.
# "race" is included with build tags but not "cgo".
go build -tags=a,b

}

// isDirective reports whether c is a comment directive.
// See go.dev/issue/37974.
// This code is also in go/ast.
func isDirective(c string) bool {
	// "//line " is a line directive.
	// "//extern " is for gccgo.
	// "//export " is for cgo.
	// (The // has been removed.)
	if strings.HasPrefix(c, "line ") || strings.HasPrefix(c, "extern ") || strings.HasPrefix(c, "export ") {
		return true
	}

	// "//[a-z0-9]+:[a-z0-9]"

// run
//go:build !nacl && !js && !wasip1 && !gccgo

// Copyright 2017 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.

// ensure that panic(x) where x is a numeric type displays a readable number
package main

import (
	"bytes"
	"fmt"
	"io/ioutil"
	"log"
	"os"
	"os/exec"
	"path/filepath"
)

const fn = `
package main

	}

	// sanity check some often mis-used options
	switch cfg.BuildContext.Compiler {
	case "gccgo":
		if load.BuildGcflags.Present() {
			fmt.Println("go build: when using gccgo toolchain, please pass compiler flags using -gccgoflags, not -gcflags")
		}
		if load.BuildLdflags.Present() {
			fmt.Println("go build: when using gccgo toolchain, please pass linker flags using -gccgoflags, not -ldflags")
		}
	case "gc":

import (
	"internal/testenv"
	"os"
	"testing"
)

const testEnvName = "GO_PKGPATH_TEST_COMPILER"

// This init function supports TestToSymbolFunc. For simplicity,
// we use the test binary itself as a sample gccgo driver.
// We set an environment variable to specify how it should behave.
func init() {
	switch os.Getenv(testEnvName) {
	case "":
		return
	case "v1":
		os.Stdout.WriteString(`.string	"go.l__ufer.Run"`)