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

// gccgo did not permit omitting the type of a composite literal
// element when one of the middle omitted types was a pointer type.

package p

type S []T
type T struct { x int }

var _ = map[string]*S{
	"a": {
		{ 1 },
	},
}

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

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

// Checks to make sure that the compiler can catch a specific invalid
// method type expression. NB: gccgo and gc have slightly different
// error messages, hence the generic test for 'method' and not something
// more specific.

package issue15722

type T int
type P *T

func (T) t() {}

func _(p P) {

[compiler:gccgo] skip # gccgo has no cover tool

! go test -n importmain/test
stderr 'not an importable package' # check that import main was detected
! go test -n -cover importmain/test
stderr 'not an importable package' # check that import main was detected

-- go.mod --
module importmain

go 1.16
-- ismain/main.go --
package main

import _ "importmain/test"

func main() {}
-- test/test.go --
package test

// run

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

// Issue 33062: gccgo generates incorrect type equality
// functions.

package main

type simpleStruct struct {
	int
	string
}

type complexStruct struct {
	int
	simpleStruct
}

func main() {
	x := complexStruct{1, simpleStruct{2, "xxx"}}

# Check errors.test mtime is updated
exec $GOBIN/now
cp stdout start_time.txt
go test -x -c -test.bench=XXX errors
! stderr '[\\/]link|gccgo' # make sure up-to-date test binary is not relinked
exec $GOBIN/mtime errors.test$GOEXE
cp stdout errors1_mod_time.txt
exec $GOBIN/before start_time.txt errors1_mod_time.txt
rm start_time.txt errors1_mod_time.txt

// run

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

// Gccgo got a compiler crash compiling the addition of more than five
// strings with mixed constants and variables.

package main

func F(s string) (string, error) {
	return s, nil
}

func G(a, b, c string) (string, error) {
	return F("a" + a + "b" + b + "c" + c)
}

// run

// 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 23545: gccgo didn't lower array comparison to
// proper equality function in some case.

package main

func main() {
	if a := Get(); a != dummyID(1234) {
		panic("FAIL")
	}
}

func dummyID(x int) [Size]interface{} {
	var out [Size]interface{}

// 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 incorrectly executed functions multiple times when they
// appeared in a composite literal that required a conversion between
// different interface types.

package main

type MyInt int

var c MyInt

func (c *MyInt) S(i int) {
	*c = MyInt(i)
}