--- /dev/null
+// errorcheck
+
+// 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.
+
+package main
+
+var (
+ a, b = f() // ERROR "initialization loop|depends upon itself|depend upon each other"
+ c = b // GCCGO_ERROR "depends upon itself|depend upon each other"
+)
+
+func f() (int, int) {
+ return c, c
+}
+
+func main() {}
--- /dev/null
+// run
+
+// 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.
+
+// Test for golang.org/issue/19403.
+// F15 should not be clobbered by float-to-int conversion on ARM.
+// This test requires enough locals that can be put in registers that the compiler can choose to use F15.
+package main
+
+var count float32 = 16
+var i0 int
+var i1 int
+var i2 int
+var i3 int
+var i4 int
+var i5 int
+var i6 int
+var i7 int
+var i8 int
+var i9 int
+var i10 int
+var i11 int
+var i12 int
+var i13 int
+var i14 int
+var i15 int
+var i16 int
+
+func main() {
+ var f0 float32 = 0.0
+ var f1 float32 = 1.0
+ var f2 float32 = 2.0
+ var f3 float32 = 3.0
+ var f4 float32 = 4.0
+ var f5 float32 = 5.0
+ var f6 float32 = 6.0
+ var f7 float32 = 7.0
+ var f8 float32 = 8.0
+ var f9 float32 = 9.0
+ var f10 float32 = 10.0
+ var f11 float32 = 11.0
+ var f12 float32 = 12.0
+ var f13 float32 = 13.0
+ var f14 float32 = 14.0
+ var f15 float32 = 15.0
+ var f16 float32 = 16.0
+ i0 = int(f0)
+ i1 = int(f1)
+ i2 = int(f2)
+ i3 = int(f3)
+ i4 = int(f4)
+ i5 = int(f5)
+ i6 = int(f6)
+ i7 = int(f7)
+ i8 = int(f8)
+ i9 = int(f9)
+ i10 = int(f10)
+ i11 = int(f11)
+ i12 = int(f12)
+ i13 = int(f13)
+ i14 = int(f14)
+ i15 = int(f15)
+ i16 = int(f16)
+ if f16 != count {
+ panic("fail")
+ }
+ count -= 1
+ if f15 != count {
+ panic("fail")
+ }
+ count -= 1
+ if f14 != count {
+ panic("fail")
+ }
+ count -= 1
+ if f13 != count {
+ panic("fail")
+ }
+ count -= 1
+ if f12 != count {
+ panic("fail")
+ }
+ count -= 1
+ if f11 != count {
+ panic("fail")
+ }
+ count -= 1
+ if f10 != count {
+ panic("fail")
+ }
+ count -= 1
+ if f9 != count {
+ panic("fail")
+ }
+ count -= 1
+ if f8 != count {
+ panic("fail")
+ }
+ count -= 1
+ if f7 != count {
+ panic("fail")
+ }
+ count -= 1
+ if f6 != count {
+ panic("fail")
+ }
+ count -= 1
+ if f5 != count {
+ panic("fail")
+ }
+ count -= 1
+ if f4 != count {
+ panic("fail")
+ }
+ count -= 1
+ if f3 != count {
+ panic("fail")
+ }
+ count -= 1
+ if f2 != count {
+ panic("fail")
+ }
+ count -= 1
+ if f1 != count {
+ panic("fail")
+ }
+ count -= 1
+ if f0 != count {
+ panic("fail")
+ }
+ count -= 1
+}
--- /dev/null
+// Copyright 2011 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.
+
+package main
+
+import (
+ "flag"
+ "os"
+ "runtime"
+ "testing"
+
+ fast "./fast"
+ slow "./slow"
+)
+
+var buf = make([]byte, 1048576)
+
+func BenchmarkFastNonASCII(b *testing.B) {
+ for i := 0; i < b.N; i++ {
+ fast.NonASCII(buf, 0)
+ }
+}
+
+func BenchmarkSlowNonASCII(b *testing.B) {
+ for i := 0; i < b.N; i++ {
+ slow.NonASCII(buf, 0)
+ }
+}
+
+func main() {
+ testing.Init()
+ os.Args = []string{os.Args[0], "-test.benchtime=100ms"}
+ flag.Parse()
+
+ rslow := testing.Benchmark(BenchmarkSlowNonASCII)
+ rfast := testing.Benchmark(BenchmarkFastNonASCII)
+ tslow := rslow.NsPerOp()
+ tfast := rfast.NsPerOp()
+
+ // Optimization should be good for at least 2x, but be forgiving.
+ // On the ARM simulator we see closer to 1.5x.
+ speedup := float64(tslow) / float64(tfast)
+ want := 1.8
+ if runtime.GOARCH == "arm" {
+ want = 1.3
+ }
+ if speedup < want {
+ // TODO(rsc): doesn't work on linux-amd64 or darwin-amd64 builders, nor on
+ // a Lenovo x200 (linux-amd64) laptop.
+ // println("fast:", tfast, "slow:", tslow, "speedup:", speedup, "want:", want)
+ // println("not fast enough")
+ // os.Exit(1)
+ }
+}
--- /dev/null
+// 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.
+
+// Test for a garbage collection bug involving not
+// marking x as having its address taken by &x[0]
+// when x is an array value.
+
+package main
+
+import (
+ "bytes"
+ "fmt"
+ "runtime"
+)
+
+func main() {
+ var x = [4]struct{ x, y interface{} }{
+ {"a", "b"},
+ {"c", "d"},
+ {"e", "f"},
+ {"g", "h"},
+ }
+
+ var buf bytes.Buffer
+ for _, z := range x {
+ runtime.GC()
+ fmt.Fprintf(&buf, "%s %s ", z.x.(string), z.y.(string))
+ }
+
+ if buf.String() != "a b c d e f g h " {
+ println("BUG wrong output\n", buf.String())
+ }
+}
--- /dev/null
+// 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.
+
+// The liveness code used to say that, in func g, s was live
+// starting at its declaration, because it appears to have its
+// address taken by the closure (different s, but the parser
+// gets slightly confused, a separate bug). The liveness analysis
+// saw s as having its address taken but the register optimizer
+// did not. This mismatch meant that s would be marked live
+// (and therefore initialized) at the call to f, but the register optimizer
+// would optimize away the initialization of s before f, causing the
+// garbage collector to use unused data.
+// The register optimizer has been changed to respect the
+// same "address taken" flag that the liveness analysis uses,
+// even if it cannot see any address being taken in the actual
+// machine code. This is conservative but keeps the two consistent,
+// which is the most important thing.
+
+package main
+
+import "runtime"
+
+//go:noinline
+func f() interface{} {
+ runtime.GC()
+ return nil
+}
+
+//go:noinline
+func g() {
+ var s interface{}
+ _ = func() {
+ s := f()
+ _ = s
+ }
+ s = f()
+ useiface(s)
+ useiface(s)
+}
+
+//go:noinline
+func useiface(x interface{}) {
+}
+
+//go:noinline
+func h() {
+ var x [16]uintptr
+ for i := range x {
+ x[i] = 1
+ }
+
+ useint(x[0])
+ useint(x[1])
+ useint(x[2])
+ useint(x[3])
+}
+
+//go:noinline
+func useint(x uintptr) {
+}
+
+func main() {
+ // scribble non-zero values on stack
+ h()
+ // call function that used to let the garbage collector
+ // see uninitialized stack values; it will see the
+ // nonzero values.
+ g()
+}
+
+func big(x int) {
+ if x >= 0 {
+ big(x - 1)
+ }
+}
--- /dev/null
+// 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)
+}
+
+type A struct {
+ embedded
+}
+
+type B struct {
+ A
+ embedded
+}
+
+func main() {
+ b := &B{
+ A: A{
+ embedded: "a",
+ },
+ embedded: "b",
+ }
+ s := b.val()
+ if s != "b" {
+ panic(s)
+ }
+}
--- /dev/null
+// 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.
+
+// The gccgo lexer had a bug handling nested comments.
+// http://gcc.gnu.org/PR61746
+// http://code.google.com/p/gofrontend/issues/detail?id=35
+
+package main
+
+/*// comment
+*/
--- /dev/null
+// 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.
+
+// The gccgo compiler used to crash building a comparison between an
+// interface and an empty struct literal.
+
+package p
+
+type S struct{}
+
+func F(v interface{}) bool {
+ return v == S{}
+}
--- /dev/null
+// 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.
+
+// Test order of calls to builtin functions.
+// Discovered during CL 144530045 review.
+
+package main
+
+func main() {
+ // append
+ {
+ x := make([]int, 0)
+ f := func() int { x = make([]int, 2); return 2 }
+ a, b, c := append(x, 1), f(), append(x, 1)
+ if len(a) != 1 || len(c) != 3 {
+ bug()
+ println("append call not ordered:", len(a), b, len(c))
+ }
+ }
+
+ // cap
+ {
+ x := make([]int, 1)
+ f := func() int { x = make([]int, 3); return 2 }
+ a, b, c := cap(x), f(), cap(x)
+ if a != 1 || c != 3 {
+ bug()
+ println("cap call not ordered:", a, b, c)
+ }
+ }
+
+ // complex
+ {
+ x := 1.0
+ f := func() int { x = 3; return 2 }
+ a, b, c := complex(x, 0), f(), complex(x, 0)
+ if real(a) != 1 || real(c) != 3 {
+ bug()
+ println("complex call not ordered:", a, b, c)
+ }
+ }
+
+ // copy
+ {
+ tmp := make([]int, 100)
+ x := make([]int, 1)
+ f := func() int { x = make([]int, 3); return 2 }
+ a, b, c := copy(tmp, x), f(), copy(tmp, x)
+ if a != 1 || c != 3 {
+ bug()
+ println("copy call not ordered:", a, b, c)
+ }
+ }
+
+ // imag
+ {
+ x := 1i
+ f := func() int { x = 3i; return 2 }
+ a, b, c := imag(x), f(), imag(x)
+ if a != 1 || c != 3 {
+ bug()
+ println("imag call not ordered:", a, b, c)
+ }
+ }
+
+ // len
+ {
+ x := make([]int, 1)
+ f := func() int { x = make([]int, 3); return 2 }
+ a, b, c := len(x), f(), len(x)
+ if a != 1 || c != 3 {
+ bug()
+ println("len call not ordered:", a, b, c)
+ }
+ }
+
+ // make
+ {
+ x := 1
+ f := func() int { x = 3; return 2 }
+ a, b, c := make([]int, x), f(), make([]int, x)
+ if len(a) != 1 || len(c) != 3 {
+ bug()
+ println("make call not ordered:", len(a), b, len(c))
+ }
+ }
+
+ // real
+ {
+ x := 1 + 0i
+ f := func() int { x = 3; return 2 }
+ a, b, c := real(x), f(), real(x)
+ if a != 1 || c != 3 {
+ bug()
+ println("real call not ordered:", a, b, c)
+ }
+ }
+}
+
+var bugged = false
+
+func bug() {
+ if !bugged {
+ println("BUG")
+ bugged = true
+ }
+}
\ No newline at end of file
--- /dev/null
+// 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 incorrect error
+// bug495.go:16:2: error: missing statement after label
+
+package p
+
+func F(i int) {
+ switch i {
+ case 0:
+ goto lab
+ lab:
+ fallthrough
+ case 1:
+ }
+}
--- /dev/null
+// 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 incorrectly rejected an assignment to multiple instances of
+// the same variable.
+
+package main
+
+var a int
+
+func F() {
+ a, a, a = 1, 2, 3
+}
+
+func main() {
+ F()
+ if a != 3 {
+ panic(a)
+ }
+}
--- /dev/null
+// Copyright 2020 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.
+
+package a
+
+import "reflect"
+
+type A = map[int] bool
+
+func F() interface{} {
+ return reflect.New(reflect.TypeOf((*A)(nil))).Elem().Interface()
+}
--- /dev/null
+// Copyright 2020 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.
+
+package main
+
+import "./a"
+
+func main() {
+ _, ok := a.F().(*map[int]bool)
+ if !ok {
+ panic("bad type")
+ }
+}
--- /dev/null
+// rundir
+
+// Copyright 2020 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 confused type descriptors for aliases.
+
+package ignored
projects / gcc.git / commitdiff