// compile

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

// Failed to compile with gccgo.

package p

import "unsafe"

const w int = int(unsafe.Sizeof(0))

// compile

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

// Crashed gccgo.

package p

type S struct {
	f interface{}
}

func F(p *S) bool {
	v := p.f
	switch a := v.(type) {
	case nil:
		_ = a
		return true
	}
	return true

// compile

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

// Issue 20923: gccgo failed to compile parenthesized select case expressions.

package p

func F(c chan bool) {
	select {
	case (<-c):
	case _ = (<-c):
	case _, _ = (<-c):
	case (c) <- true:
	default:
	}

// compile

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

// gccgo crashed compiling this file, due to failing to correctly emit
// the type descriptor for a named alias.

package p

type entry = struct {
	a, b, c int
}

[compiler:gccgo] skip # gccgo assumes cross-compilation is always possible

env GOOS=windwos # intentional misspelling of windows

! go build -n exclude

[compiler:gccgo] skip 'gccgo has no standard packages'
go build -tags 'tag1 tag2' math
! go build -tags 'tag1,tag2 tag3' math

	atomic.AddUint32(&Sink, 1)
	for time.Since(start) < dt {
		// When using gccgo the loop of mutex operations is
		// not preemptible. This can cause the loop to block a GC,
		// causing the time limits in TestDeltaContentionz to fail.
		// Since this loop is not very realistic, when using
		// gccgo add preemption points 100 times a second.
		t1 := time.Now()

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Using the same unexported name for a method as a method on an
// imported embedded type caused a gccgo compilation failure.

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

# Test coverage on cgo code.

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

-- go.mod --
module cgocover

go 1.16
-- p.go --
package p

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

var b bool

func F() {
	if b {
		for {
		}
	}
	C.f()
}
-- p_test.go --

// compile

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

// https://gcc.gnu.org/PR89321
// gccgo compiler crash building map literals with a zero-sized value type.

package p

type M map[byte]struct{}

var (
	M1 = M{1: {}, 2: {}, 3: {}}
	M2 = M{1: {}, 2: {}}