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)

// terminated with a semicolon. No semicolon is present for the labeled
// statements and because the last token is a colon ":", no semicolon is
// inserted automatically.
//
// Both gccgo and gofmt correctly refuse this program as is and accept it
// when the semicolons are present.

// This is a test case for issue 777 ( https://golang.org/issue/777 ).

package main

func main() {
	switch 0 {

// run

// 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 chose the wrong embedded method when the same type appeared
// at different levels and the correct choice was not the first
// appearance of the type in a depth-first search.

package main

type embedded string

func (s embedded) val() string {
	return string(s)

		// 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) {

// 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},