cmp -q paths-a.exe paths-b.exe


# Same sequence of tests but with gccgo.
# gccgo does not support builds in module mode.
[!exec:gccgo] stop
[cross] stop  # gccgo can't necessarily cross-compile
env GOPATH=$WORK/a

# A binary built with gccgo without -trimpath should contain the current
# GOPATH and GOROOT.
go build -compiler=gccgo -o paths-dbg.exe paths
exec ./paths-dbg.exe paths-dbg.exe

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

// For bootstrapping with gccgo.

//go:build gccgo

package abi

import "unsafe"

func FuncPCABI0(f interface{}) uintptr {
	words := (*[2]unsafe.Pointer)(unsafe.Pointer(&f))
	return *(*uintptr)(unsafe.Pointer(words[1]))
}

func FuncPCABIInternal(f interface{}) uintptr {

var fromToolchainTests = []testCase1[string, string]{
	{"go1.2.3", "1.2.3"},
	{"1.2.3", ""},
	{"go1.2.3+bigcorp", ""},
	{"go1.2.3-bigcorp", "1.2.3"},
	{"go1.2.3-bigcorp more text", "1.2.3"},
	{"gccgo-go1.23rc4", ""},
	{"gccgo-go1.23rc4-bigdwarf", ""},

		cfg.BuildContext.InstallSuffix += "_"
	}
	cfg.BuildContext.InstallSuffix += mode
	cfg.BuildContext.ToolTags = append(cfg.BuildContext.ToolTags, mode)
}

func buildModeInit() {
	gccgo := cfg.BuildToolchainName == "gccgo"
	var codegenArg string

	// Configure the build mode first, then verify that it is supported.
	// That way, if the flag is completely bogus we will prefer to error out with

// doesn't go into the Go runtime.

// wasm does not work, because the linear memory is not executable.

// This test doesn't work on gccgo/GoLLVM, because they will not find
// any unwind information for the artificial function, and will not be
// able to unwind past that point.

//go:build !windows && !wasm && !gccgo

# It should not pass --nosuchoption to the external linker.

[!cgo] skip

go build

[!exec:gccgo] skip

# TODO: remove once gccgo on builder is updated
[GOOS:aix] [GOARCH:ppc64] skip

go build -compiler gccgo

-- go.mod --
module m
-- cgo.go --
package main
// #cgo LDFLAGS: -L "./ -Wl,--nosuchoption"
import "C"

		runImporterTest(t, imp, initmap, &test)
	}
}

// gccgoPath returns a path to gccgo if it is present (either in
// path or specified via GCCGO environment variable), or an
// empty string if no gccgo is available.
func gccgoPath() string {
	gccgoname := os.Getenv("GCCGO")
	if gccgoname == "" {
		gccgoname = "gccgo"
	}
	if gpath, gerr := exec.LookPath(gccgoname); gerr == nil {
		return gpath
	}

// run

// Does not work with gccgo, which uses a smaller (but still permitted)
// exponent size.
//go:build !gccgo

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

package main

// Tests for golang.org/issue/11326.

func main() {
	{
		const n = 1e646456992
		const d = 1e646456991
		x := n / d
		if x != 10.0 {

// Package pkgpath determines the package path used by gccgo/GoLLVM symbols.
// This package is not used for the gc compiler.
package pkgpath

import (
	"bytes"
	"errors"
	"fmt"
	"os"
	"os/exec"
	"strings"
)

// ToSymbolFunc returns a function that may be used to convert a
// package path into a string suitable for use as a symbol.
// cmd is the gccgo/GoLLVM compiler in use, and tmpdir is a temporary

		perror("sigaction");
		return 2;
	}
	if (osa.sa_handler == SIG_DFL) {
		fprintf(stderr, "Go runtime did not install signal handler\n");
		return 2;
	}
	// gccgo does not set SA_ONSTACK for SIGSEGV.
	if (getenv("GCCGO") == NULL && (osa.sa_flags&SA_ONSTACK) == 0) {
		fprintf(stderr, "Go runtime did not install signal handler\n");
		return 2;
	}
	oldHandler = osa.sa_sigaction;

	return 0;
}