// compile

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

// Gccgo used to give an error:
// <built-in>: error: redefinition of ‘s$F$hash’
// <built-in>: note: previous definition of ‘s$F$hash’ was here
// <built-in>: error: redefinition of ‘s$F$equal’
// <built-in>: note: previous definition of ‘s$F$equal’ was here

package p

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

// PR61204: Making temporaries for zero-sized types caused an ICE in gccgo.
// This is a reduction of a program reported by GoSmith.

package main

func main() {
	type t [0]int
	var v t
	v, _ = [0]int{}, 0
	_ = v

// 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 code due to failing to finalize
// interfaces in the right order.

package p

type s1 struct {
	f m
	I
}

type m interface {
	Mm(*s2)
}

type s2 struct {
	*s1
}

type I interface {
	MI()

// errorcheck

// 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 code was incorrectly accepted by gccgo.

package main

type N string
type M string

const B N = "B"
const C M = "C"

func main() {
	q := B + C // ERROR "mismatched types|incompatible types"
	println(q)

// Copyright 2013 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 gccgo

#include "_cgo_export.h"
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

/* Test calling panic from C.  This is what SWIG does.  */

extern void _cgo_panic(const char *);
extern void *_cgo_allocate(size_t);

void
callPanic(void)
{

// compile

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

// Issue 10047: gccgo failed to compile a type switch where the switch variable
// and the base type of a case share the same identifier.

package main

func main() {
	type t int
	var p interface{}
	switch t := p.(type) {
	case t:
		_ = t
	}

// errorcheck

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

// Issue 21770: gccgo incorrectly accepts "p.f = 0" where p is **struct

package p

type PP **struct{ f int }

func f() {
	// anonymous type
	var p **struct{ f int }
	p.f = 0 // ERROR "field"
	// named type
	var p2 PP
	p2.f = 0 // ERROR "field"

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

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

func main() {
	// adjust precision depending on compiler
	var prec float64
	switch runtime.Compiler {
	case "gc":
		prec = math.Inf(1) // exact precision using rational arithmetic
	case "gccgo":
		prec = 256
	default:
		// unknown compiler
		return
	}
	p := 1 - math.Log(math.Abs(ulp))/math.Log(2)
	if math.Abs(p-prec) > 1e-10 {
		fmt.Printf("BUG: got %g; want %g\n", p, prec)
	}

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

// PR61265: The gccgo middle-end failed to represent array composite literals
// where the elements are zero-sized values.
// This is a reduction of a program reported by GoSmith.

package p

var a = [1][0]int{B}[0]
var B = [0]int{}
var c = [1]struct{}{D}[0]