// run

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

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

// Make sure we don't get an index out of bounds error
// while trying to print a map that is concurrently modified.
// The runtime might complain (throw) if it detects the modification,
// so we have to run the test as a subprocess.

// run

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

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

package main

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

var tmpl = template.Must(template.New("main").Parse(`
package main

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

//go:build linux && gccgo && 386

package unix

import (
	"syscall"
	"unsafe"
)

func seek(fd int, offset int64, whence int) (int64, syscall.Errno) {
	var newoffset int64
	offsetLow := uint32(offset & 0xffffffff)
	offsetHigh := uint32((offset >> 32) & 0xffffffff)

			// path is a resolved package path, not an import path.
			file, ok := cfg.PackageFile[path]
			if !ok {
				if cfg.Compiler == "gccgo" && cfg.Standard[path] {
					return nil, nil // fall back to default gccgo lookup
				}
				return nil, fmt.Errorf("no package file for %q", path)
			}
			return os.Open(file)
		})

[compiler:gccgo] skip 'gccgo does not support -ldflags -X'
env GO111MODULE=off
go build run_go.go

# Apply identity function to GOPATH
exec ./run_go$GOEXE $GOPATH/src/my.pkg/main $GOPATH IDENTITY build -o $WORK/tmp/a.exe -ldflags -X=my.pkg.Text=linkXworked
exec $WORK/tmp/a.exe
stderr 'linkXworked'
rm $WORK/tmp/a.exe

[!GOOS:windows] stop 'rest of the tests only apply to Windows'

# Replace '\' with '/' in GOPATH

env GO111MODULE=off

# smoke test for complex build configuration
go build -o complex.exe complex
[!cross] [exec:gccgo] go build -compiler=gccgo -o complex.exe complex

-- complex/main.go --
package main

import (
	_ "complex/nest/sub/test12"
	_ "complex/nest/sub/test23"
	"complex/w"
	"v"
)

func main() {
	println(v.Hello + " " + w.World)
}

-- complex/nest/sub/test12/p.go --
package test12

// arExportData takes an archive file and returns a ReadSeeker for the
// export data in that file. This assumes that there is only one
// object in the archive containing export data, which is not quite
// what gccgo does; gccgo concatenates together all the export data
// for all the objects in the file.  In practice that case does not arise.
func arExportData(archive io.ReadSeeker) (io.ReadSeeker, error) {

// run

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

// Copyright 2019 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 deadlock detection can still
// run even with an import of "_ os/signal".

package main

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

[compiler:gccgo] skip 'gccgo has no standard packages'
[short] skip

[!GOOS:windows] env NONEXE='.exe'
[GOOS:windows] env NONEXE=''

env GOBIN=$WORK/tmp/bin
go install m/isarchive &

go build x.go
exists -exec x$GOEXE
rm x$GOEXE
! exists x$NONEXE

go build -o myprog x.go
! exists x
! exists x.exe
exists -exec myprog
! exists myprogr.exe

! exists bin
go build -o bin/x x.go
exists -exec bin/x
rm bin

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

package gccgoimporter

import (
	"bufio"
	"go/types"
	"os"
	"os/exec"
	"path/filepath"
	"strings"
)

// Information about a specific installation of gccgo.
type GccgoInstallation struct {
	// Version of gcc (e.g. 4.8.0).
	GccVersion string

	// Target triple (e.g. x86_64-unknown-linux-gnu).
	TargetTriple string

	// Built-in library paths used by this installation.