Imports are processed by importing directly from the source of
imported packages (default), or by importing from compiled and
installed packages (by setting -c to the respective compiler).

The -c flag must be set to a compiler ("gc", "gccgo") when type-
checking packages containing imports with relative import paths
(import "./mypkg") because the source importer cannot know which
files to include for such packages.

Usage:

	gotype [flags] [path...]

[short] skip
[!cgo] skip
[compiler:gccgo] skip # gccgo has no cover tool

# Test coverage on cgo code. This test case has an external
# test that tests the code and an in-package test file with
# no test cases.

go test -short -cover cgocover3
stdout  'coverage:.*[1-9][0-9.]+%'
! stderr '[^0-9]0\.0%'

-- go.mod --
module cgocover3

go 1.16
-- p.go --
package p

/*
void
f(void)
{
}
*/
import "C"

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

# Check go test -cpuprofile creates errors.test
go test -cpuprofile errors.prof errors
exists -exec errors.test$GOEXE

# Check go test -cpuprofile -o myerrors.test creates errors.test
go test -cpuprofile errors.prof -o myerrors.test$GOEXE errors
exists -exec myerrors.test$GOEXE

# Check go test -mutexprofile creates errors.test
go test -mutexprofile errors.prof errors

// errorcheck

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

// The gccgo compiler did not reliably report mismatches between the
// number of function results and the number of expected results.

package p

func G() (int, int, int) {
	return 0, 0, 0
}

func F() {
	a, b := G()	// ERROR "mismatch|cannot initialize"

//compile

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

// Gccgo had a bug comparing a struct or array value with an interface
// values, when the struct or array was not addressable.

package p

type A [10]int

type S struct {
	i int
}

func F1() S {
	return S{0}
}

func F2() A {
	return A{}
}

//
// Equal is equivalent to bytes.Equal.
// It is provided here for convenience,
// because some packages cannot depend on bytes.
func Equal(a, b []byte) bool {
	// Neither cmd/compile nor gccgo allocates for these string conversions.
	// There is a test for this in package bytes.
	return string(a) == string(b)

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

// This is a copy of the file generated during the gccgo build process.
// Last update 2019-01-22.

package types

var gccgoArchSizes = map[string]*StdSizes{
	"386":         {4, 4},
	"alpha":       {8, 8},
	"amd64":       {8, 8},
	"amd64p32":    {4, 8},

// run

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

// Gccgo did not make a copy of a value receiver when using a
// goroutine to call a method.

package main

import (
	"sync"
	"sync/atomic"
)

var wg sync.WaitGroup

type S struct {
	i1, i2 int32
}

var done int32

	switch v := vals[0].(type) {
	case string:
		_ = v
	}
}

type R struct{ *T }

type Q interface {
	Foo([]interface{})
}

func main() {
	var count = 10000
	if runtime.Compiler == "gccgo" {
		// On targets without split-stack libgo allocates
		// a large stack for each goroutine. On 32-bit
		// systems this test can run out of memory.
		const intSize = 32 << (^uint(0) >> 63) // 32 or 64
		if intSize < 64 {

		// If it's windows, don't show the .exe suffix.
		name = strings.TrimSuffix(strings.ToLower(name), cfg.ToolExeSuffix())

		// The tool directory used by gccgo will have other binaries
		// in addition to go tools. Only display go tools here.
		if cfg.BuildToolchainName == "gccgo" && !isGccgoTool(name) {
			continue
		}
		fmt.Println(name)
	}
}

func impersonateDistList(args []string) (handled bool) {