Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified
📁 ..	-	2025-05-25 12:27
📄 235.go // run // Copyright 2009 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. // Solve the 2,3,5 problem (print all numbers with 2, 3, or 5 as factor) using channels. // Test the solution, silently. package main type T chan uint64 func M(f uint64) (in, out T) { in = make(T, 100) out = make(T, 100) go func(in, out T, f uint64) { for { out <- f*<-in } }(in, out, f) return in, out } func min(xs []uint64) uint64 { m := xs[0] for i := 1; i < len(xs); i++ { if xs[i] < m { m = xs[i] } } return m } func main() { F := []uint64{2, 3, 5} var n = len(F) OUT := []uint64{ 2, 3, 4, 5, 6, 8, 9, 10, 12, 15, 16, 18, 20, 24, 25, 27, 30, 32, 36, 40, 45, 48, 50, 54, 60, 64, 72, 75, 80, 81, 90, 96, 100, 108, 120, 125, 128, 135, 144, 150, 160, 162, 180, 192, 200, 216, 225, 240, 243, 250, 256, 270, 288, 300, 320, 324, 360, 375, 384, 400, 405, 432, 450, 480, 486, 500, 512, 540, 576, 600, 625, 640, 648, 675, 720, 729, 750, 768, 800, 810, 864, 900, 960, 972, 1000, 1024, 1080, 1125, 1152, 1200, 1215, 1250, 1280, 1296, 1350, 1440, 1458, 1500, 1536, 1600} x := uint64(1) ins := make([]T, n) outs := make([]T, n) xs := make([]uint64, n) for i := 0; i < n; i++ { ins[i], outs[i] = M(F[i]) xs[i] = x } for i := 0; i < len(OUT); i++ { for i := 0; i < n; i++ { ins[i] <- x } for i := 0; i < n; i++ { if xs[i] == x { xs[i] = <-outs[i] } } x = min(xs) if x != OUT[i] { println("bad: ", x, " should be ", OUT[i]) panic("235") } } }	1.56 KB	2024-02-02 18:09
📄 64bit.go // runoutput // Copyright 2009 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. // Generate test of 64-bit arithmetic. // Most synthesized routines have different cases for // constants vs variables and even the generated code has // different cases for large and small constants, // so try a good range of inputs. package main import ( "bufio" "fmt" "os" ) var bout bufio.Writer // 64-bit math without using 64-bit numbers, // so that we can generate the test program even // if the compiler has buggy or missing 64-bit support. type Uint64 struct { hi uint32 lo uint32 } type Int64 struct { hi int32 lo uint32 } func (a Uint64) Int64() (c Int64) { c.hi = int32(a.hi) c.lo = a.lo return } func (a Uint64) Cmp(b Uint64) int { switch { case a.hi < b.hi: return -1 case a.hi > b.hi: return 1 case a.lo < b.lo: return -1 case a.lo > b.lo: return 1 } return 0 } func (a Uint64) LeftShift(b uint) (c Uint64) { switch { case b >= 64: c.hi = 0 c.lo = 0 case b >= 32: c.hi = a.lo << (b - 32) c.lo = 0 default: c.hi = a.hi<<b \| a.lo>>(32-b) c.lo = a.lo << b } return } func (a Uint64) RightShift(b uint) (c Uint64) { switch { case b >= 64: c.hi = 0 c.lo = a.hi case b >= 32: c.hi = 0 c.lo = a.hi >> (b - 32) default: c.hi = a.hi >> b c.lo = a.hi<<(32-b) \| a.lo>>b } return } func (a Uint64) LeftShift64(b Uint64) (c Uint64) { if b.hi != 0 \|\| b.lo >= 64 { return } return a.LeftShift(uint(b.lo)) } func (a Uint64) RightShift64(b Uint64) (c Uint64) { if b.hi != 0 \|\| b.lo >= 64 { return } return a.RightShift(uint(b.lo)) } func (a Uint64) Plus(b Uint64) (c Uint64) { var carry uint32 if c.lo = a.lo + b.lo; c.lo < a.lo { carry = 1 } c.hi = a.hi + b.hi + carry return } func (a Uint64) Minus(b Uint64) (c Uint64) { var borrow uint32 if c.lo = a.lo - b.lo; c.lo > a.lo { borrow = 1 } c.hi = a.hi - b.hi - borrow return } func (a Uint64) Neg() (c Uint64) { var zero Uint64 return zero.Minus(a) } func (a Uint64) Com() (c Uint64) { c.hi = ^a.hi c.lo = ^a.lo return } func (a Uint64) Len() int { switch { case a.hi != 0: for i := 31; i >= 0; i-- { if a.hi&(1<<uint(i)) != 0 { return i + 1 + 32 } } case a.lo != 0: for i := 31; i >= 0; i-- { if a.lo&(1<<uint(i)) != 0 { return i + 1 } } } return 0 } func (a Uint64) HasBit(b uint) bool { switch { case b >= 64: return false case b >= 32: return a.hi&(1<<(b-32)) != 0 } return a.lo&(1<<b) != 0 } func (a Uint64) Times(b Uint64) (c Uint64) { for i := uint(0); i < 64; i++ { if b.HasBit(i) { c = c.Plus(a.LeftShift(i)) } } return } func (a Uint64) DivMod(b Uint64) (quo, rem Uint64) { n := a.Len() - b.Len() if n >= 0 { b = b.LeftShift(uint(n)) for i := 0; i <= n; i++ { quo = quo.LeftShift(1) if b.Cmp(a) <= 0 { // b <= a quo.lo \|= 1 a = a.Minus(b) } b = b.RightShift(1) } } rem = a return } func (a Uint64) And(b Uint64) (c Uint64) { c.hi = a.hi & b.hi c.lo = a.lo & b.lo return } func (a Uint64) AndNot(b Uint64) (c Uint64) { c.hi = a.hi &^ b.hi c.lo = a.lo &^ b.lo return } func (a Uint64) Or(b Uint64) (c Uint64) { c.hi = a.hi \| b.hi c.lo = a.lo \| b.lo return } func (a Uint64) Xor(b Uint64) (c Uint64) { c.hi = a.hi ^ b.hi c.lo = a.lo ^ b.lo return } func (a Uint64) String() string { return fmt.Sprintf("%#x%08x", a.hi, a.lo) } func (a Int64) Uint64() (c Uint64) { c.hi = uint32(a.hi) c.lo = a.lo return } func (a Int64) Cmp(b Int64) int { // Same body as Uint64.Cmp, // but behaves differently // because hi is uint32 not int32. switch { case a.hi < b.hi: return -1 case a.hi > b.hi: return 1 case a.lo < b.lo: return -1 case a.lo > b.lo: return 1 } return 0 } func (a Int64) LeftShift(b uint) (c Int64) { return a.Uint64().LeftShift(b).Int64() } func (a Int64) RightShift(b uint) (c Int64) { switch { case b >= 64: c.hi = a.hi >> 31 // sign extend c.lo = uint32(c.hi) case b >= 32: c.hi = a.hi >> 31 // sign extend c.lo = uint32(a.hi >> (b - 32)) default: c.hi = a.hi >> b c.lo = uint32(a.hi<<(32-b)) \| a.lo>>b } return } func (a Int64) LeftShift64(b Uint64) (c Int64) { if b.hi != 0 \|\| b.lo >= 64 { return } return a.LeftShift(uint(b.lo)) } func (a Int64) RightShift64(b Uint64) (c Int64) { if b.hi != 0 \|\| b.lo >= 64 { return a.RightShift(64) } return a.RightShift(uint(b.lo)) } func (a Int64) Plus(b Int64) (c Int64) { return a.Uint64().Plus(b.Uint64()).Int64() } func (a Int64) Minus(b Int64) (c Int64) { return a.Uint64().Minus(b.Uint64()).Int64() } func (a Int64) Neg() (c Int64) { return a.Uint64().Neg().Int64() } func (a Int64) Com() (c Int64) { return a.Uint64().Com().Int64() } func (a Int64) Times(b Int64) (c Int64) { return a.Uint64().Times(b.Uint64()).Int64() } func (a Int64) DivMod(b Int64) (quo Int64, rem Int64) { var zero Int64 quoSign := +1 remSign := +1 if a.Cmp(zero) < 0 { quoSign = -1 remSign = -1 a = a.Neg() } if b.Cmp(zero) < 0 { quoSign = -quoSign b = b.Neg() } q, r := a.Uint64().DivMod(b.Uint64()) quo = q.Int64() rem = r.Int64() if quoSign < 0 { quo = quo.Neg() } if remSign < 0 { rem = rem.Neg() } return } func (a Int64) And(b Int64) (c Int64) { return a.Uint64().And(b.Uint64()).Int64() } func (a Int64) AndNot(b Int64) (c Int64) { return a.Uint64().AndNot(b.Uint64()).Int64() } func (a Int64) Or(b Int64) (c Int64) { return a.Uint64().Or(b.Uint64()).Int64() } func (a Int64) Xor(b Int64) (c Int64) { return a.Uint64().Xor(b.Uint64()).Int64() } func (a Int64) String() string { if a.hi < 0 { return fmt.Sprintf("-%s", a.Neg().Uint64()) } return a.Uint64().String() } var int64Values = []Int64{ Int64{0, 0}, Int64{0, 1}, Int64{0, 2}, Int64{0, 3}, Int64{0, 100}, Int64{0, 10001}, Int64{0, 1<<31 - 1}, Int64{0, 1 << 31}, Int64{0, 1<<31 + 1}, Int64{0, 1<<32 - 1<<30}, Int64{0, 1<<32 - 1}, Int64{1, 0}, Int64{1, 1}, Int64{2, 0}, Int64{1<<31 - 1, 1<<32 - 10000}, Int64{1<<31 - 1, 1<<32 - 1}, Int64{0x789abcde, 0xf0123456}, Int64{-1, 1<<32 - 1}, Int64{-1, 1<<32 - 2}, Int64{-1, 1<<32 - 3}, Int64{-1, 1<<32 - 100}, Int64{-1, 1<<32 - 10001}, Int64{-1, 1<<32 - (1<<31 - 1)}, Int64{-1, 1<<32 - 1<<31}, Int64{-1, 1<<32 - (1<<31 + 1)}, Int64{-1, 1<<32 - (1<<32 - 1<<30)}, Int64{-1, 0}, Int64{-1, 1}, Int64{-2, 0}, Int64{-(1 << 31), 10000}, Int64{-(1 << 31), 1}, Int64{-(1 << 31), 0}, Int64{-0x789abcde, 0xf0123456}, } var uint64Values = []Uint64{ Uint64{0, 0}, Uint64{0, 1}, Uint64{0, 2}, Uint64{0, 3}, Uint64{0, 100}, Uint64{0, 10001}, Uint64{0, 1<<31 - 1}, Uint64{0, 1 << 31}, Uint64{0, 1<<31 + 1}, Uint64{0, 1<<32 - 1<<30}, Uint64{0, 1<<32 - 1}, Uint64{1, 0}, Uint64{1, 1}, Uint64{2, 0}, Uint64{1<<31 - 1, 1<<32 - 10000}, Uint64{1<<31 - 1, 1<<32 - 1}, Uint64{1<<32 - 1<<30, 0}, Uint64{1<<32 - 1, 0}, Uint64{1<<32 - 1, 1<<32 - 100}, Uint64{1<<32 - 1, 1<<32 - 1}, Uint64{0x789abcde, 0xf0123456}, Uint64{0xfedcba98, 0x76543210}, } var shiftValues = []Uint64{ Uint64{0, 0}, Uint64{0, 1}, Uint64{0, 2}, Uint64{0, 3}, Uint64{0, 15}, Uint64{0, 16}, Uint64{0, 17}, Uint64{0, 31}, Uint64{0, 32}, Uint64{0, 33}, Uint64{0, 61}, Uint64{0, 62}, Uint64{0, 63}, Uint64{0, 64}, Uint64{0, 65}, Uint64{0, 1<<32 - 1}, Uint64{1, 0}, Uint64{1, 1}, Uint64{1 << 28, 0}, Uint64{1 << 31, 0}, Uint64{1<<32 - 1, 0}, Uint64{1<<32 - 1, 1<<32 - 1}, } var ntest = 0 // Part 1 is tests of variable operations; generic functions // called by repetitive code. Could make a table but not worth it. const prolog = "\n" + "package main\n" + "\n" + "import \"os\"\n" + "\n" + "var ok = true\n" + "\n" + "func testInt64Unary(a, plus, xor, minus int64) {\n" + " if n, op, want := +a, `+`, plus; n != want { ok=false; println(`int64`, op, a, `=`, n, `should be`, want); }\n" + " if n, op, want := ^a, `^`, xor; n != want { ok=false; println(`int64`, op, a, `=`, n, `should be`, want); }\n" + " if n, op, want := -a, `-`, minus; n != want { ok=false; println(`int64`, op, a, `=`, n, `should be`, want); }\n" + "}\n" + "\n" + "func testInt64Binary(a, b, add, sub, mul, div, mod, and, or, xor, andnot int64, dodiv bool) {\n" + " if n, op, want := a + b, `+`, add; n != want { ok=false; println(`int64`, a, op, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a - b, `-`, sub; n != want { ok=false; println(`int64`, a, op, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a b, ``, mul; n != want { ok=false; println(`int64`, a, op, b, `=`, n, `should be`, want); }\n" + " if dodiv {\n" + " if n, op, want := a / b, `/`, div; n != want { ok=false; println(`int64`, a, op, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a % b, `%`, mod; n != want { ok=false; println(`int64`, a, op, b, `=`, n, `should be`, want); }\n" + " }\n" + " if n, op, want := a & b, `&`, and; n != want { ok=false; println(`int64`, a, op, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a \| b, `\|`, or; n != want { ok=false; println(`int64`, a, op, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a ^ b, `^`, xor; n != want { ok=false; println(`int64`, a, op, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a &^ b, `&^`, andnot; n != want { ok=false; println(`int64`, a, op, b, `=`, n, `should be`, want); }\n" + "}\n" + "\n" + "func testInt64Shift(a int64, b uint64, left, right int64) {\n" + " if n, op, s, want := a << b, `<<`, b, left; n != want { ok=false; println(`int64`, a, op, `uint64`, s, `=`, n, `should be`, want); }\n" + " if n, op, s, want := a >> b, `>>`, b, right; n != want { ok=false; println(`int64`, a, op, `uint64`, s, `=`, n, `should be`, want); }\n" + " if uint64(uint(b)) == b {\n" + " b := uint(b);\n" + " if n, op, s, want := a << b, `<<`, b, left; n != want { ok=false; println(`int64`, a, op, `uint`, s, `=`, n, `should be`, want); }\n" + " if n, op, s, want := a >> b, `>>`, b, right; n != want { ok=false; println(`int64`, a, op, `uint`, s, `=`, n, `should be`, want); }\n" + " }\n" + " if uint64(uint32(b)) == b {\n" + " b := uint32(b);\n" + " if n, op, s, want := a << b, `<<`, b, left; n != want { ok=false; println(`int64`, a, op, `uint32`, s, `=`, n, `should be`, want); }\n" + " if n, op, s, want := a >> b, `>>`, b, right; n != want { ok=false; println(`int64`, a, op, `uint32`, s, `=`, n, `should be`, want); }\n" + " }\n" + " if uint64(uint16(b)) == b {\n" + " b := uint16(b);\n" + " if n, op, s, want := a << b, `<<`, b, left; n != want { ok=false; println(`int64`, a, op, `uint16`, s, `=`, n, `should be`, want); }\n" + " if n, op, s, want := a >> b, `>>`, b, right; n != want { ok=false; println(`int64`, a, op, `uint16`, s, `=`, n, `should be`, want); }\n" + " }\n" + " if uint64(uint8(b)) == b {\n" + " b := uint8(b);\n" + " if n, op, s, want := a << b, `<<`, b, left; n != want { ok=false; println(`int64`, a, op, `uint8`, s, `=`, n, `should be`, want); }\n" + " if n, op, s, want := a >> b, `>>`, b, right; n != want { ok=false; println(`int64`, a, op, `uint8`, s, `=`, n, `should be`, want); }\n" + " }\n" + "}\n" + "\n" + "func testUint64Unary(a, plus, xor, minus uint64) {\n" + " if n, op, want := +a, `+`, plus; n != want { ok=false; println(`uint64`, op, a, `=`, n, `should be`, want); }\n" + " if n, op, want := ^a, `^`, xor; n != want { ok=false; println(`uint64`, op, a, `=`, n, `should be`, want); }\n" + " if n, op, want := -a, `-`, minus; n != want { ok=false; println(`uint64`, op, a, `=`, n, `should be`, want); }\n" + "}\n" + "\n" + "func testUint64Binary(a, b, add, sub, mul, div, mod, and, or, xor, andnot uint64, dodiv bool) {\n" + " if n, op, want := a + b, `+`, add; n != want { ok=false; println(`uint64`, a, op, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a - b, `-`, sub; n != want { ok=false; println(`uint64`, a, op, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a b, ``, mul; n != want { ok=false; println(`uint64`, a, op, b, `=`, n, `should be`, want); }\n" + " if dodiv {\n" + " if n, op, want := a / b, `/`, div; n != want { ok=false; println(`uint64`, a, op, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a % b, `%`, mod; n != want { ok=false; println(`uint64`, a, op, b, `=`, n, `should be`, want); }\n" + " }\n" + " if n, op, want := a & b, `&`, and; n != want { ok=false; println(`uint64`, a, op, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a \| b, `\|`, or; n != want { ok=false; println(`uint64`, a, op, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a ^ b, `^`, xor; n != want { ok=false; println(`uint64`, a, op, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a &^ b, `&^`, andnot; n != want { ok=false; println(`uint64`, a, op, b, `=`, n, `should be`, want); }\n" + "}\n" + "\n" + "func testUint64Shift(a, b, left, right uint64) {\n" + " if n, op, s, want := a << b, `<<`, b, left; n != want { ok=false; println(`uint64`, a, op, `uint64`, s, `=`, n, `should be`, want); }\n" + " if n, op, s, want := a >> b, `>>`, b, right; n != want { ok=false; println(`uint64`, a, op, `uint64`, s, `=`, n, `should be`, want); }\n" + " if uint64(uint(b)) == b {\n" + " b := uint(b);\n" + " if n, op, s, want := a << b, `<<`, b, left; n != want { ok=false; println(`uint64`, a, op, `uint`, s, `=`, n, `should be`, want); }\n" + " if n, op, s, want := a >> b, `>>`, b, right; n != want { ok=false; println(`uint64`, a, op, `uint`, s, `=`, n, `should be`, want); }\n" + " }\n" + " if uint64(uint32(b)) == b {\n" + " b := uint32(b);\n" + " if n, op, s, want := a << b, `<<`, b, left; n != want { ok=false; println(`uint64`, a, op, `uint32`, s, `=`, n, `should be`, want); }\n" + " if n, op, s, want := a >> b, `>>`, b, right; n != want { ok=false; println(`uint64`, a, op, `uint32`, s, `=`, n, `should be`, want); }\n" + " }\n" + " if uint64(uint16(b)) == b {\n" + " b := uint16(b);\n" + " if n, op, s, want := a << b, `<<`, b, left; n != want { ok=false; println(`uint64`, a, op, `uint16`, s, `=`, n, `should be`, want); }\n" + " if n, op, s, want := a >> b, `>>`, b, right; n != want { ok=false; println(`uint64`, a, op, `uint16`, s, `=`, n, `should be`, want); }\n" + " }\n" + " if uint64(uint8(b)) == b {\n" + " b := uint8(b);\n" + " if n, op, s, want := a << b, `<<`, b, left; n != want { ok=false; println(`uint64`, a, op, `uint8`, s, `=`, n, `should be`, want); }\n" + " if n, op, s, want := a >> b, `>>`, b, right; n != want { ok=false; println(`uint64`, a, op, `uint8`, s, `=`, n, `should be`, want); }\n" + " }\n" + "}\n" + "\n" func varTests() { fmt.Fprint(bout, prolog) for _, a := range int64Values { fmt.Fprintf(bout, "func test%v() {\n", ntest) ntest++ fmt.Fprintf(bout, "\ttestInt64Unary(%v, %v, %v, %v);\n", a, a, a.Com(), a.Neg()) for _, b := range int64Values { var div, mod Int64 dodiv := false var zero Int64 if b.Cmp(zero) != 0 { // b != 0 // Can't divide by zero but also can't divide -0x8000...000 by -1. var bigneg = Int64{-0x80000000, 0} var minus1 = Int64{-1, ^uint32(0)} if a.Cmp(bigneg) != 0 \|\| b.Cmp(minus1) != 0 { // a != -1<<63 \|\| b != -1 div, mod = a.DivMod(b) dodiv = true } } fmt.Fprintf(bout, "\ttestInt64Binary(%v, %v, %v, %v, %v, %v, %v, %v, %v, %v, %v, %v);\n", a, b, a.Plus(b), a.Minus(b), a.Times(b), div, mod, a.And(b), a.Or(b), a.Xor(b), a.AndNot(b), dodiv) } for _, b := range shiftValues { fmt.Fprintf(bout, "\ttestInt64Shift(%v, %v, %v, %v);\n", a, b, a.LeftShift64(b), a.RightShift64(b)) } fmt.Fprintf(bout, "}\n") } for _, a := range uint64Values { fmt.Fprintf(bout, "func test%v() {\n", ntest) ntest++ fmt.Fprintf(bout, "\ttestUint64Unary(%v, %v, %v, %v);\n", a, a, a.Com(), a.Neg()) for _, b := range uint64Values { var div, mod Uint64 dodiv := false var zero Uint64 if b.Cmp(zero) != 0 { // b != 0 div, mod = a.DivMod(b) dodiv = true } fmt.Fprintf(bout, "\ttestUint64Binary(%v, %v, %v, %v, %v, %v, %v, %v, %v, %v, %v, %v);\n", a, b, a.Plus(b), a.Minus(b), a.Times(b), div, mod, a.And(b), a.Or(b), a.Xor(b), a.AndNot(b), dodiv) } for _, b := range shiftValues { fmt.Fprintf(bout, "\ttestUint64Shift(%v, %v, %v, %v);\n", a, b, a.LeftShift64(b), a.RightShift64(b)) } fmt.Fprintf(bout, "}\n") } } // Part 2 is tests of operations involving one variable and one constant. const binaryConstL = "func test%vBinaryL%v(b, add, sub, mul, div, mod, and, or, xor, andnot %v, dodiv bool) {\n" + " const a %v = %v;\n" + " const typ = `%s`;\n" + " if n, op, want := a + b, `+`, add; n != want { ok=false; println(typ, `const`, a, op, `var`, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a - b, `-`, sub; n != want { ok=false; println(typ, `const`, a, op, `var`, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a b, ``, mul; n != want { ok=false; println(typ, `const`, a, op, `var`, b, `=`, n, `should be`, want); }\n" + " if dodiv {\n" + " if n, op, want := a / b, `/`, div; n != want { ok=false; println(typ, `const`, a, op, `var`, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a %% b, `%%`, mod; n != want { ok=false; println(typ, `const`, a, op, `var`, b, `=`, n, `should be`, want); }\n" + " }\n" + " if n, op, want := a & b, `&`, and; n != want { ok=false; println(typ, `const`, a, op, `var`, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a \| b, `\|`, or; n != want { ok=false; println(typ, `const`, a, op, `var`, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a ^ b, `^`, xor; n != want { ok=false; println(typ, `const`, a, op, `var`, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a &^ b, `&^`, andnot; n != want { ok=false; println(typ, `const`, a, op, `var`, b, `=`, n, `should be`, want); }\n" + "}\n" + "\n" const binaryConstR = "func test%vBinaryR%v(a, add, sub, mul, div, mod, and, or, xor, andnot %v, dodiv bool) {\n" + " const b %v = %v;\n" + " const typ = `%s`;\n" + " if n, op, want := a + b, `+`, add; n != want { ok=false; println(typ, `var`, a, op, `const`, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a - b, `-`, sub; n != want { ok=false; println(typ, `var`, a, op, `const`, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a b, ``, mul; n != want { ok=false; println(typ, `var`, a, op, `const`, b, `=`, n, `should be`, want); }\n" + " if dodiv {\n" + " if n, op, want := a / b, `/`, div; n != want { ok=false; println(typ, `var`, a, op, `const`, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a %% b, `%%`, mod; n != want { ok=false; println(typ, `var`, a, op, `const`, b, `=`, n, `should be`, want); }\n" + " }\n" + " if n, op, want := a & b, `&`, and; n != want { ok=false; println(typ, `var`, a, op, `const`, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a \| b, `\|`, or; n != want { ok=false; println(typ, `var`, a, op, `const`, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a ^ b, `^`, xor; n != want { ok=false; println(typ, `var`, a, op, `const`, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a &^ b, `&^`, andnot; n != want { ok=false; println(typ, `var`, a, op, `const`, b, `=`, n, `should be`, want); }\n" + "}\n" + "\n" const binaryConstR0 = "func test%vBinaryR%v(a, add, sub, mul, div, mod, and, or, xor, andnot %v, dodiv bool) {\n" + " const b %v = %v;\n" + " const typ = `%s`;\n" + " if n, op, want := a + b, `+`, add; n != want { ok=false; println(typ, `var`, a, op, `const`, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a - b, `-`, sub; n != want { ok=false; println(typ, `var`, a, op, `const`, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a b, `*`, mul; n != want { ok=false; println(typ, `var`, a, op, `const`, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a & b, `&`, and; n != want { ok=false; println(typ, `var`, a, op, `const`, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a \| b, `\|`, or; n != want { ok=false; println(typ, `var`, a, op, `const`, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a ^ b, `^`, xor; n != want { ok=false; println(typ, `var`, a, op, `const`, b, `=`, n, `should be`, want); }\n" + " if n, op, want := a &^ b, `&^`, andnot; n != want { ok=false; println(typ, `var`, a, op, `const`, b, `=`, n, `should be`, want); }\n" + "}\n" + "\n" const shiftConstL = "func test%vShiftL%v(b uint64, left, right %v) {\n" + " const a %v = %v;\n" + " const typ = `%s`;\n" + " if n, op, s, want := a << b, `<<`, b, left; n != want { ok=false; println(typ, `const`, a, op, `var`, s, `=`, n, `should be`, want); }\n" + " if n, op, s, want := a >> b, `>>`, b, right; n != want { ok=false; println(typ, `const`, a, op, `var`, s, `=`, n, `should be`, want); }\n" + " if uint64(uint32(b)) == b {\n" + " b := uint32(b);\n" + " if n, op, s, want := a << b, `<<`, b, left; n != want { ok=false; println(typ, `const`, a, op, `var`, s, `=`, n, `should be`, want); }\n" + " if n, op, s, want := a >> b, `>>`, b, right; n != want { ok=false; println(typ, `const`, a, op, `var`, s, `=`, n, `should be`, want); }\n" + " }\n" + "}\n" const shiftConstR = "func test%vShiftR%v(a, left, right %v) {\n" + " const b uint64 = %v;\n" + " const typ = `%s`;\n" + " if n, op, s, want := a << b, `<<`, b, left; n != want { ok=false; println(typ, `var`, a, op, `const`, s, `=`, n, `should be`, want); }\n" + " if n, op, s, want := a >> b, `>>`, b, right; n != want { ok=false; println(typ, `var`, a, op, `const`, s, `=`, n, `should be`, want); }\n" + " if b & 0xffffffff == b {\n" + " const b = uint32(b & 0xffffffff);\n" + " if n, op, s, want := a << b, `<<`, b, left; n != want { ok=false; println(typ, `var`, a, op, `const`, s, `=`, n, `should be`, want); }\n" + " if n, op, s, want := a >> b, `>>`, b, right; n != want { ok=false; println(typ, `var`, a, op, `const`, s, `=`, n, `should be`, want); }\n" + " }\n" + "}\n" func constTests() { for i, a := range int64Values { fmt.Fprintf(bout, binaryConstL, "Int64", i, "int64", "int64", a, "int64") if a.hi == 0 && a.lo == 0 { fmt.Fprintf(bout, binaryConstR0, "Int64", i, "int64", "int64", a, "int64") } else { fmt.Fprintf(bout, binaryConstR, "Int64", i, "int64", "int64", a, "int64") } fmt.Fprintf(bout, shiftConstL, "Int64", i, "int64", "int64", a, "int64") } for i, a := range uint64Values { fmt.Fprintf(bout, binaryConstL, "Uint64", i, "uint64", "uint64", a, "uint64") if a.hi == 0 && a.lo == 0 { fmt.Fprintf(bout, binaryConstR0, "Uint64", i, "uint64", "uint64", a, "uint64") } else { fmt.Fprintf(bout, binaryConstR, "Uint64", i, "uint64", "uint64", a, "uint64") } fmt.Fprintf(bout, shiftConstL, "Uint64", i, "uint64", "uint64", a, "uint64") } for i, a := range shiftValues { fmt.Fprintf(bout, shiftConstR, "Int64", i, "int64", a, "int64") fmt.Fprintf(bout, shiftConstR, "Uint64", i, "uint64", a, "uint64") } for i, a := range int64Values { fmt.Fprintf(bout, "func test%v() {\n", ntest) ntest++ for j, b := range int64Values { var div, mod Int64 dodiv := false var zero Int64 if b.Cmp(zero) != 0 { // b != 0 // Can't divide by zero but also can't divide -0x8000...000 by -1. var bigneg = Int64{-0x80000000, 0} var minus1 = Int64{-1, ^uint32(0)} if a.Cmp(bigneg) != 0 \|\| b.Cmp(minus1) != 0 { // a != -1<<63 \|\| b != -1 div, mod = a.DivMod(b) dodiv = true } } fmt.Fprintf(bout, "\ttestInt64BinaryL%v(%v, %v, %v, %v, %v, %v, %v, %v, %v, %v, %v);\n", i, b, a.Plus(b), a.Minus(b), a.Times(b), div, mod, a.And(b), a.Or(b), a.Xor(b), a.AndNot(b), dodiv) fmt.Fprintf(bout, "\ttestInt64BinaryR%v(%v, %v, %v, %v, %v, %v, %v, %v, %v, %v, %v);\n", j, a, a.Plus(b), a.Minus(b), a.Times(b), div, mod, a.And(b), a.Or(b), a.Xor(b), a.AndNot(b), dodiv) } for j, b := range shiftValues { fmt.Fprintf(bout, "\ttestInt64ShiftL%v(%v, %v, %v);\n", i, b, a.LeftShift64(b), a.RightShift64(b)) fmt.Fprintf(bout, "\ttestInt64ShiftR%v(%v, %v, %v);\n", j, a, a.LeftShift64(b), a.RightShift64(b)) } fmt.Fprintf(bout, "}\n") } for i, a := range uint64Values { fmt.Fprintf(bout, "func test%v() {\n", ntest) ntest++ for j, b := range uint64Values { var div, mod Uint64 dodiv := false var zero Uint64 if b.Cmp(zero) != 0 { // b != 0 div, mod = a.DivMod(b) dodiv = true } fmt.Fprintf(bout, "\ttestUint64BinaryL%v(%v, %v, %v, %v, %v, %v, %v, %v, %v, %v, %v);\n", i, b, a.Plus(b), a.Minus(b), a.Times(b), div, mod, a.And(b), a.Or(b), a.Xor(b), a.AndNot(b), dodiv) fmt.Fprintf(bout, "\ttestUint64BinaryR%v(%v, %v, %v, %v, %v, %v, %v, %v, %v, %v, %v);\n", j, a, a.Plus(b), a.Minus(b), a.Times(b), div, mod, a.And(b), a.Or(b), a.Xor(b), a.AndNot(b), dodiv) } for j, b := range shiftValues { fmt.Fprintf(bout, "\ttestUint64ShiftL%v(%v, %v, %v);\n", i, b, a.LeftShift64(b), a.RightShift64(b)) fmt.Fprintf(bout, "\ttestUint64ShiftR%v(%v, %v, %v);\n", j, a, a.LeftShift64(b), a.RightShift64(b)) } fmt.Fprintf(bout, "}\n") } } func main() { bout = bufio.NewWriter(os.Stdout) varTests() constTests() fmt.Fprintf(bout, "func main() {\n") for i := 0; i < ntest; i++ { fmt.Fprintf(bout, "\ttest%v();\n", i) } fmt.Fprintf(bout, "\tif !ok { os.Exit(1) }\n") fmt.Fprintf(bout, "}\n") bout.Flush() }	24.83 KB	2024-02-02 18:09
📄 README.md The test directory contains tests of the Go tool chain and runtime. It includes black box tests, regression tests, and error output tests. They are run as part of all.bash. To run just these tests, execute: ../bin/go test cmd/internal/testdir To run just tests from specified files in this directory, execute: ../bin/go test cmd/internal/testdir -run='Test/(file1.go\|file2.go\|...)' Standard library tests should be written as regular Go tests in the appropriate package. The tool chain and runtime also have regular Go tests in their packages. The main reasons to add a new test to this directory are: * it is most naturally expressed using the test runner; or * it is also applicable to `gccgo` and other Go tool chains.	731 B	2024-02-02 18:09
📁 abi	-	2024-02-02 18:09
📄 alg.go // build // 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. // This file tests that required algs are generated, // even when similar types have been marked elsewhere // as not needing algs. See CLs 19769 and 19770. package main import "fmt" //go:noinline func f(m map[[8]string]int) int { var k [8]string return m[k] } //go:noinline func g(m map[[8]interface{}]int) int { var k [8]interface{} return m[k] } //go:noinline func h(m map[[2]string]int) int { var k [2]string return m[k] } type T map[string]interface{} func v(x ...string) string { return x[0] + x[1] } func main() { fmt.Println( f(map[[8]string]int{}), g(map[[8]interface{}]int{}), h(map[[2]string]int{}), v("a", "b"), ) }	822 B	2024-02-02 18:09
📄 alias.go // errorcheck // 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. // Test that error messages say what the source file says // (uint8 vs byte, int32 vs. rune). // Does not compile. package main import ( "fmt" "unicode/utf8" ) func f(byte) {} func g(uint8) {} func main() { var x float64 f(x) // ERROR "byte" g(x) // ERROR "uint8" // Test across imports. var ff fmt.Formatter var fs fmt.State ff.Format(fs, x) // ERROR "rune" utf8.RuneStart(x) // ERROR "byte" }	588 B	2024-02-02 18:09
📄 alias1.go // run // 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. // Test that dynamic interface checks treat byte=uint8 // and rune=int or rune=int32. package main func main() { var x interface{} x = byte(1) switch x.(type) { case uint8: // ok default: panic("byte != uint8") } x = uint8(2) switch x.(type) { case byte: // ok default: panic("uint8 != byte") } rune32 := false x = rune(3) switch x.(type) { case int: // ok case int32: // must be new code rune32 = true default: panic("rune != int and rune != int32") } if rune32 { x = int32(4) } else { x = int(5) } switch x.(type) { case rune: // ok default: panic("int (or int32) != rune") } }	803 B	2024-02-02 18:09
📄 alias2.go // errorcheck // 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. // Test basic restrictions on type aliases. package p import ( "reflect" . "reflect" ) type T0 struct{} // Valid type alias declarations. type _ = T0 type _ = int type _ = struct{} type _ = reflect.Value type _ = Value type ( A0 = T0 A1 = int A2 = struct{} A3 = reflect.Value A4 = Value A5 = Value N0 A0 ) // Methods can be declared on the original named type and the alias. func (T0) m1() {} // GCCGO_ERROR "previous" func (T0) m1() {} // ERROR "method redeclared: T0\.m1\|T0\.m1 already declared\|redefinition of .m1." func (A0) m1() {} // ERROR "T0\.m1 already declared\|redefinition of .m1." func (A0) m1() {} // ERROR "T0\.m1 already declared\|redefinition of .m1." func (A0) m2() {} // Type aliases and the original type name can be used interchangeably. var _ A0 = T0{} var _ T0 = A0{} // But aliases and original types cannot be used with new types based on them. var _ N0 = T0{} // ERROR "cannot use T0{} $value of type T0$ as N0 value in variable declaration" var _ N0 = A0{} // ERROR "cannot use A0{} $value of type T0$ as N0 value in variable declaration" var _ A5 = Value{} var _ interface { m1() m2() } = T0{} var _ interface { m1() m2() } = A0{} func _() { type _ = T0 type _ = int type _ = struct{} type _ = reflect.Value type _ = Value type ( A0 = T0 A1 = int A2 = struct{} A3 = reflect.Value A4 = Value A5 Value N0 A0 ) var _ A0 = T0{} var _ T0 = A0{} var _ N0 = T0{} // ERROR "cannot use T0{} $value of type T0$ as N0 value in variable declaration" var _ N0 = A0{} // ERROR "cannot use A0{} $value of type T0$ as N0 value in variable declaration" var _ A5 = Value{} // ERROR "cannot use Value{} $value of type reflect\.Value$ as A5 value in variable declaration" } // Invalid type alias declarations. type _ = reflect.ValueOf // ERROR "reflect.ValueOf .is not a type\|expected type" func (A1) m() {} // ERROR "cannot define new methods on non-local type int\|may not define methods on non-local type" func (A2) m() {} // ERROR "invalid receiver type" func (A3) m() {} // ERROR "cannot define new methods on non-local type reflect.Value\|may not define methods on non-local type" func (A4) m() {} // ERROR "cannot define new methods on non-local type reflect.Value\|may not define methods on non-local type" type B1 = struct{} func (B1) m() {} // ERROR "invalid receiver type" // TODO(gri) expand	2.5 KB	2024-02-02 18:09
📁 alias3.dir	-	2024-02-02 18:09
📄 alias3.go // rundir // 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. package ignored	187 B	2024-02-02 18:09
📄 align.go // 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. package main // On 32-bit archs, one of the f fields of a [2]T // will be unaligned (address of 4 mod 8). // Make sure we can access the f fields successfully, // particularly for load-add combo instructions // introduced by CL 102036. type T struct { pad uint32 f float64 } //go:noinline func f(t, u *T) float64 { return 3.0 + t.f + u.f } func main() { t := [2]T{{0, 1.0}, {0, 2.0}} sink = f(&t[0], &t[1]) } var sink float64	603 B	2024-02-02 18:09
📄 append.go // run // Copyright 2010 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. // Semi-exhaustive test for the append predeclared function. package main import ( "fmt" "reflect" ) func verify(name string, result, expected interface{}) { if !reflect.DeepEqual(result, expected) { panic(name) } } func main() { for _, t := range tests { verify(t.name, t.result, t.expected) } verifyStruct() verifyInterface() verifyType() } var ( zero int = 0 one int = 1 ) var tests = []struct { name string result, expected interface{} }{ {"bool a", append([]bool{}), []bool{}}, {"bool b", append([]bool{}, true), []bool{true}}, {"bool c", append([]bool{}, true, false, true, true), []bool{true, false, true, true}}, {"bool d", append([]bool{true, false, true}), []bool{true, false, true}}, {"bool e", append([]bool{true, false, true}, false), []bool{true, false, true, false}}, {"bool f", append([]bool{true, false, true}, false, false, false), []bool{true, false, true, false, false, false}}, {"bool g", append([]bool{}, []bool{true}...), []bool{true}}, {"bool h", append([]bool{}, []bool{true, false, true, false}...), []bool{true, false, true, false}}, {"bool i", append([]bool{true, false, true}, []bool{true}...), []bool{true, false, true, true}}, {"bool j", append([]bool{true, false, true}, []bool{true, true, true}...), []bool{true, false, true, true, true, true}}, {"byte a", append([]byte{}), []byte{}}, {"byte b", append([]byte{}, 0), []byte{0}}, {"byte c", append([]byte{}, 0, 1, 2, 3), []byte{0, 1, 2, 3}}, {"byte d", append([]byte{0, 1, 2}), []byte{0, 1, 2}}, {"byte e", append([]byte{0, 1, 2}, 3), []byte{0, 1, 2, 3}}, {"byte f", append([]byte{0, 1, 2}, 3, 4, 5), []byte{0, 1, 2, 3, 4, 5}}, {"byte g", append([]byte{}, []byte{0}...), []byte{0}}, {"byte h", append([]byte{}, []byte{0, 1, 2, 3}...), []byte{0, 1, 2, 3}}, {"byte i", append([]byte{0, 1, 2}, []byte{3}...), []byte{0, 1, 2, 3}}, {"byte j", append([]byte{0, 1, 2}, []byte{3, 4, 5}...), []byte{0, 1, 2, 3, 4, 5}}, {"bytestr a", append([]byte{}, "0"...), []byte("0")}, {"bytestr b", append([]byte{}, "0123"...), []byte("0123")}, {"bytestr c", append([]byte("012"), "3"...), []byte("0123")}, {"bytestr d", append([]byte("012"), "345"...), []byte("012345")}, {"int16 a", append([]int16{}), []int16{}}, {"int16 b", append([]int16{}, 0), []int16{0}}, {"int16 c", append([]int16{}, 0, 1, 2, 3), []int16{0, 1, 2, 3}}, {"int16 d", append([]int16{0, 1, 2}), []int16{0, 1, 2}}, {"int16 e", append([]int16{0, 1, 2}, 3), []int16{0, 1, 2, 3}}, {"int16 f", append([]int16{0, 1, 2}, 3, 4, 5), []int16{0, 1, 2, 3, 4, 5}}, {"int16 g", append([]int16{}, []int16{0}...), []int16{0}}, {"int16 h", append([]int16{}, []int16{0, 1, 2, 3}...), []int16{0, 1, 2, 3}}, {"int16 i", append([]int16{0, 1, 2}, []int16{3}...), []int16{0, 1, 2, 3}}, {"int16 j", append([]int16{0, 1, 2}, []int16{3, 4, 5}...), []int16{0, 1, 2, 3, 4, 5}}, {"uint32 a", append([]uint32{}), []uint32{}}, {"uint32 b", append([]uint32{}, 0), []uint32{0}}, {"uint32 c", append([]uint32{}, 0, 1, 2, 3), []uint32{0, 1, 2, 3}}, {"uint32 d", append([]uint32{0, 1, 2}), []uint32{0, 1, 2}}, {"uint32 e", append([]uint32{0, 1, 2}, 3), []uint32{0, 1, 2, 3}}, {"uint32 f", append([]uint32{0, 1, 2}, 3, 4, 5), []uint32{0, 1, 2, 3, 4, 5}}, {"uint32 g", append([]uint32{}, []uint32{0}...), []uint32{0}}, {"uint32 h", append([]uint32{}, []uint32{0, 1, 2, 3}...), []uint32{0, 1, 2, 3}}, {"uint32 i", append([]uint32{0, 1, 2}, []uint32{3}...), []uint32{0, 1, 2, 3}}, {"uint32 j", append([]uint32{0, 1, 2}, []uint32{3, 4, 5}...), []uint32{0, 1, 2, 3, 4, 5}}, {"float64 a", append([]float64{}), []float64{}}, {"float64 b", append([]float64{}, 0), []float64{0}}, {"float64 c", append([]float64{}, 0, 1, 2, 3), []float64{0, 1, 2, 3}}, {"float64 d", append([]float64{0, 1, 2}), []float64{0, 1, 2}}, {"float64 e", append([]float64{0, 1, 2}, 3), []float64{0, 1, 2, 3}}, {"float64 f", append([]float64{0, 1, 2}, 3, 4, 5), []float64{0, 1, 2, 3, 4, 5}}, {"float64 g", append([]float64{}, []float64{0}...), []float64{0}}, {"float64 h", append([]float64{}, []float64{0, 1, 2, 3}...), []float64{0, 1, 2, 3}}, {"float64 i", append([]float64{0, 1, 2}, []float64{3}...), []float64{0, 1, 2, 3}}, {"float64 j", append([]float64{0, 1, 2}, []float64{3, 4, 5}...), []float64{0, 1, 2, 3, 4, 5}}, {"complex128 a", append([]complex128{}), []complex128{}}, {"complex128 b", append([]complex128{}, 0), []complex128{0}}, {"complex128 c", append([]complex128{}, 0, 1, 2, 3), []complex128{0, 1, 2, 3}}, {"complex128 d", append([]complex128{0, 1, 2}), []complex128{0, 1, 2}}, {"complex128 e", append([]complex128{0, 1, 2}, 3), []complex128{0, 1, 2, 3}}, {"complex128 f", append([]complex128{0, 1, 2}, 3, 4, 5), []complex128{0, 1, 2, 3, 4, 5}}, {"complex128 g", append([]complex128{}, []complex128{0}...), []complex128{0}}, {"complex128 h", append([]complex128{}, []complex128{0, 1, 2, 3}...), []complex128{0, 1, 2, 3}}, {"complex128 i", append([]complex128{0, 1, 2}, []complex128{3}...), []complex128{0, 1, 2, 3}}, {"complex128 j", append([]complex128{0, 1, 2}, []complex128{3, 4, 5}...), []complex128{0, 1, 2, 3, 4, 5}}, {"string a", append([]string{}), []string{}}, {"string b", append([]string{}, "0"), []string{"0"}}, {"string c", append([]string{}, "0", "1", "2", "3"), []string{"0", "1", "2", "3"}}, {"string d", append([]string{"0", "1", "2"}), []string{"0", "1", "2"}}, {"string e", append([]string{"0", "1", "2"}, "3"), []string{"0", "1", "2", "3"}}, {"string f", append([]string{"0", "1", "2"}, "3", "4", "5"), []string{"0", "1", "2", "3", "4", "5"}}, {"string g", append([]string{}, []string{"0"}...), []string{"0"}}, {"string h", append([]string{}, []string{"0", "1", "2", "3"}...), []string{"0", "1", "2", "3"}}, {"string i", append([]string{"0", "1", "2"}, []string{"3"}...), []string{"0", "1", "2", "3"}}, {"string j", append([]string{"0", "1", "2"}, []string{"3", "4", "5"}...), []string{"0", "1", "2", "3", "4", "5"}}, {"make a", append([]string{}, make([]string, 0)...), []string{}}, {"make b", append([]string(nil), make([]string, 0)...), []string(nil)}, {"make c", append([]struct{}{}, make([]struct{}, 0)...), []struct{}{}}, {"make d", append([]struct{}{}, make([]struct{}, 2)...), make([]struct{}, 2)}, {"make e", append([]int{0, 1}, make([]int, 0)...), []int{0, 1}}, {"make f", append([]int{0, 1}, make([]int, 2)...), []int{0, 1, 0, 0}}, {"make g", append([]int{&zero, &one}, make([]int, 0)...), []int{&zero, &one}}, {"make h", append([]int{&zero, &one}, make([]int, 2)...), []int{&zero, &one, nil, nil}}, } func verifyStruct() { type T struct { a, b, c string } type S []T e := make(S, 100) for i := range e { e[i] = T{"foo", fmt.Sprintf("%d", i), "bar"} } verify("struct a", append(S{}), S{}) verify("struct b", append(S{}, e[0]), e[0:1]) verify("struct c", append(S{}, e[0], e[1], e[2]), e[0:3]) verify("struct d", append(e[0:1]), e[0:1]) verify("struct e", append(e[0:1], e[1]), e[0:2]) verify("struct f", append(e[0:1], e[1], e[2], e[3]), e[0:4]) verify("struct g", append(e[0:3]), e[0:3]) verify("struct h", append(e[0:3], e[3]), e[0:4]) verify("struct i", append(e[0:3], e[3], e[4], e[5], e[6]), e[0:7]) for i := range e { verify("struct j", append(S{}, e[0:i]...), e[0:i]) input := make(S, i) copy(input, e[0:i]) verify("struct k", append(input, e[i:]...), e) verify("struct k - input modified", input, e[0:i]) } s := make(S, 10, 20) r := make(S, len(s)+len(e)) for i, x := range e { r[len(s)+i] = x } verify("struct l", append(s), s) verify("struct m", append(s, e...), r) } func verifyInterface() { type T interface{} type S []T e := make(S, 100) for i := range e { switch i % 4 { case 0: e[i] = i case 1: e[i] = "foo" case 2: e[i] = fmt.Sprintf("%d", i) case 3: e[i] = float64(i) } } verify("interface a", append(S{}), S{}) verify("interface b", append(S{}, e[0]), e[0:1]) verify("interface c", append(S{}, e[0], e[1], e[2]), e[0:3]) verify("interface d", append(e[0:1]), e[0:1]) verify("interface e", append(e[0:1], e[1]), e[0:2]) verify("interface f", append(e[0:1], e[1], e[2], e[3]), e[0:4]) verify("interface g", append(e[0:3]), e[0:3]) verify("interface h", append(e[0:3], e[3]), e[0:4]) verify("interface i", append(e[0:3], e[3], e[4], e[5], e[6]), e[0:7]) for i := range e { verify("interface j", append(S{}, e[0:i]...), e[0:i]) input := make(S, i) copy(input, e[0:i]) verify("interface k", append(input, e[i:]...), e) verify("interface k - input modified", input, e[0:i]) } s := make(S, 10, 20) r := make(S, len(s)+len(e)) for i, x := range e { r[len(s)+i] = x } verify("interface l", append(s), s) verify("interface m", append(s, e...), r) } type T1 []int type T2 []int func verifyType() { // The second argument to append has type []E where E is the // element type of the first argument. Test that the compiler // accepts two slice types that meet that requirement but are // not assignment compatible. The return type of append is // the type of the first argument. t1 := T1{1} t2 := T2{2} verify("T1", append(t1, t2...), T1{1, 2}) }	9.09 KB	2024-02-02 18:09
📄 append1.go // 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. // Verify that append arguments requirements are enforced by the // compiler. package main func main() { s := make([]int, 8) _ = append() // ERROR "missing arguments to append\|not enough arguments for append" _ = append(s...) // ERROR "cannot use ... on first argument\|not enough arguments in call to append" _ = append(s, 2, s...) // ERROR "too many arguments to append\|too many arguments in call to append" _ = append(s, make([]int, 0)) // ERROR "cannot use make$\[\]int, 0$ $value of type \[\]int$ as int value in argument to append" _ = append(s, make([]int, -1)...) // ERROR "negative len argument in make\|index -1.* must not be negative" }	856 B	2024-02-02 18:09
📁 arenas	-	2024-02-02 18:09
📄 args.go // run arg1 arg2 // Copyright 2009 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 os.Args. package main import "os" func main() { if len(os.Args) != 3 { panic("argc") } if os.Args[1] != "arg1" { panic("arg1") } if os.Args[2] != "arg2" { panic("arg2") } }	374 B	2024-02-02 18:09
📄 armimm.go // 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. // This file tests the splitting of constants into // multiple immediates on arm. package main import "fmt" const c32a = 0x00aa00dd const c32s = 0x00ffff00 const c64a = 0x00aa00dd55000066 const c64s = 0x00ffff00004fff00 //go:noinline func add32a(x uint32) uint32 { return x + c32a } //go:noinline func add32s(x uint32) uint32 { return x + c32s } //go:noinline func sub32a(x uint32) uint32 { return x - c32a } //go:noinline func sub32s(x uint32) uint32 { return x - c32s } //go:noinline func or32(x uint32) uint32 { return x \| c32a } //go:noinline func xor32(x uint32) uint32 { return x ^ c32a } //go:noinline func subr32a(x uint32) uint32 { return c32a - x } //go:noinline func subr32s(x uint32) uint32 { return c32s - x } //go:noinline func bic32(x uint32) uint32 { return x &^ c32a } //go:noinline func add64a(x uint64) uint64 { return x + c64a } //go:noinline func add64s(x uint64) uint64 { return x + c64s } //go:noinline func sub64a(x uint64) uint64 { return x - c64a } //go:noinline func sub64s(x uint64) uint64 { return x - c64s } //go:noinline func or64(x uint64) uint64 { return x \| c64a } //go:noinline func xor64(x uint64) uint64 { return x ^ c64a } //go:noinline func subr64a(x uint64) uint64 { return c64a - x } //go:noinline func subr64s(x uint64) uint64 { return c64s - x } //go:noinline func bic64(x uint64) uint64 { return x &^ c64a } // Note: x-c gets rewritten to x+(-c), so SUB and SBC are not directly testable. // I disabled that rewrite rule before running this test. func main() { test32() test64() } func test32() { var a uint32 = 0x11111111 var want, got uint32 if want, got = a+c32a, add32a(a); got != want { panic(fmt.Sprintf("add32a(%x) = %x, want %x", a, got, want)) } if want, got = a+c32s, add32s(a); got != want { panic(fmt.Sprintf("add32s(%x) = %x, want %x", a, got, want)) } if want, got = a-c32a, sub32a(a); got != want { panic(fmt.Sprintf("sub32a(%x) = %x, want %x", a, got, want)) } if want, got = a-c32s, sub32s(a); got != want { panic(fmt.Sprintf("sub32s(%x) = %x, want %x", a, got, want)) } if want, got = a\|c32a, or32(a); got != want { panic(fmt.Sprintf("or32(%x) = %x, want %x", a, got, want)) } if want, got = a^c32a, xor32(a); got != want { panic(fmt.Sprintf("xor32(%x) = %x, want %x", a, got, want)) } if want, got = c32a-a, subr32a(a); got != want { panic(fmt.Sprintf("subr32a(%x) = %x, want %x", a, got, want)) } if want, got = c32s-a, subr32s(a); got != want { panic(fmt.Sprintf("subr32s(%x) = %x, want %x", a, got, want)) } if want, got = a&^c32a, bic32(a); got != want { panic(fmt.Sprintf("bic32(%x) = %x, want %x", a, got, want)) } } func test64() { var a uint64 = 0x1111111111111111 var want, got uint64 if want, got = a+c64a, add64a(a); got != want { panic(fmt.Sprintf("add64a(%x) = %x, want %x", a, got, want)) } if want, got = a+c64s, add64s(a); got != want { panic(fmt.Sprintf("add64s(%x) = %x, want %x", a, got, want)) } if want, got = a-c64a, sub64a(a); got != want { panic(fmt.Sprintf("sub64a(%x) = %x, want %x", a, got, want)) } if want, got = a-c64s, sub64s(a); got != want { panic(fmt.Sprintf("sub64s(%x) = %x, want %x", a, got, want)) } if want, got = a\|c64a, or64(a); got != want { panic(fmt.Sprintf("or64(%x) = %x, want %x", a, got, want)) } if want, got = a^c64a, xor64(a); got != want { panic(fmt.Sprintf("xor64(%x) = %x, want %x", a, got, want)) } if want, got = c64a-a, subr64a(a); got != want { panic(fmt.Sprintf("subr64a(%x) = %x, want %x", a, got, want)) } if want, got = c64s-a, subr64s(a); got != want { panic(fmt.Sprintf("subr64s(%x) = %x, want %x", a, got, want)) } if want, got = a&^c64a, bic64(a); got != want { panic(fmt.Sprintf("bic64(%x) = %x, want %x", a, got, want)) } }	3.85 KB	2024-02-02 18:09
📁 asmhdr.dir	-	2024-02-02 18:09
📄 asmhdr.go // buildrundir // Copyright 2021 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 the -asmhdr output of the compiler. package ignored	237 B	2024-02-02 18:09
📄 assign.go // errorcheck // Copyright 2009 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. // Verify simple assignment errors are caught by the compiler. // Does not compile. package main import "sync" type T struct { int sync.Mutex } func main() { { var x, y sync.Mutex x = y // ok _ = x } { var x, y T x = y // ok _ = x } { var x, y [2]sync.Mutex x = y // ok _ = x } { var x, y [2]T x = y // ok _ = x } { x := sync.Mutex{0, 0} // ERROR "assignment.Mutex" _ = x } { x := sync.Mutex{key: 0} // ERROR "(unknown\|assignment).Mutex" _ = x } { x := &sync.Mutex{} // ok var y sync.Mutex // ok y = x // ok x = y // ok _ = x _ = y } { var x = 1 { x, x := 2, 3 // ERROR ".x. repeated on left side of :=\|x redeclared in this block" _ = x } _ = x } { a, a := 1, 2 // ERROR ".a. repeated on left side of :=\|a redeclared in this block" _ = a } }	1.01 KB	2024-02-02 18:09
📄 assign1.go // errorcheck // Copyright 2009 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. // Verify assignment rules are enforced by the compiler. // Does not compile. package main type ( A [10]int B []int C chan int F func() int I interface { m() int } M map[int]int P int S struct { X int } A1 [10]int B1 []int C1 chan int F1 func() int I1 interface { m() int } M1 map[int]int P1 int S1 struct { X int } ) var ( a0 [10]int b0 []int c0 chan int f0 func() int i0 interface { m() int } m0 map[int]int p0 int s0 struct { X int } a A b B c C f F i I m M p P s S a1 A1 b1 B1 c1 C1 f1 F1 i1 I1 m1 M1 p1 P1 s1 S1 pa0 [10]int pb0 []int pc0 chan int pf0 func() int pi0 interface { m() int } pm0 map[int]int pp0 int ps0 struct { X int } pa A pb B pc C pf F pi I pm M pp P ps S pa1 A1 pb1 B1 pc1 C1 pf1 F1 pi1 I1 pm1 M1 pp1 P1 ps1 S1 ) func main() { a0 = a a0 = a1 a = a0 a = a1 // ERROR "cannot use" a1 = a0 a1 = a // ERROR "cannot use" b0 = b b0 = b1 b = b0 b = b1 // ERROR "cannot use" b1 = b0 b1 = b // ERROR "cannot use" c0 = c c0 = c1 c = c0 c = c1 // ERROR "cannot use" c1 = c0 c1 = c // ERROR "cannot use" f0 = f f0 = f1 f = f0 f = f1 // ERROR "cannot use" f1 = f0 f1 = f // ERROR "cannot use" i0 = i i0 = i1 i = i0 i = i1 i1 = i0 i1 = i m0 = m m0 = m1 m = m0 m = m1 // ERROR "cannot use" m1 = m0 m1 = m // ERROR "cannot use" p0 = p p0 = p1 p = p0 p = p1 // ERROR "cannot use" p1 = p0 p1 = p // ERROR "cannot use" s0 = s s0 = s1 s = s0 s = s1 // ERROR "cannot use" s1 = s0 s1 = s // ERROR "cannot use" pa0 = pa // ERROR "cannot use\|incompatible" pa0 = pa1 // ERROR "cannot use\|incompatible" pa = pa0 // ERROR "cannot use\|incompatible" pa = pa1 // ERROR "cannot use\|incompatible" pa1 = pa0 // ERROR "cannot use\|incompatible" pa1 = pa // ERROR "cannot use\|incompatible" pb0 = pb // ERROR "cannot use\|incompatible" pb0 = pb1 // ERROR "cannot use\|incompatible" pb = pb0 // ERROR "cannot use\|incompatible" pb = pb1 // ERROR "cannot use\|incompatible" pb1 = pb0 // ERROR "cannot use\|incompatible" pb1 = pb // ERROR "cannot use\|incompatible" pc0 = pc // ERROR "cannot use\|incompatible" pc0 = pc1 // ERROR "cannot use\|incompatible" pc = pc0 // ERROR "cannot use\|incompatible" pc = pc1 // ERROR "cannot use\|incompatible" pc1 = pc0 // ERROR "cannot use\|incompatible" pc1 = pc // ERROR "cannot use\|incompatible" pf0 = pf // ERROR "cannot use\|incompatible" pf0 = pf1 // ERROR "cannot use\|incompatible" pf = pf0 // ERROR "cannot use\|incompatible" pf = pf1 // ERROR "cannot use\|incompatible" pf1 = pf0 // ERROR "cannot use\|incompatible" pf1 = pf // ERROR "cannot use\|incompatible" pi0 = pi // ERROR "cannot use\|incompatible" pi0 = pi1 // ERROR "cannot use\|incompatible" pi = pi0 // ERROR "cannot use\|incompatible" pi = pi1 // ERROR "cannot use\|incompatible" pi1 = pi0 // ERROR "cannot use\|incompatible" pi1 = pi // ERROR "cannot use\|incompatible" pm0 = pm // ERROR "cannot use\|incompatible" pm0 = pm1 // ERROR "cannot use\|incompatible" pm = pm0 // ERROR "cannot use\|incompatible" pm = pm1 // ERROR "cannot use\|incompatible" pm1 = pm0 // ERROR "cannot use\|incompatible" pm1 = pm // ERROR "cannot use\|incompatible" pp0 = pp // ERROR "cannot use\|incompatible" pp0 = pp1 // ERROR "cannot use\|incompatible" pp = pp0 // ERROR "cannot use\|incompatible" pp = pp1 // ERROR "cannot use\|incompatible" pp1 = pp0 // ERROR "cannot use\|incompatible" pp1 = pp // ERROR "cannot use\|incompatible" ps0 = ps // ERROR "cannot use\|incompatible" ps0 = ps1 // ERROR "cannot use\|incompatible" ps = ps0 // ERROR "cannot use\|incompatible" ps = ps1 // ERROR "cannot use\|incompatible" ps1 = ps0 // ERROR "cannot use\|incompatible" ps1 = ps // ERROR "cannot use\|incompatible" a0 = [10]int(a) a0 = [10]int(a1) a = A(a0) a = A(a1) a1 = A1(a0) a1 = A1(a) b0 = []int(b) b0 = []int(b1) b = B(b0) b = B(b1) b1 = B1(b0) b1 = B1(b) c0 = chan int(c) c0 = chan int(c1) c = C(c0) c = C(c1) c1 = C1(c0) c1 = C1(c) f0 = func() int(f) f0 = func() int(f1) f = F(f0) f = F(f1) f1 = F1(f0) f1 = F1(f) i0 = interface { m() int }(i) i0 = interface { m() int }(i1) i = I(i0) i = I(i1) i1 = I1(i0) i1 = I1(i) m0 = map[int]int(m) m0 = map[int]int(m1) m = M(m0) m = M(m1) m1 = M1(m0) m1 = M1(m) p0 = (int)(p) p0 = (int)(p1) p = P(p0) p = P(p1) p1 = P1(p0) p1 = P1(p) s0 = struct { X int }(s) s0 = struct { X int }(s1) s = S(s0) s = S(s1) s1 = S1(s0) s1 = S1(s) pa0 = ([10]int)(pa) pa0 = ([10]int)(pa1) pa = (A)(pa0) pa = (A)(pa1) pa1 = (A1)(pa0) pa1 = (A1)(pa) pb0 = ([]int)(pb) pb0 = ([]int)(pb1) pb = (B)(pb0) pb = (B)(pb1) pb1 = (B1)(pb0) pb1 = (B1)(pb) pc0 = (chan int)(pc) pc0 = (chan int)(pc1) pc = (C)(pc0) pc = (C)(pc1) pc1 = (C1)(pc0) pc1 = (C1)(pc) pf0 = (func() int)(pf) pf0 = (func() int)(pf1) pf = (F)(pf0) pf = (F)(pf1) pf1 = (F1)(pf0) pf1 = (F1)(pf) pi0 = (interface { m() int })(pi) pi0 = (interface { m() int })(pi1) pi = (I)(pi0) pi = (I)(pi1) pi1 = (I1)(pi0) pi1 = (I1)(pi) pm0 = (map[int]int)(pm) pm0 = (map[int]int)(pm1) pm = (M)(pm0) pm = (M)(pm1) pm1 = (M1)(pm0) pm1 = (M1)(pm) pp0 = (int)(pp) pp0 = (int)(pp1) pp = (P)(pp0) pp = (P)(pp1) pp1 = (P1)(pp0) pp1 = (P1)(pp) ps0 = (struct { X int })(ps) ps0 = (struct { X int })(ps1) ps = (S)(ps0) ps = (S)(ps1) ps1 = (S1)(ps0) ps1 = (S1)(ps) }	5.55 KB	2024-02-02 18:09
📄 atomicload.go // 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. // Check that we do loads exactly once. The SSA backend // once tried to do the load in f twice, once sign extended // and once zero extended. This can cause problems in // racy code, particularly sync/mutex. package main func f(p byte) bool { x := p a := int64(int8(x)) b := int64(uint8(x)) return a == b } func main() { var x byte const N = 1000000 c := make(chan struct{}) go func() { for i := 0; i < N; i++ { x = 1 } c <- struct{}{} }() go func() { for i := 0; i < N; i++ { x = 2 } c <- struct{}{} }() for i := 0; i < N; i++ { if !f(&x) { panic("non-atomic load!") } } <-c <-c }	798 B	2024-02-02 18:09
📄 bigalg.go // run // Copyright 2009 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 the internal "algorithms" for objects larger than a word: hashing, equality etc. package main type T struct { a float64 b int64 c string d byte } var a = []int{1, 2, 3} var NIL []int func arraycmptest() { if NIL != nil { println("fail1:", NIL, "!= nil") panic("bigalg") } if nil != NIL { println("fail2: nil !=", NIL) panic("bigalg") } if a == nil \|\| nil == a { println("fail3:", a, "== nil") panic("bigalg") } } func SameArray(a, b []int) bool { if len(a) != len(b) \|\| cap(a) != cap(b) { return false } if len(a) > 0 && &a[0] != &b[0] { return false } return true } var t = T{1.5, 123, "hello", 255} var mt = make(map[int]T) var ma = make(map[int][]int) func maptest() { mt[0] = t t1 := mt[0] if t1.a != t.a \|\| t1.b != t.b \|\| t1.c != t.c \|\| t1.d != t.d { println("fail: map val struct", t1.a, t1.b, t1.c, t1.d) panic("bigalg") } ma[1] = a a1 := ma[1] if !SameArray(a, a1) { println("fail: map val array", a, a1) panic("bigalg") } } var ct = make(chan T) var ca = make(chan []int) func send() { ct <- t ca <- a } func chantest() { go send() t1 := <-ct if t1.a != t.a \|\| t1.b != t.b \|\| t1.c != t.c \|\| t1.d != t.d { println("fail: map val struct", t1.a, t1.b, t1.c, t1.d) panic("bigalg") } a1 := <-ca if !SameArray(a, a1) { println("fail: map val array", a, a1) panic("bigalg") } } type E struct{} var e E func interfacetest() { var i interface{} i = a a1 := i.([]int) if !SameArray(a, a1) { println("interface <-> []int", a, a1) panic("bigalg") } pa := new([]int) pa = a i = pa a1 = i.([]int) if !SameArray(a, a1) { println("interface <-> []int", a, a1) panic("bigalg") } i = t t1 := i.(T) if t1.a != t.a \|\| t1.b != t.b \|\| t1.c != t.c \|\| t1.d != t.d { println("interface <-> struct", t1.a, t1.b, t1.c, t1.d) panic("bigalg") } i = e e1 := i.(E) // nothing to check; just verify it doesn't crash _ = e1 } func main() { arraycmptest() maptest() chantest() interfacetest() }	2.12 KB	2024-02-02 18:09
📄 bigmap.go // run // Copyright 2009 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. // Internally a map holds elements in up to 255 bytes of key+value. // When key or value or both are too large, it uses pointers to key+value // instead. Test all the combinations. package main func seq(x, y int) [1000]byte { var r [1000]byte for i := 0; i < len(r); i++ { r[i] = byte(x + i*y) } return r } func cmp(x, y [1000]byte) { for i := 0; i < len(x); i++ { if x[i] != y[i] { panic("BUG mismatch") } } } func main() { m := make(map[int][1000]byte) m[1] = seq(11, 13) m[2] = seq(2, 9) m[3] = seq(3, 17) cmp(m[1], seq(11, 13)) cmp(m[2], seq(2, 9)) cmp(m[3], seq(3, 17)) { type T [1]byte type V [1]byte m := make(map[T]V) m[T{}] = V{1} m[T{1}] = V{2} if x, y := m[T{}][0], m[T{1}][0]; x != 1 \|\| y != 2 { println(x, y) panic("bad map") } } { type T [100]byte type V [1]byte m := make(map[T]V) m[T{}] = V{1} m[T{1}] = V{2} if x, y := m[T{}][0], m[T{1}][0]; x != 1 \|\| y != 2 { println(x, y) panic("bad map") } } { type T [1]byte type V [100]byte m := make(map[T]V) m[T{}] = V{1} m[T{1}] = V{2} if x, y := m[T{}][0], m[T{1}][0]; x != 1 \|\| y != 2 { println(x, y) panic("bad map") } } { type T [1000]byte type V [1]byte m := make(map[T]V) m[T{}] = V{1} m[T{1}] = V{2} if x, y := m[T{}][0], m[T{1}][0]; x != 1 \|\| y != 2 { println(x, y) panic("bad map") } } { type T [1]byte type V [1000]byte m := make(map[T]V) m[T{}] = V{1} m[T{1}] = V{2} if x, y := m[T{}][0], m[T{1}][0]; x != 1 \|\| y != 2 { println(x, y) panic("bad map") } } { type T [1000]byte type V [1000]byte m := make(map[T]V) m[T{}] = V{1} m[T{1}] = V{2} if x, y := m[T{}][0], m[T{1}][0]; x != 1 \|\| y != 2 { println(x, y) panic("bad map") } } { type T [200]byte type V [1]byte m := make(map[T]V) m[T{}] = V{1} m[T{1}] = V{2} if x, y := m[T{}][0], m[T{1}][0]; x != 1 \|\| y != 2 { println(x, y) panic("bad map") } } { type T [1]byte type V [200]byte m := make(map[T]V) m[T{}] = V{1} m[T{1}] = V{2} if x, y := m[T{}][0], m[T{1}][0]; x != 1 \|\| y != 2 { println(x, y) panic("bad map") } } { type T [200]byte type V [200]byte m := make(map[T]V) m[T{}] = V{1} m[T{1}] = V{2} if x, y := m[T{}][0], m[T{1}][0]; x != 1 \|\| y != 2 { println(x, y) panic("bad map") } } }	2.46 KB	2024-02-02 18:09
📄 blank.go // run // Copyright 2009 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 behavior of the blank identifier (_). package main import ( "os" "unsafe" ) import _ "fmt" var call string type T struct { _, _, _ int } func (T) _() { } func (T) _() { } type U struct { _ struct{ a, b, c int } } const ( c0 = iota _ _ _ c4 ) var ints = []string{ "1", "2", "3", } func f() (int, int) { call += "f" return 1, 2 } func g() (float64, float64) { call += "g" return 3, 4 } func h(_ int, _ float64) { } func i() int { call += "i" return 23 } var _ = i() func main() { if call != "i" { panic("init did not run") } call = "" _, _ = f() a, _ := f() if a != 1 { panic(a) } b, _ := g() if b != 3 { panic(b) } _, a = f() if a != 2 { panic(a) } _, b = g() if b != 4 { panic(b) } _ = i() if call != "ffgfgi" { panic(call) } if c4 != 4 { panic(c4) } out := "" for _, s := range ints { out += s } if out != "123" { panic(out) } sum := 0 for s := range ints { sum += s } if sum != 3 { panic(sum) } // go.tools/ssa/interp cannot support unsafe.Pointer. if os.Getenv("GOSSAINTERP") == "" { type T1 struct{ x, y, z int } t1 := (T)(unsafe.Pointer(&T1{1, 2, 3})) t2 := (T)(unsafe.Pointer(&T1{4, 5, 6})) if t1 != t2 { panic("T{} != T{}") } var u1, u2 interface{} u1 = (U)(unsafe.Pointer(&T1{1, 2, 3})) u2 = (U)(unsafe.Pointer(&T1{4, 5, 6})) if u1 != u2 { panic("U{} != U{}") } } h(a, b) m() } type I interface { M(_ int, y int) } type TI struct{} func (_ TI) M(x int, y int) { if x != y { println("invalid M call:", x, y) panic("bad M") } } var fp = func(_ int, y int) {} func init() { fp = fp1 } func fp1(x, y int) { if x != y { println("invalid fp1 call:", x, y) panic("bad fp1") } } func m() { var i I i = TI{} i.M(1, 1) i.M(2, 2) fp(1, 1) fp(2, 2) } // useless but legal var _ int = 1 var _ = 2 var _, _ = 3, 4 const _ = 3 const _, _ = 4, 5 type _ int func _() { panic("oops") } func ff() { var _ int = 1 }	2.1 KB	2024-02-02 18:09
📄 blank1.go // errorcheck // Copyright 2009 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 that incorrect uses of the blank identifier are caught. // Does not compile. package _ // ERROR "invalid package name" var t struct { _ int } func (x int) _() { // ERROR "methods on non-local type" println(x) } type T struct { _ []int } func main() { _() // ERROR "cannot use .* as value" x := _+1 // ERROR "cannot use .* as value" _ = x _ = t._ // ERROR "cannot refer to blank field\|invalid use of\|t._ undefined" var v1, v2 T _ = v1 == v2 // ERROR "cannot be compared\|non-comparable\|cannot compare v1 == v2" }	724 B	2024-02-02 18:09
📄 bom.go // runoutput // 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. // Test source file beginning with a byte order mark. package main import ( "fmt" "strings" ) func main() { prog = strings.Replace(prog, "BOM", "\uFEFF", -1) fmt.Print(prog) } var prog = `BOM package main func main() { } `	406 B	2024-02-02 18:09
📄 bombad.go // errorcheck // 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. // Here for reference, but hard to test automatically // because the BOM muddles the // processing done by ../run. package main func main() { // There's a bom here. // ERROR "BOM" // And here. // ERROR "BOM" /* And here.*/ // ERROR "BOM" println("hi there") // and here // ERROR "BOM" }	480 B	2024-02-02 18:09
📄 bounds.go // errorcheck -0 -m -l // 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. // Test, using compiler diagnostic flags, that bounds check elimination // is eliminating the correct checks. package foo var ( s []int a1 [1]int a1k [1000]int a100k [100000]int p1 [1]int p1k [1000]int p100k *[100000]int i int ui uint i8 int8 ui8 uint8 i16 int16 ui16 uint16 i32 int32 ui32 uint32 i64 int64 ui64 uint64 ) func main() { // Most things need checks. use(s[i]) use(a1[i]) use(a1k[i]) use(a100k[i]) use(p1[i]) use(p1k[i]) use(p100k[i]) use(s[ui]) use(a1[ui]) use(a1k[ui]) use(a100k[ui]) use(p1[ui]) use(p1k[ui]) use(p100k[ui]) use(s[i8]) use(a1[i8]) use(a1k[i8]) use(a100k[i8]) use(p1[i8]) use(p1k[i8]) use(p100k[i8]) // Unsigned 8-bit numbers don't need checks for len >= 2⁸. use(s[ui8]) use(a1[ui8]) use(a1k[ui8]) // ERROR "index bounds check elided" use(a100k[ui8]) // ERROR "index bounds check elided" use(p1[ui8]) use(p1k[ui8]) // ERROR "index bounds check elided" use(p100k[ui8]) // ERROR "index bounds check elided" use(s[i16]) use(a1[i16]) use(a1k[i16]) use(a100k[i16]) use(p1[i16]) use(p1k[i16]) use(p100k[i16]) // Unsigned 16-bit numbers don't need checks for len >= 2¹⁶. use(s[ui16]) use(a1[ui16]) use(a1k[ui16]) use(a100k[ui16]) // ERROR "index bounds check elided" use(p1[ui16]) use(p1k[ui16]) use(p100k[ui16]) // ERROR "index bounds check elided" use(s[i32]) use(a1[i32]) use(a1k[i32]) use(a100k[i32]) use(p1[i32]) use(p1k[i32]) use(p100k[i32]) use(s[ui32]) use(a1[ui32]) use(a1k[ui32]) use(a100k[ui32]) use(p1[ui32]) use(p1k[ui32]) use(p100k[ui32]) use(s[i64]) use(a1[i64]) use(a1k[i64]) use(a100k[i64]) use(p1[i64]) use(p1k[i64]) use(p100k[i64]) use(s[ui64]) use(a1[ui64]) use(a1k[ui64]) use(a100k[ui64]) use(p1[ui64]) use(p1k[ui64]) use(p100k[ui64]) // Mod truncates the maximum value to one less than the argument, // but signed mod can be negative, so only unsigned mod counts. use(s[i%999]) use(a1[i%999]) use(a1k[i%999]) use(a100k[i%999]) use(p1[i%999]) use(p1k[i%999]) use(p100k[i%999]) use(s[ui%999]) use(a1[ui%999]) use(a1k[ui%999]) // ERROR "index bounds check elided" use(a100k[ui%999]) // ERROR "index bounds check elided" use(p1[ui%999]) use(p1k[ui%999]) // ERROR "index bounds check elided" use(p100k[ui%999]) // ERROR "index bounds check elided" use(s[i%1000]) use(a1[i%1000]) use(a1k[i%1000]) use(a100k[i%1000]) use(p1[i%1000]) use(p1k[i%1000]) use(p100k[i%1000]) use(s[ui%1000]) use(a1[ui%1000]) use(a1k[ui%1000]) // ERROR "index bounds check elided" use(a100k[ui%1000]) // ERROR "index bounds check elided" use(p1[ui%1000]) use(p1k[ui%1000]) // ERROR "index bounds check elided" use(p100k[ui%1000]) // ERROR "index bounds check elided" use(s[i%1001]) use(a1[i%1001]) use(a1k[i%1001]) use(a100k[i%1001]) use(p1[i%1001]) use(p1k[i%1001]) use(p100k[i%1001]) use(s[ui%1001]) use(a1[ui%1001]) use(a1k[ui%1001]) use(a100k[ui%1001]) // ERROR "index bounds check elided" use(p1[ui%1001]) use(p1k[ui%1001]) use(p100k[ui%1001]) // ERROR "index bounds check elided" // Bitwise and truncates the maximum value to the mask value. // The result (for a positive mask) cannot be negative, so elision // applies to both signed and unsigned indexes. use(s[i&999]) use(a1[i&999]) use(a1k[i&999]) // ERROR "index bounds check elided" use(a100k[i&999]) // ERROR "index bounds check elided" use(p1[i&999]) use(p1k[i&999]) // ERROR "index bounds check elided" use(p100k[i&999]) // ERROR "index bounds check elided" use(s[ui&999]) use(a1[ui&999]) use(a1k[ui&999]) // ERROR "index bounds check elided" use(a100k[ui&999]) // ERROR "index bounds check elided" use(p1[ui&999]) use(p1k[ui&999]) // ERROR "index bounds check elided" use(p100k[ui&999]) // ERROR "index bounds check elided" use(s[i&1000]) use(a1[i&1000]) use(a1k[i&1000]) use(a100k[i&1000]) // ERROR "index bounds check elided" use(p1[i&1000]) use(p1k[i&1000]) use(p100k[i&1000]) // ERROR "index bounds check elided" use(s[ui&1000]) use(a1[ui&1000]) use(a1k[ui&1000]) use(a100k[ui&1000]) // ERROR "index bounds check elided" use(p1[ui&1000]) use(p1k[ui&1000]) use(p100k[ui&1000]) // ERROR "index bounds check elided" use(a1[i&^-1]) // ERROR "index bounds check elided" use(a1[i&^0]) use(a1[i&^-2]) use(a1[i&^1]) use(a1k[i&^-1]) // ERROR "index bounds check elided" use(a1k[i&^0]) use(a1k[i&^-2]) // ERROR "index bounds check elided" use(a1k[i&^1]) use(a1k[i8&^0]) use(a1k[i8&^-128]) // ERROR "index bounds check elided" use(a1k[ui8&^1]) // ERROR "index bounds check elided" use(a1k[ui16&^0xf000]) use(a1k[ui16&^0xff00]) // ERROR "index bounds check elided" // Right shift cuts the effective number of bits in the index, // but only for unsigned (signed stays negative). use(s[i32>>22]) use(a1[i32>>22]) use(a1k[i32>>22]) use(a100k[i32>>22]) use(p1[i32>>22]) use(p1k[i32>>22]) use(p100k[i32>>22]) use(s[ui32>>22]) use(a1[ui32>>22]) use(a1k[ui32>>22]) use(a100k[ui32>>22]) // ERROR "index bounds check elided" use(p1[ui32>>22]) use(p1k[ui32>>22]) use(p100k[ui32>>22]) // ERROR "index bounds check elided" use(s[i32>>23]) use(a1[i32>>23]) use(a1k[i32>>23]) use(a100k[i32>>23]) use(p1[i32>>23]) use(p1k[i32>>23]) use(p100k[i32>>23]) use(s[ui32>>23]) use(a1[ui32>>23]) use(a1k[ui32>>23]) // ERROR "index bounds check elided" use(a100k[ui32>>23]) // ERROR "index bounds check elided" use(p1[ui32>>23]) use(p1k[ui32>>23]) // ERROR "index bounds check elided" use(p100k[ui32>>23]) // ERROR "index bounds check elided" // Division cuts the range like right shift does. use(s[i/1e6]) use(a1[i/1e6]) use(a1k[i/1e6]) use(a100k[i/1e6]) use(p1[i/1e6]) use(p1k[i/1e6]) use(p100k[i/1e6]) use(s[ui/1e6]) use(a1[ui/1e6]) use(a1k[ui/1e6]) use(p1[ui/1e6]) use(p1k[ui/1e6]) use(s[i/1e7]) use(a1[i/1e7]) use(a1k[i/1e7]) use(a100k[i/1e7]) use(p1[i/1e7]) use(p1k[i/1e7]) use(p100k[i/1e7]) use(s[ui/1e7]) use(a1[ui/1e7]) use(p1[ui/1e7]) } var sum int func use(x int) { sum += x }	6.09 KB	2024-02-02 18:09
📄 cannotassign.go // errorcheck // 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. // Test "cannot assign" errors package main func main() { var s string = "hello" s[1:2] = "a" // ERROR "cannot assign to .* ($strings are immutable$)?" s[3] = "b" // ERROR "cannot assign to .* ($strings are immutable$)?" const n int = 1 const cs string = "hello" n = 2 // ERROR "cannot assign to .* ($declared const$)?" cs = "hi" // ERROR "cannot assign to .* ($declared const$)?" true = false // ERROR "cannot assign to .* ($declared const$)?" var m map[int]struct{ n int } m[0].n = 7 // ERROR "cannot assign to struct field .* in map$" 1 = 7 // ERROR "cannot assign to 1" "hi" = 7 // ERROR `cannot assign to "hi"` nil = 7 // ERROR "cannot assign to nil" len("") = 7 // ERROR `cannot assign to len$""$` []int{} = nil // ERROR "cannot assign to \[\]int\{\}" var x int = 7 x + 1 = 7 // ERROR "cannot assign to x \+ 1" }	1.04 KB	2024-02-02 18:09
📁 chan	-	2024-02-02 18:09
📄 chancap.go // run // Copyright 2009 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 the cap predeclared function applied to channels. package main import ( "strings" "unsafe" ) type T chan int const ptrSize = unsafe.Sizeof((byte)(nil)) func main() { c := make(T, 10) if len(c) != 0 \|\| cap(c) != 10 { println("chan len/cap ", len(c), cap(c), " want 0 10") panic("fail") } for i := 0; i < 3; i++ { c <- i } if len(c) != 3 \|\| cap(c) != 10 { println("chan len/cap ", len(c), cap(c), " want 3 10") panic("fail") } c = make(T) if len(c) != 0 \|\| cap(c) != 0 { println("chan len/cap ", len(c), cap(c), " want 0 0") panic("fail") } n := -1 shouldPanic("makechan: size out of range", func() { _ = make(T, n) }) shouldPanic("makechan: size out of range", func() { _ = make(T, int64(n)) }) if ptrSize == 8 { // Test mem > maxAlloc var n2 int64 = 1 << 59 shouldPanic("makechan: size out of range", func() { _ = make(T, int(n2)) }) // Test elem.sizecap overflow n2 = 1<<63 - 1 shouldPanic("makechan: size out of range", func() { _ = make(T, int(n2)) }) } else { n = 1<<31 - 1 shouldPanic("makechan: size out of range", func() { _ = make(T, n) }) shouldPanic("makechan: size out of range", func() { _ = make(T, int64(n)) }) } } func shouldPanic(str string, f func()) { defer func() { err := recover() if err == nil { panic("did not panic") } s := err.(error).Error() if !strings.Contains(s, str) { panic("got panic " + s + ", want " + str) } }() f() }	1.57 KB	2024-02-02 18:09
📄 chanlinear.go // run //go:build darwin \|\| linux // 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 that dequeuing from a pending channel doesn't // take linear time. package main import ( "fmt" "runtime" "time" ) // checkLinear asserts that the running time of f(n) is in O(n). // tries is the initial number of iterations. func checkLinear(typ string, tries int, f func(n int)) { // Depending on the machine and OS, this test might be too fast // to measure with accurate enough granularity. On failure, // make it run longer, hoping that the timing granularity // is eventually sufficient. timeF := func(n int) time.Duration { t1 := time.Now() f(n) return time.Since(t1) } t0 := time.Now() n := tries fails := 0 for { runtime.GC() t1 := timeF(n) runtime.GC() t2 := timeF(2 * n) // should be 2x (linear); allow up to 3x if t2 < 3t1 { if false { fmt.Println(typ, "\t", time.Since(t0)) } return } // If n ops run in under a second and the ratio // doesn't work out, make n bigger, trying to reduce // the effect that a constant amount of overhead has // on the computed ratio. if t1 < 1time.Second { n = 2 continue } // Once the test runs long enough for n ops, // try to get the right ratio at least once. // If five in a row all fail, give up. if fails++; fails >= 5 { panic(fmt.Sprintf("%s: too slow: %d channels: %v; %d channels: %v\n", typ, n, t1, 2n, t2)) } } } func main() { checkLinear("chanSelect", 1000, func(n int) { const messages = 10 c := make(chan bool) // global channel var a []chan bool // local channels for each goroutine for i := 0; i < n; i++ { d := make(chan bool) a = append(a, d) go func() { for j := 0; j < messages; j++ { // queue ourselves on the global channel select { case <-c: case <-d: } } }() } for i := 0; i < messages; i++ { // wake each goroutine up, forcing it to dequeue and then enqueue // on the global channel. for _, d := range a { d <- true } } }) }	2.12 KB	2024-02-02 18:09
📄 char_lit.go // run // Copyright 2009 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 character literal syntax. package main import "os" func main() { var i uint64 = ' ' + 'a' + 'ä' + '本' + '\a' + '\b' + '\f' + '\n' + '\r' + '\t' + '\v' + '\\' + '\'' + '\000' + '\123' + '\x00' + '\xca' + '\xFE' + '\u0123' + '\ubabe' + '\U0010FFFF' + '\U000ebabe' if '\U000ebabe' != 0x000ebabe { print("ebabe wrong\n") os.Exit(1) } if i != 0x20e213 { print("number is ", i, " should be ", 0x20e213, "\n") os.Exit(1) } }	657 B	2024-02-02 18:09
📄 char_lit1.go // errorcheck -d=panic // Copyright 2009 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. // Verify that illegal character literals are detected. // Does not compile. package main const ( // check that surrogate pair elements are invalid // (d800-dbff, dc00-dfff). _ = '\ud7ff' // ok _ = '\ud800' // ERROR "Unicode\|unicode" _ = "\U0000D999" // ERROR "Unicode\|unicode" _ = '\udc01' // ERROR "Unicode\|unicode" _ = '\U0000dddd' // ERROR "Unicode\|unicode" _ = '\udfff' // ERROR "Unicode\|unicode" _ = '\ue000' // ok _ = '\U0010ffff' // ok _ = '\U00110000' // ERROR "Unicode\|unicode" _ = "abc\U0010ffffdef" // ok _ = "abc\U00110000def" // ERROR "Unicode\|unicode" _ = '\Uffffffff' // ERROR "Unicode\|unicode" )	822 B	2024-02-02 18:09
📄 checkbce.go // errorcheck -0 -d=ssa/check_bce/debug=3 //go:build amd64 && !gcflags_noopt // 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. // Test that the compiler does bounds check elimination as expected. // This avoids accidental regressions. package main import "encoding/binary" func f0(a []int) { a[0] = 1 // ERROR "Found IsInBounds$" a[0] = 1 a[6] = 1 // ERROR "Found IsInBounds$" a[6] = 1 a[5] = 1 a[5] = 1 } func f1(a [256]int, i int) { var j int useInt(a[i]) // ERROR "Found IsInBounds$" j = i % 256 useInt(a[j]) // ERROR "Found IsInBounds$" j = i & 255 useInt(a[j]) j = i & 17 useInt(a[j]) if 4 <= i && i < len(a) { useInt(a[i]) useInt(a[i-1]) useInt(a[i-4]) } } func f2(a [256]int, i uint) { useInt(a[i]) // ERROR "Found IsInBounds$" j := i % 256 useInt(a[j]) j = i & 255 useInt(a[j]) j = i & 17 useInt(a[j]) } func f2a(a [35]int, i uint8) { useInt(a[i]) // ERROR "Found IsInBounds$" j := i & 34 useInt(a[j]) j = i & 17 useInt(a[j]) } func f2b(a [35]int, i uint16) { useInt(a[i]) // ERROR "Found IsInBounds$" j := i & 34 useInt(a[j]) j = i & 17 useInt(a[j]) } func f2c(a [35]int, i uint32) { useInt(a[i]) // ERROR "Found IsInBounds$" j := i & 34 useInt(a[j]) j = i & 17 useInt(a[j]) } func f3(a [256]int, i uint8) { useInt(a[i]) useInt(a[i+10]) useInt(a[i+14]) } func f4(a [27]int, i uint8) { useInt(a[i%15]) useInt(a[i%19]) useInt(a[i%27]) } func f5(a []int) { if len(a) > 5 { useInt(a[5]) useSlice(a[6:]) useSlice(a[:6]) } } func f6(a [32]int, b [64]int, i int) { useInt(a[uint32(i0x07C4ACDD)>>27]) useInt(b[uint64(i0x07C4ACDD)>>58]) useInt(a[uint(i0x07C4ACDD)>>59]) // The following bounds should not be removed because they can overflow. useInt(a[uint32(i0x106297f105d0cc86)>>26]) // ERROR "Found IsInBounds$" useInt(b[uint64(i0x106297f105d0cc86)>>57]) // ERROR "Found IsInBounds$" useInt(a[int32(i0x106297f105d0cc86)>>26]) // ERROR "Found IsInBounds$" useInt(b[int64(i*0x106297f105d0cc86)>>57]) // ERROR "Found IsInBounds$" } func g1(a []int) { for i := range a { a[i] = i useSlice(a[:i+1]) useSlice(a[:i]) } } func g2(a []int) { useInt(a[3]) // ERROR "Found IsInBounds$" useInt(a[2]) useInt(a[1]) useInt(a[0]) } func g3(a []int) { for i := range a[:256] { // ERROR "Found IsSliceInBounds$" useInt(a[i]) // ERROR "Found IsInBounds$" } b := a[:256] for i := range b { useInt(b[i]) } } func g4(a [100]int) { for i := 10; i < 50; i++ { useInt(a[i-10]) useInt(a[i]) useInt(a[i+25]) useInt(a[i+50]) // The following are out of bounds. if a[0] == 0xdeadbeef { // This is a trick to prohibit sccp to optimize out the following out of bound check continue } useInt(a[i-11]) // ERROR "Found IsInBounds$" useInt(a[i+51]) // ERROR "Found IsInBounds$" } } func decode1(data []byte) (x uint64) { for len(data) >= 32 { x += binary.BigEndian.Uint64(data[:8]) x += binary.BigEndian.Uint64(data[8:16]) x += binary.BigEndian.Uint64(data[16:24]) x += binary.BigEndian.Uint64(data[24:32]) data = data[32:] } return x } func decode2(data []byte) (x uint64) { // TODO(rasky): this should behave like decode1 and compile to no // boundchecks. We're currently not able to remove all of them. for len(data) >= 32 { x += binary.BigEndian.Uint64(data) data = data[8:] x += binary.BigEndian.Uint64(data) // ERROR "Found IsInBounds$" data = data[8:] x += binary.BigEndian.Uint64(data) // ERROR "Found IsInBounds$" data = data[8:] x += binary.BigEndian.Uint64(data) // ERROR "Found IsInBounds$" data = data[8:] } return x } //go:noinline func useInt(a int) { } //go:noinline func useSlice(a []int) { } func main() { }	3.7 KB	2024-02-02 18:09
📄 clear.go // run // Copyright 2022 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 "math" func checkClearSlice() { s := []int{1, 2, 3} clear(s) for i := range s { if s[i] != 0 { panic("clear not zeroing slice elem") } } clear([]int{}) } func checkClearMap() { m1 := make(map[int]int) m1[0] = 0 m1[1] = 1 clear(m1) if len(m1) != 0 { panic("m1 is not cleared") } // map contains NaN keys is also cleared. m2 := make(map[float64]int) m2[math.NaN()] = 1 m2[math.NaN()] = 1 clear(m2) if len(m2) != 0 { panic("m2 is not cleared") } clear(map[int]int{}) } func main() { checkClearSlice() checkClearMap() }	743 B	2024-02-02 18:09
📄 clearfat.go // runoutput // 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. // Check that {5,6,8,9}g/ggen.c:clearfat is zeroing the entire object. package main import ( "bytes" "fmt" "strconv" "strings" ) const ntest = 1100 func main() { var decls, calls bytes.Buffer for i := 1; i <= ntest; i++ { s := strconv.Itoa(i) decls.WriteString(strings.Replace(decl, "$", s, -1)) calls.WriteString(strings.Replace("poison$()\n\tclearfat$()\n\t", "$", s, -1)) } program = strings.Replace(program, "$DECLS", decls.String(), 1) program = strings.Replace(program, "$CALLS", calls.String(), 1) fmt.Print(program) } var program = `package main var count int $DECLS func main() { $CALLS if count != 0 { println("failed", count, "case(s)") } } ` const decl = ` func poison$() { // Grow and poison the stack space that will be used by clearfat$ var t [2*$]byte for i := range t { t[i] = 0xff } } func clearfat$() { var t [$]byte for _, x := range t { if x != 0 { // println("clearfat$: index", i, "expected 0, got", x) count++ break } } } `	1.15 KB	2024-02-02 18:09
📄 closedchan.go // run // Copyright 2009 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 close(c), receive of closed channel. // // TODO(rsc): Doesn't check behavior of close(c) when there // are blocked senders/receivers. package main import "os" var failed bool type Chan interface { Send(int) Nbsend(int) bool Recv() (int) Nbrecv() (int, bool) Recv2() (int, bool) Nbrecv2() (int, bool, bool) Close() Impl() string } // direct channel operations when possible type XChan chan int func (c XChan) Send(x int) { c <- x } func (c XChan) Nbsend(x int) bool { select { case c <- x: return true default: return false } panic("nbsend") } func (c XChan) Recv() int { return <-c } func (c XChan) Nbrecv() (int, bool) { select { case x := <-c: return x, true default: return 0, false } panic("nbrecv") } func (c XChan) Recv2() (int, bool) { x, ok := <-c return x, ok } func (c XChan) Nbrecv2() (int, bool, bool) { select { case x, ok := <-c: return x, ok, true default: return 0, false, false } panic("nbrecv2") } func (c XChan) Close() { close(c) } func (c XChan) Impl() string { return "(<- operator)" } // indirect operations via select type SChan chan int func (c SChan) Send(x int) { select { case c <- x: } } func (c SChan) Nbsend(x int) bool { select { default: return false case c <- x: return true } panic("nbsend") } func (c SChan) Recv() int { select { case x := <-c: return x } panic("recv") } func (c SChan) Nbrecv() (int, bool) { select { default: return 0, false case x := <-c: return x, true } panic("nbrecv") } func (c SChan) Recv2() (int, bool) { select { case x, ok := <-c: return x, ok } panic("recv") } func (c SChan) Nbrecv2() (int, bool, bool) { select { default: return 0, false, false case x, ok := <-c: return x, ok, true } panic("nbrecv") } func (c SChan) Close() { close(c) } func (c SChan) Impl() string { return "(select)" } // indirect operations via larger selects var dummy = make(chan bool) type SSChan chan int func (c SSChan) Send(x int) { select { case c <- x: case <-dummy: } } func (c SSChan) Nbsend(x int) bool { select { default: return false case <-dummy: case c <- x: return true } panic("nbsend") } func (c SSChan) Recv() int { select { case <-dummy: case x := <-c: return x } panic("recv") } func (c SSChan) Nbrecv() (int, bool) { select { case <-dummy: default: return 0, false case x := <-c: return x, true } panic("nbrecv") } func (c SSChan) Recv2() (int, bool) { select { case <-dummy: case x, ok := <-c: return x, ok } panic("recv") } func (c SSChan) Nbrecv2() (int, bool, bool) { select { case <-dummy: default: return 0, false, false case x, ok := <-c: return x, ok, true } panic("nbrecv") } func (c SSChan) Close() { close(c) } func (c SSChan) Impl() string { return "(select)" } func shouldPanic(f func()) { defer func() { if recover() == nil { panic("did not panic") } }() f() } func test1(c Chan) { for i := 0; i < 3; i++ { // recv a close signal (a zero value) if x := c.Recv(); x != 0 { println("test1: recv on closed:", x, c.Impl()) failed = true } if x, ok := c.Recv2(); x != 0 \|\| ok { println("test1: recv2 on closed:", x, ok, c.Impl()) failed = true } // should work with select: received a value without blocking, so selected == true. x, selected := c.Nbrecv() if x != 0 \|\| !selected { println("test1: recv on closed nb:", x, selected, c.Impl()) failed = true } x, ok, selected := c.Nbrecv2() if x != 0 \|\| ok \|\| !selected { println("test1: recv2 on closed nb:", x, ok, selected, c.Impl()) failed = true } } // send should work with ,ok too: sent a value without blocking, so ok == true. shouldPanic(func() { c.Nbsend(1) }) // the value should have been discarded. if x := c.Recv(); x != 0 { println("test1: recv on closed got non-zero after send on closed:", x, c.Impl()) failed = true } // similarly Send. shouldPanic(func() { c.Send(2) }) if x := c.Recv(); x != 0 { println("test1: recv on closed got non-zero after send on closed:", x, c.Impl()) failed = true } } func testasync1(c Chan) { // should be able to get the last value via Recv if x := c.Recv(); x != 1 { println("testasync1: Recv did not get 1:", x, c.Impl()) failed = true } test1(c) } func testasync2(c Chan) { // should be able to get the last value via Recv2 if x, ok := c.Recv2(); x != 1 \|\| !ok { println("testasync1: Recv did not get 1, true:", x, ok, c.Impl()) failed = true } test1(c) } func testasync3(c Chan) { // should be able to get the last value via Nbrecv if x, selected := c.Nbrecv(); x != 1 \|\| !selected { println("testasync2: Nbrecv did not get 1, true:", x, selected, c.Impl()) failed = true } test1(c) } func testasync4(c Chan) { // should be able to get the last value via Nbrecv2 if x, ok, selected := c.Nbrecv2(); x != 1 \|\| !ok \|\| !selected { println("testasync2: Nbrecv did not get 1, true, true:", x, ok, selected, c.Impl()) failed = true } test1(c) } func closedsync() chan int { c := make(chan int) close(c) return c } func closedasync() chan int { c := make(chan int, 2) c <- 1 close(c) return c } var mks = []func(chan int) Chan { func(c chan int) Chan { return XChan(c) }, func(c chan int) Chan { return SChan(c) }, func(c chan int) Chan { return SSChan(c) }, } var testcloseds = []func(Chan) { testasync1, testasync2, testasync3, testasync4, } func main() { for _, mk := range mks { test1(mk(closedsync())) } for _, testclosed := range testcloseds { for _, mk := range mks { testclosed(mk(closedasync())) } } var ch chan int shouldPanic(func() { close(ch) }) ch = make(chan int) close(ch) shouldPanic(func() { close(ch) }) if failed { os.Exit(1) } }	5.79 KB	2024-02-02 18:09
📄 closure.go // run // Copyright 2009 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 the behavior of closures. package main import "runtime" var c = make(chan int) func check(a []int) { for i := 0; i < len(a); i++ { n := <-c if n != a[i] { println("want", a[i], "got", n, "at", i) panic("fail") } } } func f() { var i, j int i = 1 j = 2 f := func() { c <- i i = 4 g := func() { c <- i c <- j } g() c <- i } j = 5 f() } // Accumulator generator func accum(n int) func(int) int { return func(i int) int { n += i return n } } func g(a, b func(int) int) { c <- a(2) c <- b(3) c <- a(4) c <- b(5) } func h() { var x8 byte = 100 var x64 int64 = 200 c <- int(x8) c <- int(x64) f := func(z int) { g := func() { c <- int(x8) c <- int(x64) c <- z } g() c <- int(x8) c <- int(x64) c <- int(z) } x8 = 101 x64 = 201 f(500) } func newfunc() func(int) int { return func(x int) int { return x } } func main() { runtime.GOMAXPROCS(1) var fail bool go f() check([]int{1, 4, 5, 4}) a := accum(0) b := accum(1) go g(a, b) check([]int{2, 4, 6, 9}) go h() check([]int{100, 200, 101, 201, 500, 101, 201, 500}) memstats := new(runtime.MemStats) runtime.ReadMemStats(memstats) n0 := memstats.Mallocs x, y := newfunc(), newfunc() if x(1) != 1 \|\| y(2) != 2 { println("newfunc returned broken funcs") fail = true } runtime.ReadMemStats(memstats) if n0 != memstats.Mallocs { println("newfunc allocated unexpectedly") fail = true } ff(1) if fail { panic("fail") } } func ff(x int) { call(func() { _ = x }) } func call(func()) { }	1.69 KB	2024-02-02 18:09
📄 closure1.go // run // 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 func main() { x := 0 func() { x = 1 }() func() { if x != 1 { panic("x != 1") } }() }	280 B	2024-02-02 18:09
📄 closure2.go // run // 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. // Check that these do not use "by value" capturing, // because changes are made to the value during the closure. package main var never bool func main() { { type X struct { v int } var x X func() { x.v++ }() if x.v != 1 { panic("x.v != 1") } type Y struct { X } var y Y func() { y.v = 1 }() if y.v != 1 { panic("y.v != 1") } } { type Z struct { a [3]byte } var z Z func() { i := 0 for z.a[1] = 1; i < 10; i++ { } }() if z.a[1] != 1 { panic("z.a[1] != 1") } } { w := 0 tmp := 0 f := func() { if w != 1 { panic("w != 1") } } func() { tmp = w // force capture of w, but do not write to it yet _ = tmp func() { func() { w++ // write in a nested closure }() }() }() f() } { var g func() int var i int for i = range [2]int{} { if i == 0 { g = func() int { return i // test that we capture by ref here, i is mutated on every interaction } } } if g() != 1 { panic("g() != 1") } } { var g func() int q := 0 for range [2]int{} { q++ g = func() int { return q // test that we capture by ref here // q++ must on a different decldepth than q declaration } } if g() != 2 { panic("g() != 2") } } { var g func() int var a [2]int q := 0 for a[func() int { q++ return 0 }()] = range [2]int{} { g = func() int { return q // test that we capture by ref here // q++ must on a different decldepth than q declaration } } if g() != 2 { panic("g() != 2") } } { var g func() int q := 0 q, g = 1, func() int { return q } if never { g = func() int { return 2 } } if g() != 1 { panic("g() != 1") } } }	1.87 KB	2024-02-02 18:09
📁 closure3.dir	-	2024-02-02 18:09
📄 closure3.go // errorcheckandrundir -0 -m -d=inlfuncswithclosures=1 //go:build !goexperiment.newinliner // 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. // Check correctness of various closure corner cases // that are expected to be inlined package ignored	358 B	2024-02-02 18:09
📄 closure4.go // 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. // Check that calling a nil func causes a proper panic. package main func main() { defer func() { err := recover() if err == nil { panic("panic expected") } }() var f func() f() }	364 B	2024-02-02 18:09
📁 closure5.dir	-	2024-02-02 18:09
📄 closure5.go // compiledir // Copyright 2021 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. // Check correctness of various closure corner cases // that are expected to be inlined package ignored	280 B	2024-02-02 18:09
📄 closure6.go // compile // 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 p type Float64Slice []float64 func (a Float64Slice) Search1(x float64) int { f := func(q int) bool { return a[q] >= x } i := 0 if !f(3) { i = 5 } return i }	346 B	2024-02-02 18:09
📄 closure7.go // run // 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 func g(f func()) { } // Must have exportable name func F() { g(func() { ch := make(chan int) for { select { case <-ch: return default: } } }) } func main() { F() }	373 B	2024-02-02 18:09
📄 cmp.go // run // Copyright 2009 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 equality and inequality operations. package main import ( "os" "unsafe" ) var global bool func use(b bool) { global = b } func stringptr(s string) uintptr { return (uintptr)(unsafe.Pointer(&s)) } func isfalse(b bool) { if b { // stack will explain where panic("wanted false, got true") } } func istrue(b bool) { if !b { // stack will explain where panic("wanted true, got false") } } type T *int type X int func (X) x() {} func main() { var a []int var b map[string]int var c string = "hello" var d string = "hel" // try to get different pointer d = d + "lo" // go.tools/ssa/interp can't handle unsafe.Pointer. if os.Getenv("GOSSAINTERP") == "" { if stringptr(c) == stringptr(d) { panic("compiler too smart -- got same string") } } var e = make(chan int) var ia interface{} = a var ib interface{} = b var ic interface{} = c var id interface{} = d var ie interface{} = e // these comparisons are okay because // string compare is okay and the others // are comparisons where the types differ. isfalse(ia == ib) isfalse(ia == ic) isfalse(ia == id) isfalse(ib == ic) isfalse(ib == id) istrue(ic == id) istrue(ie == ie) istrue(ia != ib) istrue(ia != ic) istrue(ia != id) istrue(ib != ic) istrue(ib != id) isfalse(ic != id) isfalse(ie != ie) // these are not okay, because there is no comparison on slices or maps. //isfalse(a == ib) //isfalse(a == ic) //isfalse(a == id) //isfalse(b == ic) //isfalse(b == id) istrue(c == id) istrue(e == ie) //isfalse(ia == b) isfalse(ia == c) isfalse(ia == d) isfalse(ib == c) isfalse(ib == d) istrue(ic == d) istrue(ie == e) //istrue(a != ib) //istrue(a != ic) //istrue(a != id) //istrue(b != ic) //istrue(b != id) isfalse(c != id) isfalse(e != ie) //istrue(ia != b) istrue(ia != c) istrue(ia != d) istrue(ib != c) istrue(ib != d) isfalse(ic != d) isfalse(ie != e) // gc used to let this go through as true. var g uint64 = 123 var h int64 = 123 var ig interface{} = g var ih interface{} = h isfalse(ig == ih) istrue(ig != ih) // map of interface should use == on interface values, // not memory. var m = make(map[interface{}]int) m[ic] = 1 m[id] = 2 if m[c] != 2 { println("m[c] = ", m[c]) panic("bad m[c]") } // interface comparisons (issue 7207) { type I1 interface { x() } type I2 interface { x() } a1 := I1(X(0)) b1 := I1(X(1)) a2 := I2(X(0)) b2 := I2(X(1)) a3 := I1(a2) a4 := I2(a1) var e interface{} = X(0) a5 := e.(I1) a6 := e.(I2) isfalse(a1 == b1) isfalse(a1 == b2) isfalse(a2 == b1) isfalse(a2 == b2) istrue(a1 == a2) istrue(a1 == a3) istrue(a1 == a4) istrue(a1 == a5) istrue(a1 == a6) istrue(a2 == a3) istrue(a2 == a4) istrue(a2 == a5) istrue(a2 == a6) istrue(a3 == a4) istrue(a3 == a5) istrue(a3 == a6) istrue(a4 == a5) istrue(a4 == a6) istrue(a5 == a6) } // non-interface comparisons { c := make(chan int) c1 := (<-chan int)(c) c2 := (chan<- int)(c) istrue(c == c1) istrue(c == c2) istrue(c1 == c) istrue(c2 == c) isfalse(c != c1) isfalse(c != c2) isfalse(c1 != c) isfalse(c2 != c) d := make(chan int) isfalse(c == d) isfalse(d == c) isfalse(d == c1) isfalse(d == c2) isfalse(c1 == d) isfalse(c2 == d) istrue(c != d) istrue(d != c) istrue(d != c1) istrue(d != c2) istrue(c1 != d) istrue(c2 != d) } // named types vs not { var x = new(int) var y T var z T = x isfalse(x == y) istrue(x == z) isfalse(y == z) isfalse(y == x) istrue(z == x) isfalse(z == y) istrue(x != y) isfalse(x != z) istrue(y != z) istrue(y != x) isfalse(z != x) istrue(z != y) } // structs { var x = struct { x int y string }{1, "hi"} var y = struct { x int y string }{2, "bye"} var z = struct { x int y string }{1, "hi"} isfalse(x == y) isfalse(y == x) isfalse(y == z) isfalse(z == y) istrue(x == z) istrue(z == x) istrue(x != y) istrue(y != x) istrue(y != z) istrue(z != y) isfalse(x != z) isfalse(z != x) var m = make(map[struct { x int y string }]int) m[x] = 10 m[y] = 20 m[z] = 30 istrue(m[x] == 30) istrue(m[y] == 20) istrue(m[z] == 30) istrue(m[x] != 10) isfalse(m[x] != 30) isfalse(m[y] != 20) isfalse(m[z] != 30) isfalse(m[x] == 10) var m1 = make(map[struct { x int y string }]struct { x int y string }) m1[x] = x m1[y] = y m1[z] = z istrue(m1[x] == z) istrue(m1[y] == y) istrue(m1[z] == z) istrue(m1[x] == x) isfalse(m1[x] != z) isfalse(m1[y] != y) isfalse(m1[z] != z) isfalse(m1[x] != x) var ix, iy, iz interface{} = x, y, z isfalse(ix == iy) isfalse(iy == ix) isfalse(iy == iz) isfalse(iz == iy) istrue(ix == iz) istrue(iz == ix) isfalse(x == iy) isfalse(y == ix) isfalse(y == iz) isfalse(z == iy) istrue(x == iz) istrue(z == ix) isfalse(ix == y) isfalse(iy == x) isfalse(iy == z) isfalse(iz == y) istrue(ix == z) istrue(iz == x) istrue(ix != iy) istrue(iy != ix) istrue(iy != iz) istrue(iz != iy) isfalse(ix != iz) isfalse(iz != ix) istrue(x != iy) istrue(y != ix) istrue(y != iz) istrue(z != iy) isfalse(x != iz) isfalse(z != ix) istrue(ix != y) istrue(iy != x) istrue(iy != z) istrue(iz != y) isfalse(ix != z) isfalse(iz != x) } // structs with _ fields { var x = struct { x int _ string y float64 _ float64 z int }{ x: 1, y: 2, z: 3, } var ix interface{} = x istrue(x == x) istrue(x == ix) istrue(ix == x) istrue(ix == ix) } // arrays { var x = [2]string{"1", "hi"} var y = [2]string{"2", "bye"} var z = [2]string{"1", "hi"} isfalse(x == y) isfalse(y == x) isfalse(y == z) isfalse(z == y) istrue(x == z) istrue(z == x) istrue(x != y) istrue(y != x) istrue(y != z) istrue(z != y) isfalse(x != z) isfalse(z != x) var m = make(map[[2]string]int) m[x] = 10 m[y] = 20 m[z] = 30 istrue(m[x] == 30) istrue(m[y] == 20) istrue(m[z] == 30) isfalse(m[x] != 30) isfalse(m[y] != 20) isfalse(m[z] != 30) var ix, iy, iz interface{} = x, y, z isfalse(ix == iy) isfalse(iy == ix) isfalse(iy == iz) isfalse(iz == iy) istrue(ix == iz) istrue(iz == ix) isfalse(x == iy) isfalse(y == ix) isfalse(y == iz) isfalse(z == iy) istrue(x == iz) istrue(z == ix) isfalse(ix == y) isfalse(iy == x) isfalse(iy == z) isfalse(iz == y) istrue(ix == z) istrue(iz == x) istrue(ix != iy) istrue(iy != ix) istrue(iy != iz) istrue(iz != iy) isfalse(ix != iz) isfalse(iz != ix) istrue(x != iy) istrue(y != ix) istrue(y != iz) istrue(z != iy) isfalse(x != iz) isfalse(z != ix) istrue(ix != y) istrue(iy != x) istrue(iy != z) istrue(iz != y) isfalse(ix != z) isfalse(iz != x) } // named booleans { type mybool bool var b mybool type T struct{ data [20]byte } var x, y T b = x == y istrue(x == y) istrue(bool(b)) m := make(map[string][10]interface{}) b = m["x"] == m["y"] istrue(m["x"] == m["y"]) istrue(bool(b)) } shouldPanic(p1) shouldPanic(p2) shouldPanic(p3) shouldPanic(p4) } func p1() { var a []int var ia interface{} = a use(ia == ia) } func p2() { var b []int var ib interface{} = b use(ib == ib) } func p3() { var a []int var ia interface{} = a var m = make(map[interface{}]int) m[ia] = 1 } func p4() { var b []int var ib interface{} = b var m = make(map[interface{}]int) m[ib] = 1 } func shouldPanic(f func()) { defer func() { if recover() == nil { panic("function should panic") } }() f() }	7.63 KB	2024-02-02 18:09
📄 cmp6.go // errorcheck // Copyright 2010 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. // Verify that incorrect comparisons are detected. // Does not compile. package main func use(bool) {} type T1 int type T2 int type T3 struct{ z []int } var t3 T3 type T4 struct { _ []int a float64 } var t4 T4 func main() { // Arguments to comparison must be // assignable one to the other (or vice versa) // so chan int can be compared against // directional channels but channel of different // direction cannot be compared against each other. var c1 chan<- int var c2 <-chan int var c3 chan int use(c1 == c2) // ERROR "invalid operation\|incompatible" use(c2 == c1) // ERROR "invalid operation\|incompatible" use(c1 == c3) use(c2 == c2) use(c3 == c1) use(c3 == c2) // Same applies to named types. var p1 T1 var p2 T2 var p3 *int use(p1 == p2) // ERROR "invalid operation\|incompatible" use(p2 == p1) // ERROR "invalid operation\|incompatible" use(p1 == p3) use(p2 == p2) use(p3 == p1) use(p3 == p2) // Arrays are comparable if and only if their element type is comparable. var a1 [1]int var a2 [1]func() var a3 [0]func() use(a1 == a1) use(a2 == a2) // ERROR "invalid operation\|invalid comparison" use(a3 == a3) // ERROR "invalid operation\|invalid comparison" // Comparison of structs should have a good message use(t3 == t3) // ERROR "struct\|expected\|cannot compare" use(t4 == t4) // ERROR "cannot be compared\|non-comparable\|cannot compare" // Slices, functions, and maps too. var x []int var f func() var m map[int]int use(x == x) // ERROR "slice can only be compared to nil\|cannot compare" use(f == f) // ERROR "func can only be compared to nil\|cannot compare" use(m == m) // ERROR "map can only be compared to nil\|cannot compare" // Comparison with interface that cannot return true // (would panic). var i interface{} use(i == x) // ERROR "invalid operation" use(x == i) // ERROR "invalid operation" use(i == f) // ERROR "invalid operation" use(f == i) // ERROR "invalid operation" use(i == m) // ERROR "invalid operation" use(m == i) // ERROR "invalid operation" }	2.16 KB	2024-02-02 18:09
📄 cmplx.go // errorcheck // Copyright 2010 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. // Verify that incorrect invocations of the complex predeclared function are detected. // Does not compile. package main type ( Float32 float32 Float64 float64 Complex64 complex64 Complex128 complex128 ) var ( f32 float32 f64 float64 F32 Float32 F64 Float64 c64 complex64 c128 complex128 C64 Complex64 C128 Complex128 ) func F1() int { return 1 } func F3() (int, int, int) { return 1, 2, 3 } func main() { // ok c64 = complex(f32, f32) c128 = complex(f64, f64) _ = complex128(0) // ok _ = complex(f32, f64) // ERROR "complex" _ = complex(f64, f32) // ERROR "complex" _ = complex(f32, F32) // ERROR "complex" _ = complex(F32, f32) // ERROR "complex" _ = complex(f64, F64) // ERROR "complex" _ = complex(F64, f64) // ERROR "complex" _ = complex(F1()) // ERROR "not enough arguments" _ = complex(F3()) // ERROR "too many arguments" _ = complex() // ERROR "not enough arguments" c128 = complex(f32, f32) // ERROR "cannot use" c64 = complex(f64, f64) // ERROR "cannot use" c64 = complex(1.0, 2.0) // ok, constant is untyped c128 = complex(1.0, 2.0) C64 = complex(1.0, 2.0) C128 = complex(1.0, 2.0) C64 = complex(f32, f32) // ERROR "cannot use" C128 = complex(f64, f64) // ERROR "cannot use" }	1.39 KB	2024-02-02 18:09
📄 cmplxdivide.c // Copyright 2010 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 C program generates the file cmplxdivide1.go. It uses the // output of the operations by C99 as the reference to check // the implementation of complex numbers in Go. // The generated file, cmplxdivide1.go, is compiled along // with the driver cmplxdivide.go (the names are confusing // and unimaginative) to run the actual test. This is done by // the usual test runner. // // The file cmplxdivide1.go is checked in to the repository, but // if it needs to be regenerated, compile and run this C program // like this: // gcc '-std=c99' cmplxdivide.c && a.out >cmplxdivide1.go #include <complex.h> #include <math.h> #include <stdio.h> #include <string.h> #define nelem(x) (sizeof(x)/sizeof((x)[0])) double f[] = { 0.0, -0.0, 1.0, -1.0, 2.0, NAN, INFINITY, -INFINITY, }; char* fmt(double g) { static char buf[10][30]; static int n; char p; p = buf[n++]; if(n == 10) { n = 0; } sprintf(p, "%g", g); if(strcmp(p, "0") == 0) { strcpy(p, "zero"); return p; } if(strcmp(p, "-0") == 0) { strcpy(p, "-zero"); return p; } return p; } int main(void) { int i, j, k, l; double complex n, d, q; printf("// skip\n"); printf("// # generated by cmplxdivide.c\n"); printf("\n"); printf("package main\n"); printf("\n"); printf("import \"math\"\n"); printf("\n"); printf("var (\n"); printf("\tnan = math.NaN()\n"); printf("\tinf = math.Inf(1)\n"); printf("\tzero = 0.0\n"); printf(")\n"); printf("\n"); printf("var tests = []struct {\n"); printf("\tf, g complex128\n"); printf("\tout complex128\n"); printf("}{\n"); for(i=0; i<nelem(f); i++) for(j=0; j<nelem(f); j++) for(k=0; k<nelem(f); k++) for(l=0; l<nelem(f); l++) { n = f[i] + f[j]I; d = f[k] + f[l]*I; q = n/d; printf("\t{complex(%s, %s), complex(%s, %s), complex(%s, %s)},\n", fmt(creal(n)), fmt(cimag(n)), fmt(creal(d)), fmt(cimag(d)), fmt(creal(q)), fmt(cimag(q))); } printf("}\n"); return 0; }	2.05 KB	2024-02-02 18:09
📄 cmplxdivide.go // run cmplxdivide1.go // Copyright 2010 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. // Driver for complex division table defined in cmplxdivide1.go // For details, see the comment at the top of cmplxdivide.c. package main import ( "fmt" "math" ) func calike(a, b complex128) bool { if imag(a) != imag(b) && !(math.IsNaN(imag(a)) && math.IsNaN(imag(b))) { return false } if real(a) != real(b) && !(math.IsNaN(real(a)) && math.IsNaN(real(b))) { return false } return true } func main() { bad := false for _, t := range tests { x := t.f / t.g if !calike(x, t.out) { if !bad { fmt.Printf("BUG\n") bad = true } fmt.Printf("%v/%v: expected %v error; got %v\n", t.f, t.g, t.out, x) } } if bad { panic("cmplxdivide failed.") } }	868 B	2024-02-02 18:09
📄 cmplxdivide1.go // skip // # generated by cmplxdivide.c package main import "math" var ( nan = math.NaN() inf = math.Inf(1) zero = 0.0 ) var tests = []struct { f, g complex128 out complex128 }{ {complex(zero, zero), complex(zero, zero), complex(nan, nan)}, {complex(zero, zero), complex(zero, -zero), complex(nan, nan)}, {complex(zero, zero), complex(zero, 1), complex(zero, zero)}, {complex(zero, zero), complex(zero, -1), complex(-zero, zero)}, {complex(zero, zero), complex(zero, 2), complex(zero, zero)}, {complex(zero, zero), complex(nan, nan), complex(nan, nan)}, {complex(zero, zero), complex(nan, inf), complex(zero, -zero)}, {complex(zero, zero), complex(nan, -inf), complex(-zero, zero)}, {complex(zero, zero), complex(zero, zero), complex(nan, nan)}, {complex(zero, zero), complex(-zero, -zero), complex(nan, nan)}, {complex(zero, zero), complex(zero, 1), complex(zero, zero)}, {complex(zero, zero), complex(-zero, -1), complex(-zero, -zero)}, {complex(zero, zero), complex(zero, 2), complex(zero, zero)}, {complex(zero, zero), complex(nan, nan), complex(nan, nan)}, {complex(zero, zero), complex(nan, inf), complex(zero, -zero)}, {complex(zero, zero), complex(nan, -inf), complex(-zero, zero)}, {complex(zero, zero), complex(1, zero), complex(zero, zero)}, {complex(zero, zero), complex(1, -zero), complex(zero, zero)}, {complex(zero, zero), complex(1, 1), complex(zero, zero)}, {complex(zero, zero), complex(1, -1), complex(zero, zero)}, {complex(zero, zero), complex(1, 2), complex(zero, zero)}, {complex(zero, zero), complex(nan, nan), complex(nan, nan)}, {complex(zero, zero), complex(nan, inf), complex(zero, -zero)}, {complex(zero, zero), complex(nan, -inf), complex(-zero, zero)}, {complex(zero, zero), complex(-1, zero), complex(-zero, -zero)}, {complex(zero, zero), complex(-1, -zero), complex(-zero, -zero)}, {complex(zero, zero), complex(-1, 1), complex(-zero, -zero)}, {complex(zero, zero), complex(-1, -1), complex(-zero, -zero)}, {complex(zero, zero), complex(-1, 2), complex(zero, -zero)}, {complex(zero, zero), complex(nan, nan), complex(nan, nan)}, {complex(zero, zero), complex(nan, inf), complex(zero, -zero)}, {complex(zero, zero), complex(nan, -inf), complex(-zero, zero)}, {complex(zero, zero), complex(2, zero), complex(zero, zero)}, {complex(zero, zero), complex(2, -zero), complex(zero, zero)}, {complex(zero, zero), complex(2, 1), complex(zero, zero)}, {complex(zero, zero), complex(2, -1), complex(zero, zero)}, {complex(zero, zero), complex(2, 2), complex(zero, zero)}, {complex(zero, zero), complex(nan, nan), complex(nan, nan)}, {complex(zero, zero), complex(nan, inf), complex(zero, -zero)}, {complex(zero, zero), complex(nan, -inf), complex(-zero, zero)}, {complex(zero, zero), complex(nan, zero), complex(nan, nan)}, {complex(zero, zero), complex(nan, -zero), complex(nan, nan)}, {complex(zero, zero), complex(nan, 1), complex(nan, nan)}, {complex(zero, zero), complex(nan, -1), complex(nan, nan)}, {complex(zero, zero), complex(nan, 2), complex(nan, nan)}, {complex(zero, zero), complex(nan, nan), complex(nan, nan)}, {complex(zero, zero), complex(nan, inf), complex(zero, -zero)}, {complex(zero, zero), complex(nan, -inf), complex(-zero, zero)}, {complex(zero, zero), complex(inf, zero), complex(zero, zero)}, {complex(zero, zero), complex(inf, -zero), complex(zero, zero)}, {complex(zero, zero), complex(inf, 1), complex(zero, zero)}, {complex(zero, zero), complex(inf, -1), complex(zero, zero)}, {complex(zero, zero), complex(inf, 2), complex(zero, zero)}, {complex(zero, zero), complex(nan, nan), complex(nan, nan)}, {complex(zero, zero), complex(nan, inf), complex(zero, -zero)}, {complex(zero, zero), complex(nan, -inf), complex(-zero, zero)}, {complex(zero, zero), complex(-inf, zero), complex(-zero, -zero)}, {complex(zero, zero), complex(-inf, -zero), complex(-zero, -zero)}, {complex(zero, zero), complex(-inf, 1), complex(-zero, -zero)}, {complex(zero, zero), complex(-inf, -1), complex(-zero, -zero)}, {complex(zero, zero), complex(-inf, 2), complex(-zero, -zero)}, {complex(zero, zero), complex(nan, nan), complex(nan, nan)}, {complex(zero, zero), complex(nan, inf), complex(zero, -zero)}, {complex(zero, zero), complex(nan, -inf), complex(-zero, zero)}, {complex(zero, -zero), complex(zero, zero), complex(nan, nan)}, {complex(zero, -zero), complex(zero, -zero), complex(nan, nan)}, {complex(zero, -zero), complex(zero, 1), complex(zero, -zero)}, {complex(zero, -zero), complex(zero, -1), complex(zero, -zero)}, {complex(zero, -zero), complex(zero, 2), complex(zero, -zero)}, {complex(zero, -zero), complex(nan, nan), complex(nan, nan)}, {complex(zero, -zero), complex(nan, inf), complex(-zero, zero)}, {complex(zero, -zero), complex(nan, -inf), complex(zero, zero)}, {complex(zero, -zero), complex(zero, zero), complex(nan, nan)}, {complex(zero, -zero), complex(-zero, -zero), complex(nan, nan)}, {complex(zero, -zero), complex(zero, 1), complex(zero, -zero)}, {complex(zero, -zero), complex(-zero, -1), complex(-zero, zero)}, {complex(zero, -zero), complex(zero, 2), complex(zero, -zero)}, {complex(zero, -zero), complex(nan, nan), complex(nan, nan)}, {complex(zero, -zero), complex(nan, inf), complex(-zero, zero)}, {complex(zero, -zero), complex(nan, -inf), complex(zero, zero)}, {complex(zero, -zero), complex(1, zero), complex(zero, -zero)}, {complex(zero, -zero), complex(1, -zero), complex(zero, zero)}, {complex(zero, -zero), complex(1, 1), complex(zero, -zero)}, {complex(zero, -zero), complex(1, -1), complex(zero, zero)}, {complex(zero, -zero), complex(1, 2), complex(zero, -zero)}, {complex(zero, -zero), complex(nan, nan), complex(nan, nan)}, {complex(zero, -zero), complex(nan, inf), complex(-zero, zero)}, {complex(zero, -zero), complex(nan, -inf), complex(zero, zero)}, {complex(zero, -zero), complex(-1, zero), complex(-zero, -zero)}, {complex(zero, -zero), complex(-1, -zero), complex(-zero, zero)}, {complex(zero, -zero), complex(-1, 1), complex(-zero, -zero)}, {complex(zero, -zero), complex(-1, -1), complex(-zero, zero)}, {complex(zero, -zero), complex(-1, 2), complex(-zero, zero)}, {complex(zero, -zero), complex(nan, nan), complex(nan, nan)}, {complex(zero, -zero), complex(nan, inf), complex(-zero, zero)}, {complex(zero, -zero), complex(nan, -inf), complex(zero, zero)}, {complex(zero, -zero), complex(2, zero), complex(zero, -zero)}, {complex(zero, -zero), complex(2, -zero), complex(zero, zero)}, {complex(zero, -zero), complex(2, 1), complex(zero, -zero)}, {complex(zero, -zero), complex(2, -1), complex(zero, zero)}, {complex(zero, -zero), complex(2, 2), complex(zero, -zero)}, {complex(zero, -zero), complex(nan, nan), complex(nan, nan)}, {complex(zero, -zero), complex(nan, inf), complex(-zero, zero)}, {complex(zero, -zero), complex(nan, -inf), complex(zero, zero)}, {complex(zero, -zero), complex(nan, zero), complex(nan, nan)}, {complex(zero, -zero), complex(nan, -zero), complex(nan, nan)}, {complex(zero, -zero), complex(nan, 1), complex(nan, nan)}, {complex(zero, -zero), complex(nan, -1), complex(nan, nan)}, {complex(zero, -zero), complex(nan, 2), complex(nan, nan)}, {complex(zero, -zero), complex(nan, nan), complex(nan, nan)}, {complex(zero, -zero), complex(nan, inf), complex(-zero, zero)}, {complex(zero, -zero), complex(nan, -inf), complex(zero, zero)}, {complex(zero, -zero), complex(inf, zero), complex(zero, -zero)}, {complex(zero, -zero), complex(inf, -zero), complex(zero, zero)}, {complex(zero, -zero), complex(inf, 1), complex(zero, -zero)}, {complex(zero, -zero), complex(inf, -1), complex(zero, zero)}, {complex(zero, -zero), complex(inf, 2), complex(zero, -zero)}, {complex(zero, -zero), complex(nan, nan), complex(nan, nan)}, {complex(zero, -zero), complex(nan, inf), complex(-zero, zero)}, {complex(zero, -zero), complex(nan, -inf), complex(zero, zero)}, {complex(zero, -zero), complex(-inf, zero), complex(-zero, -zero)}, {complex(zero, -zero), complex(-inf, -zero), complex(-zero, zero)}, {complex(zero, -zero), complex(-inf, 1), complex(-zero, -zero)}, {complex(zero, -zero), complex(-inf, -1), complex(-zero, zero)}, {complex(zero, -zero), complex(-inf, 2), complex(-zero, -zero)}, {complex(zero, -zero), complex(nan, nan), complex(nan, nan)}, {complex(zero, -zero), complex(nan, inf), complex(-zero, zero)}, {complex(zero, -zero), complex(nan, -inf), complex(zero, zero)}, {complex(zero, 1), complex(zero, zero), complex(nan, inf)}, {complex(zero, 1), complex(zero, -zero), complex(nan, inf)}, {complex(zero, 1), complex(zero, 1), complex(1, zero)}, {complex(zero, 1), complex(zero, -1), complex(-1, zero)}, {complex(zero, 1), complex(zero, 2), complex(0.5, zero)}, {complex(zero, 1), complex(nan, nan), complex(nan, nan)}, {complex(zero, 1), complex(nan, inf), complex(zero, -zero)}, {complex(zero, 1), complex(nan, -inf), complex(-zero, zero)}, {complex(zero, 1), complex(zero, zero), complex(nan, inf)}, {complex(zero, 1), complex(-zero, -zero), complex(nan, -inf)}, {complex(zero, 1), complex(zero, 1), complex(1, zero)}, {complex(zero, 1), complex(-zero, -1), complex(-1, -zero)}, {complex(zero, 1), complex(zero, 2), complex(0.5, zero)}, {complex(zero, 1), complex(nan, nan), complex(nan, nan)}, {complex(zero, 1), complex(nan, inf), complex(zero, -zero)}, {complex(zero, 1), complex(nan, -inf), complex(-zero, zero)}, {complex(zero, 1), complex(1, zero), complex(zero, 1)}, {complex(zero, 1), complex(1, -zero), complex(zero, 1)}, {complex(zero, 1), complex(1, 1), complex(0.5, 0.5)}, {complex(zero, 1), complex(1, -1), complex(-0.5, 0.5)}, {complex(zero, 1), complex(1, 2), complex(0.4, 0.2)}, {complex(zero, 1), complex(nan, nan), complex(nan, nan)}, {complex(zero, 1), complex(nan, inf), complex(zero, -zero)}, {complex(zero, 1), complex(nan, -inf), complex(-zero, zero)}, {complex(zero, 1), complex(-1, zero), complex(-zero, -1)}, {complex(zero, 1), complex(-1, -zero), complex(-zero, -1)}, {complex(zero, 1), complex(-1, 1), complex(0.5, -0.5)}, {complex(zero, 1), complex(-1, -1), complex(-0.5, -0.5)}, {complex(zero, 1), complex(-1, 2), complex(0.4, -0.2)}, {complex(zero, 1), complex(nan, nan), complex(nan, nan)}, {complex(zero, 1), complex(nan, inf), complex(zero, -zero)}, {complex(zero, 1), complex(nan, -inf), complex(-zero, zero)}, {complex(zero, 1), complex(2, zero), complex(zero, 0.5)}, {complex(zero, 1), complex(2, -zero), complex(zero, 0.5)}, {complex(zero, 1), complex(2, 1), complex(0.2, 0.4)}, {complex(zero, 1), complex(2, -1), complex(-0.2, 0.4)}, {complex(zero, 1), complex(2, 2), complex(0.25, 0.25)}, {complex(zero, 1), complex(nan, nan), complex(nan, nan)}, {complex(zero, 1), complex(nan, inf), complex(zero, -zero)}, {complex(zero, 1), complex(nan, -inf), complex(-zero, zero)}, {complex(zero, 1), complex(nan, zero), complex(nan, nan)}, {complex(zero, 1), complex(nan, -zero), complex(nan, nan)}, {complex(zero, 1), complex(nan, 1), complex(nan, nan)}, {complex(zero, 1), complex(nan, -1), complex(nan, nan)}, {complex(zero, 1), complex(nan, 2), complex(nan, nan)}, {complex(zero, 1), complex(nan, nan), complex(nan, nan)}, {complex(zero, 1), complex(nan, inf), complex(zero, -zero)}, {complex(zero, 1), complex(nan, -inf), complex(-zero, zero)}, {complex(zero, 1), complex(inf, zero), complex(zero, zero)}, {complex(zero, 1), complex(inf, -zero), complex(zero, zero)}, {complex(zero, 1), complex(inf, 1), complex(zero, zero)}, {complex(zero, 1), complex(inf, -1), complex(zero, zero)}, {complex(zero, 1), complex(inf, 2), complex(zero, zero)}, {complex(zero, 1), complex(nan, nan), complex(nan, nan)}, {complex(zero, 1), complex(nan, inf), complex(zero, -zero)}, {complex(zero, 1), complex(nan, -inf), complex(-zero, zero)}, {complex(zero, 1), complex(-inf, zero), complex(-zero, -zero)}, {complex(zero, 1), complex(-inf, -zero), complex(-zero, -zero)}, {complex(zero, 1), complex(-inf, 1), complex(-zero, -zero)}, {complex(zero, 1), complex(-inf, -1), complex(-zero, -zero)}, {complex(zero, 1), complex(-inf, 2), complex(-zero, -zero)}, {complex(zero, 1), complex(nan, nan), complex(nan, nan)}, {complex(zero, 1), complex(nan, inf), complex(zero, -zero)}, {complex(zero, 1), complex(nan, -inf), complex(-zero, zero)}, {complex(zero, -1), complex(zero, zero), complex(nan, -inf)}, {complex(zero, -1), complex(zero, -zero), complex(nan, -inf)}, {complex(zero, -1), complex(zero, 1), complex(-1, -zero)}, {complex(zero, -1), complex(zero, -1), complex(1, -zero)}, {complex(zero, -1), complex(zero, 2), complex(-0.5, -zero)}, {complex(zero, -1), complex(nan, nan), complex(nan, nan)}, {complex(zero, -1), complex(nan, inf), complex(-zero, zero)}, {complex(zero, -1), complex(nan, -inf), complex(zero, zero)}, {complex(zero, -1), complex(zero, zero), complex(nan, -inf)}, {complex(zero, -1), complex(-zero, -zero), complex(nan, inf)}, {complex(zero, -1), complex(zero, 1), complex(-1, -zero)}, {complex(zero, -1), complex(-zero, -1), complex(1, zero)}, {complex(zero, -1), complex(zero, 2), complex(-0.5, -zero)}, {complex(zero, -1), complex(nan, nan), complex(nan, nan)}, {complex(zero, -1), complex(nan, inf), complex(-zero, zero)}, {complex(zero, -1), complex(nan, -inf), complex(zero, zero)}, {complex(zero, -1), complex(1, zero), complex(zero, -1)}, {complex(zero, -1), complex(1, -zero), complex(zero, -1)}, {complex(zero, -1), complex(1, 1), complex(-0.5, -0.5)}, {complex(zero, -1), complex(1, -1), complex(0.5, -0.5)}, {complex(zero, -1), complex(1, 2), complex(-0.4, -0.2)}, {complex(zero, -1), complex(nan, nan), complex(nan, nan)}, {complex(zero, -1), complex(nan, inf), complex(-zero, zero)}, {complex(zero, -1), complex(nan, -inf), complex(zero, zero)}, {complex(zero, -1), complex(-1, zero), complex(-zero, 1)}, {complex(zero, -1), complex(-1, -zero), complex(-zero, 1)}, {complex(zero, -1), complex(-1, 1), complex(-0.5, 0.5)}, {complex(zero, -1), complex(-1, -1), complex(0.5, 0.5)}, {complex(zero, -1), complex(-1, 2), complex(-0.4, 0.2)}, {complex(zero, -1), complex(nan, nan), complex(nan, nan)}, {complex(zero, -1), complex(nan, inf), complex(-zero, zero)}, {complex(zero, -1), complex(nan, -inf), complex(zero, zero)}, {complex(zero, -1), complex(2, zero), complex(zero, -0.5)}, {complex(zero, -1), complex(2, -zero), complex(zero, -0.5)}, {complex(zero, -1), complex(2, 1), complex(-0.2, -0.4)}, {complex(zero, -1), complex(2, -1), complex(0.2, -0.4)}, {complex(zero, -1), complex(2, 2), complex(-0.25, -0.25)}, {complex(zero, -1), complex(nan, nan), complex(nan, nan)}, {complex(zero, -1), complex(nan, inf), complex(-zero, zero)}, {complex(zero, -1), complex(nan, -inf), complex(zero, zero)}, {complex(zero, -1), complex(nan, zero), complex(nan, nan)}, {complex(zero, -1), complex(nan, -zero), complex(nan, nan)}, {complex(zero, -1), complex(nan, 1), complex(nan, nan)}, {complex(zero, -1), complex(nan, -1), complex(nan, nan)}, {complex(zero, -1), complex(nan, 2), complex(nan, nan)}, {complex(zero, -1), complex(nan, nan), complex(nan, nan)}, {complex(zero, -1), complex(nan, inf), complex(-zero, zero)}, {complex(zero, -1), complex(nan, -inf), complex(zero, zero)}, {complex(zero, -1), complex(inf, zero), complex(zero, -zero)}, {complex(zero, -1), complex(inf, -zero), complex(zero, -zero)}, {complex(zero, -1), complex(inf, 1), complex(zero, -zero)}, {complex(zero, -1), complex(inf, -1), complex(zero, -zero)}, {complex(zero, -1), complex(inf, 2), complex(zero, -zero)}, {complex(zero, -1), complex(nan, nan), complex(nan, nan)}, {complex(zero, -1), complex(nan, inf), complex(-zero, zero)}, {complex(zero, -1), complex(nan, -inf), complex(zero, zero)}, {complex(zero, -1), complex(-inf, zero), complex(-zero, zero)}, {complex(zero, -1), complex(-inf, -zero), complex(-zero, zero)}, {complex(zero, -1), complex(-inf, 1), complex(-zero, zero)}, {complex(zero, -1), complex(-inf, -1), complex(-zero, zero)}, {complex(zero, -1), complex(-inf, 2), complex(-zero, zero)}, {complex(zero, -1), complex(nan, nan), complex(nan, nan)}, {complex(zero, -1), complex(nan, inf), complex(-zero, zero)}, {complex(zero, -1), complex(nan, -inf), complex(zero, zero)}, {complex(zero, 2), complex(zero, zero), complex(nan, inf)}, {complex(zero, 2), complex(zero, -zero), complex(nan, inf)}, {complex(zero, 2), complex(zero, 1), complex(2, zero)}, {complex(zero, 2), complex(zero, -1), complex(-2, zero)}, {complex(zero, 2), complex(zero, 2), complex(1, zero)}, {complex(zero, 2), complex(nan, nan), complex(nan, nan)}, {complex(zero, 2), complex(nan, inf), complex(zero, -zero)}, {complex(zero, 2), complex(nan, -inf), complex(-zero, zero)}, {complex(zero, 2), complex(zero, zero), complex(nan, inf)}, {complex(zero, 2), complex(-zero, -zero), complex(nan, -inf)}, {complex(zero, 2), complex(zero, 1), complex(2, zero)}, {complex(zero, 2), complex(-zero, -1), complex(-2, -zero)}, {complex(zero, 2), complex(zero, 2), complex(1, zero)}, {complex(zero, 2), complex(nan, nan), complex(nan, nan)}, {complex(zero, 2), complex(nan, inf), complex(zero, -zero)}, {complex(zero, 2), complex(nan, -inf), complex(-zero, zero)}, {complex(zero, 2), complex(1, zero), complex(zero, 2)}, {complex(zero, 2), complex(1, -zero), complex(zero, 2)}, {complex(zero, 2), complex(1, 1), complex(1, 1)}, {complex(zero, 2), complex(1, -1), complex(-1, 1)}, {complex(zero, 2), complex(1, 2), complex(0.8, 0.4)}, {complex(zero, 2), complex(nan, nan), complex(nan, nan)}, {complex(zero, 2), complex(nan, inf), complex(zero, -zero)}, {complex(zero, 2), complex(nan, -inf), complex(-zero, zero)}, {complex(zero, 2), complex(-1, zero), complex(-zero, -2)}, {complex(zero, 2), complex(-1, -zero), complex(-zero, -2)}, {complex(zero, 2), complex(-1, 1), complex(1, -1)}, {complex(zero, 2), complex(-1, -1), complex(-1, -1)}, {complex(zero, 2), complex(-1, 2), complex(0.8, -0.4)}, {complex(zero, 2), complex(nan, nan), complex(nan, nan)}, {complex(zero, 2), complex(nan, inf), complex(zero, -zero)}, {complex(zero, 2), complex(nan, -inf), complex(-zero, zero)}, {complex(zero, 2), complex(2, zero), complex(zero, 1)}, {complex(zero, 2), complex(2, -zero), complex(zero, 1)}, {complex(zero, 2), complex(2, 1), complex(0.4, 0.8)}, {complex(zero, 2), complex(2, -1), complex(-0.4, 0.8)}, {complex(zero, 2), complex(2, 2), complex(0.5, 0.5)}, {complex(zero, 2), complex(nan, nan), complex(nan, nan)}, {complex(zero, 2), complex(nan, inf), complex(zero, -zero)}, {complex(zero, 2), complex(nan, -inf), complex(-zero, zero)}, {complex(zero, 2), complex(nan, zero), complex(nan, nan)}, {complex(zero, 2), complex(nan, -zero), complex(nan, nan)}, {complex(zero, 2), complex(nan, 1), complex(nan, nan)}, {complex(zero, 2), complex(nan, -1), complex(nan, nan)}, {complex(zero, 2), complex(nan, 2), complex(nan, nan)}, {complex(zero, 2), complex(nan, nan), complex(nan, nan)}, {complex(zero, 2), complex(nan, inf), complex(zero, -zero)}, {complex(zero, 2), complex(nan, -inf), complex(-zero, zero)}, {complex(zero, 2), complex(inf, zero), complex(zero, zero)}, {complex(zero, 2), complex(inf, -zero), complex(zero, zero)}, {complex(zero, 2), complex(inf, 1), complex(zero, zero)}, {complex(zero, 2), complex(inf, -1), complex(zero, zero)}, {complex(zero, 2), complex(inf, 2), complex(zero, zero)}, {complex(zero, 2), complex(nan, nan), complex(nan, nan)}, {complex(zero, 2), complex(nan, inf), complex(zero, -zero)}, {complex(zero, 2), complex(nan, -inf), complex(-zero, zero)}, {complex(zero, 2), complex(-inf, zero), complex(-zero, -zero)}, {complex(zero, 2), complex(-inf, -zero), complex(-zero, -zero)}, {complex(zero, 2), complex(-inf, 1), complex(-zero, -zero)}, {complex(zero, 2), complex(-inf, -1), complex(-zero, -zero)}, {complex(zero, 2), complex(-inf, 2), complex(-zero, -zero)}, {complex(zero, 2), complex(nan, nan), complex(nan, nan)}, {complex(zero, 2), complex(nan, inf), complex(zero, -zero)}, {complex(zero, 2), complex(nan, -inf), complex(-zero, zero)}, {complex(nan, nan), complex(zero, zero), complex(nan, nan)}, {complex(nan, nan), complex(zero, -zero), complex(nan, nan)}, {complex(nan, nan), complex(zero, 1), complex(nan, nan)}, {complex(nan, nan), complex(zero, -1), complex(nan, nan)}, {complex(nan, nan), complex(zero, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(zero, zero), complex(nan, nan)}, {complex(nan, nan), complex(-zero, -zero), complex(nan, nan)}, {complex(nan, nan), complex(zero, 1), complex(nan, nan)}, {complex(nan, nan), complex(-zero, -1), complex(nan, nan)}, {complex(nan, nan), complex(zero, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(1, zero), complex(nan, nan)}, {complex(nan, nan), complex(1, -zero), complex(nan, nan)}, {complex(nan, nan), complex(1, 1), complex(nan, nan)}, {complex(nan, nan), complex(1, -1), complex(nan, nan)}, {complex(nan, nan), complex(1, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(-1, zero), complex(nan, nan)}, {complex(nan, nan), complex(-1, -zero), complex(nan, nan)}, {complex(nan, nan), complex(-1, 1), complex(nan, nan)}, {complex(nan, nan), complex(-1, -1), complex(nan, nan)}, {complex(nan, nan), complex(-1, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(2, zero), complex(nan, nan)}, {complex(nan, nan), complex(2, -zero), complex(nan, nan)}, {complex(nan, nan), complex(2, 1), complex(nan, nan)}, {complex(nan, nan), complex(2, -1), complex(nan, nan)}, {complex(nan, nan), complex(2, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, zero), complex(nan, nan)}, {complex(nan, nan), complex(nan, -zero), complex(nan, nan)}, {complex(nan, nan), complex(nan, 1), complex(nan, nan)}, {complex(nan, nan), complex(nan, -1), complex(nan, nan)}, {complex(nan, nan), complex(nan, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(inf, zero), complex(nan, nan)}, {complex(nan, nan), complex(inf, -zero), complex(nan, nan)}, {complex(nan, nan), complex(inf, 1), complex(nan, nan)}, {complex(nan, nan), complex(inf, -1), complex(nan, nan)}, {complex(nan, nan), complex(inf, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(-inf, zero), complex(nan, nan)}, {complex(nan, nan), complex(-inf, -zero), complex(nan, nan)}, {complex(nan, nan), complex(-inf, 1), complex(nan, nan)}, {complex(nan, nan), complex(-inf, -1), complex(nan, nan)}, {complex(nan, nan), complex(-inf, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(zero, zero), complex(nan, inf)}, {complex(nan, inf), complex(zero, -zero), complex(nan, inf)}, {complex(nan, inf), complex(zero, 1), complex(inf, nan)}, {complex(nan, inf), complex(zero, -1), complex(-inf, nan)}, {complex(nan, inf), complex(zero, 2), complex(inf, nan)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(zero, zero), complex(nan, inf)}, {complex(nan, inf), complex(-zero, -zero), complex(nan, -inf)}, {complex(nan, inf), complex(zero, 1), complex(inf, nan)}, {complex(nan, inf), complex(-zero, -1), complex(-inf, nan)}, {complex(nan, inf), complex(zero, 2), complex(inf, nan)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(1, zero), complex(nan, inf)}, {complex(nan, inf), complex(1, -zero), complex(nan, inf)}, {complex(nan, inf), complex(1, 1), complex(inf, inf)}, {complex(nan, inf), complex(1, -1), complex(-inf, inf)}, {complex(nan, inf), complex(1, 2), complex(inf, inf)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(-1, zero), complex(nan, -inf)}, {complex(nan, inf), complex(-1, -zero), complex(nan, -inf)}, {complex(nan, inf), complex(-1, 1), complex(inf, -inf)}, {complex(nan, inf), complex(-1, -1), complex(-inf, -inf)}, {complex(nan, inf), complex(-1, 2), complex(inf, -inf)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(2, zero), complex(nan, inf)}, {complex(nan, inf), complex(2, -zero), complex(nan, inf)}, {complex(nan, inf), complex(2, 1), complex(inf, inf)}, {complex(nan, inf), complex(2, -1), complex(-inf, inf)}, {complex(nan, inf), complex(2, 2), complex(inf, inf)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, zero), complex(nan, nan)}, {complex(nan, inf), complex(nan, -zero), complex(nan, nan)}, {complex(nan, inf), complex(nan, 1), complex(nan, nan)}, {complex(nan, inf), complex(nan, -1), complex(nan, nan)}, {complex(nan, inf), complex(nan, 2), complex(nan, nan)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(inf, zero), complex(nan, nan)}, {complex(nan, inf), complex(inf, -zero), complex(nan, nan)}, {complex(nan, inf), complex(inf, 1), complex(nan, nan)}, {complex(nan, inf), complex(inf, -1), complex(nan, nan)}, {complex(nan, inf), complex(inf, 2), complex(nan, nan)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(-inf, zero), complex(nan, nan)}, {complex(nan, inf), complex(-inf, -zero), complex(nan, nan)}, {complex(nan, inf), complex(-inf, 1), complex(nan, nan)}, {complex(nan, inf), complex(-inf, -1), complex(nan, nan)}, {complex(nan, inf), complex(-inf, 2), complex(nan, nan)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(zero, zero), complex(nan, -inf)}, {complex(nan, -inf), complex(zero, -zero), complex(nan, -inf)}, {complex(nan, -inf), complex(zero, 1), complex(-inf, nan)}, {complex(nan, -inf), complex(zero, -1), complex(inf, nan)}, {complex(nan, -inf), complex(zero, 2), complex(-inf, nan)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(zero, zero), complex(nan, -inf)}, {complex(nan, -inf), complex(-zero, -zero), complex(nan, inf)}, {complex(nan, -inf), complex(zero, 1), complex(-inf, nan)}, {complex(nan, -inf), complex(-zero, -1), complex(inf, nan)}, {complex(nan, -inf), complex(zero, 2), complex(-inf, nan)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(1, zero), complex(nan, -inf)}, {complex(nan, -inf), complex(1, -zero), complex(nan, -inf)}, {complex(nan, -inf), complex(1, 1), complex(-inf, -inf)}, {complex(nan, -inf), complex(1, -1), complex(inf, -inf)}, {complex(nan, -inf), complex(1, 2), complex(-inf, -inf)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(-1, zero), complex(nan, inf)}, {complex(nan, -inf), complex(-1, -zero), complex(nan, inf)}, {complex(nan, -inf), complex(-1, 1), complex(-inf, inf)}, {complex(nan, -inf), complex(-1, -1), complex(inf, inf)}, {complex(nan, -inf), complex(-1, 2), complex(-inf, inf)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(2, zero), complex(nan, -inf)}, {complex(nan, -inf), complex(2, -zero), complex(nan, -inf)}, {complex(nan, -inf), complex(2, 1), complex(-inf, -inf)}, {complex(nan, -inf), complex(2, -1), complex(inf, -inf)}, {complex(nan, -inf), complex(2, 2), complex(-inf, -inf)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, zero), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -zero), complex(nan, nan)}, {complex(nan, -inf), complex(nan, 1), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -1), complex(nan, nan)}, {complex(nan, -inf), complex(nan, 2), complex(nan, nan)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(inf, zero), complex(nan, nan)}, {complex(nan, -inf), complex(inf, -zero), complex(nan, nan)}, {complex(nan, -inf), complex(inf, 1), complex(nan, nan)}, {complex(nan, -inf), complex(inf, -1), complex(nan, nan)}, {complex(nan, -inf), complex(inf, 2), complex(nan, nan)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(-inf, zero), complex(nan, nan)}, {complex(nan, -inf), complex(-inf, -zero), complex(nan, nan)}, {complex(nan, -inf), complex(-inf, 1), complex(nan, nan)}, {complex(nan, -inf), complex(-inf, -1), complex(nan, nan)}, {complex(nan, -inf), complex(-inf, 2), complex(nan, nan)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(zero, zero), complex(zero, zero), complex(nan, nan)}, {complex(zero, zero), complex(zero, -zero), complex(nan, nan)}, {complex(zero, zero), complex(zero, 1), complex(zero, zero)}, {complex(zero, zero), complex(zero, -1), complex(-zero, zero)}, {complex(zero, zero), complex(zero, 2), complex(zero, zero)}, {complex(zero, zero), complex(nan, nan), complex(nan, nan)}, {complex(zero, zero), complex(nan, inf), complex(zero, -zero)}, {complex(zero, zero), complex(nan, -inf), complex(-zero, zero)}, {complex(zero, zero), complex(zero, zero), complex(nan, nan)}, {complex(zero, zero), complex(-zero, -zero), complex(nan, nan)}, {complex(zero, zero), complex(zero, 1), complex(zero, zero)}, {complex(zero, zero), complex(-zero, -1), complex(-zero, -zero)}, {complex(zero, zero), complex(zero, 2), complex(zero, zero)}, {complex(zero, zero), complex(nan, nan), complex(nan, nan)}, {complex(zero, zero), complex(nan, inf), complex(zero, -zero)}, {complex(zero, zero), complex(nan, -inf), complex(-zero, zero)}, {complex(zero, zero), complex(1, zero), complex(zero, zero)}, {complex(zero, zero), complex(1, -zero), complex(zero, zero)}, {complex(zero, zero), complex(1, 1), complex(zero, zero)}, {complex(zero, zero), complex(1, -1), complex(zero, zero)}, {complex(zero, zero), complex(1, 2), complex(zero, zero)}, {complex(zero, zero), complex(nan, nan), complex(nan, nan)}, {complex(zero, zero), complex(nan, inf), complex(zero, -zero)}, {complex(zero, zero), complex(nan, -inf), complex(-zero, zero)}, {complex(zero, zero), complex(-1, zero), complex(-zero, -zero)}, {complex(zero, zero), complex(-1, -zero), complex(-zero, -zero)}, {complex(zero, zero), complex(-1, 1), complex(-zero, -zero)}, {complex(zero, zero), complex(-1, -1), complex(-zero, -zero)}, {complex(zero, zero), complex(-1, 2), complex(zero, -zero)}, {complex(zero, zero), complex(nan, nan), complex(nan, nan)}, {complex(zero, zero), complex(nan, inf), complex(zero, -zero)}, {complex(zero, zero), complex(nan, -inf), complex(-zero, zero)}, {complex(zero, zero), complex(2, zero), complex(zero, zero)}, {complex(zero, zero), complex(2, -zero), complex(zero, zero)}, {complex(zero, zero), complex(2, 1), complex(zero, zero)}, {complex(zero, zero), complex(2, -1), complex(zero, zero)}, {complex(zero, zero), complex(2, 2), complex(zero, zero)}, {complex(zero, zero), complex(nan, nan), complex(nan, nan)}, {complex(zero, zero), complex(nan, inf), complex(zero, -zero)}, {complex(zero, zero), complex(nan, -inf), complex(-zero, zero)}, {complex(zero, zero), complex(nan, zero), complex(nan, nan)}, {complex(zero, zero), complex(nan, -zero), complex(nan, nan)}, {complex(zero, zero), complex(nan, 1), complex(nan, nan)}, {complex(zero, zero), complex(nan, -1), complex(nan, nan)}, {complex(zero, zero), complex(nan, 2), complex(nan, nan)}, {complex(zero, zero), complex(nan, nan), complex(nan, nan)}, {complex(zero, zero), complex(nan, inf), complex(zero, -zero)}, {complex(zero, zero), complex(nan, -inf), complex(-zero, zero)}, {complex(zero, zero), complex(inf, zero), complex(zero, zero)}, {complex(zero, zero), complex(inf, -zero), complex(zero, zero)}, {complex(zero, zero), complex(inf, 1), complex(zero, zero)}, {complex(zero, zero), complex(inf, -1), complex(zero, zero)}, {complex(zero, zero), complex(inf, 2), complex(zero, zero)}, {complex(zero, zero), complex(nan, nan), complex(nan, nan)}, {complex(zero, zero), complex(nan, inf), complex(zero, -zero)}, {complex(zero, zero), complex(nan, -inf), complex(-zero, zero)}, {complex(zero, zero), complex(-inf, zero), complex(-zero, -zero)}, {complex(zero, zero), complex(-inf, -zero), complex(-zero, -zero)}, {complex(zero, zero), complex(-inf, 1), complex(-zero, -zero)}, {complex(zero, zero), complex(-inf, -1), complex(-zero, -zero)}, {complex(zero, zero), complex(-inf, 2), complex(-zero, -zero)}, {complex(zero, zero), complex(nan, nan), complex(nan, nan)}, {complex(zero, zero), complex(nan, inf), complex(zero, -zero)}, {complex(zero, zero), complex(nan, -inf), complex(-zero, zero)}, {complex(-zero, -zero), complex(zero, zero), complex(nan, nan)}, {complex(-zero, -zero), complex(zero, -zero), complex(nan, nan)}, {complex(-zero, -zero), complex(zero, 1), complex(-zero, zero)}, {complex(-zero, -zero), complex(zero, -1), complex(-zero, -zero)}, {complex(-zero, -zero), complex(zero, 2), complex(-zero, zero)}, {complex(-zero, -zero), complex(nan, nan), complex(nan, nan)}, {complex(-zero, -zero), complex(nan, inf), complex(zero, zero)}, {complex(-zero, -zero), complex(nan, -inf), complex(zero, zero)}, {complex(-zero, -zero), complex(zero, zero), complex(nan, nan)}, {complex(-zero, -zero), complex(-zero, -zero), complex(nan, nan)}, {complex(-zero, -zero), complex(zero, 1), complex(-zero, zero)}, {complex(-zero, -zero), complex(-zero, -1), complex(zero, -zero)}, {complex(-zero, -zero), complex(zero, 2), complex(-zero, zero)}, {complex(-zero, -zero), complex(nan, nan), complex(nan, nan)}, {complex(-zero, -zero), complex(nan, inf), complex(zero, zero)}, {complex(-zero, -zero), complex(nan, -inf), complex(zero, zero)}, {complex(-zero, -zero), complex(1, zero), complex(-zero, zero)}, {complex(-zero, -zero), complex(1, -zero), complex(zero, -zero)}, {complex(-zero, -zero), complex(1, 1), complex(-zero, zero)}, {complex(-zero, -zero), complex(1, -1), complex(zero, -zero)}, {complex(-zero, -zero), complex(1, 2), complex(-zero, zero)}, {complex(-zero, -zero), complex(nan, nan), complex(nan, nan)}, {complex(-zero, -zero), complex(nan, inf), complex(zero, zero)}, {complex(-zero, -zero), complex(nan, -inf), complex(zero, zero)}, {complex(-zero, -zero), complex(-1, zero), complex(-zero, zero)}, {complex(-zero, -zero), complex(-1, -zero), complex(zero, -zero)}, {complex(-zero, -zero), complex(-1, 1), complex(-zero, zero)}, {complex(-zero, -zero), complex(-1, -1), complex(zero, -zero)}, {complex(-zero, -zero), complex(-1, 2), complex(zero, zero)}, {complex(-zero, -zero), complex(nan, nan), complex(nan, nan)}, {complex(-zero, -zero), complex(nan, inf), complex(zero, zero)}, {complex(-zero, -zero), complex(nan, -inf), complex(zero, zero)}, {complex(-zero, -zero), complex(2, zero), complex(-zero, zero)}, {complex(-zero, -zero), complex(2, -zero), complex(zero, -zero)}, {complex(-zero, -zero), complex(2, 1), complex(-zero, zero)}, {complex(-zero, -zero), complex(2, -1), complex(zero, -zero)}, {complex(-zero, -zero), complex(2, 2), complex(-zero, zero)}, {complex(-zero, -zero), complex(nan, nan), complex(nan, nan)}, {complex(-zero, -zero), complex(nan, inf), complex(zero, zero)}, {complex(-zero, -zero), complex(nan, -inf), complex(zero, zero)}, {complex(-zero, -zero), complex(nan, zero), complex(nan, nan)}, {complex(-zero, -zero), complex(nan, -zero), complex(nan, nan)}, {complex(-zero, -zero), complex(nan, 1), complex(nan, nan)}, {complex(-zero, -zero), complex(nan, -1), complex(nan, nan)}, {complex(-zero, -zero), complex(nan, 2), complex(nan, nan)}, {complex(-zero, -zero), complex(nan, nan), complex(nan, nan)}, {complex(-zero, -zero), complex(nan, inf), complex(zero, zero)}, {complex(-zero, -zero), complex(nan, -inf), complex(zero, zero)}, {complex(-zero, -zero), complex(inf, zero), complex(-zero, zero)}, {complex(-zero, -zero), complex(inf, -zero), complex(zero, -zero)}, {complex(-zero, -zero), complex(inf, 1), complex(-zero, zero)}, {complex(-zero, -zero), complex(inf, -1), complex(zero, -zero)}, {complex(-zero, -zero), complex(inf, 2), complex(-zero, zero)}, {complex(-zero, -zero), complex(nan, nan), complex(nan, nan)}, {complex(-zero, -zero), complex(nan, inf), complex(zero, zero)}, {complex(-zero, -zero), complex(nan, -inf), complex(zero, zero)}, {complex(-zero, -zero), complex(-inf, zero), complex(-zero, zero)}, {complex(-zero, -zero), complex(-inf, -zero), complex(zero, -zero)}, {complex(-zero, -zero), complex(-inf, 1), complex(-zero, zero)}, {complex(-zero, -zero), complex(-inf, -1), complex(zero, -zero)}, {complex(-zero, -zero), complex(-inf, 2), complex(-zero, zero)}, {complex(-zero, -zero), complex(nan, nan), complex(nan, nan)}, {complex(-zero, -zero), complex(nan, inf), complex(zero, zero)}, {complex(-zero, -zero), complex(nan, -inf), complex(zero, zero)}, {complex(zero, 1), complex(zero, zero), complex(nan, inf)}, {complex(zero, 1), complex(zero, -zero), complex(nan, inf)}, {complex(zero, 1), complex(zero, 1), complex(1, zero)}, {complex(zero, 1), complex(zero, -1), complex(-1, zero)}, {complex(zero, 1), complex(zero, 2), complex(0.5, zero)}, {complex(zero, 1), complex(nan, nan), complex(nan, nan)}, {complex(zero, 1), complex(nan, inf), complex(zero, -zero)}, {complex(zero, 1), complex(nan, -inf), complex(-zero, zero)}, {complex(zero, 1), complex(zero, zero), complex(nan, inf)}, {complex(zero, 1), complex(-zero, -zero), complex(nan, -inf)}, {complex(zero, 1), complex(zero, 1), complex(1, zero)}, {complex(zero, 1), complex(-zero, -1), complex(-1, -zero)}, {complex(zero, 1), complex(zero, 2), complex(0.5, zero)}, {complex(zero, 1), complex(nan, nan), complex(nan, nan)}, {complex(zero, 1), complex(nan, inf), complex(zero, -zero)}, {complex(zero, 1), complex(nan, -inf), complex(-zero, zero)}, {complex(zero, 1), complex(1, zero), complex(zero, 1)}, {complex(zero, 1), complex(1, -zero), complex(zero, 1)}, {complex(zero, 1), complex(1, 1), complex(0.5, 0.5)}, {complex(zero, 1), complex(1, -1), complex(-0.5, 0.5)}, {complex(zero, 1), complex(1, 2), complex(0.4, 0.2)}, {complex(zero, 1), complex(nan, nan), complex(nan, nan)}, {complex(zero, 1), complex(nan, inf), complex(zero, -zero)}, {complex(zero, 1), complex(nan, -inf), complex(-zero, zero)}, {complex(zero, 1), complex(-1, zero), complex(-zero, -1)}, {complex(zero, 1), complex(-1, -zero), complex(-zero, -1)}, {complex(zero, 1), complex(-1, 1), complex(0.5, -0.5)}, {complex(zero, 1), complex(-1, -1), complex(-0.5, -0.5)}, {complex(zero, 1), complex(-1, 2), complex(0.4, -0.2)}, {complex(zero, 1), complex(nan, nan), complex(nan, nan)}, {complex(zero, 1), complex(nan, inf), complex(zero, -zero)}, {complex(zero, 1), complex(nan, -inf), complex(-zero, zero)}, {complex(zero, 1), complex(2, zero), complex(zero, 0.5)}, {complex(zero, 1), complex(2, -zero), complex(zero, 0.5)}, {complex(zero, 1), complex(2, 1), complex(0.2, 0.4)}, {complex(zero, 1), complex(2, -1), complex(-0.2, 0.4)}, {complex(zero, 1), complex(2, 2), complex(0.25, 0.25)}, {complex(zero, 1), complex(nan, nan), complex(nan, nan)}, {complex(zero, 1), complex(nan, inf), complex(zero, -zero)}, {complex(zero, 1), complex(nan, -inf), complex(-zero, zero)}, {complex(zero, 1), complex(nan, zero), complex(nan, nan)}, {complex(zero, 1), complex(nan, -zero), complex(nan, nan)}, {complex(zero, 1), complex(nan, 1), complex(nan, nan)}, {complex(zero, 1), complex(nan, -1), complex(nan, nan)}, {complex(zero, 1), complex(nan, 2), complex(nan, nan)}, {complex(zero, 1), complex(nan, nan), complex(nan, nan)}, {complex(zero, 1), complex(nan, inf), complex(zero, -zero)}, {complex(zero, 1), complex(nan, -inf), complex(-zero, zero)}, {complex(zero, 1), complex(inf, zero), complex(zero, zero)}, {complex(zero, 1), complex(inf, -zero), complex(zero, zero)}, {complex(zero, 1), complex(inf, 1), complex(zero, zero)}, {complex(zero, 1), complex(inf, -1), complex(zero, zero)}, {complex(zero, 1), complex(inf, 2), complex(zero, zero)}, {complex(zero, 1), complex(nan, nan), complex(nan, nan)}, {complex(zero, 1), complex(nan, inf), complex(zero, -zero)}, {complex(zero, 1), complex(nan, -inf), complex(-zero, zero)}, {complex(zero, 1), complex(-inf, zero), complex(-zero, -zero)}, {complex(zero, 1), complex(-inf, -zero), complex(-zero, -zero)}, {complex(zero, 1), complex(-inf, 1), complex(-zero, -zero)}, {complex(zero, 1), complex(-inf, -1), complex(-zero, -zero)}, {complex(zero, 1), complex(-inf, 2), complex(-zero, -zero)}, {complex(zero, 1), complex(nan, nan), complex(nan, nan)}, {complex(zero, 1), complex(nan, inf), complex(zero, -zero)}, {complex(zero, 1), complex(nan, -inf), complex(-zero, zero)}, {complex(-zero, -1), complex(zero, zero), complex(nan, -inf)}, {complex(-zero, -1), complex(zero, -zero), complex(nan, -inf)}, {complex(-zero, -1), complex(zero, 1), complex(-1, zero)}, {complex(-zero, -1), complex(zero, -1), complex(1, -zero)}, {complex(-zero, -1), complex(zero, 2), complex(-0.5, zero)}, {complex(-zero, -1), complex(nan, nan), complex(nan, nan)}, {complex(-zero, -1), complex(nan, inf), complex(-zero, zero)}, {complex(-zero, -1), complex(nan, -inf), complex(zero, zero)}, {complex(-zero, -1), complex(zero, zero), complex(nan, -inf)}, {complex(-zero, -1), complex(-zero, -zero), complex(nan, inf)}, {complex(-zero, -1), complex(zero, 1), complex(-1, zero)}, {complex(-zero, -1), complex(-zero, -1), complex(1, -zero)}, {complex(-zero, -1), complex(zero, 2), complex(-0.5, zero)}, {complex(-zero, -1), complex(nan, nan), complex(nan, nan)}, {complex(-zero, -1), complex(nan, inf), complex(-zero, zero)}, {complex(-zero, -1), complex(nan, -inf), complex(zero, zero)}, {complex(-zero, -1), complex(1, zero), complex(-zero, -1)}, {complex(-zero, -1), complex(1, -zero), complex(zero, -1)}, {complex(-zero, -1), complex(1, 1), complex(-0.5, -0.5)}, {complex(-zero, -1), complex(1, -1), complex(0.5, -0.5)}, {complex(-zero, -1), complex(1, 2), complex(-0.4, -0.2)}, {complex(-zero, -1), complex(nan, nan), complex(nan, nan)}, {complex(-zero, -1), complex(nan, inf), complex(-zero, zero)}, {complex(-zero, -1), complex(nan, -inf), complex(zero, zero)}, {complex(-zero, -1), complex(-1, zero), complex(-zero, 1)}, {complex(-zero, -1), complex(-1, -zero), complex(zero, 1)}, {complex(-zero, -1), complex(-1, 1), complex(-0.5, 0.5)}, {complex(-zero, -1), complex(-1, -1), complex(0.5, 0.5)}, {complex(-zero, -1), complex(-1, 2), complex(-0.4, 0.2)}, {complex(-zero, -1), complex(nan, nan), complex(nan, nan)}, {complex(-zero, -1), complex(nan, inf), complex(-zero, zero)}, {complex(-zero, -1), complex(nan, -inf), complex(zero, zero)}, {complex(-zero, -1), complex(2, zero), complex(-zero, -0.5)}, {complex(-zero, -1), complex(2, -zero), complex(zero, -0.5)}, {complex(-zero, -1), complex(2, 1), complex(-0.2, -0.4)}, {complex(-zero, -1), complex(2, -1), complex(0.2, -0.4)}, {complex(-zero, -1), complex(2, 2), complex(-0.25, -0.25)}, {complex(-zero, -1), complex(nan, nan), complex(nan, nan)}, {complex(-zero, -1), complex(nan, inf), complex(-zero, zero)}, {complex(-zero, -1), complex(nan, -inf), complex(zero, zero)}, {complex(-zero, -1), complex(nan, zero), complex(nan, nan)}, {complex(-zero, -1), complex(nan, -zero), complex(nan, nan)}, {complex(-zero, -1), complex(nan, 1), complex(nan, nan)}, {complex(-zero, -1), complex(nan, -1), complex(nan, nan)}, {complex(-zero, -1), complex(nan, 2), complex(nan, nan)}, {complex(-zero, -1), complex(nan, nan), complex(nan, nan)}, {complex(-zero, -1), complex(nan, inf), complex(-zero, zero)}, {complex(-zero, -1), complex(nan, -inf), complex(zero, zero)}, {complex(-zero, -1), complex(inf, zero), complex(-zero, -zero)}, {complex(-zero, -1), complex(inf, -zero), complex(zero, -zero)}, {complex(-zero, -1), complex(inf, 1), complex(-zero, -zero)}, {complex(-zero, -1), complex(inf, -1), complex(zero, -zero)}, {complex(-zero, -1), complex(inf, 2), complex(-zero, -zero)}, {complex(-zero, -1), complex(nan, nan), complex(nan, nan)}, {complex(-zero, -1), complex(nan, inf), complex(-zero, zero)}, {complex(-zero, -1), complex(nan, -inf), complex(zero, zero)}, {complex(-zero, -1), complex(-inf, zero), complex(-zero, zero)}, {complex(-zero, -1), complex(-inf, -zero), complex(zero, zero)}, {complex(-zero, -1), complex(-inf, 1), complex(-zero, zero)}, {complex(-zero, -1), complex(-inf, -1), complex(zero, zero)}, {complex(-zero, -1), complex(-inf, 2), complex(-zero, zero)}, {complex(-zero, -1), complex(nan, nan), complex(nan, nan)}, {complex(-zero, -1), complex(nan, inf), complex(-zero, zero)}, {complex(-zero, -1), complex(nan, -inf), complex(zero, zero)}, {complex(zero, 2), complex(zero, zero), complex(nan, inf)}, {complex(zero, 2), complex(zero, -zero), complex(nan, inf)}, {complex(zero, 2), complex(zero, 1), complex(2, zero)}, {complex(zero, 2), complex(zero, -1), complex(-2, zero)}, {complex(zero, 2), complex(zero, 2), complex(1, zero)}, {complex(zero, 2), complex(nan, nan), complex(nan, nan)}, {complex(zero, 2), complex(nan, inf), complex(zero, -zero)}, {complex(zero, 2), complex(nan, -inf), complex(-zero, zero)}, {complex(zero, 2), complex(zero, zero), complex(nan, inf)}, {complex(zero, 2), complex(-zero, -zero), complex(nan, -inf)}, {complex(zero, 2), complex(zero, 1), complex(2, zero)}, {complex(zero, 2), complex(-zero, -1), complex(-2, -zero)}, {complex(zero, 2), complex(zero, 2), complex(1, zero)}, {complex(zero, 2), complex(nan, nan), complex(nan, nan)}, {complex(zero, 2), complex(nan, inf), complex(zero, -zero)}, {complex(zero, 2), complex(nan, -inf), complex(-zero, zero)}, {complex(zero, 2), complex(1, zero), complex(zero, 2)}, {complex(zero, 2), complex(1, -zero), complex(zero, 2)}, {complex(zero, 2), complex(1, 1), complex(1, 1)}, {complex(zero, 2), complex(1, -1), complex(-1, 1)}, {complex(zero, 2), complex(1, 2), complex(0.8, 0.4)}, {complex(zero, 2), complex(nan, nan), complex(nan, nan)}, {complex(zero, 2), complex(nan, inf), complex(zero, -zero)}, {complex(zero, 2), complex(nan, -inf), complex(-zero, zero)}, {complex(zero, 2), complex(-1, zero), complex(-zero, -2)}, {complex(zero, 2), complex(-1, -zero), complex(-zero, -2)}, {complex(zero, 2), complex(-1, 1), complex(1, -1)}, {complex(zero, 2), complex(-1, -1), complex(-1, -1)}, {complex(zero, 2), complex(-1, 2), complex(0.8, -0.4)}, {complex(zero, 2), complex(nan, nan), complex(nan, nan)}, {complex(zero, 2), complex(nan, inf), complex(zero, -zero)}, {complex(zero, 2), complex(nan, -inf), complex(-zero, zero)}, {complex(zero, 2), complex(2, zero), complex(zero, 1)}, {complex(zero, 2), complex(2, -zero), complex(zero, 1)}, {complex(zero, 2), complex(2, 1), complex(0.4, 0.8)}, {complex(zero, 2), complex(2, -1), complex(-0.4, 0.8)}, {complex(zero, 2), complex(2, 2), complex(0.5, 0.5)}, {complex(zero, 2), complex(nan, nan), complex(nan, nan)}, {complex(zero, 2), complex(nan, inf), complex(zero, -zero)}, {complex(zero, 2), complex(nan, -inf), complex(-zero, zero)}, {complex(zero, 2), complex(nan, zero), complex(nan, nan)}, {complex(zero, 2), complex(nan, -zero), complex(nan, nan)}, {complex(zero, 2), complex(nan, 1), complex(nan, nan)}, {complex(zero, 2), complex(nan, -1), complex(nan, nan)}, {complex(zero, 2), complex(nan, 2), complex(nan, nan)}, {complex(zero, 2), complex(nan, nan), complex(nan, nan)}, {complex(zero, 2), complex(nan, inf), complex(zero, -zero)}, {complex(zero, 2), complex(nan, -inf), complex(-zero, zero)}, {complex(zero, 2), complex(inf, zero), complex(zero, zero)}, {complex(zero, 2), complex(inf, -zero), complex(zero, zero)}, {complex(zero, 2), complex(inf, 1), complex(zero, zero)}, {complex(zero, 2), complex(inf, -1), complex(zero, zero)}, {complex(zero, 2), complex(inf, 2), complex(zero, zero)}, {complex(zero, 2), complex(nan, nan), complex(nan, nan)}, {complex(zero, 2), complex(nan, inf), complex(zero, -zero)}, {complex(zero, 2), complex(nan, -inf), complex(-zero, zero)}, {complex(zero, 2), complex(-inf, zero), complex(-zero, -zero)}, {complex(zero, 2), complex(-inf, -zero), complex(-zero, -zero)}, {complex(zero, 2), complex(-inf, 1), complex(-zero, -zero)}, {complex(zero, 2), complex(-inf, -1), complex(-zero, -zero)}, {complex(zero, 2), complex(-inf, 2), complex(-zero, -zero)}, {complex(zero, 2), complex(nan, nan), complex(nan, nan)}, {complex(zero, 2), complex(nan, inf), complex(zero, -zero)}, {complex(zero, 2), complex(nan, -inf), complex(-zero, zero)}, {complex(nan, nan), complex(zero, zero), complex(nan, nan)}, {complex(nan, nan), complex(zero, -zero), complex(nan, nan)}, {complex(nan, nan), complex(zero, 1), complex(nan, nan)}, {complex(nan, nan), complex(zero, -1), complex(nan, nan)}, {complex(nan, nan), complex(zero, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(zero, zero), complex(nan, nan)}, {complex(nan, nan), complex(-zero, -zero), complex(nan, nan)}, {complex(nan, nan), complex(zero, 1), complex(nan, nan)}, {complex(nan, nan), complex(-zero, -1), complex(nan, nan)}, {complex(nan, nan), complex(zero, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(1, zero), complex(nan, nan)}, {complex(nan, nan), complex(1, -zero), complex(nan, nan)}, {complex(nan, nan), complex(1, 1), complex(nan, nan)}, {complex(nan, nan), complex(1, -1), complex(nan, nan)}, {complex(nan, nan), complex(1, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(-1, zero), complex(nan, nan)}, {complex(nan, nan), complex(-1, -zero), complex(nan, nan)}, {complex(nan, nan), complex(-1, 1), complex(nan, nan)}, {complex(nan, nan), complex(-1, -1), complex(nan, nan)}, {complex(nan, nan), complex(-1, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(2, zero), complex(nan, nan)}, {complex(nan, nan), complex(2, -zero), complex(nan, nan)}, {complex(nan, nan), complex(2, 1), complex(nan, nan)}, {complex(nan, nan), complex(2, -1), complex(nan, nan)}, {complex(nan, nan), complex(2, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, zero), complex(nan, nan)}, {complex(nan, nan), complex(nan, -zero), complex(nan, nan)}, {complex(nan, nan), complex(nan, 1), complex(nan, nan)}, {complex(nan, nan), complex(nan, -1), complex(nan, nan)}, {complex(nan, nan), complex(nan, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(inf, zero), complex(nan, nan)}, {complex(nan, nan), complex(inf, -zero), complex(nan, nan)}, {complex(nan, nan), complex(inf, 1), complex(nan, nan)}, {complex(nan, nan), complex(inf, -1), complex(nan, nan)}, {complex(nan, nan), complex(inf, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(-inf, zero), complex(nan, nan)}, {complex(nan, nan), complex(-inf, -zero), complex(nan, nan)}, {complex(nan, nan), complex(-inf, 1), complex(nan, nan)}, {complex(nan, nan), complex(-inf, -1), complex(nan, nan)}, {complex(nan, nan), complex(-inf, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(zero, zero), complex(nan, inf)}, {complex(nan, inf), complex(zero, -zero), complex(nan, inf)}, {complex(nan, inf), complex(zero, 1), complex(inf, nan)}, {complex(nan, inf), complex(zero, -1), complex(-inf, nan)}, {complex(nan, inf), complex(zero, 2), complex(inf, nan)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(zero, zero), complex(nan, inf)}, {complex(nan, inf), complex(-zero, -zero), complex(nan, -inf)}, {complex(nan, inf), complex(zero, 1), complex(inf, nan)}, {complex(nan, inf), complex(-zero, -1), complex(-inf, nan)}, {complex(nan, inf), complex(zero, 2), complex(inf, nan)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(1, zero), complex(nan, inf)}, {complex(nan, inf), complex(1, -zero), complex(nan, inf)}, {complex(nan, inf), complex(1, 1), complex(inf, inf)}, {complex(nan, inf), complex(1, -1), complex(-inf, inf)}, {complex(nan, inf), complex(1, 2), complex(inf, inf)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(-1, zero), complex(nan, -inf)}, {complex(nan, inf), complex(-1, -zero), complex(nan, -inf)}, {complex(nan, inf), complex(-1, 1), complex(inf, -inf)}, {complex(nan, inf), complex(-1, -1), complex(-inf, -inf)}, {complex(nan, inf), complex(-1, 2), complex(inf, -inf)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(2, zero), complex(nan, inf)}, {complex(nan, inf), complex(2, -zero), complex(nan, inf)}, {complex(nan, inf), complex(2, 1), complex(inf, inf)}, {complex(nan, inf), complex(2, -1), complex(-inf, inf)}, {complex(nan, inf), complex(2, 2), complex(inf, inf)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, zero), complex(nan, nan)}, {complex(nan, inf), complex(nan, -zero), complex(nan, nan)}, {complex(nan, inf), complex(nan, 1), complex(nan, nan)}, {complex(nan, inf), complex(nan, -1), complex(nan, nan)}, {complex(nan, inf), complex(nan, 2), complex(nan, nan)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(inf, zero), complex(nan, nan)}, {complex(nan, inf), complex(inf, -zero), complex(nan, nan)}, {complex(nan, inf), complex(inf, 1), complex(nan, nan)}, {complex(nan, inf), complex(inf, -1), complex(nan, nan)}, {complex(nan, inf), complex(inf, 2), complex(nan, nan)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(-inf, zero), complex(nan, nan)}, {complex(nan, inf), complex(-inf, -zero), complex(nan, nan)}, {complex(nan, inf), complex(-inf, 1), complex(nan, nan)}, {complex(nan, inf), complex(-inf, -1), complex(nan, nan)}, {complex(nan, inf), complex(-inf, 2), complex(nan, nan)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(zero, zero), complex(nan, -inf)}, {complex(nan, -inf), complex(zero, -zero), complex(nan, -inf)}, {complex(nan, -inf), complex(zero, 1), complex(-inf, nan)}, {complex(nan, -inf), complex(zero, -1), complex(inf, nan)}, {complex(nan, -inf), complex(zero, 2), complex(-inf, nan)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(zero, zero), complex(nan, -inf)}, {complex(nan, -inf), complex(-zero, -zero), complex(nan, inf)}, {complex(nan, -inf), complex(zero, 1), complex(-inf, nan)}, {complex(nan, -inf), complex(-zero, -1), complex(inf, nan)}, {complex(nan, -inf), complex(zero, 2), complex(-inf, nan)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(1, zero), complex(nan, -inf)}, {complex(nan, -inf), complex(1, -zero), complex(nan, -inf)}, {complex(nan, -inf), complex(1, 1), complex(-inf, -inf)}, {complex(nan, -inf), complex(1, -1), complex(inf, -inf)}, {complex(nan, -inf), complex(1, 2), complex(-inf, -inf)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(-1, zero), complex(nan, inf)}, {complex(nan, -inf), complex(-1, -zero), complex(nan, inf)}, {complex(nan, -inf), complex(-1, 1), complex(-inf, inf)}, {complex(nan, -inf), complex(-1, -1), complex(inf, inf)}, {complex(nan, -inf), complex(-1, 2), complex(-inf, inf)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(2, zero), complex(nan, -inf)}, {complex(nan, -inf), complex(2, -zero), complex(nan, -inf)}, {complex(nan, -inf), complex(2, 1), complex(-inf, -inf)}, {complex(nan, -inf), complex(2, -1), complex(inf, -inf)}, {complex(nan, -inf), complex(2, 2), complex(-inf, -inf)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, zero), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -zero), complex(nan, nan)}, {complex(nan, -inf), complex(nan, 1), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -1), complex(nan, nan)}, {complex(nan, -inf), complex(nan, 2), complex(nan, nan)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(inf, zero), complex(nan, nan)}, {complex(nan, -inf), complex(inf, -zero), complex(nan, nan)}, {complex(nan, -inf), complex(inf, 1), complex(nan, nan)}, {complex(nan, -inf), complex(inf, -1), complex(nan, nan)}, {complex(nan, -inf), complex(inf, 2), complex(nan, nan)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(-inf, zero), complex(nan, nan)}, {complex(nan, -inf), complex(-inf, -zero), complex(nan, nan)}, {complex(nan, -inf), complex(-inf, 1), complex(nan, nan)}, {complex(nan, -inf), complex(-inf, -1), complex(nan, nan)}, {complex(nan, -inf), complex(-inf, 2), complex(nan, nan)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(1, zero), complex(zero, zero), complex(inf, nan)}, {complex(1, zero), complex(zero, -zero), complex(inf, nan)}, {complex(1, zero), complex(zero, 1), complex(zero, -1)}, {complex(1, zero), complex(zero, -1), complex(-zero, 1)}, {complex(1, zero), complex(zero, 2), complex(zero, -0.5)}, {complex(1, zero), complex(nan, nan), complex(nan, nan)}, {complex(1, zero), complex(nan, inf), complex(zero, -zero)}, {complex(1, zero), complex(nan, -inf), complex(-zero, zero)}, {complex(1, zero), complex(zero, zero), complex(inf, nan)}, {complex(1, zero), complex(-zero, -zero), complex(-inf, nan)}, {complex(1, zero), complex(zero, 1), complex(zero, -1)}, {complex(1, zero), complex(-zero, -1), complex(-zero, 1)}, {complex(1, zero), complex(zero, 2), complex(zero, -0.5)}, {complex(1, zero), complex(nan, nan), complex(nan, nan)}, {complex(1, zero), complex(nan, inf), complex(zero, -zero)}, {complex(1, zero), complex(nan, -inf), complex(-zero, zero)}, {complex(1, zero), complex(1, zero), complex(1, zero)}, {complex(1, zero), complex(1, -zero), complex(1, zero)}, {complex(1, zero), complex(1, 1), complex(0.5, -0.5)}, {complex(1, zero), complex(1, -1), complex(0.5, 0.5)}, {complex(1, zero), complex(1, 2), complex(0.2, -0.4)}, {complex(1, zero), complex(nan, nan), complex(nan, nan)}, {complex(1, zero), complex(nan, inf), complex(zero, -zero)}, {complex(1, zero), complex(nan, -inf), complex(-zero, zero)}, {complex(1, zero), complex(-1, zero), complex(-1, -zero)}, {complex(1, zero), complex(-1, -zero), complex(-1, -zero)}, {complex(1, zero), complex(-1, 1), complex(-0.5, -0.5)}, {complex(1, zero), complex(-1, -1), complex(-0.5, 0.5)}, {complex(1, zero), complex(-1, 2), complex(-0.2, -0.4)}, {complex(1, zero), complex(nan, nan), complex(nan, nan)}, {complex(1, zero), complex(nan, inf), complex(zero, -zero)}, {complex(1, zero), complex(nan, -inf), complex(-zero, zero)}, {complex(1, zero), complex(2, zero), complex(0.5, zero)}, {complex(1, zero), complex(2, -zero), complex(0.5, zero)}, {complex(1, zero), complex(2, 1), complex(0.4, -0.2)}, {complex(1, zero), complex(2, -1), complex(0.4, 0.2)}, {complex(1, zero), complex(2, 2), complex(0.25, -0.25)}, {complex(1, zero), complex(nan, nan), complex(nan, nan)}, {complex(1, zero), complex(nan, inf), complex(zero, -zero)}, {complex(1, zero), complex(nan, -inf), complex(-zero, zero)}, {complex(1, zero), complex(nan, zero), complex(nan, nan)}, {complex(1, zero), complex(nan, -zero), complex(nan, nan)}, {complex(1, zero), complex(nan, 1), complex(nan, nan)}, {complex(1, zero), complex(nan, -1), complex(nan, nan)}, {complex(1, zero), complex(nan, 2), complex(nan, nan)}, {complex(1, zero), complex(nan, nan), complex(nan, nan)}, {complex(1, zero), complex(nan, inf), complex(zero, -zero)}, {complex(1, zero), complex(nan, -inf), complex(-zero, zero)}, {complex(1, zero), complex(inf, zero), complex(zero, zero)}, {complex(1, zero), complex(inf, -zero), complex(zero, zero)}, {complex(1, zero), complex(inf, 1), complex(zero, zero)}, {complex(1, zero), complex(inf, -1), complex(zero, zero)}, {complex(1, zero), complex(inf, 2), complex(zero, zero)}, {complex(1, zero), complex(nan, nan), complex(nan, nan)}, {complex(1, zero), complex(nan, inf), complex(zero, -zero)}, {complex(1, zero), complex(nan, -inf), complex(-zero, zero)}, {complex(1, zero), complex(-inf, zero), complex(-zero, -zero)}, {complex(1, zero), complex(-inf, -zero), complex(-zero, -zero)}, {complex(1, zero), complex(-inf, 1), complex(-zero, -zero)}, {complex(1, zero), complex(-inf, -1), complex(-zero, -zero)}, {complex(1, zero), complex(-inf, 2), complex(-zero, -zero)}, {complex(1, zero), complex(nan, nan), complex(nan, nan)}, {complex(1, zero), complex(nan, inf), complex(zero, -zero)}, {complex(1, zero), complex(nan, -inf), complex(-zero, zero)}, {complex(1, -zero), complex(zero, zero), complex(inf, nan)}, {complex(1, -zero), complex(zero, -zero), complex(inf, nan)}, {complex(1, -zero), complex(zero, 1), complex(zero, -1)}, {complex(1, -zero), complex(zero, -1), complex(zero, 1)}, {complex(1, -zero), complex(zero, 2), complex(zero, -0.5)}, {complex(1, -zero), complex(nan, nan), complex(nan, nan)}, {complex(1, -zero), complex(nan, inf), complex(-zero, -zero)}, {complex(1, -zero), complex(nan, -inf), complex(zero, zero)}, {complex(1, -zero), complex(zero, zero), complex(inf, nan)}, {complex(1, -zero), complex(-zero, -zero), complex(-inf, nan)}, {complex(1, -zero), complex(zero, 1), complex(zero, -1)}, {complex(1, -zero), complex(-zero, -1), complex(-zero, 1)}, {complex(1, -zero), complex(zero, 2), complex(zero, -0.5)}, {complex(1, -zero), complex(nan, nan), complex(nan, nan)}, {complex(1, -zero), complex(nan, inf), complex(-zero, -zero)}, {complex(1, -zero), complex(nan, -inf), complex(zero, zero)}, {complex(1, -zero), complex(1, zero), complex(1, -zero)}, {complex(1, -zero), complex(1, -zero), complex(1, zero)}, {complex(1, -zero), complex(1, 1), complex(0.5, -0.5)}, {complex(1, -zero), complex(1, -1), complex(0.5, 0.5)}, {complex(1, -zero), complex(1, 2), complex(0.2, -0.4)}, {complex(1, -zero), complex(nan, nan), complex(nan, nan)}, {complex(1, -zero), complex(nan, inf), complex(-zero, -zero)}, {complex(1, -zero), complex(nan, -inf), complex(zero, zero)}, {complex(1, -zero), complex(-1, zero), complex(-1, -zero)}, {complex(1, -zero), complex(-1, -zero), complex(-1, zero)}, {complex(1, -zero), complex(-1, 1), complex(-0.5, -0.5)}, {complex(1, -zero), complex(-1, -1), complex(-0.5, 0.5)}, {complex(1, -zero), complex(-1, 2), complex(-0.2, -0.4)}, {complex(1, -zero), complex(nan, nan), complex(nan, nan)}, {complex(1, -zero), complex(nan, inf), complex(-zero, -zero)}, {complex(1, -zero), complex(nan, -inf), complex(zero, zero)}, {complex(1, -zero), complex(2, zero), complex(0.5, -zero)}, {complex(1, -zero), complex(2, -zero), complex(0.5, zero)}, {complex(1, -zero), complex(2, 1), complex(0.4, -0.2)}, {complex(1, -zero), complex(2, -1), complex(0.4, 0.2)}, {complex(1, -zero), complex(2, 2), complex(0.25, -0.25)}, {complex(1, -zero), complex(nan, nan), complex(nan, nan)}, {complex(1, -zero), complex(nan, inf), complex(-zero, -zero)}, {complex(1, -zero), complex(nan, -inf), complex(zero, zero)}, {complex(1, -zero), complex(nan, zero), complex(nan, nan)}, {complex(1, -zero), complex(nan, -zero), complex(nan, nan)}, {complex(1, -zero), complex(nan, 1), complex(nan, nan)}, {complex(1, -zero), complex(nan, -1), complex(nan, nan)}, {complex(1, -zero), complex(nan, 2), complex(nan, nan)}, {complex(1, -zero), complex(nan, nan), complex(nan, nan)}, {complex(1, -zero), complex(nan, inf), complex(-zero, -zero)}, {complex(1, -zero), complex(nan, -inf), complex(zero, zero)}, {complex(1, -zero), complex(inf, zero), complex(zero, -zero)}, {complex(1, -zero), complex(inf, -zero), complex(zero, zero)}, {complex(1, -zero), complex(inf, 1), complex(zero, -zero)}, {complex(1, -zero), complex(inf, -1), complex(zero, zero)}, {complex(1, -zero), complex(inf, 2), complex(zero, -zero)}, {complex(1, -zero), complex(nan, nan), complex(nan, nan)}, {complex(1, -zero), complex(nan, inf), complex(-zero, -zero)}, {complex(1, -zero), complex(nan, -inf), complex(zero, zero)}, {complex(1, -zero), complex(-inf, zero), complex(-zero, -zero)}, {complex(1, -zero), complex(-inf, -zero), complex(-zero, zero)}, {complex(1, -zero), complex(-inf, 1), complex(-zero, -zero)}, {complex(1, -zero), complex(-inf, -1), complex(-zero, zero)}, {complex(1, -zero), complex(-inf, 2), complex(-zero, -zero)}, {complex(1, -zero), complex(nan, nan), complex(nan, nan)}, {complex(1, -zero), complex(nan, inf), complex(-zero, -zero)}, {complex(1, -zero), complex(nan, -inf), complex(zero, zero)}, {complex(1, 1), complex(zero, zero), complex(inf, inf)}, {complex(1, 1), complex(zero, -zero), complex(inf, inf)}, {complex(1, 1), complex(zero, 1), complex(1, -1)}, {complex(1, 1), complex(zero, -1), complex(-1, 1)}, {complex(1, 1), complex(zero, 2), complex(0.5, -0.5)}, {complex(1, 1), complex(nan, nan), complex(nan, nan)}, {complex(1, 1), complex(nan, inf), complex(zero, -zero)}, {complex(1, 1), complex(nan, -inf), complex(-zero, zero)}, {complex(1, 1), complex(zero, zero), complex(inf, inf)}, {complex(1, 1), complex(-zero, -zero), complex(-inf, -inf)}, {complex(1, 1), complex(zero, 1), complex(1, -1)}, {complex(1, 1), complex(-zero, -1), complex(-1, 1)}, {complex(1, 1), complex(zero, 2), complex(0.5, -0.5)}, {complex(1, 1), complex(nan, nan), complex(nan, nan)}, {complex(1, 1), complex(nan, inf), complex(zero, -zero)}, {complex(1, 1), complex(nan, -inf), complex(-zero, zero)}, {complex(1, 1), complex(1, zero), complex(1, 1)}, {complex(1, 1), complex(1, -zero), complex(1, 1)}, {complex(1, 1), complex(1, 1), complex(1, zero)}, {complex(1, 1), complex(1, -1), complex(zero, 1)}, {complex(1, 1), complex(1, 2), complex(0.6, -0.2)}, {complex(1, 1), complex(nan, nan), complex(nan, nan)}, {complex(1, 1), complex(nan, inf), complex(zero, -zero)}, {complex(1, 1), complex(nan, -inf), complex(-zero, zero)}, {complex(1, 1), complex(-1, zero), complex(-1, -1)}, {complex(1, 1), complex(-1, -zero), complex(-1, -1)}, {complex(1, 1), complex(-1, 1), complex(-zero, -1)}, {complex(1, 1), complex(-1, -1), complex(-1, -zero)}, {complex(1, 1), complex(-1, 2), complex(0.2, -0.6)}, {complex(1, 1), complex(nan, nan), complex(nan, nan)}, {complex(1, 1), complex(nan, inf), complex(zero, -zero)}, {complex(1, 1), complex(nan, -inf), complex(-zero, zero)}, {complex(1, 1), complex(2, zero), complex(0.5, 0.5)}, {complex(1, 1), complex(2, -zero), complex(0.5, 0.5)}, {complex(1, 1), complex(2, 1), complex(0.6, 0.2)}, {complex(1, 1), complex(2, -1), complex(0.2, 0.6)}, {complex(1, 1), complex(2, 2), complex(0.5, zero)}, {complex(1, 1), complex(nan, nan), complex(nan, nan)}, {complex(1, 1), complex(nan, inf), complex(zero, -zero)}, {complex(1, 1), complex(nan, -inf), complex(-zero, zero)}, {complex(1, 1), complex(nan, zero), complex(nan, nan)}, {complex(1, 1), complex(nan, -zero), complex(nan, nan)}, {complex(1, 1), complex(nan, 1), complex(nan, nan)}, {complex(1, 1), complex(nan, -1), complex(nan, nan)}, {complex(1, 1), complex(nan, 2), complex(nan, nan)}, {complex(1, 1), complex(nan, nan), complex(nan, nan)}, {complex(1, 1), complex(nan, inf), complex(zero, -zero)}, {complex(1, 1), complex(nan, -inf), complex(-zero, zero)}, {complex(1, 1), complex(inf, zero), complex(zero, zero)}, {complex(1, 1), complex(inf, -zero), complex(zero, zero)}, {complex(1, 1), complex(inf, 1), complex(zero, zero)}, {complex(1, 1), complex(inf, -1), complex(zero, zero)}, {complex(1, 1), complex(inf, 2), complex(zero, zero)}, {complex(1, 1), complex(nan, nan), complex(nan, nan)}, {complex(1, 1), complex(nan, inf), complex(zero, -zero)}, {complex(1, 1), complex(nan, -inf), complex(-zero, zero)}, {complex(1, 1), complex(-inf, zero), complex(-zero, -zero)}, {complex(1, 1), complex(-inf, -zero), complex(-zero, -zero)}, {complex(1, 1), complex(-inf, 1), complex(-zero, -zero)}, {complex(1, 1), complex(-inf, -1), complex(-zero, -zero)}, {complex(1, 1), complex(-inf, 2), complex(-zero, -zero)}, {complex(1, 1), complex(nan, nan), complex(nan, nan)}, {complex(1, 1), complex(nan, inf), complex(zero, -zero)}, {complex(1, 1), complex(nan, -inf), complex(-zero, zero)}, {complex(1, -1), complex(zero, zero), complex(inf, -inf)}, {complex(1, -1), complex(zero, -zero), complex(inf, -inf)}, {complex(1, -1), complex(zero, 1), complex(-1, -1)}, {complex(1, -1), complex(zero, -1), complex(1, 1)}, {complex(1, -1), complex(zero, 2), complex(-0.5, -0.5)}, {complex(1, -1), complex(nan, nan), complex(nan, nan)}, {complex(1, -1), complex(nan, inf), complex(-zero, -zero)}, {complex(1, -1), complex(nan, -inf), complex(zero, zero)}, {complex(1, -1), complex(zero, zero), complex(inf, -inf)}, {complex(1, -1), complex(-zero, -zero), complex(-inf, inf)}, {complex(1, -1), complex(zero, 1), complex(-1, -1)}, {complex(1, -1), complex(-zero, -1), complex(1, 1)}, {complex(1, -1), complex(zero, 2), complex(-0.5, -0.5)}, {complex(1, -1), complex(nan, nan), complex(nan, nan)}, {complex(1, -1), complex(nan, inf), complex(-zero, -zero)}, {complex(1, -1), complex(nan, -inf), complex(zero, zero)}, {complex(1, -1), complex(1, zero), complex(1, -1)}, {complex(1, -1), complex(1, -zero), complex(1, -1)}, {complex(1, -1), complex(1, 1), complex(zero, -1)}, {complex(1, -1), complex(1, -1), complex(1, zero)}, {complex(1, -1), complex(1, 2), complex(-0.2, -0.6)}, {complex(1, -1), complex(nan, nan), complex(nan, nan)}, {complex(1, -1), complex(nan, inf), complex(-zero, -zero)}, {complex(1, -1), complex(nan, -inf), complex(zero, zero)}, {complex(1, -1), complex(-1, zero), complex(-1, 1)}, {complex(1, -1), complex(-1, -zero), complex(-1, 1)}, {complex(1, -1), complex(-1, 1), complex(-1, -zero)}, {complex(1, -1), complex(-1, -1), complex(-zero, 1)}, {complex(1, -1), complex(-1, 2), complex(-0.6, -0.2)}, {complex(1, -1), complex(nan, nan), complex(nan, nan)}, {complex(1, -1), complex(nan, inf), complex(-zero, -zero)}, {complex(1, -1), complex(nan, -inf), complex(zero, zero)}, {complex(1, -1), complex(2, zero), complex(0.5, -0.5)}, {complex(1, -1), complex(2, -zero), complex(0.5, -0.5)}, {complex(1, -1), complex(2, 1), complex(0.2, -0.6)}, {complex(1, -1), complex(2, -1), complex(0.6, -0.2)}, {complex(1, -1), complex(2, 2), complex(zero, -0.5)}, {complex(1, -1), complex(nan, nan), complex(nan, nan)}, {complex(1, -1), complex(nan, inf), complex(-zero, -zero)}, {complex(1, -1), complex(nan, -inf), complex(zero, zero)}, {complex(1, -1), complex(nan, zero), complex(nan, nan)}, {complex(1, -1), complex(nan, -zero), complex(nan, nan)}, {complex(1, -1), complex(nan, 1), complex(nan, nan)}, {complex(1, -1), complex(nan, -1), complex(nan, nan)}, {complex(1, -1), complex(nan, 2), complex(nan, nan)}, {complex(1, -1), complex(nan, nan), complex(nan, nan)}, {complex(1, -1), complex(nan, inf), complex(-zero, -zero)}, {complex(1, -1), complex(nan, -inf), complex(zero, zero)}, {complex(1, -1), complex(inf, zero), complex(zero, -zero)}, {complex(1, -1), complex(inf, -zero), complex(zero, -zero)}, {complex(1, -1), complex(inf, 1), complex(zero, -zero)}, {complex(1, -1), complex(inf, -1), complex(zero, -zero)}, {complex(1, -1), complex(inf, 2), complex(zero, -zero)}, {complex(1, -1), complex(nan, nan), complex(nan, nan)}, {complex(1, -1), complex(nan, inf), complex(-zero, -zero)}, {complex(1, -1), complex(nan, -inf), complex(zero, zero)}, {complex(1, -1), complex(-inf, zero), complex(-zero, zero)}, {complex(1, -1), complex(-inf, -zero), complex(-zero, zero)}, {complex(1, -1), complex(-inf, 1), complex(-zero, zero)}, {complex(1, -1), complex(-inf, -1), complex(-zero, zero)}, {complex(1, -1), complex(-inf, 2), complex(-zero, zero)}, {complex(1, -1), complex(nan, nan), complex(nan, nan)}, {complex(1, -1), complex(nan, inf), complex(-zero, -zero)}, {complex(1, -1), complex(nan, -inf), complex(zero, zero)}, {complex(1, 2), complex(zero, zero), complex(inf, inf)}, {complex(1, 2), complex(zero, -zero), complex(inf, inf)}, {complex(1, 2), complex(zero, 1), complex(2, -1)}, {complex(1, 2), complex(zero, -1), complex(-2, 1)}, {complex(1, 2), complex(zero, 2), complex(1, -0.5)}, {complex(1, 2), complex(nan, nan), complex(nan, nan)}, {complex(1, 2), complex(nan, inf), complex(zero, -zero)}, {complex(1, 2), complex(nan, -inf), complex(-zero, zero)}, {complex(1, 2), complex(zero, zero), complex(inf, inf)}, {complex(1, 2), complex(-zero, -zero), complex(-inf, -inf)}, {complex(1, 2), complex(zero, 1), complex(2, -1)}, {complex(1, 2), complex(-zero, -1), complex(-2, 1)}, {complex(1, 2), complex(zero, 2), complex(1, -0.5)}, {complex(1, 2), complex(nan, nan), complex(nan, nan)}, {complex(1, 2), complex(nan, inf), complex(zero, -zero)}, {complex(1, 2), complex(nan, -inf), complex(-zero, zero)}, {complex(1, 2), complex(1, zero), complex(1, 2)}, {complex(1, 2), complex(1, -zero), complex(1, 2)}, {complex(1, 2), complex(1, 1), complex(1.5, 0.5)}, {complex(1, 2), complex(1, -1), complex(-0.5, 1.5)}, {complex(1, 2), complex(1, 2), complex(1, zero)}, {complex(1, 2), complex(nan, nan), complex(nan, nan)}, {complex(1, 2), complex(nan, inf), complex(zero, -zero)}, {complex(1, 2), complex(nan, -inf), complex(-zero, zero)}, {complex(1, 2), complex(-1, zero), complex(-1, -2)}, {complex(1, 2), complex(-1, -zero), complex(-1, -2)}, {complex(1, 2), complex(-1, 1), complex(0.5, -1.5)}, {complex(1, 2), complex(-1, -1), complex(-1.5, -0.5)}, {complex(1, 2), complex(-1, 2), complex(0.6, -0.8)}, {complex(1, 2), complex(nan, nan), complex(nan, nan)}, {complex(1, 2), complex(nan, inf), complex(zero, -zero)}, {complex(1, 2), complex(nan, -inf), complex(-zero, zero)}, {complex(1, 2), complex(2, zero), complex(0.5, 1)}, {complex(1, 2), complex(2, -zero), complex(0.5, 1)}, {complex(1, 2), complex(2, 1), complex(0.8, 0.6)}, {complex(1, 2), complex(2, -1), complex(zero, 1)}, {complex(1, 2), complex(2, 2), complex(0.75, 0.25)}, {complex(1, 2), complex(nan, nan), complex(nan, nan)}, {complex(1, 2), complex(nan, inf), complex(zero, -zero)}, {complex(1, 2), complex(nan, -inf), complex(-zero, zero)}, {complex(1, 2), complex(nan, zero), complex(nan, nan)}, {complex(1, 2), complex(nan, -zero), complex(nan, nan)}, {complex(1, 2), complex(nan, 1), complex(nan, nan)}, {complex(1, 2), complex(nan, -1), complex(nan, nan)}, {complex(1, 2), complex(nan, 2), complex(nan, nan)}, {complex(1, 2), complex(nan, nan), complex(nan, nan)}, {complex(1, 2), complex(nan, inf), complex(zero, -zero)}, {complex(1, 2), complex(nan, -inf), complex(-zero, zero)}, {complex(1, 2), complex(inf, zero), complex(zero, zero)}, {complex(1, 2), complex(inf, -zero), complex(zero, zero)}, {complex(1, 2), complex(inf, 1), complex(zero, zero)}, {complex(1, 2), complex(inf, -1), complex(zero, zero)}, {complex(1, 2), complex(inf, 2), complex(zero, zero)}, {complex(1, 2), complex(nan, nan), complex(nan, nan)}, {complex(1, 2), complex(nan, inf), complex(zero, -zero)}, {complex(1, 2), complex(nan, -inf), complex(-zero, zero)}, {complex(1, 2), complex(-inf, zero), complex(-zero, -zero)}, {complex(1, 2), complex(-inf, -zero), complex(-zero, -zero)}, {complex(1, 2), complex(-inf, 1), complex(-zero, -zero)}, {complex(1, 2), complex(-inf, -1), complex(-zero, -zero)}, {complex(1, 2), complex(-inf, 2), complex(-zero, -zero)}, {complex(1, 2), complex(nan, nan), complex(nan, nan)}, {complex(1, 2), complex(nan, inf), complex(zero, -zero)}, {complex(1, 2), complex(nan, -inf), complex(-zero, zero)}, {complex(nan, nan), complex(zero, zero), complex(nan, nan)}, {complex(nan, nan), complex(zero, -zero), complex(nan, nan)}, {complex(nan, nan), complex(zero, 1), complex(nan, nan)}, {complex(nan, nan), complex(zero, -1), complex(nan, nan)}, {complex(nan, nan), complex(zero, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(zero, zero), complex(nan, nan)}, {complex(nan, nan), complex(-zero, -zero), complex(nan, nan)}, {complex(nan, nan), complex(zero, 1), complex(nan, nan)}, {complex(nan, nan), complex(-zero, -1), complex(nan, nan)}, {complex(nan, nan), complex(zero, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(1, zero), complex(nan, nan)}, {complex(nan, nan), complex(1, -zero), complex(nan, nan)}, {complex(nan, nan), complex(1, 1), complex(nan, nan)}, {complex(nan, nan), complex(1, -1), complex(nan, nan)}, {complex(nan, nan), complex(1, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(-1, zero), complex(nan, nan)}, {complex(nan, nan), complex(-1, -zero), complex(nan, nan)}, {complex(nan, nan), complex(-1, 1), complex(nan, nan)}, {complex(nan, nan), complex(-1, -1), complex(nan, nan)}, {complex(nan, nan), complex(-1, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(2, zero), complex(nan, nan)}, {complex(nan, nan), complex(2, -zero), complex(nan, nan)}, {complex(nan, nan), complex(2, 1), complex(nan, nan)}, {complex(nan, nan), complex(2, -1), complex(nan, nan)}, {complex(nan, nan), complex(2, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, zero), complex(nan, nan)}, {complex(nan, nan), complex(nan, -zero), complex(nan, nan)}, {complex(nan, nan), complex(nan, 1), complex(nan, nan)}, {complex(nan, nan), complex(nan, -1), complex(nan, nan)}, {complex(nan, nan), complex(nan, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(inf, zero), complex(nan, nan)}, {complex(nan, nan), complex(inf, -zero), complex(nan, nan)}, {complex(nan, nan), complex(inf, 1), complex(nan, nan)}, {complex(nan, nan), complex(inf, -1), complex(nan, nan)}, {complex(nan, nan), complex(inf, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(-inf, zero), complex(nan, nan)}, {complex(nan, nan), complex(-inf, -zero), complex(nan, nan)}, {complex(nan, nan), complex(-inf, 1), complex(nan, nan)}, {complex(nan, nan), complex(-inf, -1), complex(nan, nan)}, {complex(nan, nan), complex(-inf, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(zero, zero), complex(nan, inf)}, {complex(nan, inf), complex(zero, -zero), complex(nan, inf)}, {complex(nan, inf), complex(zero, 1), complex(inf, nan)}, {complex(nan, inf), complex(zero, -1), complex(-inf, nan)}, {complex(nan, inf), complex(zero, 2), complex(inf, nan)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(zero, zero), complex(nan, inf)}, {complex(nan, inf), complex(-zero, -zero), complex(nan, -inf)}, {complex(nan, inf), complex(zero, 1), complex(inf, nan)}, {complex(nan, inf), complex(-zero, -1), complex(-inf, nan)}, {complex(nan, inf), complex(zero, 2), complex(inf, nan)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(1, zero), complex(nan, inf)}, {complex(nan, inf), complex(1, -zero), complex(nan, inf)}, {complex(nan, inf), complex(1, 1), complex(inf, inf)}, {complex(nan, inf), complex(1, -1), complex(-inf, inf)}, {complex(nan, inf), complex(1, 2), complex(inf, inf)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(-1, zero), complex(nan, -inf)}, {complex(nan, inf), complex(-1, -zero), complex(nan, -inf)}, {complex(nan, inf), complex(-1, 1), complex(inf, -inf)}, {complex(nan, inf), complex(-1, -1), complex(-inf, -inf)}, {complex(nan, inf), complex(-1, 2), complex(inf, -inf)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(2, zero), complex(nan, inf)}, {complex(nan, inf), complex(2, -zero), complex(nan, inf)}, {complex(nan, inf), complex(2, 1), complex(inf, inf)}, {complex(nan, inf), complex(2, -1), complex(-inf, inf)}, {complex(nan, inf), complex(2, 2), complex(inf, inf)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, zero), complex(nan, nan)}, {complex(nan, inf), complex(nan, -zero), complex(nan, nan)}, {complex(nan, inf), complex(nan, 1), complex(nan, nan)}, {complex(nan, inf), complex(nan, -1), complex(nan, nan)}, {complex(nan, inf), complex(nan, 2), complex(nan, nan)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(inf, zero), complex(nan, nan)}, {complex(nan, inf), complex(inf, -zero), complex(nan, nan)}, {complex(nan, inf), complex(inf, 1), complex(nan, nan)}, {complex(nan, inf), complex(inf, -1), complex(nan, nan)}, {complex(nan, inf), complex(inf, 2), complex(nan, nan)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(-inf, zero), complex(nan, nan)}, {complex(nan, inf), complex(-inf, -zero), complex(nan, nan)}, {complex(nan, inf), complex(-inf, 1), complex(nan, nan)}, {complex(nan, inf), complex(-inf, -1), complex(nan, nan)}, {complex(nan, inf), complex(-inf, 2), complex(nan, nan)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(zero, zero), complex(nan, -inf)}, {complex(nan, -inf), complex(zero, -zero), complex(nan, -inf)}, {complex(nan, -inf), complex(zero, 1), complex(-inf, nan)}, {complex(nan, -inf), complex(zero, -1), complex(inf, nan)}, {complex(nan, -inf), complex(zero, 2), complex(-inf, nan)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(zero, zero), complex(nan, -inf)}, {complex(nan, -inf), complex(-zero, -zero), complex(nan, inf)}, {complex(nan, -inf), complex(zero, 1), complex(-inf, nan)}, {complex(nan, -inf), complex(-zero, -1), complex(inf, nan)}, {complex(nan, -inf), complex(zero, 2), complex(-inf, nan)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(1, zero), complex(nan, -inf)}, {complex(nan, -inf), complex(1, -zero), complex(nan, -inf)}, {complex(nan, -inf), complex(1, 1), complex(-inf, -inf)}, {complex(nan, -inf), complex(1, -1), complex(inf, -inf)}, {complex(nan, -inf), complex(1, 2), complex(-inf, -inf)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(-1, zero), complex(nan, inf)}, {complex(nan, -inf), complex(-1, -zero), complex(nan, inf)}, {complex(nan, -inf), complex(-1, 1), complex(-inf, inf)}, {complex(nan, -inf), complex(-1, -1), complex(inf, inf)}, {complex(nan, -inf), complex(-1, 2), complex(-inf, inf)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(2, zero), complex(nan, -inf)}, {complex(nan, -inf), complex(2, -zero), complex(nan, -inf)}, {complex(nan, -inf), complex(2, 1), complex(-inf, -inf)}, {complex(nan, -inf), complex(2, -1), complex(inf, -inf)}, {complex(nan, -inf), complex(2, 2), complex(-inf, -inf)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, zero), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -zero), complex(nan, nan)}, {complex(nan, -inf), complex(nan, 1), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -1), complex(nan, nan)}, {complex(nan, -inf), complex(nan, 2), complex(nan, nan)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(inf, zero), complex(nan, nan)}, {complex(nan, -inf), complex(inf, -zero), complex(nan, nan)}, {complex(nan, -inf), complex(inf, 1), complex(nan, nan)}, {complex(nan, -inf), complex(inf, -1), complex(nan, nan)}, {complex(nan, -inf), complex(inf, 2), complex(nan, nan)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(-inf, zero), complex(nan, nan)}, {complex(nan, -inf), complex(-inf, -zero), complex(nan, nan)}, {complex(nan, -inf), complex(-inf, 1), complex(nan, nan)}, {complex(nan, -inf), complex(-inf, -1), complex(nan, nan)}, {complex(nan, -inf), complex(-inf, 2), complex(nan, nan)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(-1, zero), complex(zero, zero), complex(-inf, nan)}, {complex(-1, zero), complex(zero, -zero), complex(-inf, nan)}, {complex(-1, zero), complex(zero, 1), complex(zero, 1)}, {complex(-1, zero), complex(zero, -1), complex(-zero, -1)}, {complex(-1, zero), complex(zero, 2), complex(zero, 0.5)}, {complex(-1, zero), complex(nan, nan), complex(nan, nan)}, {complex(-1, zero), complex(nan, inf), complex(zero, zero)}, {complex(-1, zero), complex(nan, -inf), complex(zero, -zero)}, {complex(-1, zero), complex(zero, zero), complex(-inf, nan)}, {complex(-1, zero), complex(-zero, -zero), complex(inf, nan)}, {complex(-1, zero), complex(zero, 1), complex(zero, 1)}, {complex(-1, zero), complex(-zero, -1), complex(-zero, -1)}, {complex(-1, zero), complex(zero, 2), complex(zero, 0.5)}, {complex(-1, zero), complex(nan, nan), complex(nan, nan)}, {complex(-1, zero), complex(nan, inf), complex(zero, zero)}, {complex(-1, zero), complex(nan, -inf), complex(zero, -zero)}, {complex(-1, zero), complex(1, zero), complex(-1, zero)}, {complex(-1, zero), complex(1, -zero), complex(-1, zero)}, {complex(-1, zero), complex(1, 1), complex(-0.5, 0.5)}, {complex(-1, zero), complex(1, -1), complex(-0.5, -0.5)}, {complex(-1, zero), complex(1, 2), complex(-0.2, 0.4)}, {complex(-1, zero), complex(nan, nan), complex(nan, nan)}, {complex(-1, zero), complex(nan, inf), complex(zero, zero)}, {complex(-1, zero), complex(nan, -inf), complex(zero, -zero)}, {complex(-1, zero), complex(-1, zero), complex(1, -zero)}, {complex(-1, zero), complex(-1, -zero), complex(1, -zero)}, {complex(-1, zero), complex(-1, 1), complex(0.5, 0.5)}, {complex(-1, zero), complex(-1, -1), complex(0.5, -0.5)}, {complex(-1, zero), complex(-1, 2), complex(0.2, 0.4)}, {complex(-1, zero), complex(nan, nan), complex(nan, nan)}, {complex(-1, zero), complex(nan, inf), complex(zero, zero)}, {complex(-1, zero), complex(nan, -inf), complex(zero, -zero)}, {complex(-1, zero), complex(2, zero), complex(-0.5, zero)}, {complex(-1, zero), complex(2, -zero), complex(-0.5, zero)}, {complex(-1, zero), complex(2, 1), complex(-0.4, 0.2)}, {complex(-1, zero), complex(2, -1), complex(-0.4, -0.2)}, {complex(-1, zero), complex(2, 2), complex(-0.25, 0.25)}, {complex(-1, zero), complex(nan, nan), complex(nan, nan)}, {complex(-1, zero), complex(nan, inf), complex(zero, zero)}, {complex(-1, zero), complex(nan, -inf), complex(zero, -zero)}, {complex(-1, zero), complex(nan, zero), complex(nan, nan)}, {complex(-1, zero), complex(nan, -zero), complex(nan, nan)}, {complex(-1, zero), complex(nan, 1), complex(nan, nan)}, {complex(-1, zero), complex(nan, -1), complex(nan, nan)}, {complex(-1, zero), complex(nan, 2), complex(nan, nan)}, {complex(-1, zero), complex(nan, nan), complex(nan, nan)}, {complex(-1, zero), complex(nan, inf), complex(zero, zero)}, {complex(-1, zero), complex(nan, -inf), complex(zero, -zero)}, {complex(-1, zero), complex(inf, zero), complex(-zero, zero)}, {complex(-1, zero), complex(inf, -zero), complex(-zero, zero)}, {complex(-1, zero), complex(inf, 1), complex(-zero, zero)}, {complex(-1, zero), complex(inf, -1), complex(-zero, zero)}, {complex(-1, zero), complex(inf, 2), complex(-zero, zero)}, {complex(-1, zero), complex(nan, nan), complex(nan, nan)}, {complex(-1, zero), complex(nan, inf), complex(zero, zero)}, {complex(-1, zero), complex(nan, -inf), complex(zero, -zero)}, {complex(-1, zero), complex(-inf, zero), complex(zero, -zero)}, {complex(-1, zero), complex(-inf, -zero), complex(zero, -zero)}, {complex(-1, zero), complex(-inf, 1), complex(zero, -zero)}, {complex(-1, zero), complex(-inf, -1), complex(zero, -zero)}, {complex(-1, zero), complex(-inf, 2), complex(zero, -zero)}, {complex(-1, zero), complex(nan, nan), complex(nan, nan)}, {complex(-1, zero), complex(nan, inf), complex(zero, zero)}, {complex(-1, zero), complex(nan, -inf), complex(zero, -zero)}, {complex(-1, -zero), complex(zero, zero), complex(-inf, nan)}, {complex(-1, -zero), complex(zero, -zero), complex(-inf, nan)}, {complex(-1, -zero), complex(zero, 1), complex(-zero, 1)}, {complex(-1, -zero), complex(zero, -1), complex(-zero, -1)}, {complex(-1, -zero), complex(zero, 2), complex(-zero, 0.5)}, {complex(-1, -zero), complex(nan, nan), complex(nan, nan)}, {complex(-1, -zero), complex(nan, inf), complex(zero, zero)}, {complex(-1, -zero), complex(nan, -inf), complex(zero, -zero)}, {complex(-1, -zero), complex(zero, zero), complex(-inf, nan)}, {complex(-1, -zero), complex(-zero, -zero), complex(inf, nan)}, {complex(-1, -zero), complex(zero, 1), complex(-zero, 1)}, {complex(-1, -zero), complex(-zero, -1), complex(zero, -1)}, {complex(-1, -zero), complex(zero, 2), complex(-zero, 0.5)}, {complex(-1, -zero), complex(nan, nan), complex(nan, nan)}, {complex(-1, -zero), complex(nan, inf), complex(zero, zero)}, {complex(-1, -zero), complex(nan, -inf), complex(zero, -zero)}, {complex(-1, -zero), complex(1, zero), complex(-1, zero)}, {complex(-1, -zero), complex(1, -zero), complex(-1, -zero)}, {complex(-1, -zero), complex(1, 1), complex(-0.5, 0.5)}, {complex(-1, -zero), complex(1, -1), complex(-0.5, -0.5)}, {complex(-1, -zero), complex(1, 2), complex(-0.2, 0.4)}, {complex(-1, -zero), complex(nan, nan), complex(nan, nan)}, {complex(-1, -zero), complex(nan, inf), complex(zero, zero)}, {complex(-1, -zero), complex(nan, -inf), complex(zero, -zero)}, {complex(-1, -zero), complex(-1, zero), complex(1, zero)}, {complex(-1, -zero), complex(-1, -zero), complex(1, -zero)}, {complex(-1, -zero), complex(-1, 1), complex(0.5, 0.5)}, {complex(-1, -zero), complex(-1, -1), complex(0.5, -0.5)}, {complex(-1, -zero), complex(-1, 2), complex(0.2, 0.4)}, {complex(-1, -zero), complex(nan, nan), complex(nan, nan)}, {complex(-1, -zero), complex(nan, inf), complex(zero, zero)}, {complex(-1, -zero), complex(nan, -inf), complex(zero, -zero)}, {complex(-1, -zero), complex(2, zero), complex(-0.5, zero)}, {complex(-1, -zero), complex(2, -zero), complex(-0.5, -zero)}, {complex(-1, -zero), complex(2, 1), complex(-0.4, 0.2)}, {complex(-1, -zero), complex(2, -1), complex(-0.4, -0.2)}, {complex(-1, -zero), complex(2, 2), complex(-0.25, 0.25)}, {complex(-1, -zero), complex(nan, nan), complex(nan, nan)}, {complex(-1, -zero), complex(nan, inf), complex(zero, zero)}, {complex(-1, -zero), complex(nan, -inf), complex(zero, -zero)}, {complex(-1, -zero), complex(nan, zero), complex(nan, nan)}, {complex(-1, -zero), complex(nan, -zero), complex(nan, nan)}, {complex(-1, -zero), complex(nan, 1), complex(nan, nan)}, {complex(-1, -zero), complex(nan, -1), complex(nan, nan)}, {complex(-1, -zero), complex(nan, 2), complex(nan, nan)}, {complex(-1, -zero), complex(nan, nan), complex(nan, nan)}, {complex(-1, -zero), complex(nan, inf), complex(zero, zero)}, {complex(-1, -zero), complex(nan, -inf), complex(zero, -zero)}, {complex(-1, -zero), complex(inf, zero), complex(-zero, zero)}, {complex(-1, -zero), complex(inf, -zero), complex(-zero, -zero)}, {complex(-1, -zero), complex(inf, 1), complex(-zero, zero)}, {complex(-1, -zero), complex(inf, -1), complex(-zero, -zero)}, {complex(-1, -zero), complex(inf, 2), complex(-zero, zero)}, {complex(-1, -zero), complex(nan, nan), complex(nan, nan)}, {complex(-1, -zero), complex(nan, inf), complex(zero, zero)}, {complex(-1, -zero), complex(nan, -inf), complex(zero, -zero)}, {complex(-1, -zero), complex(-inf, zero), complex(zero, zero)}, {complex(-1, -zero), complex(-inf, -zero), complex(zero, -zero)}, {complex(-1, -zero), complex(-inf, 1), complex(zero, zero)}, {complex(-1, -zero), complex(-inf, -1), complex(zero, -zero)}, {complex(-1, -zero), complex(-inf, 2), complex(zero, zero)}, {complex(-1, -zero), complex(nan, nan), complex(nan, nan)}, {complex(-1, -zero), complex(nan, inf), complex(zero, zero)}, {complex(-1, -zero), complex(nan, -inf), complex(zero, -zero)}, {complex(-1, 1), complex(zero, zero), complex(-inf, inf)}, {complex(-1, 1), complex(zero, -zero), complex(-inf, inf)}, {complex(-1, 1), complex(zero, 1), complex(1, 1)}, {complex(-1, 1), complex(zero, -1), complex(-1, -1)}, {complex(-1, 1), complex(zero, 2), complex(0.5, 0.5)}, {complex(-1, 1), complex(nan, nan), complex(nan, nan)}, {complex(-1, 1), complex(nan, inf), complex(zero, zero)}, {complex(-1, 1), complex(nan, -inf), complex(-zero, -zero)}, {complex(-1, 1), complex(zero, zero), complex(-inf, inf)}, {complex(-1, 1), complex(-zero, -zero), complex(inf, -inf)}, {complex(-1, 1), complex(zero, 1), complex(1, 1)}, {complex(-1, 1), complex(-zero, -1), complex(-1, -1)}, {complex(-1, 1), complex(zero, 2), complex(0.5, 0.5)}, {complex(-1, 1), complex(nan, nan), complex(nan, nan)}, {complex(-1, 1), complex(nan, inf), complex(zero, zero)}, {complex(-1, 1), complex(nan, -inf), complex(-zero, -zero)}, {complex(-1, 1), complex(1, zero), complex(-1, 1)}, {complex(-1, 1), complex(1, -zero), complex(-1, 1)}, {complex(-1, 1), complex(1, 1), complex(zero, 1)}, {complex(-1, 1), complex(1, -1), complex(-1, zero)}, {complex(-1, 1), complex(1, 2), complex(0.2, 0.6)}, {complex(-1, 1), complex(nan, nan), complex(nan, nan)}, {complex(-1, 1), complex(nan, inf), complex(zero, zero)}, {complex(-1, 1), complex(nan, -inf), complex(-zero, -zero)}, {complex(-1, 1), complex(-1, zero), complex(1, -1)}, {complex(-1, 1), complex(-1, -zero), complex(1, -1)}, {complex(-1, 1), complex(-1, 1), complex(1, -zero)}, {complex(-1, 1), complex(-1, -1), complex(-zero, -1)}, {complex(-1, 1), complex(-1, 2), complex(0.6, 0.2)}, {complex(-1, 1), complex(nan, nan), complex(nan, nan)}, {complex(-1, 1), complex(nan, inf), complex(zero, zero)}, {complex(-1, 1), complex(nan, -inf), complex(-zero, -zero)}, {complex(-1, 1), complex(2, zero), complex(-0.5, 0.5)}, {complex(-1, 1), complex(2, -zero), complex(-0.5, 0.5)}, {complex(-1, 1), complex(2, 1), complex(-0.2, 0.6)}, {complex(-1, 1), complex(2, -1), complex(-0.6, 0.2)}, {complex(-1, 1), complex(2, 2), complex(zero, 0.5)}, {complex(-1, 1), complex(nan, nan), complex(nan, nan)}, {complex(-1, 1), complex(nan, inf), complex(zero, zero)}, {complex(-1, 1), complex(nan, -inf), complex(-zero, -zero)}, {complex(-1, 1), complex(nan, zero), complex(nan, nan)}, {complex(-1, 1), complex(nan, -zero), complex(nan, nan)}, {complex(-1, 1), complex(nan, 1), complex(nan, nan)}, {complex(-1, 1), complex(nan, -1), complex(nan, nan)}, {complex(-1, 1), complex(nan, 2), complex(nan, nan)}, {complex(-1, 1), complex(nan, nan), complex(nan, nan)}, {complex(-1, 1), complex(nan, inf), complex(zero, zero)}, {complex(-1, 1), complex(nan, -inf), complex(-zero, -zero)}, {complex(-1, 1), complex(inf, zero), complex(-zero, zero)}, {complex(-1, 1), complex(inf, -zero), complex(-zero, zero)}, {complex(-1, 1), complex(inf, 1), complex(-zero, zero)}, {complex(-1, 1), complex(inf, -1), complex(-zero, zero)}, {complex(-1, 1), complex(inf, 2), complex(-zero, zero)}, {complex(-1, 1), complex(nan, nan), complex(nan, nan)}, {complex(-1, 1), complex(nan, inf), complex(zero, zero)}, {complex(-1, 1), complex(nan, -inf), complex(-zero, -zero)}, {complex(-1, 1), complex(-inf, zero), complex(zero, -zero)}, {complex(-1, 1), complex(-inf, -zero), complex(zero, -zero)}, {complex(-1, 1), complex(-inf, 1), complex(zero, -zero)}, {complex(-1, 1), complex(-inf, -1), complex(zero, -zero)}, {complex(-1, 1), complex(-inf, 2), complex(zero, -zero)}, {complex(-1, 1), complex(nan, nan), complex(nan, nan)}, {complex(-1, 1), complex(nan, inf), complex(zero, zero)}, {complex(-1, 1), complex(nan, -inf), complex(-zero, -zero)}, {complex(-1, -1), complex(zero, zero), complex(-inf, -inf)}, {complex(-1, -1), complex(zero, -zero), complex(-inf, -inf)}, {complex(-1, -1), complex(zero, 1), complex(-1, 1)}, {complex(-1, -1), complex(zero, -1), complex(1, -1)}, {complex(-1, -1), complex(zero, 2), complex(-0.5, 0.5)}, {complex(-1, -1), complex(nan, nan), complex(nan, nan)}, {complex(-1, -1), complex(nan, inf), complex(-zero, zero)}, {complex(-1, -1), complex(nan, -inf), complex(zero, -zero)}, {complex(-1, -1), complex(zero, zero), complex(-inf, -inf)}, {complex(-1, -1), complex(-zero, -zero), complex(inf, inf)}, {complex(-1, -1), complex(zero, 1), complex(-1, 1)}, {complex(-1, -1), complex(-zero, -1), complex(1, -1)}, {complex(-1, -1), complex(zero, 2), complex(-0.5, 0.5)}, {complex(-1, -1), complex(nan, nan), complex(nan, nan)}, {complex(-1, -1), complex(nan, inf), complex(-zero, zero)}, {complex(-1, -1), complex(nan, -inf), complex(zero, -zero)}, {complex(-1, -1), complex(1, zero), complex(-1, -1)}, {complex(-1, -1), complex(1, -zero), complex(-1, -1)}, {complex(-1, -1), complex(1, 1), complex(-1, zero)}, {complex(-1, -1), complex(1, -1), complex(zero, -1)}, {complex(-1, -1), complex(1, 2), complex(-0.6, 0.2)}, {complex(-1, -1), complex(nan, nan), complex(nan, nan)}, {complex(-1, -1), complex(nan, inf), complex(-zero, zero)}, {complex(-1, -1), complex(nan, -inf), complex(zero, -zero)}, {complex(-1, -1), complex(-1, zero), complex(1, 1)}, {complex(-1, -1), complex(-1, -zero), complex(1, 1)}, {complex(-1, -1), complex(-1, 1), complex(-zero, 1)}, {complex(-1, -1), complex(-1, -1), complex(1, -zero)}, {complex(-1, -1), complex(-1, 2), complex(-0.2, 0.6)}, {complex(-1, -1), complex(nan, nan), complex(nan, nan)}, {complex(-1, -1), complex(nan, inf), complex(-zero, zero)}, {complex(-1, -1), complex(nan, -inf), complex(zero, -zero)}, {complex(-1, -1), complex(2, zero), complex(-0.5, -0.5)}, {complex(-1, -1), complex(2, -zero), complex(-0.5, -0.5)}, {complex(-1, -1), complex(2, 1), complex(-0.6, -0.2)}, {complex(-1, -1), complex(2, -1), complex(-0.2, -0.6)}, {complex(-1, -1), complex(2, 2), complex(-0.5, zero)}, {complex(-1, -1), complex(nan, nan), complex(nan, nan)}, {complex(-1, -1), complex(nan, inf), complex(-zero, zero)}, {complex(-1, -1), complex(nan, -inf), complex(zero, -zero)}, {complex(-1, -1), complex(nan, zero), complex(nan, nan)}, {complex(-1, -1), complex(nan, -zero), complex(nan, nan)}, {complex(-1, -1), complex(nan, 1), complex(nan, nan)}, {complex(-1, -1), complex(nan, -1), complex(nan, nan)}, {complex(-1, -1), complex(nan, 2), complex(nan, nan)}, {complex(-1, -1), complex(nan, nan), complex(nan, nan)}, {complex(-1, -1), complex(nan, inf), complex(-zero, zero)}, {complex(-1, -1), complex(nan, -inf), complex(zero, -zero)}, {complex(-1, -1), complex(inf, zero), complex(-zero, -zero)}, {complex(-1, -1), complex(inf, -zero), complex(-zero, -zero)}, {complex(-1, -1), complex(inf, 1), complex(-zero, -zero)}, {complex(-1, -1), complex(inf, -1), complex(-zero, -zero)}, {complex(-1, -1), complex(inf, 2), complex(-zero, -zero)}, {complex(-1, -1), complex(nan, nan), complex(nan, nan)}, {complex(-1, -1), complex(nan, inf), complex(-zero, zero)}, {complex(-1, -1), complex(nan, -inf), complex(zero, -zero)}, {complex(-1, -1), complex(-inf, zero), complex(zero, zero)}, {complex(-1, -1), complex(-inf, -zero), complex(zero, zero)}, {complex(-1, -1), complex(-inf, 1), complex(zero, zero)}, {complex(-1, -1), complex(-inf, -1), complex(zero, zero)}, {complex(-1, -1), complex(-inf, 2), complex(zero, zero)}, {complex(-1, -1), complex(nan, nan), complex(nan, nan)}, {complex(-1, -1), complex(nan, inf), complex(-zero, zero)}, {complex(-1, -1), complex(nan, -inf), complex(zero, -zero)}, {complex(-1, 2), complex(zero, zero), complex(-inf, inf)}, {complex(-1, 2), complex(zero, -zero), complex(-inf, inf)}, {complex(-1, 2), complex(zero, 1), complex(2, 1)}, {complex(-1, 2), complex(zero, -1), complex(-2, -1)}, {complex(-1, 2), complex(zero, 2), complex(1, 0.5)}, {complex(-1, 2), complex(nan, nan), complex(nan, nan)}, {complex(-1, 2), complex(nan, inf), complex(zero, zero)}, {complex(-1, 2), complex(nan, -inf), complex(-zero, -zero)}, {complex(-1, 2), complex(zero, zero), complex(-inf, inf)}, {complex(-1, 2), complex(-zero, -zero), complex(inf, -inf)}, {complex(-1, 2), complex(zero, 1), complex(2, 1)}, {complex(-1, 2), complex(-zero, -1), complex(-2, -1)}, {complex(-1, 2), complex(zero, 2), complex(1, 0.5)}, {complex(-1, 2), complex(nan, nan), complex(nan, nan)}, {complex(-1, 2), complex(nan, inf), complex(zero, zero)}, {complex(-1, 2), complex(nan, -inf), complex(-zero, -zero)}, {complex(-1, 2), complex(1, zero), complex(-1, 2)}, {complex(-1, 2), complex(1, -zero), complex(-1, 2)}, {complex(-1, 2), complex(1, 1), complex(0.5, 1.5)}, {complex(-1, 2), complex(1, -1), complex(-1.5, 0.5)}, {complex(-1, 2), complex(1, 2), complex(0.6, 0.8)}, {complex(-1, 2), complex(nan, nan), complex(nan, nan)}, {complex(-1, 2), complex(nan, inf), complex(zero, zero)}, {complex(-1, 2), complex(nan, -inf), complex(-zero, -zero)}, {complex(-1, 2), complex(-1, zero), complex(1, -2)}, {complex(-1, 2), complex(-1, -zero), complex(1, -2)}, {complex(-1, 2), complex(-1, 1), complex(1.5, -0.5)}, {complex(-1, 2), complex(-1, -1), complex(-0.5, -1.5)}, {complex(-1, 2), complex(-1, 2), complex(1, zero)}, {complex(-1, 2), complex(nan, nan), complex(nan, nan)}, {complex(-1, 2), complex(nan, inf), complex(zero, zero)}, {complex(-1, 2), complex(nan, -inf), complex(-zero, -zero)}, {complex(-1, 2), complex(2, zero), complex(-0.5, 1)}, {complex(-1, 2), complex(2, -zero), complex(-0.5, 1)}, {complex(-1, 2), complex(2, 1), complex(zero, 1)}, {complex(-1, 2), complex(2, -1), complex(-0.8, 0.6)}, {complex(-1, 2), complex(2, 2), complex(0.25, 0.75)}, {complex(-1, 2), complex(nan, nan), complex(nan, nan)}, {complex(-1, 2), complex(nan, inf), complex(zero, zero)}, {complex(-1, 2), complex(nan, -inf), complex(-zero, -zero)}, {complex(-1, 2), complex(nan, zero), complex(nan, nan)}, {complex(-1, 2), complex(nan, -zero), complex(nan, nan)}, {complex(-1, 2), complex(nan, 1), complex(nan, nan)}, {complex(-1, 2), complex(nan, -1), complex(nan, nan)}, {complex(-1, 2), complex(nan, 2), complex(nan, nan)}, {complex(-1, 2), complex(nan, nan), complex(nan, nan)}, {complex(-1, 2), complex(nan, inf), complex(zero, zero)}, {complex(-1, 2), complex(nan, -inf), complex(-zero, -zero)}, {complex(-1, 2), complex(inf, zero), complex(-zero, zero)}, {complex(-1, 2), complex(inf, -zero), complex(-zero, zero)}, {complex(-1, 2), complex(inf, 1), complex(-zero, zero)}, {complex(-1, 2), complex(inf, -1), complex(-zero, zero)}, {complex(-1, 2), complex(inf, 2), complex(-zero, zero)}, {complex(-1, 2), complex(nan, nan), complex(nan, nan)}, {complex(-1, 2), complex(nan, inf), complex(zero, zero)}, {complex(-1, 2), complex(nan, -inf), complex(-zero, -zero)}, {complex(-1, 2), complex(-inf, zero), complex(zero, -zero)}, {complex(-1, 2), complex(-inf, -zero), complex(zero, -zero)}, {complex(-1, 2), complex(-inf, 1), complex(zero, -zero)}, {complex(-1, 2), complex(-inf, -1), complex(zero, -zero)}, {complex(-1, 2), complex(-inf, 2), complex(zero, -zero)}, {complex(-1, 2), complex(nan, nan), complex(nan, nan)}, {complex(-1, 2), complex(nan, inf), complex(zero, zero)}, {complex(-1, 2), complex(nan, -inf), complex(-zero, -zero)}, {complex(nan, nan), complex(zero, zero), complex(nan, nan)}, {complex(nan, nan), complex(zero, -zero), complex(nan, nan)}, {complex(nan, nan), complex(zero, 1), complex(nan, nan)}, {complex(nan, nan), complex(zero, -1), complex(nan, nan)}, {complex(nan, nan), complex(zero, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(zero, zero), complex(nan, nan)}, {complex(nan, nan), complex(-zero, -zero), complex(nan, nan)}, {complex(nan, nan), complex(zero, 1), complex(nan, nan)}, {complex(nan, nan), complex(-zero, -1), complex(nan, nan)}, {complex(nan, nan), complex(zero, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(1, zero), complex(nan, nan)}, {complex(nan, nan), complex(1, -zero), complex(nan, nan)}, {complex(nan, nan), complex(1, 1), complex(nan, nan)}, {complex(nan, nan), complex(1, -1), complex(nan, nan)}, {complex(nan, nan), complex(1, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(-1, zero), complex(nan, nan)}, {complex(nan, nan), complex(-1, -zero), complex(nan, nan)}, {complex(nan, nan), complex(-1, 1), complex(nan, nan)}, {complex(nan, nan), complex(-1, -1), complex(nan, nan)}, {complex(nan, nan), complex(-1, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(2, zero), complex(nan, nan)}, {complex(nan, nan), complex(2, -zero), complex(nan, nan)}, {complex(nan, nan), complex(2, 1), complex(nan, nan)}, {complex(nan, nan), complex(2, -1), complex(nan, nan)}, {complex(nan, nan), complex(2, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, zero), complex(nan, nan)}, {complex(nan, nan), complex(nan, -zero), complex(nan, nan)}, {complex(nan, nan), complex(nan, 1), complex(nan, nan)}, {complex(nan, nan), complex(nan, -1), complex(nan, nan)}, {complex(nan, nan), complex(nan, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(inf, zero), complex(nan, nan)}, {complex(nan, nan), complex(inf, -zero), complex(nan, nan)}, {complex(nan, nan), complex(inf, 1), complex(nan, nan)}, {complex(nan, nan), complex(inf, -1), complex(nan, nan)}, {complex(nan, nan), complex(inf, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(-inf, zero), complex(nan, nan)}, {complex(nan, nan), complex(-inf, -zero), complex(nan, nan)}, {complex(nan, nan), complex(-inf, 1), complex(nan, nan)}, {complex(nan, nan), complex(-inf, -1), complex(nan, nan)}, {complex(nan, nan), complex(-inf, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(zero, zero), complex(nan, inf)}, {complex(nan, inf), complex(zero, -zero), complex(nan, inf)}, {complex(nan, inf), complex(zero, 1), complex(inf, nan)}, {complex(nan, inf), complex(zero, -1), complex(-inf, nan)}, {complex(nan, inf), complex(zero, 2), complex(inf, nan)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(zero, zero), complex(nan, inf)}, {complex(nan, inf), complex(-zero, -zero), complex(nan, -inf)}, {complex(nan, inf), complex(zero, 1), complex(inf, nan)}, {complex(nan, inf), complex(-zero, -1), complex(-inf, nan)}, {complex(nan, inf), complex(zero, 2), complex(inf, nan)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(1, zero), complex(nan, inf)}, {complex(nan, inf), complex(1, -zero), complex(nan, inf)}, {complex(nan, inf), complex(1, 1), complex(inf, inf)}, {complex(nan, inf), complex(1, -1), complex(-inf, inf)}, {complex(nan, inf), complex(1, 2), complex(inf, inf)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(-1, zero), complex(nan, -inf)}, {complex(nan, inf), complex(-1, -zero), complex(nan, -inf)}, {complex(nan, inf), complex(-1, 1), complex(inf, -inf)}, {complex(nan, inf), complex(-1, -1), complex(-inf, -inf)}, {complex(nan, inf), complex(-1, 2), complex(inf, -inf)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(2, zero), complex(nan, inf)}, {complex(nan, inf), complex(2, -zero), complex(nan, inf)}, {complex(nan, inf), complex(2, 1), complex(inf, inf)}, {complex(nan, inf), complex(2, -1), complex(-inf, inf)}, {complex(nan, inf), complex(2, 2), complex(inf, inf)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, zero), complex(nan, nan)}, {complex(nan, inf), complex(nan, -zero), complex(nan, nan)}, {complex(nan, inf), complex(nan, 1), complex(nan, nan)}, {complex(nan, inf), complex(nan, -1), complex(nan, nan)}, {complex(nan, inf), complex(nan, 2), complex(nan, nan)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(inf, zero), complex(nan, nan)}, {complex(nan, inf), complex(inf, -zero), complex(nan, nan)}, {complex(nan, inf), complex(inf, 1), complex(nan, nan)}, {complex(nan, inf), complex(inf, -1), complex(nan, nan)}, {complex(nan, inf), complex(inf, 2), complex(nan, nan)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(-inf, zero), complex(nan, nan)}, {complex(nan, inf), complex(-inf, -zero), complex(nan, nan)}, {complex(nan, inf), complex(-inf, 1), complex(nan, nan)}, {complex(nan, inf), complex(-inf, -1), complex(nan, nan)}, {complex(nan, inf), complex(-inf, 2), complex(nan, nan)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(zero, zero), complex(nan, -inf)}, {complex(nan, -inf), complex(zero, -zero), complex(nan, -inf)}, {complex(nan, -inf), complex(zero, 1), complex(-inf, nan)}, {complex(nan, -inf), complex(zero, -1), complex(inf, nan)}, {complex(nan, -inf), complex(zero, 2), complex(-inf, nan)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(zero, zero), complex(nan, -inf)}, {complex(nan, -inf), complex(-zero, -zero), complex(nan, inf)}, {complex(nan, -inf), complex(zero, 1), complex(-inf, nan)}, {complex(nan, -inf), complex(-zero, -1), complex(inf, nan)}, {complex(nan, -inf), complex(zero, 2), complex(-inf, nan)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(1, zero), complex(nan, -inf)}, {complex(nan, -inf), complex(1, -zero), complex(nan, -inf)}, {complex(nan, -inf), complex(1, 1), complex(-inf, -inf)}, {complex(nan, -inf), complex(1, -1), complex(inf, -inf)}, {complex(nan, -inf), complex(1, 2), complex(-inf, -inf)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(-1, zero), complex(nan, inf)}, {complex(nan, -inf), complex(-1, -zero), complex(nan, inf)}, {complex(nan, -inf), complex(-1, 1), complex(-inf, inf)}, {complex(nan, -inf), complex(-1, -1), complex(inf, inf)}, {complex(nan, -inf), complex(-1, 2), complex(-inf, inf)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(2, zero), complex(nan, -inf)}, {complex(nan, -inf), complex(2, -zero), complex(nan, -inf)}, {complex(nan, -inf), complex(2, 1), complex(-inf, -inf)}, {complex(nan, -inf), complex(2, -1), complex(inf, -inf)}, {complex(nan, -inf), complex(2, 2), complex(-inf, -inf)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, zero), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -zero), complex(nan, nan)}, {complex(nan, -inf), complex(nan, 1), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -1), complex(nan, nan)}, {complex(nan, -inf), complex(nan, 2), complex(nan, nan)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(inf, zero), complex(nan, nan)}, {complex(nan, -inf), complex(inf, -zero), complex(nan, nan)}, {complex(nan, -inf), complex(inf, 1), complex(nan, nan)}, {complex(nan, -inf), complex(inf, -1), complex(nan, nan)}, {complex(nan, -inf), complex(inf, 2), complex(nan, nan)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(-inf, zero), complex(nan, nan)}, {complex(nan, -inf), complex(-inf, -zero), complex(nan, nan)}, {complex(nan, -inf), complex(-inf, 1), complex(nan, nan)}, {complex(nan, -inf), complex(-inf, -1), complex(nan, nan)}, {complex(nan, -inf), complex(-inf, 2), complex(nan, nan)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(2, zero), complex(zero, zero), complex(inf, nan)}, {complex(2, zero), complex(zero, -zero), complex(inf, nan)}, {complex(2, zero), complex(zero, 1), complex(zero, -2)}, {complex(2, zero), complex(zero, -1), complex(-zero, 2)}, {complex(2, zero), complex(zero, 2), complex(zero, -1)}, {complex(2, zero), complex(nan, nan), complex(nan, nan)}, {complex(2, zero), complex(nan, inf), complex(zero, -zero)}, {complex(2, zero), complex(nan, -inf), complex(-zero, zero)}, {complex(2, zero), complex(zero, zero), complex(inf, nan)}, {complex(2, zero), complex(-zero, -zero), complex(-inf, nan)}, {complex(2, zero), complex(zero, 1), complex(zero, -2)}, {complex(2, zero), complex(-zero, -1), complex(-zero, 2)}, {complex(2, zero), complex(zero, 2), complex(zero, -1)}, {complex(2, zero), complex(nan, nan), complex(nan, nan)}, {complex(2, zero), complex(nan, inf), complex(zero, -zero)}, {complex(2, zero), complex(nan, -inf), complex(-zero, zero)}, {complex(2, zero), complex(1, zero), complex(2, zero)}, {complex(2, zero), complex(1, -zero), complex(2, zero)}, {complex(2, zero), complex(1, 1), complex(1, -1)}, {complex(2, zero), complex(1, -1), complex(1, 1)}, {complex(2, zero), complex(1, 2), complex(0.4, -0.8)}, {complex(2, zero), complex(nan, nan), complex(nan, nan)}, {complex(2, zero), complex(nan, inf), complex(zero, -zero)}, {complex(2, zero), complex(nan, -inf), complex(-zero, zero)}, {complex(2, zero), complex(-1, zero), complex(-2, -zero)}, {complex(2, zero), complex(-1, -zero), complex(-2, -zero)}, {complex(2, zero), complex(-1, 1), complex(-1, -1)}, {complex(2, zero), complex(-1, -1), complex(-1, 1)}, {complex(2, zero), complex(-1, 2), complex(-0.4, -0.8)}, {complex(2, zero), complex(nan, nan), complex(nan, nan)}, {complex(2, zero), complex(nan, inf), complex(zero, -zero)}, {complex(2, zero), complex(nan, -inf), complex(-zero, zero)}, {complex(2, zero), complex(2, zero), complex(1, zero)}, {complex(2, zero), complex(2, -zero), complex(1, zero)}, {complex(2, zero), complex(2, 1), complex(0.8, -0.4)}, {complex(2, zero), complex(2, -1), complex(0.8, 0.4)}, {complex(2, zero), complex(2, 2), complex(0.5, -0.5)}, {complex(2, zero), complex(nan, nan), complex(nan, nan)}, {complex(2, zero), complex(nan, inf), complex(zero, -zero)}, {complex(2, zero), complex(nan, -inf), complex(-zero, zero)}, {complex(2, zero), complex(nan, zero), complex(nan, nan)}, {complex(2, zero), complex(nan, -zero), complex(nan, nan)}, {complex(2, zero), complex(nan, 1), complex(nan, nan)}, {complex(2, zero), complex(nan, -1), complex(nan, nan)}, {complex(2, zero), complex(nan, 2), complex(nan, nan)}, {complex(2, zero), complex(nan, nan), complex(nan, nan)}, {complex(2, zero), complex(nan, inf), complex(zero, -zero)}, {complex(2, zero), complex(nan, -inf), complex(-zero, zero)}, {complex(2, zero), complex(inf, zero), complex(zero, zero)}, {complex(2, zero), complex(inf, -zero), complex(zero, zero)}, {complex(2, zero), complex(inf, 1), complex(zero, zero)}, {complex(2, zero), complex(inf, -1), complex(zero, zero)}, {complex(2, zero), complex(inf, 2), complex(zero, zero)}, {complex(2, zero), complex(nan, nan), complex(nan, nan)}, {complex(2, zero), complex(nan, inf), complex(zero, -zero)}, {complex(2, zero), complex(nan, -inf), complex(-zero, zero)}, {complex(2, zero), complex(-inf, zero), complex(-zero, -zero)}, {complex(2, zero), complex(-inf, -zero), complex(-zero, -zero)}, {complex(2, zero), complex(-inf, 1), complex(-zero, -zero)}, {complex(2, zero), complex(-inf, -1), complex(-zero, -zero)}, {complex(2, zero), complex(-inf, 2), complex(-zero, -zero)}, {complex(2, zero), complex(nan, nan), complex(nan, nan)}, {complex(2, zero), complex(nan, inf), complex(zero, -zero)}, {complex(2, zero), complex(nan, -inf), complex(-zero, zero)}, {complex(2, -zero), complex(zero, zero), complex(inf, nan)}, {complex(2, -zero), complex(zero, -zero), complex(inf, nan)}, {complex(2, -zero), complex(zero, 1), complex(zero, -2)}, {complex(2, -zero), complex(zero, -1), complex(zero, 2)}, {complex(2, -zero), complex(zero, 2), complex(zero, -1)}, {complex(2, -zero), complex(nan, nan), complex(nan, nan)}, {complex(2, -zero), complex(nan, inf), complex(-zero, -zero)}, {complex(2, -zero), complex(nan, -inf), complex(zero, zero)}, {complex(2, -zero), complex(zero, zero), complex(inf, nan)}, {complex(2, -zero), complex(-zero, -zero), complex(-inf, nan)}, {complex(2, -zero), complex(zero, 1), complex(zero, -2)}, {complex(2, -zero), complex(-zero, -1), complex(-zero, 2)}, {complex(2, -zero), complex(zero, 2), complex(zero, -1)}, {complex(2, -zero), complex(nan, nan), complex(nan, nan)}, {complex(2, -zero), complex(nan, inf), complex(-zero, -zero)}, {complex(2, -zero), complex(nan, -inf), complex(zero, zero)}, {complex(2, -zero), complex(1, zero), complex(2, -zero)}, {complex(2, -zero), complex(1, -zero), complex(2, zero)}, {complex(2, -zero), complex(1, 1), complex(1, -1)}, {complex(2, -zero), complex(1, -1), complex(1, 1)}, {complex(2, -zero), complex(1, 2), complex(0.4, -0.8)}, {complex(2, -zero), complex(nan, nan), complex(nan, nan)}, {complex(2, -zero), complex(nan, inf), complex(-zero, -zero)}, {complex(2, -zero), complex(nan, -inf), complex(zero, zero)}, {complex(2, -zero), complex(-1, zero), complex(-2, -zero)}, {complex(2, -zero), complex(-1, -zero), complex(-2, zero)}, {complex(2, -zero), complex(-1, 1), complex(-1, -1)}, {complex(2, -zero), complex(-1, -1), complex(-1, 1)}, {complex(2, -zero), complex(-1, 2), complex(-0.4, -0.8)}, {complex(2, -zero), complex(nan, nan), complex(nan, nan)}, {complex(2, -zero), complex(nan, inf), complex(-zero, -zero)}, {complex(2, -zero), complex(nan, -inf), complex(zero, zero)}, {complex(2, -zero), complex(2, zero), complex(1, -zero)}, {complex(2, -zero), complex(2, -zero), complex(1, zero)}, {complex(2, -zero), complex(2, 1), complex(0.8, -0.4)}, {complex(2, -zero), complex(2, -1), complex(0.8, 0.4)}, {complex(2, -zero), complex(2, 2), complex(0.5, -0.5)}, {complex(2, -zero), complex(nan, nan), complex(nan, nan)}, {complex(2, -zero), complex(nan, inf), complex(-zero, -zero)}, {complex(2, -zero), complex(nan, -inf), complex(zero, zero)}, {complex(2, -zero), complex(nan, zero), complex(nan, nan)}, {complex(2, -zero), complex(nan, -zero), complex(nan, nan)}, {complex(2, -zero), complex(nan, 1), complex(nan, nan)}, {complex(2, -zero), complex(nan, -1), complex(nan, nan)}, {complex(2, -zero), complex(nan, 2), complex(nan, nan)}, {complex(2, -zero), complex(nan, nan), complex(nan, nan)}, {complex(2, -zero), complex(nan, inf), complex(-zero, -zero)}, {complex(2, -zero), complex(nan, -inf), complex(zero, zero)}, {complex(2, -zero), complex(inf, zero), complex(zero, -zero)}, {complex(2, -zero), complex(inf, -zero), complex(zero, zero)}, {complex(2, -zero), complex(inf, 1), complex(zero, -zero)}, {complex(2, -zero), complex(inf, -1), complex(zero, zero)}, {complex(2, -zero), complex(inf, 2), complex(zero, -zero)}, {complex(2, -zero), complex(nan, nan), complex(nan, nan)}, {complex(2, -zero), complex(nan, inf), complex(-zero, -zero)}, {complex(2, -zero), complex(nan, -inf), complex(zero, zero)}, {complex(2, -zero), complex(-inf, zero), complex(-zero, -zero)}, {complex(2, -zero), complex(-inf, -zero), complex(-zero, zero)}, {complex(2, -zero), complex(-inf, 1), complex(-zero, -zero)}, {complex(2, -zero), complex(-inf, -1), complex(-zero, zero)}, {complex(2, -zero), complex(-inf, 2), complex(-zero, -zero)}, {complex(2, -zero), complex(nan, nan), complex(nan, nan)}, {complex(2, -zero), complex(nan, inf), complex(-zero, -zero)}, {complex(2, -zero), complex(nan, -inf), complex(zero, zero)}, {complex(2, 1), complex(zero, zero), complex(inf, inf)}, {complex(2, 1), complex(zero, -zero), complex(inf, inf)}, {complex(2, 1), complex(zero, 1), complex(1, -2)}, {complex(2, 1), complex(zero, -1), complex(-1, 2)}, {complex(2, 1), complex(zero, 2), complex(0.5, -1)}, {complex(2, 1), complex(nan, nan), complex(nan, nan)}, {complex(2, 1), complex(nan, inf), complex(zero, -zero)}, {complex(2, 1), complex(nan, -inf), complex(-zero, zero)}, {complex(2, 1), complex(zero, zero), complex(inf, inf)}, {complex(2, 1), complex(-zero, -zero), complex(-inf, -inf)}, {complex(2, 1), complex(zero, 1), complex(1, -2)}, {complex(2, 1), complex(-zero, -1), complex(-1, 2)}, {complex(2, 1), complex(zero, 2), complex(0.5, -1)}, {complex(2, 1), complex(nan, nan), complex(nan, nan)}, {complex(2, 1), complex(nan, inf), complex(zero, -zero)}, {complex(2, 1), complex(nan, -inf), complex(-zero, zero)}, {complex(2, 1), complex(1, zero), complex(2, 1)}, {complex(2, 1), complex(1, -zero), complex(2, 1)}, {complex(2, 1), complex(1, 1), complex(1.5, -0.5)}, {complex(2, 1), complex(1, -1), complex(0.5, 1.5)}, {complex(2, 1), complex(1, 2), complex(0.8, -0.6)}, {complex(2, 1), complex(nan, nan), complex(nan, nan)}, {complex(2, 1), complex(nan, inf), complex(zero, -zero)}, {complex(2, 1), complex(nan, -inf), complex(-zero, zero)}, {complex(2, 1), complex(-1, zero), complex(-2, -1)}, {complex(2, 1), complex(-1, -zero), complex(-2, -1)}, {complex(2, 1), complex(-1, 1), complex(-0.5, -1.5)}, {complex(2, 1), complex(-1, -1), complex(-1.5, 0.5)}, {complex(2, 1), complex(-1, 2), complex(zero, -1)}, {complex(2, 1), complex(nan, nan), complex(nan, nan)}, {complex(2, 1), complex(nan, inf), complex(zero, -zero)}, {complex(2, 1), complex(nan, -inf), complex(-zero, zero)}, {complex(2, 1), complex(2, zero), complex(1, 0.5)}, {complex(2, 1), complex(2, -zero), complex(1, 0.5)}, {complex(2, 1), complex(2, 1), complex(1, zero)}, {complex(2, 1), complex(2, -1), complex(0.6, 0.8)}, {complex(2, 1), complex(2, 2), complex(0.75, -0.25)}, {complex(2, 1), complex(nan, nan), complex(nan, nan)}, {complex(2, 1), complex(nan, inf), complex(zero, -zero)}, {complex(2, 1), complex(nan, -inf), complex(-zero, zero)}, {complex(2, 1), complex(nan, zero), complex(nan, nan)}, {complex(2, 1), complex(nan, -zero), complex(nan, nan)}, {complex(2, 1), complex(nan, 1), complex(nan, nan)}, {complex(2, 1), complex(nan, -1), complex(nan, nan)}, {complex(2, 1), complex(nan, 2), complex(nan, nan)}, {complex(2, 1), complex(nan, nan), complex(nan, nan)}, {complex(2, 1), complex(nan, inf), complex(zero, -zero)}, {complex(2, 1), complex(nan, -inf), complex(-zero, zero)}, {complex(2, 1), complex(inf, zero), complex(zero, zero)}, {complex(2, 1), complex(inf, -zero), complex(zero, zero)}, {complex(2, 1), complex(inf, 1), complex(zero, zero)}, {complex(2, 1), complex(inf, -1), complex(zero, zero)}, {complex(2, 1), complex(inf, 2), complex(zero, zero)}, {complex(2, 1), complex(nan, nan), complex(nan, nan)}, {complex(2, 1), complex(nan, inf), complex(zero, -zero)}, {complex(2, 1), complex(nan, -inf), complex(-zero, zero)}, {complex(2, 1), complex(-inf, zero), complex(-zero, -zero)}, {complex(2, 1), complex(-inf, -zero), complex(-zero, -zero)}, {complex(2, 1), complex(-inf, 1), complex(-zero, -zero)}, {complex(2, 1), complex(-inf, -1), complex(-zero, -zero)}, {complex(2, 1), complex(-inf, 2), complex(-zero, -zero)}, {complex(2, 1), complex(nan, nan), complex(nan, nan)}, {complex(2, 1), complex(nan, inf), complex(zero, -zero)}, {complex(2, 1), complex(nan, -inf), complex(-zero, zero)}, {complex(2, -1), complex(zero, zero), complex(inf, -inf)}, {complex(2, -1), complex(zero, -zero), complex(inf, -inf)}, {complex(2, -1), complex(zero, 1), complex(-1, -2)}, {complex(2, -1), complex(zero, -1), complex(1, 2)}, {complex(2, -1), complex(zero, 2), complex(-0.5, -1)}, {complex(2, -1), complex(nan, nan), complex(nan, nan)}, {complex(2, -1), complex(nan, inf), complex(-zero, -zero)}, {complex(2, -1), complex(nan, -inf), complex(zero, zero)}, {complex(2, -1), complex(zero, zero), complex(inf, -inf)}, {complex(2, -1), complex(-zero, -zero), complex(-inf, inf)}, {complex(2, -1), complex(zero, 1), complex(-1, -2)}, {complex(2, -1), complex(-zero, -1), complex(1, 2)}, {complex(2, -1), complex(zero, 2), complex(-0.5, -1)}, {complex(2, -1), complex(nan, nan), complex(nan, nan)}, {complex(2, -1), complex(nan, inf), complex(-zero, -zero)}, {complex(2, -1), complex(nan, -inf), complex(zero, zero)}, {complex(2, -1), complex(1, zero), complex(2, -1)}, {complex(2, -1), complex(1, -zero), complex(2, -1)}, {complex(2, -1), complex(1, 1), complex(0.5, -1.5)}, {complex(2, -1), complex(1, -1), complex(1.5, 0.5)}, {complex(2, -1), complex(1, 2), complex(zero, -1)}, {complex(2, -1), complex(nan, nan), complex(nan, nan)}, {complex(2, -1), complex(nan, inf), complex(-zero, -zero)}, {complex(2, -1), complex(nan, -inf), complex(zero, zero)}, {complex(2, -1), complex(-1, zero), complex(-2, 1)}, {complex(2, -1), complex(-1, -zero), complex(-2, 1)}, {complex(2, -1), complex(-1, 1), complex(-1.5, -0.5)}, {complex(2, -1), complex(-1, -1), complex(-0.5, 1.5)}, {complex(2, -1), complex(-1, 2), complex(-0.8, -0.6)}, {complex(2, -1), complex(nan, nan), complex(nan, nan)}, {complex(2, -1), complex(nan, inf), complex(-zero, -zero)}, {complex(2, -1), complex(nan, -inf), complex(zero, zero)}, {complex(2, -1), complex(2, zero), complex(1, -0.5)}, {complex(2, -1), complex(2, -zero), complex(1, -0.5)}, {complex(2, -1), complex(2, 1), complex(0.6, -0.8)}, {complex(2, -1), complex(2, -1), complex(1, zero)}, {complex(2, -1), complex(2, 2), complex(0.25, -0.75)}, {complex(2, -1), complex(nan, nan), complex(nan, nan)}, {complex(2, -1), complex(nan, inf), complex(-zero, -zero)}, {complex(2, -1), complex(nan, -inf), complex(zero, zero)}, {complex(2, -1), complex(nan, zero), complex(nan, nan)}, {complex(2, -1), complex(nan, -zero), complex(nan, nan)}, {complex(2, -1), complex(nan, 1), complex(nan, nan)}, {complex(2, -1), complex(nan, -1), complex(nan, nan)}, {complex(2, -1), complex(nan, 2), complex(nan, nan)}, {complex(2, -1), complex(nan, nan), complex(nan, nan)}, {complex(2, -1), complex(nan, inf), complex(-zero, -zero)}, {complex(2, -1), complex(nan, -inf), complex(zero, zero)}, {complex(2, -1), complex(inf, zero), complex(zero, -zero)}, {complex(2, -1), complex(inf, -zero), complex(zero, -zero)}, {complex(2, -1), complex(inf, 1), complex(zero, -zero)}, {complex(2, -1), complex(inf, -1), complex(zero, -zero)}, {complex(2, -1), complex(inf, 2), complex(zero, -zero)}, {complex(2, -1), complex(nan, nan), complex(nan, nan)}, {complex(2, -1), complex(nan, inf), complex(-zero, -zero)}, {complex(2, -1), complex(nan, -inf), complex(zero, zero)}, {complex(2, -1), complex(-inf, zero), complex(-zero, zero)}, {complex(2, -1), complex(-inf, -zero), complex(-zero, zero)}, {complex(2, -1), complex(-inf, 1), complex(-zero, zero)}, {complex(2, -1), complex(-inf, -1), complex(-zero, zero)}, {complex(2, -1), complex(-inf, 2), complex(-zero, zero)}, {complex(2, -1), complex(nan, nan), complex(nan, nan)}, {complex(2, -1), complex(nan, inf), complex(-zero, -zero)}, {complex(2, -1), complex(nan, -inf), complex(zero, zero)}, {complex(2, 2), complex(zero, zero), complex(inf, inf)}, {complex(2, 2), complex(zero, -zero), complex(inf, inf)}, {complex(2, 2), complex(zero, 1), complex(2, -2)}, {complex(2, 2), complex(zero, -1), complex(-2, 2)}, {complex(2, 2), complex(zero, 2), complex(1, -1)}, {complex(2, 2), complex(nan, nan), complex(nan, nan)}, {complex(2, 2), complex(nan, inf), complex(zero, -zero)}, {complex(2, 2), complex(nan, -inf), complex(-zero, zero)}, {complex(2, 2), complex(zero, zero), complex(inf, inf)}, {complex(2, 2), complex(-zero, -zero), complex(-inf, -inf)}, {complex(2, 2), complex(zero, 1), complex(2, -2)}, {complex(2, 2), complex(-zero, -1), complex(-2, 2)}, {complex(2, 2), complex(zero, 2), complex(1, -1)}, {complex(2, 2), complex(nan, nan), complex(nan, nan)}, {complex(2, 2), complex(nan, inf), complex(zero, -zero)}, {complex(2, 2), complex(nan, -inf), complex(-zero, zero)}, {complex(2, 2), complex(1, zero), complex(2, 2)}, {complex(2, 2), complex(1, -zero), complex(2, 2)}, {complex(2, 2), complex(1, 1), complex(2, zero)}, {complex(2, 2), complex(1, -1), complex(zero, 2)}, {complex(2, 2), complex(1, 2), complex(1.2, -0.4)}, {complex(2, 2), complex(nan, nan), complex(nan, nan)}, {complex(2, 2), complex(nan, inf), complex(zero, -zero)}, {complex(2, 2), complex(nan, -inf), complex(-zero, zero)}, {complex(2, 2), complex(-1, zero), complex(-2, -2)}, {complex(2, 2), complex(-1, -zero), complex(-2, -2)}, {complex(2, 2), complex(-1, 1), complex(-zero, -2)}, {complex(2, 2), complex(-1, -1), complex(-2, -zero)}, {complex(2, 2), complex(-1, 2), complex(0.4, -1.2)}, {complex(2, 2), complex(nan, nan), complex(nan, nan)}, {complex(2, 2), complex(nan, inf), complex(zero, -zero)}, {complex(2, 2), complex(nan, -inf), complex(-zero, zero)}, {complex(2, 2), complex(2, zero), complex(1, 1)}, {complex(2, 2), complex(2, -zero), complex(1, 1)}, {complex(2, 2), complex(2, 1), complex(1.2, 0.4)}, {complex(2, 2), complex(2, -1), complex(0.4, 1.2)}, {complex(2, 2), complex(2, 2), complex(1, zero)}, {complex(2, 2), complex(nan, nan), complex(nan, nan)}, {complex(2, 2), complex(nan, inf), complex(zero, -zero)}, {complex(2, 2), complex(nan, -inf), complex(-zero, zero)}, {complex(2, 2), complex(nan, zero), complex(nan, nan)}, {complex(2, 2), complex(nan, -zero), complex(nan, nan)}, {complex(2, 2), complex(nan, 1), complex(nan, nan)}, {complex(2, 2), complex(nan, -1), complex(nan, nan)}, {complex(2, 2), complex(nan, 2), complex(nan, nan)}, {complex(2, 2), complex(nan, nan), complex(nan, nan)}, {complex(2, 2), complex(nan, inf), complex(zero, -zero)}, {complex(2, 2), complex(nan, -inf), complex(-zero, zero)}, {complex(2, 2), complex(inf, zero), complex(zero, zero)}, {complex(2, 2), complex(inf, -zero), complex(zero, zero)}, {complex(2, 2), complex(inf, 1), complex(zero, zero)}, {complex(2, 2), complex(inf, -1), complex(zero, zero)}, {complex(2, 2), complex(inf, 2), complex(zero, zero)}, {complex(2, 2), complex(nan, nan), complex(nan, nan)}, {complex(2, 2), complex(nan, inf), complex(zero, -zero)}, {complex(2, 2), complex(nan, -inf), complex(-zero, zero)}, {complex(2, 2), complex(-inf, zero), complex(-zero, -zero)}, {complex(2, 2), complex(-inf, -zero), complex(-zero, -zero)}, {complex(2, 2), complex(-inf, 1), complex(-zero, -zero)}, {complex(2, 2), complex(-inf, -1), complex(-zero, -zero)}, {complex(2, 2), complex(-inf, 2), complex(-zero, -zero)}, {complex(2, 2), complex(nan, nan), complex(nan, nan)}, {complex(2, 2), complex(nan, inf), complex(zero, -zero)}, {complex(2, 2), complex(nan, -inf), complex(-zero, zero)}, {complex(nan, nan), complex(zero, zero), complex(nan, nan)}, {complex(nan, nan), complex(zero, -zero), complex(nan, nan)}, {complex(nan, nan), complex(zero, 1), complex(nan, nan)}, {complex(nan, nan), complex(zero, -1), complex(nan, nan)}, {complex(nan, nan), complex(zero, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(zero, zero), complex(nan, nan)}, {complex(nan, nan), complex(-zero, -zero), complex(nan, nan)}, {complex(nan, nan), complex(zero, 1), complex(nan, nan)}, {complex(nan, nan), complex(-zero, -1), complex(nan, nan)}, {complex(nan, nan), complex(zero, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(1, zero), complex(nan, nan)}, {complex(nan, nan), complex(1, -zero), complex(nan, nan)}, {complex(nan, nan), complex(1, 1), complex(nan, nan)}, {complex(nan, nan), complex(1, -1), complex(nan, nan)}, {complex(nan, nan), complex(1, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(-1, zero), complex(nan, nan)}, {complex(nan, nan), complex(-1, -zero), complex(nan, nan)}, {complex(nan, nan), complex(-1, 1), complex(nan, nan)}, {complex(nan, nan), complex(-1, -1), complex(nan, nan)}, {complex(nan, nan), complex(-1, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(2, zero), complex(nan, nan)}, {complex(nan, nan), complex(2, -zero), complex(nan, nan)}, {complex(nan, nan), complex(2, 1), complex(nan, nan)}, {complex(nan, nan), complex(2, -1), complex(nan, nan)}, {complex(nan, nan), complex(2, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, zero), complex(nan, nan)}, {complex(nan, nan), complex(nan, -zero), complex(nan, nan)}, {complex(nan, nan), complex(nan, 1), complex(nan, nan)}, {complex(nan, nan), complex(nan, -1), complex(nan, nan)}, {complex(nan, nan), complex(nan, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(inf, zero), complex(nan, nan)}, {complex(nan, nan), complex(inf, -zero), complex(nan, nan)}, {complex(nan, nan), complex(inf, 1), complex(nan, nan)}, {complex(nan, nan), complex(inf, -1), complex(nan, nan)}, {complex(nan, nan), complex(inf, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(-inf, zero), complex(nan, nan)}, {complex(nan, nan), complex(-inf, -zero), complex(nan, nan)}, {complex(nan, nan), complex(-inf, 1), complex(nan, nan)}, {complex(nan, nan), complex(-inf, -1), complex(nan, nan)}, {complex(nan, nan), complex(-inf, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(zero, zero), complex(nan, inf)}, {complex(nan, inf), complex(zero, -zero), complex(nan, inf)}, {complex(nan, inf), complex(zero, 1), complex(inf, nan)}, {complex(nan, inf), complex(zero, -1), complex(-inf, nan)}, {complex(nan, inf), complex(zero, 2), complex(inf, nan)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(zero, zero), complex(nan, inf)}, {complex(nan, inf), complex(-zero, -zero), complex(nan, -inf)}, {complex(nan, inf), complex(zero, 1), complex(inf, nan)}, {complex(nan, inf), complex(-zero, -1), complex(-inf, nan)}, {complex(nan, inf), complex(zero, 2), complex(inf, nan)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(1, zero), complex(nan, inf)}, {complex(nan, inf), complex(1, -zero), complex(nan, inf)}, {complex(nan, inf), complex(1, 1), complex(inf, inf)}, {complex(nan, inf), complex(1, -1), complex(-inf, inf)}, {complex(nan, inf), complex(1, 2), complex(inf, inf)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(-1, zero), complex(nan, -inf)}, {complex(nan, inf), complex(-1, -zero), complex(nan, -inf)}, {complex(nan, inf), complex(-1, 1), complex(inf, -inf)}, {complex(nan, inf), complex(-1, -1), complex(-inf, -inf)}, {complex(nan, inf), complex(-1, 2), complex(inf, -inf)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(2, zero), complex(nan, inf)}, {complex(nan, inf), complex(2, -zero), complex(nan, inf)}, {complex(nan, inf), complex(2, 1), complex(inf, inf)}, {complex(nan, inf), complex(2, -1), complex(-inf, inf)}, {complex(nan, inf), complex(2, 2), complex(inf, inf)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, zero), complex(nan, nan)}, {complex(nan, inf), complex(nan, -zero), complex(nan, nan)}, {complex(nan, inf), complex(nan, 1), complex(nan, nan)}, {complex(nan, inf), complex(nan, -1), complex(nan, nan)}, {complex(nan, inf), complex(nan, 2), complex(nan, nan)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(inf, zero), complex(nan, nan)}, {complex(nan, inf), complex(inf, -zero), complex(nan, nan)}, {complex(nan, inf), complex(inf, 1), complex(nan, nan)}, {complex(nan, inf), complex(inf, -1), complex(nan, nan)}, {complex(nan, inf), complex(inf, 2), complex(nan, nan)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(-inf, zero), complex(nan, nan)}, {complex(nan, inf), complex(-inf, -zero), complex(nan, nan)}, {complex(nan, inf), complex(-inf, 1), complex(nan, nan)}, {complex(nan, inf), complex(-inf, -1), complex(nan, nan)}, {complex(nan, inf), complex(-inf, 2), complex(nan, nan)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(zero, zero), complex(nan, -inf)}, {complex(nan, -inf), complex(zero, -zero), complex(nan, -inf)}, {complex(nan, -inf), complex(zero, 1), complex(-inf, nan)}, {complex(nan, -inf), complex(zero, -1), complex(inf, nan)}, {complex(nan, -inf), complex(zero, 2), complex(-inf, nan)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(zero, zero), complex(nan, -inf)}, {complex(nan, -inf), complex(-zero, -zero), complex(nan, inf)}, {complex(nan, -inf), complex(zero, 1), complex(-inf, nan)}, {complex(nan, -inf), complex(-zero, -1), complex(inf, nan)}, {complex(nan, -inf), complex(zero, 2), complex(-inf, nan)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(1, zero), complex(nan, -inf)}, {complex(nan, -inf), complex(1, -zero), complex(nan, -inf)}, {complex(nan, -inf), complex(1, 1), complex(-inf, -inf)}, {complex(nan, -inf), complex(1, -1), complex(inf, -inf)}, {complex(nan, -inf), complex(1, 2), complex(-inf, -inf)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(-1, zero), complex(nan, inf)}, {complex(nan, -inf), complex(-1, -zero), complex(nan, inf)}, {complex(nan, -inf), complex(-1, 1), complex(-inf, inf)}, {complex(nan, -inf), complex(-1, -1), complex(inf, inf)}, {complex(nan, -inf), complex(-1, 2), complex(-inf, inf)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(2, zero), complex(nan, -inf)}, {complex(nan, -inf), complex(2, -zero), complex(nan, -inf)}, {complex(nan, -inf), complex(2, 1), complex(-inf, -inf)}, {complex(nan, -inf), complex(2, -1), complex(inf, -inf)}, {complex(nan, -inf), complex(2, 2), complex(-inf, -inf)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, zero), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -zero), complex(nan, nan)}, {complex(nan, -inf), complex(nan, 1), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -1), complex(nan, nan)}, {complex(nan, -inf), complex(nan, 2), complex(nan, nan)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(inf, zero), complex(nan, nan)}, {complex(nan, -inf), complex(inf, -zero), complex(nan, nan)}, {complex(nan, -inf), complex(inf, 1), complex(nan, nan)}, {complex(nan, -inf), complex(inf, -1), complex(nan, nan)}, {complex(nan, -inf), complex(inf, 2), complex(nan, nan)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(-inf, zero), complex(nan, nan)}, {complex(nan, -inf), complex(-inf, -zero), complex(nan, nan)}, {complex(nan, -inf), complex(-inf, 1), complex(nan, nan)}, {complex(nan, -inf), complex(-inf, -1), complex(nan, nan)}, {complex(nan, -inf), complex(-inf, 2), complex(nan, nan)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, zero), complex(zero, zero), complex(nan, nan)}, {complex(nan, zero), complex(zero, -zero), complex(nan, nan)}, {complex(nan, zero), complex(zero, 1), complex(nan, nan)}, {complex(nan, zero), complex(zero, -1), complex(nan, nan)}, {complex(nan, zero), complex(zero, 2), complex(nan, nan)}, {complex(nan, zero), complex(nan, nan), complex(nan, nan)}, {complex(nan, zero), complex(nan, inf), complex(nan, nan)}, {complex(nan, zero), complex(nan, -inf), complex(nan, nan)}, {complex(nan, zero), complex(zero, zero), complex(nan, nan)}, {complex(nan, zero), complex(-zero, -zero), complex(nan, nan)}, {complex(nan, zero), complex(zero, 1), complex(nan, nan)}, {complex(nan, zero), complex(-zero, -1), complex(nan, nan)}, {complex(nan, zero), complex(zero, 2), complex(nan, nan)}, {complex(nan, zero), complex(nan, nan), complex(nan, nan)}, {complex(nan, zero), complex(nan, inf), complex(nan, nan)}, {complex(nan, zero), complex(nan, -inf), complex(nan, nan)}, {complex(nan, zero), complex(1, zero), complex(nan, nan)}, {complex(nan, zero), complex(1, -zero), complex(nan, nan)}, {complex(nan, zero), complex(1, 1), complex(nan, nan)}, {complex(nan, zero), complex(1, -1), complex(nan, nan)}, {complex(nan, zero), complex(1, 2), complex(nan, nan)}, {complex(nan, zero), complex(nan, nan), complex(nan, nan)}, {complex(nan, zero), complex(nan, inf), complex(nan, nan)}, {complex(nan, zero), complex(nan, -inf), complex(nan, nan)}, {complex(nan, zero), complex(-1, zero), complex(nan, nan)}, {complex(nan, zero), complex(-1, -zero), complex(nan, nan)}, {complex(nan, zero), complex(-1, 1), complex(nan, nan)}, {complex(nan, zero), complex(-1, -1), complex(nan, nan)}, {complex(nan, zero), complex(-1, 2), complex(nan, nan)}, {complex(nan, zero), complex(nan, nan), complex(nan, nan)}, {complex(nan, zero), complex(nan, inf), complex(nan, nan)}, {complex(nan, zero), complex(nan, -inf), complex(nan, nan)}, {complex(nan, zero), complex(2, zero), complex(nan, nan)}, {complex(nan, zero), complex(2, -zero), complex(nan, nan)}, {complex(nan, zero), complex(2, 1), complex(nan, nan)}, {complex(nan, zero), complex(2, -1), complex(nan, nan)}, {complex(nan, zero), complex(2, 2), complex(nan, nan)}, {complex(nan, zero), complex(nan, nan), complex(nan, nan)}, {complex(nan, zero), complex(nan, inf), complex(nan, nan)}, {complex(nan, zero), complex(nan, -inf), complex(nan, nan)}, {complex(nan, zero), complex(nan, zero), complex(nan, nan)}, {complex(nan, zero), complex(nan, -zero), complex(nan, nan)}, {complex(nan, zero), complex(nan, 1), complex(nan, nan)}, {complex(nan, zero), complex(nan, -1), complex(nan, nan)}, {complex(nan, zero), complex(nan, 2), complex(nan, nan)}, {complex(nan, zero), complex(nan, nan), complex(nan, nan)}, {complex(nan, zero), complex(nan, inf), complex(nan, nan)}, {complex(nan, zero), complex(nan, -inf), complex(nan, nan)}, {complex(nan, zero), complex(inf, zero), complex(nan, nan)}, {complex(nan, zero), complex(inf, -zero), complex(nan, nan)}, {complex(nan, zero), complex(inf, 1), complex(nan, nan)}, {complex(nan, zero), complex(inf, -1), complex(nan, nan)}, {complex(nan, zero), complex(inf, 2), complex(nan, nan)}, {complex(nan, zero), complex(nan, nan), complex(nan, nan)}, {complex(nan, zero), complex(nan, inf), complex(nan, nan)}, {complex(nan, zero), complex(nan, -inf), complex(nan, nan)}, {complex(nan, zero), complex(-inf, zero), complex(nan, nan)}, {complex(nan, zero), complex(-inf, -zero), complex(nan, nan)}, {complex(nan, zero), complex(-inf, 1), complex(nan, nan)}, {complex(nan, zero), complex(-inf, -1), complex(nan, nan)}, {complex(nan, zero), complex(-inf, 2), complex(nan, nan)}, {complex(nan, zero), complex(nan, nan), complex(nan, nan)}, {complex(nan, zero), complex(nan, inf), complex(nan, nan)}, {complex(nan, zero), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -zero), complex(zero, zero), complex(nan, nan)}, {complex(nan, -zero), complex(zero, -zero), complex(nan, nan)}, {complex(nan, -zero), complex(zero, 1), complex(nan, nan)}, {complex(nan, -zero), complex(zero, -1), complex(nan, nan)}, {complex(nan, -zero), complex(zero, 2), complex(nan, nan)}, {complex(nan, -zero), complex(nan, nan), complex(nan, nan)}, {complex(nan, -zero), complex(nan, inf), complex(nan, nan)}, {complex(nan, -zero), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -zero), complex(zero, zero), complex(nan, nan)}, {complex(nan, -zero), complex(-zero, -zero), complex(nan, nan)}, {complex(nan, -zero), complex(zero, 1), complex(nan, nan)}, {complex(nan, -zero), complex(-zero, -1), complex(nan, nan)}, {complex(nan, -zero), complex(zero, 2), complex(nan, nan)}, {complex(nan, -zero), complex(nan, nan), complex(nan, nan)}, {complex(nan, -zero), complex(nan, inf), complex(nan, nan)}, {complex(nan, -zero), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -zero), complex(1, zero), complex(nan, nan)}, {complex(nan, -zero), complex(1, -zero), complex(nan, nan)}, {complex(nan, -zero), complex(1, 1), complex(nan, nan)}, {complex(nan, -zero), complex(1, -1), complex(nan, nan)}, {complex(nan, -zero), complex(1, 2), complex(nan, nan)}, {complex(nan, -zero), complex(nan, nan), complex(nan, nan)}, {complex(nan, -zero), complex(nan, inf), complex(nan, nan)}, {complex(nan, -zero), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -zero), complex(-1, zero), complex(nan, nan)}, {complex(nan, -zero), complex(-1, -zero), complex(nan, nan)}, {complex(nan, -zero), complex(-1, 1), complex(nan, nan)}, {complex(nan, -zero), complex(-1, -1), complex(nan, nan)}, {complex(nan, -zero), complex(-1, 2), complex(nan, nan)}, {complex(nan, -zero), complex(nan, nan), complex(nan, nan)}, {complex(nan, -zero), complex(nan, inf), complex(nan, nan)}, {complex(nan, -zero), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -zero), complex(2, zero), complex(nan, nan)}, {complex(nan, -zero), complex(2, -zero), complex(nan, nan)}, {complex(nan, -zero), complex(2, 1), complex(nan, nan)}, {complex(nan, -zero), complex(2, -1), complex(nan, nan)}, {complex(nan, -zero), complex(2, 2), complex(nan, nan)}, {complex(nan, -zero), complex(nan, nan), complex(nan, nan)}, {complex(nan, -zero), complex(nan, inf), complex(nan, nan)}, {complex(nan, -zero), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -zero), complex(nan, zero), complex(nan, nan)}, {complex(nan, -zero), complex(nan, -zero), complex(nan, nan)}, {complex(nan, -zero), complex(nan, 1), complex(nan, nan)}, {complex(nan, -zero), complex(nan, -1), complex(nan, nan)}, {complex(nan, -zero), complex(nan, 2), complex(nan, nan)}, {complex(nan, -zero), complex(nan, nan), complex(nan, nan)}, {complex(nan, -zero), complex(nan, inf), complex(nan, nan)}, {complex(nan, -zero), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -zero), complex(inf, zero), complex(nan, nan)}, {complex(nan, -zero), complex(inf, -zero), complex(nan, nan)}, {complex(nan, -zero), complex(inf, 1), complex(nan, nan)}, {complex(nan, -zero), complex(inf, -1), complex(nan, nan)}, {complex(nan, -zero), complex(inf, 2), complex(nan, nan)}, {complex(nan, -zero), complex(nan, nan), complex(nan, nan)}, {complex(nan, -zero), complex(nan, inf), complex(nan, nan)}, {complex(nan, -zero), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -zero), complex(-inf, zero), complex(nan, nan)}, {complex(nan, -zero), complex(-inf, -zero), complex(nan, nan)}, {complex(nan, -zero), complex(-inf, 1), complex(nan, nan)}, {complex(nan, -zero), complex(-inf, -1), complex(nan, nan)}, {complex(nan, -zero), complex(-inf, 2), complex(nan, nan)}, {complex(nan, -zero), complex(nan, nan), complex(nan, nan)}, {complex(nan, -zero), complex(nan, inf), complex(nan, nan)}, {complex(nan, -zero), complex(nan, -inf), complex(nan, nan)}, {complex(nan, 1), complex(zero, zero), complex(nan, inf)}, {complex(nan, 1), complex(zero, -zero), complex(nan, inf)}, {complex(nan, 1), complex(zero, 1), complex(nan, nan)}, {complex(nan, 1), complex(zero, -1), complex(nan, nan)}, {complex(nan, 1), complex(zero, 2), complex(nan, nan)}, {complex(nan, 1), complex(nan, nan), complex(nan, nan)}, {complex(nan, 1), complex(nan, inf), complex(nan, nan)}, {complex(nan, 1), complex(nan, -inf), complex(nan, nan)}, {complex(nan, 1), complex(zero, zero), complex(nan, inf)}, {complex(nan, 1), complex(-zero, -zero), complex(nan, -inf)}, {complex(nan, 1), complex(zero, 1), complex(nan, nan)}, {complex(nan, 1), complex(-zero, -1), complex(nan, nan)}, {complex(nan, 1), complex(zero, 2), complex(nan, nan)}, {complex(nan, 1), complex(nan, nan), complex(nan, nan)}, {complex(nan, 1), complex(nan, inf), complex(nan, nan)}, {complex(nan, 1), complex(nan, -inf), complex(nan, nan)}, {complex(nan, 1), complex(1, zero), complex(nan, nan)}, {complex(nan, 1), complex(1, -zero), complex(nan, nan)}, {complex(nan, 1), complex(1, 1), complex(nan, nan)}, {complex(nan, 1), complex(1, -1), complex(nan, nan)}, {complex(nan, 1), complex(1, 2), complex(nan, nan)}, {complex(nan, 1), complex(nan, nan), complex(nan, nan)}, {complex(nan, 1), complex(nan, inf), complex(nan, nan)}, {complex(nan, 1), complex(nan, -inf), complex(nan, nan)}, {complex(nan, 1), complex(-1, zero), complex(nan, nan)}, {complex(nan, 1), complex(-1, -zero), complex(nan, nan)}, {complex(nan, 1), complex(-1, 1), complex(nan, nan)}, {complex(nan, 1), complex(-1, -1), complex(nan, nan)}, {complex(nan, 1), complex(-1, 2), complex(nan, nan)}, {complex(nan, 1), complex(nan, nan), complex(nan, nan)}, {complex(nan, 1), complex(nan, inf), complex(nan, nan)}, {complex(nan, 1), complex(nan, -inf), complex(nan, nan)}, {complex(nan, 1), complex(2, zero), complex(nan, nan)}, {complex(nan, 1), complex(2, -zero), complex(nan, nan)}, {complex(nan, 1), complex(2, 1), complex(nan, nan)}, {complex(nan, 1), complex(2, -1), complex(nan, nan)}, {complex(nan, 1), complex(2, 2), complex(nan, nan)}, {complex(nan, 1), complex(nan, nan), complex(nan, nan)}, {complex(nan, 1), complex(nan, inf), complex(nan, nan)}, {complex(nan, 1), complex(nan, -inf), complex(nan, nan)}, {complex(nan, 1), complex(nan, zero), complex(nan, nan)}, {complex(nan, 1), complex(nan, -zero), complex(nan, nan)}, {complex(nan, 1), complex(nan, 1), complex(nan, nan)}, {complex(nan, 1), complex(nan, -1), complex(nan, nan)}, {complex(nan, 1), complex(nan, 2), complex(nan, nan)}, {complex(nan, 1), complex(nan, nan), complex(nan, nan)}, {complex(nan, 1), complex(nan, inf), complex(nan, nan)}, {complex(nan, 1), complex(nan, -inf), complex(nan, nan)}, {complex(nan, 1), complex(inf, zero), complex(nan, nan)}, {complex(nan, 1), complex(inf, -zero), complex(nan, nan)}, {complex(nan, 1), complex(inf, 1), complex(nan, nan)}, {complex(nan, 1), complex(inf, -1), complex(nan, nan)}, {complex(nan, 1), complex(inf, 2), complex(nan, nan)}, {complex(nan, 1), complex(nan, nan), complex(nan, nan)}, {complex(nan, 1), complex(nan, inf), complex(nan, nan)}, {complex(nan, 1), complex(nan, -inf), complex(nan, nan)}, {complex(nan, 1), complex(-inf, zero), complex(nan, nan)}, {complex(nan, 1), complex(-inf, -zero), complex(nan, nan)}, {complex(nan, 1), complex(-inf, 1), complex(nan, nan)}, {complex(nan, 1), complex(-inf, -1), complex(nan, nan)}, {complex(nan, 1), complex(-inf, 2), complex(nan, nan)}, {complex(nan, 1), complex(nan, nan), complex(nan, nan)}, {complex(nan, 1), complex(nan, inf), complex(nan, nan)}, {complex(nan, 1), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -1), complex(zero, zero), complex(nan, -inf)}, {complex(nan, -1), complex(zero, -zero), complex(nan, -inf)}, {complex(nan, -1), complex(zero, 1), complex(nan, nan)}, {complex(nan, -1), complex(zero, -1), complex(nan, nan)}, {complex(nan, -1), complex(zero, 2), complex(nan, nan)}, {complex(nan, -1), complex(nan, nan), complex(nan, nan)}, {complex(nan, -1), complex(nan, inf), complex(nan, nan)}, {complex(nan, -1), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -1), complex(zero, zero), complex(nan, -inf)}, {complex(nan, -1), complex(-zero, -zero), complex(nan, inf)}, {complex(nan, -1), complex(zero, 1), complex(nan, nan)}, {complex(nan, -1), complex(-zero, -1), complex(nan, nan)}, {complex(nan, -1), complex(zero, 2), complex(nan, nan)}, {complex(nan, -1), complex(nan, nan), complex(nan, nan)}, {complex(nan, -1), complex(nan, inf), complex(nan, nan)}, {complex(nan, -1), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -1), complex(1, zero), complex(nan, nan)}, {complex(nan, -1), complex(1, -zero), complex(nan, nan)}, {complex(nan, -1), complex(1, 1), complex(nan, nan)}, {complex(nan, -1), complex(1, -1), complex(nan, nan)}, {complex(nan, -1), complex(1, 2), complex(nan, nan)}, {complex(nan, -1), complex(nan, nan), complex(nan, nan)}, {complex(nan, -1), complex(nan, inf), complex(nan, nan)}, {complex(nan, -1), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -1), complex(-1, zero), complex(nan, nan)}, {complex(nan, -1), complex(-1, -zero), complex(nan, nan)}, {complex(nan, -1), complex(-1, 1), complex(nan, nan)}, {complex(nan, -1), complex(-1, -1), complex(nan, nan)}, {complex(nan, -1), complex(-1, 2), complex(nan, nan)}, {complex(nan, -1), complex(nan, nan), complex(nan, nan)}, {complex(nan, -1), complex(nan, inf), complex(nan, nan)}, {complex(nan, -1), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -1), complex(2, zero), complex(nan, nan)}, {complex(nan, -1), complex(2, -zero), complex(nan, nan)}, {complex(nan, -1), complex(2, 1), complex(nan, nan)}, {complex(nan, -1), complex(2, -1), complex(nan, nan)}, {complex(nan, -1), complex(2, 2), complex(nan, nan)}, {complex(nan, -1), complex(nan, nan), complex(nan, nan)}, {complex(nan, -1), complex(nan, inf), complex(nan, nan)}, {complex(nan, -1), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -1), complex(nan, zero), complex(nan, nan)}, {complex(nan, -1), complex(nan, -zero), complex(nan, nan)}, {complex(nan, -1), complex(nan, 1), complex(nan, nan)}, {complex(nan, -1), complex(nan, -1), complex(nan, nan)}, {complex(nan, -1), complex(nan, 2), complex(nan, nan)}, {complex(nan, -1), complex(nan, nan), complex(nan, nan)}, {complex(nan, -1), complex(nan, inf), complex(nan, nan)}, {complex(nan, -1), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -1), complex(inf, zero), complex(nan, nan)}, {complex(nan, -1), complex(inf, -zero), complex(nan, nan)}, {complex(nan, -1), complex(inf, 1), complex(nan, nan)}, {complex(nan, -1), complex(inf, -1), complex(nan, nan)}, {complex(nan, -1), complex(inf, 2), complex(nan, nan)}, {complex(nan, -1), complex(nan, nan), complex(nan, nan)}, {complex(nan, -1), complex(nan, inf), complex(nan, nan)}, {complex(nan, -1), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -1), complex(-inf, zero), complex(nan, nan)}, {complex(nan, -1), complex(-inf, -zero), complex(nan, nan)}, {complex(nan, -1), complex(-inf, 1), complex(nan, nan)}, {complex(nan, -1), complex(-inf, -1), complex(nan, nan)}, {complex(nan, -1), complex(-inf, 2), complex(nan, nan)}, {complex(nan, -1), complex(nan, nan), complex(nan, nan)}, {complex(nan, -1), complex(nan, inf), complex(nan, nan)}, {complex(nan, -1), complex(nan, -inf), complex(nan, nan)}, {complex(nan, 2), complex(zero, zero), complex(nan, inf)}, {complex(nan, 2), complex(zero, -zero), complex(nan, inf)}, {complex(nan, 2), complex(zero, 1), complex(nan, nan)}, {complex(nan, 2), complex(zero, -1), complex(nan, nan)}, {complex(nan, 2), complex(zero, 2), complex(nan, nan)}, {complex(nan, 2), complex(nan, nan), complex(nan, nan)}, {complex(nan, 2), complex(nan, inf), complex(nan, nan)}, {complex(nan, 2), complex(nan, -inf), complex(nan, nan)}, {complex(nan, 2), complex(zero, zero), complex(nan, inf)}, {complex(nan, 2), complex(-zero, -zero), complex(nan, -inf)}, {complex(nan, 2), complex(zero, 1), complex(nan, nan)}, {complex(nan, 2), complex(-zero, -1), complex(nan, nan)}, {complex(nan, 2), complex(zero, 2), complex(nan, nan)}, {complex(nan, 2), complex(nan, nan), complex(nan, nan)}, {complex(nan, 2), complex(nan, inf), complex(nan, nan)}, {complex(nan, 2), complex(nan, -inf), complex(nan, nan)}, {complex(nan, 2), complex(1, zero), complex(nan, nan)}, {complex(nan, 2), complex(1, -zero), complex(nan, nan)}, {complex(nan, 2), complex(1, 1), complex(nan, nan)}, {complex(nan, 2), complex(1, -1), complex(nan, nan)}, {complex(nan, 2), complex(1, 2), complex(nan, nan)}, {complex(nan, 2), complex(nan, nan), complex(nan, nan)}, {complex(nan, 2), complex(nan, inf), complex(nan, nan)}, {complex(nan, 2), complex(nan, -inf), complex(nan, nan)}, {complex(nan, 2), complex(-1, zero), complex(nan, nan)}, {complex(nan, 2), complex(-1, -zero), complex(nan, nan)}, {complex(nan, 2), complex(-1, 1), complex(nan, nan)}, {complex(nan, 2), complex(-1, -1), complex(nan, nan)}, {complex(nan, 2), complex(-1, 2), complex(nan, nan)}, {complex(nan, 2), complex(nan, nan), complex(nan, nan)}, {complex(nan, 2), complex(nan, inf), complex(nan, nan)}, {complex(nan, 2), complex(nan, -inf), complex(nan, nan)}, {complex(nan, 2), complex(2, zero), complex(nan, nan)}, {complex(nan, 2), complex(2, -zero), complex(nan, nan)}, {complex(nan, 2), complex(2, 1), complex(nan, nan)}, {complex(nan, 2), complex(2, -1), complex(nan, nan)}, {complex(nan, 2), complex(2, 2), complex(nan, nan)}, {complex(nan, 2), complex(nan, nan), complex(nan, nan)}, {complex(nan, 2), complex(nan, inf), complex(nan, nan)}, {complex(nan, 2), complex(nan, -inf), complex(nan, nan)}, {complex(nan, 2), complex(nan, zero), complex(nan, nan)}, {complex(nan, 2), complex(nan, -zero), complex(nan, nan)}, {complex(nan, 2), complex(nan, 1), complex(nan, nan)}, {complex(nan, 2), complex(nan, -1), complex(nan, nan)}, {complex(nan, 2), complex(nan, 2), complex(nan, nan)}, {complex(nan, 2), complex(nan, nan), complex(nan, nan)}, {complex(nan, 2), complex(nan, inf), complex(nan, nan)}, {complex(nan, 2), complex(nan, -inf), complex(nan, nan)}, {complex(nan, 2), complex(inf, zero), complex(nan, nan)}, {complex(nan, 2), complex(inf, -zero), complex(nan, nan)}, {complex(nan, 2), complex(inf, 1), complex(nan, nan)}, {complex(nan, 2), complex(inf, -1), complex(nan, nan)}, {complex(nan, 2), complex(inf, 2), complex(nan, nan)}, {complex(nan, 2), complex(nan, nan), complex(nan, nan)}, {complex(nan, 2), complex(nan, inf), complex(nan, nan)}, {complex(nan, 2), complex(nan, -inf), complex(nan, nan)}, {complex(nan, 2), complex(-inf, zero), complex(nan, nan)}, {complex(nan, 2), complex(-inf, -zero), complex(nan, nan)}, {complex(nan, 2), complex(-inf, 1), complex(nan, nan)}, {complex(nan, 2), complex(-inf, -1), complex(nan, nan)}, {complex(nan, 2), complex(-inf, 2), complex(nan, nan)}, {complex(nan, 2), complex(nan, nan), complex(nan, nan)}, {complex(nan, 2), complex(nan, inf), complex(nan, nan)}, {complex(nan, 2), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(zero, zero), complex(nan, nan)}, {complex(nan, nan), complex(zero, -zero), complex(nan, nan)}, {complex(nan, nan), complex(zero, 1), complex(nan, nan)}, {complex(nan, nan), complex(zero, -1), complex(nan, nan)}, {complex(nan, nan), complex(zero, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(zero, zero), complex(nan, nan)}, {complex(nan, nan), complex(-zero, -zero), complex(nan, nan)}, {complex(nan, nan), complex(zero, 1), complex(nan, nan)}, {complex(nan, nan), complex(-zero, -1), complex(nan, nan)}, {complex(nan, nan), complex(zero, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(1, zero), complex(nan, nan)}, {complex(nan, nan), complex(1, -zero), complex(nan, nan)}, {complex(nan, nan), complex(1, 1), complex(nan, nan)}, {complex(nan, nan), complex(1, -1), complex(nan, nan)}, {complex(nan, nan), complex(1, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(-1, zero), complex(nan, nan)}, {complex(nan, nan), complex(-1, -zero), complex(nan, nan)}, {complex(nan, nan), complex(-1, 1), complex(nan, nan)}, {complex(nan, nan), complex(-1, -1), complex(nan, nan)}, {complex(nan, nan), complex(-1, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(2, zero), complex(nan, nan)}, {complex(nan, nan), complex(2, -zero), complex(nan, nan)}, {complex(nan, nan), complex(2, 1), complex(nan, nan)}, {complex(nan, nan), complex(2, -1), complex(nan, nan)}, {complex(nan, nan), complex(2, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, zero), complex(nan, nan)}, {complex(nan, nan), complex(nan, -zero), complex(nan, nan)}, {complex(nan, nan), complex(nan, 1), complex(nan, nan)}, {complex(nan, nan), complex(nan, -1), complex(nan, nan)}, {complex(nan, nan), complex(nan, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(inf, zero), complex(nan, nan)}, {complex(nan, nan), complex(inf, -zero), complex(nan, nan)}, {complex(nan, nan), complex(inf, 1), complex(nan, nan)}, {complex(nan, nan), complex(inf, -1), complex(nan, nan)}, {complex(nan, nan), complex(inf, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(-inf, zero), complex(nan, nan)}, {complex(nan, nan), complex(-inf, -zero), complex(nan, nan)}, {complex(nan, nan), complex(-inf, 1), complex(nan, nan)}, {complex(nan, nan), complex(-inf, -1), complex(nan, nan)}, {complex(nan, nan), complex(-inf, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(zero, zero), complex(nan, inf)}, {complex(nan, inf), complex(zero, -zero), complex(nan, inf)}, {complex(nan, inf), complex(zero, 1), complex(inf, nan)}, {complex(nan, inf), complex(zero, -1), complex(-inf, nan)}, {complex(nan, inf), complex(zero, 2), complex(inf, nan)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(zero, zero), complex(nan, inf)}, {complex(nan, inf), complex(-zero, -zero), complex(nan, -inf)}, {complex(nan, inf), complex(zero, 1), complex(inf, nan)}, {complex(nan, inf), complex(-zero, -1), complex(-inf, nan)}, {complex(nan, inf), complex(zero, 2), complex(inf, nan)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(1, zero), complex(nan, inf)}, {complex(nan, inf), complex(1, -zero), complex(nan, inf)}, {complex(nan, inf), complex(1, 1), complex(inf, inf)}, {complex(nan, inf), complex(1, -1), complex(-inf, inf)}, {complex(nan, inf), complex(1, 2), complex(inf, inf)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(-1, zero), complex(nan, -inf)}, {complex(nan, inf), complex(-1, -zero), complex(nan, -inf)}, {complex(nan, inf), complex(-1, 1), complex(inf, -inf)}, {complex(nan, inf), complex(-1, -1), complex(-inf, -inf)}, {complex(nan, inf), complex(-1, 2), complex(inf, -inf)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(2, zero), complex(nan, inf)}, {complex(nan, inf), complex(2, -zero), complex(nan, inf)}, {complex(nan, inf), complex(2, 1), complex(inf, inf)}, {complex(nan, inf), complex(2, -1), complex(-inf, inf)}, {complex(nan, inf), complex(2, 2), complex(inf, inf)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, zero), complex(nan, nan)}, {complex(nan, inf), complex(nan, -zero), complex(nan, nan)}, {complex(nan, inf), complex(nan, 1), complex(nan, nan)}, {complex(nan, inf), complex(nan, -1), complex(nan, nan)}, {complex(nan, inf), complex(nan, 2), complex(nan, nan)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(inf, zero), complex(nan, nan)}, {complex(nan, inf), complex(inf, -zero), complex(nan, nan)}, {complex(nan, inf), complex(inf, 1), complex(nan, nan)}, {complex(nan, inf), complex(inf, -1), complex(nan, nan)}, {complex(nan, inf), complex(inf, 2), complex(nan, nan)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(-inf, zero), complex(nan, nan)}, {complex(nan, inf), complex(-inf, -zero), complex(nan, nan)}, {complex(nan, inf), complex(-inf, 1), complex(nan, nan)}, {complex(nan, inf), complex(-inf, -1), complex(nan, nan)}, {complex(nan, inf), complex(-inf, 2), complex(nan, nan)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(zero, zero), complex(nan, -inf)}, {complex(nan, -inf), complex(zero, -zero), complex(nan, -inf)}, {complex(nan, -inf), complex(zero, 1), complex(-inf, nan)}, {complex(nan, -inf), complex(zero, -1), complex(inf, nan)}, {complex(nan, -inf), complex(zero, 2), complex(-inf, nan)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(zero, zero), complex(nan, -inf)}, {complex(nan, -inf), complex(-zero, -zero), complex(nan, inf)}, {complex(nan, -inf), complex(zero, 1), complex(-inf, nan)}, {complex(nan, -inf), complex(-zero, -1), complex(inf, nan)}, {complex(nan, -inf), complex(zero, 2), complex(-inf, nan)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(1, zero), complex(nan, -inf)}, {complex(nan, -inf), complex(1, -zero), complex(nan, -inf)}, {complex(nan, -inf), complex(1, 1), complex(-inf, -inf)}, {complex(nan, -inf), complex(1, -1), complex(inf, -inf)}, {complex(nan, -inf), complex(1, 2), complex(-inf, -inf)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(-1, zero), complex(nan, inf)}, {complex(nan, -inf), complex(-1, -zero), complex(nan, inf)}, {complex(nan, -inf), complex(-1, 1), complex(-inf, inf)}, {complex(nan, -inf), complex(-1, -1), complex(inf, inf)}, {complex(nan, -inf), complex(-1, 2), complex(-inf, inf)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(2, zero), complex(nan, -inf)}, {complex(nan, -inf), complex(2, -zero), complex(nan, -inf)}, {complex(nan, -inf), complex(2, 1), complex(-inf, -inf)}, {complex(nan, -inf), complex(2, -1), complex(inf, -inf)}, {complex(nan, -inf), complex(2, 2), complex(-inf, -inf)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, zero), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -zero), complex(nan, nan)}, {complex(nan, -inf), complex(nan, 1), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -1), complex(nan, nan)}, {complex(nan, -inf), complex(nan, 2), complex(nan, nan)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(inf, zero), complex(nan, nan)}, {complex(nan, -inf), complex(inf, -zero), complex(nan, nan)}, {complex(nan, -inf), complex(inf, 1), complex(nan, nan)}, {complex(nan, -inf), complex(inf, -1), complex(nan, nan)}, {complex(nan, -inf), complex(inf, 2), complex(nan, nan)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(-inf, zero), complex(nan, nan)}, {complex(nan, -inf), complex(-inf, -zero), complex(nan, nan)}, {complex(nan, -inf), complex(-inf, 1), complex(nan, nan)}, {complex(nan, -inf), complex(-inf, -1), complex(nan, nan)}, {complex(nan, -inf), complex(-inf, 2), complex(nan, nan)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(inf, zero), complex(zero, zero), complex(inf, nan)}, {complex(inf, zero), complex(zero, -zero), complex(inf, nan)}, {complex(inf, zero), complex(zero, 1), complex(nan, -inf)}, {complex(inf, zero), complex(zero, -1), complex(nan, inf)}, {complex(inf, zero), complex(zero, 2), complex(nan, -inf)}, {complex(inf, zero), complex(nan, nan), complex(nan, nan)}, {complex(inf, zero), complex(nan, inf), complex(nan, nan)}, {complex(inf, zero), complex(nan, -inf), complex(nan, nan)}, {complex(inf, zero), complex(zero, zero), complex(inf, nan)}, {complex(inf, zero), complex(-zero, -zero), complex(-inf, nan)}, {complex(inf, zero), complex(zero, 1), complex(nan, -inf)}, {complex(inf, zero), complex(-zero, -1), complex(nan, inf)}, {complex(inf, zero), complex(zero, 2), complex(nan, -inf)}, {complex(inf, zero), complex(nan, nan), complex(nan, nan)}, {complex(inf, zero), complex(nan, inf), complex(nan, nan)}, {complex(inf, zero), complex(nan, -inf), complex(nan, nan)}, {complex(inf, zero), complex(1, zero), complex(inf, nan)}, {complex(inf, zero), complex(1, -zero), complex(inf, nan)}, {complex(inf, zero), complex(1, 1), complex(inf, -inf)}, {complex(inf, zero), complex(1, -1), complex(inf, inf)}, {complex(inf, zero), complex(1, 2), complex(inf, -inf)}, {complex(inf, zero), complex(nan, nan), complex(nan, nan)}, {complex(inf, zero), complex(nan, inf), complex(nan, nan)}, {complex(inf, zero), complex(nan, -inf), complex(nan, nan)}, {complex(inf, zero), complex(-1, zero), complex(-inf, nan)}, {complex(inf, zero), complex(-1, -zero), complex(-inf, nan)}, {complex(inf, zero), complex(-1, 1), complex(-inf, -inf)}, {complex(inf, zero), complex(-1, -1), complex(-inf, inf)}, {complex(inf, zero), complex(-1, 2), complex(-inf, -inf)}, {complex(inf, zero), complex(nan, nan), complex(nan, nan)}, {complex(inf, zero), complex(nan, inf), complex(nan, nan)}, {complex(inf, zero), complex(nan, -inf), complex(nan, nan)}, {complex(inf, zero), complex(2, zero), complex(inf, nan)}, {complex(inf, zero), complex(2, -zero), complex(inf, nan)}, {complex(inf, zero), complex(2, 1), complex(inf, -inf)}, {complex(inf, zero), complex(2, -1), complex(inf, inf)}, {complex(inf, zero), complex(2, 2), complex(inf, -inf)}, {complex(inf, zero), complex(nan, nan), complex(nan, nan)}, {complex(inf, zero), complex(nan, inf), complex(nan, nan)}, {complex(inf, zero), complex(nan, -inf), complex(nan, nan)}, {complex(inf, zero), complex(nan, zero), complex(nan, nan)}, {complex(inf, zero), complex(nan, -zero), complex(nan, nan)}, {complex(inf, zero), complex(nan, 1), complex(nan, nan)}, {complex(inf, zero), complex(nan, -1), complex(nan, nan)}, {complex(inf, zero), complex(nan, 2), complex(nan, nan)}, {complex(inf, zero), complex(nan, nan), complex(nan, nan)}, {complex(inf, zero), complex(nan, inf), complex(nan, nan)}, {complex(inf, zero), complex(nan, -inf), complex(nan, nan)}, {complex(inf, zero), complex(inf, zero), complex(nan, nan)}, {complex(inf, zero), complex(inf, -zero), complex(nan, nan)}, {complex(inf, zero), complex(inf, 1), complex(nan, nan)}, {complex(inf, zero), complex(inf, -1), complex(nan, nan)}, {complex(inf, zero), complex(inf, 2), complex(nan, nan)}, {complex(inf, zero), complex(nan, nan), complex(nan, nan)}, {complex(inf, zero), complex(nan, inf), complex(nan, nan)}, {complex(inf, zero), complex(nan, -inf), complex(nan, nan)}, {complex(inf, zero), complex(-inf, zero), complex(nan, nan)}, {complex(inf, zero), complex(-inf, -zero), complex(nan, nan)}, {complex(inf, zero), complex(-inf, 1), complex(nan, nan)}, {complex(inf, zero), complex(-inf, -1), complex(nan, nan)}, {complex(inf, zero), complex(-inf, 2), complex(nan, nan)}, {complex(inf, zero), complex(nan, nan), complex(nan, nan)}, {complex(inf, zero), complex(nan, inf), complex(nan, nan)}, {complex(inf, zero), complex(nan, -inf), complex(nan, nan)}, {complex(inf, -zero), complex(zero, zero), complex(inf, nan)}, {complex(inf, -zero), complex(zero, -zero), complex(inf, nan)}, {complex(inf, -zero), complex(zero, 1), complex(nan, -inf)}, {complex(inf, -zero), complex(zero, -1), complex(nan, inf)}, {complex(inf, -zero), complex(zero, 2), complex(nan, -inf)}, {complex(inf, -zero), complex(nan, nan), complex(nan, nan)}, {complex(inf, -zero), complex(nan, inf), complex(nan, nan)}, {complex(inf, -zero), complex(nan, -inf), complex(nan, nan)}, {complex(inf, -zero), complex(zero, zero), complex(inf, nan)}, {complex(inf, -zero), complex(-zero, -zero), complex(-inf, nan)}, {complex(inf, -zero), complex(zero, 1), complex(nan, -inf)}, {complex(inf, -zero), complex(-zero, -1), complex(nan, inf)}, {complex(inf, -zero), complex(zero, 2), complex(nan, -inf)}, {complex(inf, -zero), complex(nan, nan), complex(nan, nan)}, {complex(inf, -zero), complex(nan, inf), complex(nan, nan)}, {complex(inf, -zero), complex(nan, -inf), complex(nan, nan)}, {complex(inf, -zero), complex(1, zero), complex(inf, nan)}, {complex(inf, -zero), complex(1, -zero), complex(inf, nan)}, {complex(inf, -zero), complex(1, 1), complex(inf, -inf)}, {complex(inf, -zero), complex(1, -1), complex(inf, inf)}, {complex(inf, -zero), complex(1, 2), complex(inf, -inf)}, {complex(inf, -zero), complex(nan, nan), complex(nan, nan)}, {complex(inf, -zero), complex(nan, inf), complex(nan, nan)}, {complex(inf, -zero), complex(nan, -inf), complex(nan, nan)}, {complex(inf, -zero), complex(-1, zero), complex(-inf, nan)}, {complex(inf, -zero), complex(-1, -zero), complex(-inf, nan)}, {complex(inf, -zero), complex(-1, 1), complex(-inf, -inf)}, {complex(inf, -zero), complex(-1, -1), complex(-inf, inf)}, {complex(inf, -zero), complex(-1, 2), complex(-inf, -inf)}, {complex(inf, -zero), complex(nan, nan), complex(nan, nan)}, {complex(inf, -zero), complex(nan, inf), complex(nan, nan)}, {complex(inf, -zero), complex(nan, -inf), complex(nan, nan)}, {complex(inf, -zero), complex(2, zero), complex(inf, nan)}, {complex(inf, -zero), complex(2, -zero), complex(inf, nan)}, {complex(inf, -zero), complex(2, 1), complex(inf, -inf)}, {complex(inf, -zero), complex(2, -1), complex(inf, inf)}, {complex(inf, -zero), complex(2, 2), complex(inf, -inf)}, {complex(inf, -zero), complex(nan, nan), complex(nan, nan)}, {complex(inf, -zero), complex(nan, inf), complex(nan, nan)}, {complex(inf, -zero), complex(nan, -inf), complex(nan, nan)}, {complex(inf, -zero), complex(nan, zero), complex(nan, nan)}, {complex(inf, -zero), complex(nan, -zero), complex(nan, nan)}, {complex(inf, -zero), complex(nan, 1), complex(nan, nan)}, {complex(inf, -zero), complex(nan, -1), complex(nan, nan)}, {complex(inf, -zero), complex(nan, 2), complex(nan, nan)}, {complex(inf, -zero), complex(nan, nan), complex(nan, nan)}, {complex(inf, -zero), complex(nan, inf), complex(nan, nan)}, {complex(inf, -zero), complex(nan, -inf), complex(nan, nan)}, {complex(inf, -zero), complex(inf, zero), complex(nan, nan)}, {complex(inf, -zero), complex(inf, -zero), complex(nan, nan)}, {complex(inf, -zero), complex(inf, 1), complex(nan, nan)}, {complex(inf, -zero), complex(inf, -1), complex(nan, nan)}, {complex(inf, -zero), complex(inf, 2), complex(nan, nan)}, {complex(inf, -zero), complex(nan, nan), complex(nan, nan)}, {complex(inf, -zero), complex(nan, inf), complex(nan, nan)}, {complex(inf, -zero), complex(nan, -inf), complex(nan, nan)}, {complex(inf, -zero), complex(-inf, zero), complex(nan, nan)}, {complex(inf, -zero), complex(-inf, -zero), complex(nan, nan)}, {complex(inf, -zero), complex(-inf, 1), complex(nan, nan)}, {complex(inf, -zero), complex(-inf, -1), complex(nan, nan)}, {complex(inf, -zero), complex(-inf, 2), complex(nan, nan)}, {complex(inf, -zero), complex(nan, nan), complex(nan, nan)}, {complex(inf, -zero), complex(nan, inf), complex(nan, nan)}, {complex(inf, -zero), complex(nan, -inf), complex(nan, nan)}, {complex(inf, 1), complex(zero, zero), complex(inf, inf)}, {complex(inf, 1), complex(zero, -zero), complex(inf, inf)}, {complex(inf, 1), complex(zero, 1), complex(nan, -inf)}, {complex(inf, 1), complex(zero, -1), complex(nan, inf)}, {complex(inf, 1), complex(zero, 2), complex(nan, -inf)}, {complex(inf, 1), complex(nan, nan), complex(nan, nan)}, {complex(inf, 1), complex(nan, inf), complex(nan, nan)}, {complex(inf, 1), complex(nan, -inf), complex(nan, nan)}, {complex(inf, 1), complex(zero, zero), complex(inf, inf)}, {complex(inf, 1), complex(-zero, -zero), complex(-inf, -inf)}, {complex(inf, 1), complex(zero, 1), complex(nan, -inf)}, {complex(inf, 1), complex(-zero, -1), complex(nan, inf)}, {complex(inf, 1), complex(zero, 2), complex(nan, -inf)}, {complex(inf, 1), complex(nan, nan), complex(nan, nan)}, {complex(inf, 1), complex(nan, inf), complex(nan, nan)}, {complex(inf, 1), complex(nan, -inf), complex(nan, nan)}, {complex(inf, 1), complex(1, zero), complex(inf, nan)}, {complex(inf, 1), complex(1, -zero), complex(inf, nan)}, {complex(inf, 1), complex(1, 1), complex(inf, -inf)}, {complex(inf, 1), complex(1, -1), complex(inf, inf)}, {complex(inf, 1), complex(1, 2), complex(inf, -inf)}, {complex(inf, 1), complex(nan, nan), complex(nan, nan)}, {complex(inf, 1), complex(nan, inf), complex(nan, nan)}, {complex(inf, 1), complex(nan, -inf), complex(nan, nan)}, {complex(inf, 1), complex(-1, zero), complex(-inf, nan)}, {complex(inf, 1), complex(-1, -zero), complex(-inf, nan)}, {complex(inf, 1), complex(-1, 1), complex(-inf, -inf)}, {complex(inf, 1), complex(-1, -1), complex(-inf, inf)}, {complex(inf, 1), complex(-1, 2), complex(-inf, -inf)}, {complex(inf, 1), complex(nan, nan), complex(nan, nan)}, {complex(inf, 1), complex(nan, inf), complex(nan, nan)}, {complex(inf, 1), complex(nan, -inf), complex(nan, nan)}, {complex(inf, 1), complex(2, zero), complex(inf, nan)}, {complex(inf, 1), complex(2, -zero), complex(inf, nan)}, {complex(inf, 1), complex(2, 1), complex(inf, -inf)}, {complex(inf, 1), complex(2, -1), complex(inf, inf)}, {complex(inf, 1), complex(2, 2), complex(inf, -inf)}, {complex(inf, 1), complex(nan, nan), complex(nan, nan)}, {complex(inf, 1), complex(nan, inf), complex(nan, nan)}, {complex(inf, 1), complex(nan, -inf), complex(nan, nan)}, {complex(inf, 1), complex(nan, zero), complex(nan, nan)}, {complex(inf, 1), complex(nan, -zero), complex(nan, nan)}, {complex(inf, 1), complex(nan, 1), complex(nan, nan)}, {complex(inf, 1), complex(nan, -1), complex(nan, nan)}, {complex(inf, 1), complex(nan, 2), complex(nan, nan)}, {complex(inf, 1), complex(nan, nan), complex(nan, nan)}, {complex(inf, 1), complex(nan, inf), complex(nan, nan)}, {complex(inf, 1), complex(nan, -inf), complex(nan, nan)}, {complex(inf, 1), complex(inf, zero), complex(nan, nan)}, {complex(inf, 1), complex(inf, -zero), complex(nan, nan)}, {complex(inf, 1), complex(inf, 1), complex(nan, nan)}, {complex(inf, 1), complex(inf, -1), complex(nan, nan)}, {complex(inf, 1), complex(inf, 2), complex(nan, nan)}, {complex(inf, 1), complex(nan, nan), complex(nan, nan)}, {complex(inf, 1), complex(nan, inf), complex(nan, nan)}, {complex(inf, 1), complex(nan, -inf), complex(nan, nan)}, {complex(inf, 1), complex(-inf, zero), complex(nan, nan)}, {complex(inf, 1), complex(-inf, -zero), complex(nan, nan)}, {complex(inf, 1), complex(-inf, 1), complex(nan, nan)}, {complex(inf, 1), complex(-inf, -1), complex(nan, nan)}, {complex(inf, 1), complex(-inf, 2), complex(nan, nan)}, {complex(inf, 1), complex(nan, nan), complex(nan, nan)}, {complex(inf, 1), complex(nan, inf), complex(nan, nan)}, {complex(inf, 1), complex(nan, -inf), complex(nan, nan)}, {complex(inf, -1), complex(zero, zero), complex(inf, -inf)}, {complex(inf, -1), complex(zero, -zero), complex(inf, -inf)}, {complex(inf, -1), complex(zero, 1), complex(nan, -inf)}, {complex(inf, -1), complex(zero, -1), complex(nan, inf)}, {complex(inf, -1), complex(zero, 2), complex(nan, -inf)}, {complex(inf, -1), complex(nan, nan), complex(nan, nan)}, {complex(inf, -1), complex(nan, inf), complex(nan, nan)}, {complex(inf, -1), complex(nan, -inf), complex(nan, nan)}, {complex(inf, -1), complex(zero, zero), complex(inf, -inf)}, {complex(inf, -1), complex(-zero, -zero), complex(-inf, inf)}, {complex(inf, -1), complex(zero, 1), complex(nan, -inf)}, {complex(inf, -1), complex(-zero, -1), complex(nan, inf)}, {complex(inf, -1), complex(zero, 2), complex(nan, -inf)}, {complex(inf, -1), complex(nan, nan), complex(nan, nan)}, {complex(inf, -1), complex(nan, inf), complex(nan, nan)}, {complex(inf, -1), complex(nan, -inf), complex(nan, nan)}, {complex(inf, -1), complex(1, zero), complex(inf, nan)}, {complex(inf, -1), complex(1, -zero), complex(inf, nan)}, {complex(inf, -1), complex(1, 1), complex(inf, -inf)}, {complex(inf, -1), complex(1, -1), complex(inf, inf)}, {complex(inf, -1), complex(1, 2), complex(inf, -inf)}, {complex(inf, -1), complex(nan, nan), complex(nan, nan)}, {complex(inf, -1), complex(nan, inf), complex(nan, nan)}, {complex(inf, -1), complex(nan, -inf), complex(nan, nan)}, {complex(inf, -1), complex(-1, zero), complex(-inf, nan)}, {complex(inf, -1), complex(-1, -zero), complex(-inf, nan)}, {complex(inf, -1), complex(-1, 1), complex(-inf, -inf)}, {complex(inf, -1), complex(-1, -1), complex(-inf, inf)}, {complex(inf, -1), complex(-1, 2), complex(-inf, -inf)}, {complex(inf, -1), complex(nan, nan), complex(nan, nan)}, {complex(inf, -1), complex(nan, inf), complex(nan, nan)}, {complex(inf, -1), complex(nan, -inf), complex(nan, nan)}, {complex(inf, -1), complex(2, zero), complex(inf, nan)}, {complex(inf, -1), complex(2, -zero), complex(inf, nan)}, {complex(inf, -1), complex(2, 1), complex(inf, -inf)}, {complex(inf, -1), complex(2, -1), complex(inf, inf)}, {complex(inf, -1), complex(2, 2), complex(inf, -inf)}, {complex(inf, -1), complex(nan, nan), complex(nan, nan)}, {complex(inf, -1), complex(nan, inf), complex(nan, nan)}, {complex(inf, -1), complex(nan, -inf), complex(nan, nan)}, {complex(inf, -1), complex(nan, zero), complex(nan, nan)}, {complex(inf, -1), complex(nan, -zero), complex(nan, nan)}, {complex(inf, -1), complex(nan, 1), complex(nan, nan)}, {complex(inf, -1), complex(nan, -1), complex(nan, nan)}, {complex(inf, -1), complex(nan, 2), complex(nan, nan)}, {complex(inf, -1), complex(nan, nan), complex(nan, nan)}, {complex(inf, -1), complex(nan, inf), complex(nan, nan)}, {complex(inf, -1), complex(nan, -inf), complex(nan, nan)}, {complex(inf, -1), complex(inf, zero), complex(nan, nan)}, {complex(inf, -1), complex(inf, -zero), complex(nan, nan)}, {complex(inf, -1), complex(inf, 1), complex(nan, nan)}, {complex(inf, -1), complex(inf, -1), complex(nan, nan)}, {complex(inf, -1), complex(inf, 2), complex(nan, nan)}, {complex(inf, -1), complex(nan, nan), complex(nan, nan)}, {complex(inf, -1), complex(nan, inf), complex(nan, nan)}, {complex(inf, -1), complex(nan, -inf), complex(nan, nan)}, {complex(inf, -1), complex(-inf, zero), complex(nan, nan)}, {complex(inf, -1), complex(-inf, -zero), complex(nan, nan)}, {complex(inf, -1), complex(-inf, 1), complex(nan, nan)}, {complex(inf, -1), complex(-inf, -1), complex(nan, nan)}, {complex(inf, -1), complex(-inf, 2), complex(nan, nan)}, {complex(inf, -1), complex(nan, nan), complex(nan, nan)}, {complex(inf, -1), complex(nan, inf), complex(nan, nan)}, {complex(inf, -1), complex(nan, -inf), complex(nan, nan)}, {complex(inf, 2), complex(zero, zero), complex(inf, inf)}, {complex(inf, 2), complex(zero, -zero), complex(inf, inf)}, {complex(inf, 2), complex(zero, 1), complex(nan, -inf)}, {complex(inf, 2), complex(zero, -1), complex(nan, inf)}, {complex(inf, 2), complex(zero, 2), complex(nan, -inf)}, {complex(inf, 2), complex(nan, nan), complex(nan, nan)}, {complex(inf, 2), complex(nan, inf), complex(nan, nan)}, {complex(inf, 2), complex(nan, -inf), complex(nan, nan)}, {complex(inf, 2), complex(zero, zero), complex(inf, inf)}, {complex(inf, 2), complex(-zero, -zero), complex(-inf, -inf)}, {complex(inf, 2), complex(zero, 1), complex(nan, -inf)}, {complex(inf, 2), complex(-zero, -1), complex(nan, inf)}, {complex(inf, 2), complex(zero, 2), complex(nan, -inf)}, {complex(inf, 2), complex(nan, nan), complex(nan, nan)}, {complex(inf, 2), complex(nan, inf), complex(nan, nan)}, {complex(inf, 2), complex(nan, -inf), complex(nan, nan)}, {complex(inf, 2), complex(1, zero), complex(inf, nan)}, {complex(inf, 2), complex(1, -zero), complex(inf, nan)}, {complex(inf, 2), complex(1, 1), complex(inf, -inf)}, {complex(inf, 2), complex(1, -1), complex(inf, inf)}, {complex(inf, 2), complex(1, 2), complex(inf, -inf)}, {complex(inf, 2), complex(nan, nan), complex(nan, nan)}, {complex(inf, 2), complex(nan, inf), complex(nan, nan)}, {complex(inf, 2), complex(nan, -inf), complex(nan, nan)}, {complex(inf, 2), complex(-1, zero), complex(-inf, nan)}, {complex(inf, 2), complex(-1, -zero), complex(-inf, nan)}, {complex(inf, 2), complex(-1, 1), complex(-inf, -inf)}, {complex(inf, 2), complex(-1, -1), complex(-inf, inf)}, {complex(inf, 2), complex(-1, 2), complex(-inf, -inf)}, {complex(inf, 2), complex(nan, nan), complex(nan, nan)}, {complex(inf, 2), complex(nan, inf), complex(nan, nan)}, {complex(inf, 2), complex(nan, -inf), complex(nan, nan)}, {complex(inf, 2), complex(2, zero), complex(inf, nan)}, {complex(inf, 2), complex(2, -zero), complex(inf, nan)}, {complex(inf, 2), complex(2, 1), complex(inf, -inf)}, {complex(inf, 2), complex(2, -1), complex(inf, inf)}, {complex(inf, 2), complex(2, 2), complex(inf, -inf)}, {complex(inf, 2), complex(nan, nan), complex(nan, nan)}, {complex(inf, 2), complex(nan, inf), complex(nan, nan)}, {complex(inf, 2), complex(nan, -inf), complex(nan, nan)}, {complex(inf, 2), complex(nan, zero), complex(nan, nan)}, {complex(inf, 2), complex(nan, -zero), complex(nan, nan)}, {complex(inf, 2), complex(nan, 1), complex(nan, nan)}, {complex(inf, 2), complex(nan, -1), complex(nan, nan)}, {complex(inf, 2), complex(nan, 2), complex(nan, nan)}, {complex(inf, 2), complex(nan, nan), complex(nan, nan)}, {complex(inf, 2), complex(nan, inf), complex(nan, nan)}, {complex(inf, 2), complex(nan, -inf), complex(nan, nan)}, {complex(inf, 2), complex(inf, zero), complex(nan, nan)}, {complex(inf, 2), complex(inf, -zero), complex(nan, nan)}, {complex(inf, 2), complex(inf, 1), complex(nan, nan)}, {complex(inf, 2), complex(inf, -1), complex(nan, nan)}, {complex(inf, 2), complex(inf, 2), complex(nan, nan)}, {complex(inf, 2), complex(nan, nan), complex(nan, nan)}, {complex(inf, 2), complex(nan, inf), complex(nan, nan)}, {complex(inf, 2), complex(nan, -inf), complex(nan, nan)}, {complex(inf, 2), complex(-inf, zero), complex(nan, nan)}, {complex(inf, 2), complex(-inf, -zero), complex(nan, nan)}, {complex(inf, 2), complex(-inf, 1), complex(nan, nan)}, {complex(inf, 2), complex(-inf, -1), complex(nan, nan)}, {complex(inf, 2), complex(-inf, 2), complex(nan, nan)}, {complex(inf, 2), complex(nan, nan), complex(nan, nan)}, {complex(inf, 2), complex(nan, inf), complex(nan, nan)}, {complex(inf, 2), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(zero, zero), complex(nan, nan)}, {complex(nan, nan), complex(zero, -zero), complex(nan, nan)}, {complex(nan, nan), complex(zero, 1), complex(nan, nan)}, {complex(nan, nan), complex(zero, -1), complex(nan, nan)}, {complex(nan, nan), complex(zero, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(zero, zero), complex(nan, nan)}, {complex(nan, nan), complex(-zero, -zero), complex(nan, nan)}, {complex(nan, nan), complex(zero, 1), complex(nan, nan)}, {complex(nan, nan), complex(-zero, -1), complex(nan, nan)}, {complex(nan, nan), complex(zero, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(1, zero), complex(nan, nan)}, {complex(nan, nan), complex(1, -zero), complex(nan, nan)}, {complex(nan, nan), complex(1, 1), complex(nan, nan)}, {complex(nan, nan), complex(1, -1), complex(nan, nan)}, {complex(nan, nan), complex(1, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(-1, zero), complex(nan, nan)}, {complex(nan, nan), complex(-1, -zero), complex(nan, nan)}, {complex(nan, nan), complex(-1, 1), complex(nan, nan)}, {complex(nan, nan), complex(-1, -1), complex(nan, nan)}, {complex(nan, nan), complex(-1, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(2, zero), complex(nan, nan)}, {complex(nan, nan), complex(2, -zero), complex(nan, nan)}, {complex(nan, nan), complex(2, 1), complex(nan, nan)}, {complex(nan, nan), complex(2, -1), complex(nan, nan)}, {complex(nan, nan), complex(2, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, zero), complex(nan, nan)}, {complex(nan, nan), complex(nan, -zero), complex(nan, nan)}, {complex(nan, nan), complex(nan, 1), complex(nan, nan)}, {complex(nan, nan), complex(nan, -1), complex(nan, nan)}, {complex(nan, nan), complex(nan, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(inf, zero), complex(nan, nan)}, {complex(nan, nan), complex(inf, -zero), complex(nan, nan)}, {complex(nan, nan), complex(inf, 1), complex(nan, nan)}, {complex(nan, nan), complex(inf, -1), complex(nan, nan)}, {complex(nan, nan), complex(inf, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(-inf, zero), complex(nan, nan)}, {complex(nan, nan), complex(-inf, -zero), complex(nan, nan)}, {complex(nan, nan), complex(-inf, 1), complex(nan, nan)}, {complex(nan, nan), complex(-inf, -1), complex(nan, nan)}, {complex(nan, nan), complex(-inf, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(zero, zero), complex(nan, inf)}, {complex(nan, inf), complex(zero, -zero), complex(nan, inf)}, {complex(nan, inf), complex(zero, 1), complex(inf, nan)}, {complex(nan, inf), complex(zero, -1), complex(-inf, nan)}, {complex(nan, inf), complex(zero, 2), complex(inf, nan)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(zero, zero), complex(nan, inf)}, {complex(nan, inf), complex(-zero, -zero), complex(nan, -inf)}, {complex(nan, inf), complex(zero, 1), complex(inf, nan)}, {complex(nan, inf), complex(-zero, -1), complex(-inf, nan)}, {complex(nan, inf), complex(zero, 2), complex(inf, nan)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(1, zero), complex(nan, inf)}, {complex(nan, inf), complex(1, -zero), complex(nan, inf)}, {complex(nan, inf), complex(1, 1), complex(inf, inf)}, {complex(nan, inf), complex(1, -1), complex(-inf, inf)}, {complex(nan, inf), complex(1, 2), complex(inf, inf)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(-1, zero), complex(nan, -inf)}, {complex(nan, inf), complex(-1, -zero), complex(nan, -inf)}, {complex(nan, inf), complex(-1, 1), complex(inf, -inf)}, {complex(nan, inf), complex(-1, -1), complex(-inf, -inf)}, {complex(nan, inf), complex(-1, 2), complex(inf, -inf)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(2, zero), complex(nan, inf)}, {complex(nan, inf), complex(2, -zero), complex(nan, inf)}, {complex(nan, inf), complex(2, 1), complex(inf, inf)}, {complex(nan, inf), complex(2, -1), complex(-inf, inf)}, {complex(nan, inf), complex(2, 2), complex(inf, inf)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, zero), complex(nan, nan)}, {complex(nan, inf), complex(nan, -zero), complex(nan, nan)}, {complex(nan, inf), complex(nan, 1), complex(nan, nan)}, {complex(nan, inf), complex(nan, -1), complex(nan, nan)}, {complex(nan, inf), complex(nan, 2), complex(nan, nan)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(inf, zero), complex(nan, nan)}, {complex(nan, inf), complex(inf, -zero), complex(nan, nan)}, {complex(nan, inf), complex(inf, 1), complex(nan, nan)}, {complex(nan, inf), complex(inf, -1), complex(nan, nan)}, {complex(nan, inf), complex(inf, 2), complex(nan, nan)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(-inf, zero), complex(nan, nan)}, {complex(nan, inf), complex(-inf, -zero), complex(nan, nan)}, {complex(nan, inf), complex(-inf, 1), complex(nan, nan)}, {complex(nan, inf), complex(-inf, -1), complex(nan, nan)}, {complex(nan, inf), complex(-inf, 2), complex(nan, nan)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(zero, zero), complex(nan, -inf)}, {complex(nan, -inf), complex(zero, -zero), complex(nan, -inf)}, {complex(nan, -inf), complex(zero, 1), complex(-inf, nan)}, {complex(nan, -inf), complex(zero, -1), complex(inf, nan)}, {complex(nan, -inf), complex(zero, 2), complex(-inf, nan)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(zero, zero), complex(nan, -inf)}, {complex(nan, -inf), complex(-zero, -zero), complex(nan, inf)}, {complex(nan, -inf), complex(zero, 1), complex(-inf, nan)}, {complex(nan, -inf), complex(-zero, -1), complex(inf, nan)}, {complex(nan, -inf), complex(zero, 2), complex(-inf, nan)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(1, zero), complex(nan, -inf)}, {complex(nan, -inf), complex(1, -zero), complex(nan, -inf)}, {complex(nan, -inf), complex(1, 1), complex(-inf, -inf)}, {complex(nan, -inf), complex(1, -1), complex(inf, -inf)}, {complex(nan, -inf), complex(1, 2), complex(-inf, -inf)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(-1, zero), complex(nan, inf)}, {complex(nan, -inf), complex(-1, -zero), complex(nan, inf)}, {complex(nan, -inf), complex(-1, 1), complex(-inf, inf)}, {complex(nan, -inf), complex(-1, -1), complex(inf, inf)}, {complex(nan, -inf), complex(-1, 2), complex(-inf, inf)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(2, zero), complex(nan, -inf)}, {complex(nan, -inf), complex(2, -zero), complex(nan, -inf)}, {complex(nan, -inf), complex(2, 1), complex(-inf, -inf)}, {complex(nan, -inf), complex(2, -1), complex(inf, -inf)}, {complex(nan, -inf), complex(2, 2), complex(-inf, -inf)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, zero), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -zero), complex(nan, nan)}, {complex(nan, -inf), complex(nan, 1), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -1), complex(nan, nan)}, {complex(nan, -inf), complex(nan, 2), complex(nan, nan)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(inf, zero), complex(nan, nan)}, {complex(nan, -inf), complex(inf, -zero), complex(nan, nan)}, {complex(nan, -inf), complex(inf, 1), complex(nan, nan)}, {complex(nan, -inf), complex(inf, -1), complex(nan, nan)}, {complex(nan, -inf), complex(inf, 2), complex(nan, nan)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(-inf, zero), complex(nan, nan)}, {complex(nan, -inf), complex(-inf, -zero), complex(nan, nan)}, {complex(nan, -inf), complex(-inf, 1), complex(nan, nan)}, {complex(nan, -inf), complex(-inf, -1), complex(nan, nan)}, {complex(nan, -inf), complex(-inf, 2), complex(nan, nan)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(-inf, zero), complex(zero, zero), complex(-inf, nan)}, {complex(-inf, zero), complex(zero, -zero), complex(-inf, nan)}, {complex(-inf, zero), complex(zero, 1), complex(nan, inf)}, {complex(-inf, zero), complex(zero, -1), complex(nan, -inf)}, {complex(-inf, zero), complex(zero, 2), complex(nan, inf)}, {complex(-inf, zero), complex(nan, nan), complex(nan, nan)}, {complex(-inf, zero), complex(nan, inf), complex(nan, nan)}, {complex(-inf, zero), complex(nan, -inf), complex(nan, nan)}, {complex(-inf, zero), complex(zero, zero), complex(-inf, nan)}, {complex(-inf, zero), complex(-zero, -zero), complex(inf, nan)}, {complex(-inf, zero), complex(zero, 1), complex(nan, inf)}, {complex(-inf, zero), complex(-zero, -1), complex(nan, -inf)}, {complex(-inf, zero), complex(zero, 2), complex(nan, inf)}, {complex(-inf, zero), complex(nan, nan), complex(nan, nan)}, {complex(-inf, zero), complex(nan, inf), complex(nan, nan)}, {complex(-inf, zero), complex(nan, -inf), complex(nan, nan)}, {complex(-inf, zero), complex(1, zero), complex(-inf, nan)}, {complex(-inf, zero), complex(1, -zero), complex(-inf, nan)}, {complex(-inf, zero), complex(1, 1), complex(-inf, inf)}, {complex(-inf, zero), complex(1, -1), complex(-inf, -inf)}, {complex(-inf, zero), complex(1, 2), complex(-inf, inf)}, {complex(-inf, zero), complex(nan, nan), complex(nan, nan)}, {complex(-inf, zero), complex(nan, inf), complex(nan, nan)}, {complex(-inf, zero), complex(nan, -inf), complex(nan, nan)}, {complex(-inf, zero), complex(-1, zero), complex(inf, nan)}, {complex(-inf, zero), complex(-1, -zero), complex(inf, nan)}, {complex(-inf, zero), complex(-1, 1), complex(inf, inf)}, {complex(-inf, zero), complex(-1, -1), complex(inf, -inf)}, {complex(-inf, zero), complex(-1, 2), complex(inf, inf)}, {complex(-inf, zero), complex(nan, nan), complex(nan, nan)}, {complex(-inf, zero), complex(nan, inf), complex(nan, nan)}, {complex(-inf, zero), complex(nan, -inf), complex(nan, nan)}, {complex(-inf, zero), complex(2, zero), complex(-inf, nan)}, {complex(-inf, zero), complex(2, -zero), complex(-inf, nan)}, {complex(-inf, zero), complex(2, 1), complex(-inf, inf)}, {complex(-inf, zero), complex(2, -1), complex(-inf, -inf)}, {complex(-inf, zero), complex(2, 2), complex(-inf, inf)}, {complex(-inf, zero), complex(nan, nan), complex(nan, nan)}, {complex(-inf, zero), complex(nan, inf), complex(nan, nan)}, {complex(-inf, zero), complex(nan, -inf), complex(nan, nan)}, {complex(-inf, zero), complex(nan, zero), complex(nan, nan)}, {complex(-inf, zero), complex(nan, -zero), complex(nan, nan)}, {complex(-inf, zero), complex(nan, 1), complex(nan, nan)}, {complex(-inf, zero), complex(nan, -1), complex(nan, nan)}, {complex(-inf, zero), complex(nan, 2), complex(nan, nan)}, {complex(-inf, zero), complex(nan, nan), complex(nan, nan)}, {complex(-inf, zero), complex(nan, inf), complex(nan, nan)}, {complex(-inf, zero), complex(nan, -inf), complex(nan, nan)}, {complex(-inf, zero), complex(inf, zero), complex(nan, nan)}, {complex(-inf, zero), complex(inf, -zero), complex(nan, nan)}, {complex(-inf, zero), complex(inf, 1), complex(nan, nan)}, {complex(-inf, zero), complex(inf, -1), complex(nan, nan)}, {complex(-inf, zero), complex(inf, 2), complex(nan, nan)}, {complex(-inf, zero), complex(nan, nan), complex(nan, nan)}, {complex(-inf, zero), complex(nan, inf), complex(nan, nan)}, {complex(-inf, zero), complex(nan, -inf), complex(nan, nan)}, {complex(-inf, zero), complex(-inf, zero), complex(nan, nan)}, {complex(-inf, zero), complex(-inf, -zero), complex(nan, nan)}, {complex(-inf, zero), complex(-inf, 1), complex(nan, nan)}, {complex(-inf, zero), complex(-inf, -1), complex(nan, nan)}, {complex(-inf, zero), complex(-inf, 2), complex(nan, nan)}, {complex(-inf, zero), complex(nan, nan), complex(nan, nan)}, {complex(-inf, zero), complex(nan, inf), complex(nan, nan)}, {complex(-inf, zero), complex(nan, -inf), complex(nan, nan)}, {complex(-inf, -zero), complex(zero, zero), complex(-inf, nan)}, {complex(-inf, -zero), complex(zero, -zero), complex(-inf, nan)}, {complex(-inf, -zero), complex(zero, 1), complex(nan, inf)}, {complex(-inf, -zero), complex(zero, -1), complex(nan, -inf)}, {complex(-inf, -zero), complex(zero, 2), complex(nan, inf)}, {complex(-inf, -zero), complex(nan, nan), complex(nan, nan)}, {complex(-inf, -zero), complex(nan, inf), complex(nan, nan)}, {complex(-inf, -zero), complex(nan, -inf), complex(nan, nan)}, {complex(-inf, -zero), complex(zero, zero), complex(-inf, nan)}, {complex(-inf, -zero), complex(-zero, -zero), complex(inf, nan)}, {complex(-inf, -zero), complex(zero, 1), complex(nan, inf)}, {complex(-inf, -zero), complex(-zero, -1), complex(nan, -inf)}, {complex(-inf, -zero), complex(zero, 2), complex(nan, inf)}, {complex(-inf, -zero), complex(nan, nan), complex(nan, nan)}, {complex(-inf, -zero), complex(nan, inf), complex(nan, nan)}, {complex(-inf, -zero), complex(nan, -inf), complex(nan, nan)}, {complex(-inf, -zero), complex(1, zero), complex(-inf, nan)}, {complex(-inf, -zero), complex(1, -zero), complex(-inf, nan)}, {complex(-inf, -zero), complex(1, 1), complex(-inf, inf)}, {complex(-inf, -zero), complex(1, -1), complex(-inf, -inf)}, {complex(-inf, -zero), complex(1, 2), complex(-inf, inf)}, {complex(-inf, -zero), complex(nan, nan), complex(nan, nan)}, {complex(-inf, -zero), complex(nan, inf), complex(nan, nan)}, {complex(-inf, -zero), complex(nan, -inf), complex(nan, nan)}, {complex(-inf, -zero), complex(-1, zero), complex(inf, nan)}, {complex(-inf, -zero), complex(-1, -zero), complex(inf, nan)}, {complex(-inf, -zero), complex(-1, 1), complex(inf, inf)}, {complex(-inf, -zero), complex(-1, -1), complex(inf, -inf)}, {complex(-inf, -zero), complex(-1, 2), complex(inf, inf)}, {complex(-inf, -zero), complex(nan, nan), complex(nan, nan)}, {complex(-inf, -zero), complex(nan, inf), complex(nan, nan)}, {complex(-inf, -zero), complex(nan, -inf), complex(nan, nan)}, {complex(-inf, -zero), complex(2, zero), complex(-inf, nan)}, {complex(-inf, -zero), complex(2, -zero), complex(-inf, nan)}, {complex(-inf, -zero), complex(2, 1), complex(-inf, inf)}, {complex(-inf, -zero), complex(2, -1), complex(-inf, -inf)}, {complex(-inf, -zero), complex(2, 2), complex(-inf, inf)}, {complex(-inf, -zero), complex(nan, nan), complex(nan, nan)}, {complex(-inf, -zero), complex(nan, inf), complex(nan, nan)}, {complex(-inf, -zero), complex(nan, -inf), complex(nan, nan)}, {complex(-inf, -zero), complex(nan, zero), complex(nan, nan)}, {complex(-inf, -zero), complex(nan, -zero), complex(nan, nan)}, {complex(-inf, -zero), complex(nan, 1), complex(nan, nan)}, {complex(-inf, -zero), complex(nan, -1), complex(nan, nan)}, {complex(-inf, -zero), complex(nan, 2), complex(nan, nan)}, {complex(-inf, -zero), complex(nan, nan), complex(nan, nan)}, {complex(-inf, -zero), complex(nan, inf), complex(nan, nan)}, {complex(-inf, -zero), complex(nan, -inf), complex(nan, nan)}, {complex(-inf, -zero), complex(inf, zero), complex(nan, nan)}, {complex(-inf, -zero), complex(inf, -zero), complex(nan, nan)}, {complex(-inf, -zero), complex(inf, 1), complex(nan, nan)}, {complex(-inf, -zero), complex(inf, -1), complex(nan, nan)}, {complex(-inf, -zero), complex(inf, 2), complex(nan, nan)}, {complex(-inf, -zero), complex(nan, nan), complex(nan, nan)}, {complex(-inf, -zero), complex(nan, inf), complex(nan, nan)}, {complex(-inf, -zero), complex(nan, -inf), complex(nan, nan)}, {complex(-inf, -zero), complex(-inf, zero), complex(nan, nan)}, {complex(-inf, -zero), complex(-inf, -zero), complex(nan, nan)}, {complex(-inf, -zero), complex(-inf, 1), complex(nan, nan)}, {complex(-inf, -zero), complex(-inf, -1), complex(nan, nan)}, {complex(-inf, -zero), complex(-inf, 2), complex(nan, nan)}, {complex(-inf, -zero), complex(nan, nan), complex(nan, nan)}, {complex(-inf, -zero), complex(nan, inf), complex(nan, nan)}, {complex(-inf, -zero), complex(nan, -inf), complex(nan, nan)}, {complex(-inf, 1), complex(zero, zero), complex(-inf, inf)}, {complex(-inf, 1), complex(zero, -zero), complex(-inf, inf)}, {complex(-inf, 1), complex(zero, 1), complex(nan, inf)}, {complex(-inf, 1), complex(zero, -1), complex(nan, -inf)}, {complex(-inf, 1), complex(zero, 2), complex(nan, inf)}, {complex(-inf, 1), complex(nan, nan), complex(nan, nan)}, {complex(-inf, 1), complex(nan, inf), complex(nan, nan)}, {complex(-inf, 1), complex(nan, -inf), complex(nan, nan)}, {complex(-inf, 1), complex(zero, zero), complex(-inf, inf)}, {complex(-inf, 1), complex(-zero, -zero), complex(inf, -inf)}, {complex(-inf, 1), complex(zero, 1), complex(nan, inf)}, {complex(-inf, 1), complex(-zero, -1), complex(nan, -inf)}, {complex(-inf, 1), complex(zero, 2), complex(nan, inf)}, {complex(-inf, 1), complex(nan, nan), complex(nan, nan)}, {complex(-inf, 1), complex(nan, inf), complex(nan, nan)}, {complex(-inf, 1), complex(nan, -inf), complex(nan, nan)}, {complex(-inf, 1), complex(1, zero), complex(-inf, nan)}, {complex(-inf, 1), complex(1, -zero), complex(-inf, nan)}, {complex(-inf, 1), complex(1, 1), complex(-inf, inf)}, {complex(-inf, 1), complex(1, -1), complex(-inf, -inf)}, {complex(-inf, 1), complex(1, 2), complex(-inf, inf)}, {complex(-inf, 1), complex(nan, nan), complex(nan, nan)}, {complex(-inf, 1), complex(nan, inf), complex(nan, nan)}, {complex(-inf, 1), complex(nan, -inf), complex(nan, nan)}, {complex(-inf, 1), complex(-1, zero), complex(inf, nan)}, {complex(-inf, 1), complex(-1, -zero), complex(inf, nan)}, {complex(-inf, 1), complex(-1, 1), complex(inf, inf)}, {complex(-inf, 1), complex(-1, -1), complex(inf, -inf)}, {complex(-inf, 1), complex(-1, 2), complex(inf, inf)}, {complex(-inf, 1), complex(nan, nan), complex(nan, nan)}, {complex(-inf, 1), complex(nan, inf), complex(nan, nan)}, {complex(-inf, 1), complex(nan, -inf), complex(nan, nan)}, {complex(-inf, 1), complex(2, zero), complex(-inf, nan)}, {complex(-inf, 1), complex(2, -zero), complex(-inf, nan)}, {complex(-inf, 1), complex(2, 1), complex(-inf, inf)}, {complex(-inf, 1), complex(2, -1), complex(-inf, -inf)}, {complex(-inf, 1), complex(2, 2), complex(-inf, inf)}, {complex(-inf, 1), complex(nan, nan), complex(nan, nan)}, {complex(-inf, 1), complex(nan, inf), complex(nan, nan)}, {complex(-inf, 1), complex(nan, -inf), complex(nan, nan)}, {complex(-inf, 1), complex(nan, zero), complex(nan, nan)}, {complex(-inf, 1), complex(nan, -zero), complex(nan, nan)}, {complex(-inf, 1), complex(nan, 1), complex(nan, nan)}, {complex(-inf, 1), complex(nan, -1), complex(nan, nan)}, {complex(-inf, 1), complex(nan, 2), complex(nan, nan)}, {complex(-inf, 1), complex(nan, nan), complex(nan, nan)}, {complex(-inf, 1), complex(nan, inf), complex(nan, nan)}, {complex(-inf, 1), complex(nan, -inf), complex(nan, nan)}, {complex(-inf, 1), complex(inf, zero), complex(nan, nan)}, {complex(-inf, 1), complex(inf, -zero), complex(nan, nan)}, {complex(-inf, 1), complex(inf, 1), complex(nan, nan)}, {complex(-inf, 1), complex(inf, -1), complex(nan, nan)}, {complex(-inf, 1), complex(inf, 2), complex(nan, nan)}, {complex(-inf, 1), complex(nan, nan), complex(nan, nan)}, {complex(-inf, 1), complex(nan, inf), complex(nan, nan)}, {complex(-inf, 1), complex(nan, -inf), complex(nan, nan)}, {complex(-inf, 1), complex(-inf, zero), complex(nan, nan)}, {complex(-inf, 1), complex(-inf, -zero), complex(nan, nan)}, {complex(-inf, 1), complex(-inf, 1), complex(nan, nan)}, {complex(-inf, 1), complex(-inf, -1), complex(nan, nan)}, {complex(-inf, 1), complex(-inf, 2), complex(nan, nan)}, {complex(-inf, 1), complex(nan, nan), complex(nan, nan)}, {complex(-inf, 1), complex(nan, inf), complex(nan, nan)}, {complex(-inf, 1), complex(nan, -inf), complex(nan, nan)}, {complex(-inf, -1), complex(zero, zero), complex(-inf, -inf)}, {complex(-inf, -1), complex(zero, -zero), complex(-inf, -inf)}, {complex(-inf, -1), complex(zero, 1), complex(nan, inf)}, {complex(-inf, -1), complex(zero, -1), complex(nan, -inf)}, {complex(-inf, -1), complex(zero, 2), complex(nan, inf)}, {complex(-inf, -1), complex(nan, nan), complex(nan, nan)}, {complex(-inf, -1), complex(nan, inf), complex(nan, nan)}, {complex(-inf, -1), complex(nan, -inf), complex(nan, nan)}, {complex(-inf, -1), complex(zero, zero), complex(-inf, -inf)}, {complex(-inf, -1), complex(-zero, -zero), complex(inf, inf)}, {complex(-inf, -1), complex(zero, 1), complex(nan, inf)}, {complex(-inf, -1), complex(-zero, -1), complex(nan, -inf)}, {complex(-inf, -1), complex(zero, 2), complex(nan, inf)}, {complex(-inf, -1), complex(nan, nan), complex(nan, nan)}, {complex(-inf, -1), complex(nan, inf), complex(nan, nan)}, {complex(-inf, -1), complex(nan, -inf), complex(nan, nan)}, {complex(-inf, -1), complex(1, zero), complex(-inf, nan)}, {complex(-inf, -1), complex(1, -zero), complex(-inf, nan)}, {complex(-inf, -1), complex(1, 1), complex(-inf, inf)}, {complex(-inf, -1), complex(1, -1), complex(-inf, -inf)}, {complex(-inf, -1), complex(1, 2), complex(-inf, inf)}, {complex(-inf, -1), complex(nan, nan), complex(nan, nan)}, {complex(-inf, -1), complex(nan, inf), complex(nan, nan)}, {complex(-inf, -1), complex(nan, -inf), complex(nan, nan)}, {complex(-inf, -1), complex(-1, zero), complex(inf, nan)}, {complex(-inf, -1), complex(-1, -zero), complex(inf, nan)}, {complex(-inf, -1), complex(-1, 1), complex(inf, inf)}, {complex(-inf, -1), complex(-1, -1), complex(inf, -inf)}, {complex(-inf, -1), complex(-1, 2), complex(inf, inf)}, {complex(-inf, -1), complex(nan, nan), complex(nan, nan)}, {complex(-inf, -1), complex(nan, inf), complex(nan, nan)}, {complex(-inf, -1), complex(nan, -inf), complex(nan, nan)}, {complex(-inf, -1), complex(2, zero), complex(-inf, nan)}, {complex(-inf, -1), complex(2, -zero), complex(-inf, nan)}, {complex(-inf, -1), complex(2, 1), complex(-inf, inf)}, {complex(-inf, -1), complex(2, -1), complex(-inf, -inf)}, {complex(-inf, -1), complex(2, 2), complex(-inf, inf)}, {complex(-inf, -1), complex(nan, nan), complex(nan, nan)}, {complex(-inf, -1), complex(nan, inf), complex(nan, nan)}, {complex(-inf, -1), complex(nan, -inf), complex(nan, nan)}, {complex(-inf, -1), complex(nan, zero), complex(nan, nan)}, {complex(-inf, -1), complex(nan, -zero), complex(nan, nan)}, {complex(-inf, -1), complex(nan, 1), complex(nan, nan)}, {complex(-inf, -1), complex(nan, -1), complex(nan, nan)}, {complex(-inf, -1), complex(nan, 2), complex(nan, nan)}, {complex(-inf, -1), complex(nan, nan), complex(nan, nan)}, {complex(-inf, -1), complex(nan, inf), complex(nan, nan)}, {complex(-inf, -1), complex(nan, -inf), complex(nan, nan)}, {complex(-inf, -1), complex(inf, zero), complex(nan, nan)}, {complex(-inf, -1), complex(inf, -zero), complex(nan, nan)}, {complex(-inf, -1), complex(inf, 1), complex(nan, nan)}, {complex(-inf, -1), complex(inf, -1), complex(nan, nan)}, {complex(-inf, -1), complex(inf, 2), complex(nan, nan)}, {complex(-inf, -1), complex(nan, nan), complex(nan, nan)}, {complex(-inf, -1), complex(nan, inf), complex(nan, nan)}, {complex(-inf, -1), complex(nan, -inf), complex(nan, nan)}, {complex(-inf, -1), complex(-inf, zero), complex(nan, nan)}, {complex(-inf, -1), complex(-inf, -zero), complex(nan, nan)}, {complex(-inf, -1), complex(-inf, 1), complex(nan, nan)}, {complex(-inf, -1), complex(-inf, -1), complex(nan, nan)}, {complex(-inf, -1), complex(-inf, 2), complex(nan, nan)}, {complex(-inf, -1), complex(nan, nan), complex(nan, nan)}, {complex(-inf, -1), complex(nan, inf), complex(nan, nan)}, {complex(-inf, -1), complex(nan, -inf), complex(nan, nan)}, {complex(-inf, 2), complex(zero, zero), complex(-inf, inf)}, {complex(-inf, 2), complex(zero, -zero), complex(-inf, inf)}, {complex(-inf, 2), complex(zero, 1), complex(nan, inf)}, {complex(-inf, 2), complex(zero, -1), complex(nan, -inf)}, {complex(-inf, 2), complex(zero, 2), complex(nan, inf)}, {complex(-inf, 2), complex(nan, nan), complex(nan, nan)}, {complex(-inf, 2), complex(nan, inf), complex(nan, nan)}, {complex(-inf, 2), complex(nan, -inf), complex(nan, nan)}, {complex(-inf, 2), complex(zero, zero), complex(-inf, inf)}, {complex(-inf, 2), complex(-zero, -zero), complex(inf, -inf)}, {complex(-inf, 2), complex(zero, 1), complex(nan, inf)}, {complex(-inf, 2), complex(-zero, -1), complex(nan, -inf)}, {complex(-inf, 2), complex(zero, 2), complex(nan, inf)}, {complex(-inf, 2), complex(nan, nan), complex(nan, nan)}, {complex(-inf, 2), complex(nan, inf), complex(nan, nan)}, {complex(-inf, 2), complex(nan, -inf), complex(nan, nan)}, {complex(-inf, 2), complex(1, zero), complex(-inf, nan)}, {complex(-inf, 2), complex(1, -zero), complex(-inf, nan)}, {complex(-inf, 2), complex(1, 1), complex(-inf, inf)}, {complex(-inf, 2), complex(1, -1), complex(-inf, -inf)}, {complex(-inf, 2), complex(1, 2), complex(-inf, inf)}, {complex(-inf, 2), complex(nan, nan), complex(nan, nan)}, {complex(-inf, 2), complex(nan, inf), complex(nan, nan)}, {complex(-inf, 2), complex(nan, -inf), complex(nan, nan)}, {complex(-inf, 2), complex(-1, zero), complex(inf, nan)}, {complex(-inf, 2), complex(-1, -zero), complex(inf, nan)}, {complex(-inf, 2), complex(-1, 1), complex(inf, inf)}, {complex(-inf, 2), complex(-1, -1), complex(inf, -inf)}, {complex(-inf, 2), complex(-1, 2), complex(inf, inf)}, {complex(-inf, 2), complex(nan, nan), complex(nan, nan)}, {complex(-inf, 2), complex(nan, inf), complex(nan, nan)}, {complex(-inf, 2), complex(nan, -inf), complex(nan, nan)}, {complex(-inf, 2), complex(2, zero), complex(-inf, nan)}, {complex(-inf, 2), complex(2, -zero), complex(-inf, nan)}, {complex(-inf, 2), complex(2, 1), complex(-inf, inf)}, {complex(-inf, 2), complex(2, -1), complex(-inf, -inf)}, {complex(-inf, 2), complex(2, 2), complex(-inf, inf)}, {complex(-inf, 2), complex(nan, nan), complex(nan, nan)}, {complex(-inf, 2), complex(nan, inf), complex(nan, nan)}, {complex(-inf, 2), complex(nan, -inf), complex(nan, nan)}, {complex(-inf, 2), complex(nan, zero), complex(nan, nan)}, {complex(-inf, 2), complex(nan, -zero), complex(nan, nan)}, {complex(-inf, 2), complex(nan, 1), complex(nan, nan)}, {complex(-inf, 2), complex(nan, -1), complex(nan, nan)}, {complex(-inf, 2), complex(nan, 2), complex(nan, nan)}, {complex(-inf, 2), complex(nan, nan), complex(nan, nan)}, {complex(-inf, 2), complex(nan, inf), complex(nan, nan)}, {complex(-inf, 2), complex(nan, -inf), complex(nan, nan)}, {complex(-inf, 2), complex(inf, zero), complex(nan, nan)}, {complex(-inf, 2), complex(inf, -zero), complex(nan, nan)}, {complex(-inf, 2), complex(inf, 1), complex(nan, nan)}, {complex(-inf, 2), complex(inf, -1), complex(nan, nan)}, {complex(-inf, 2), complex(inf, 2), complex(nan, nan)}, {complex(-inf, 2), complex(nan, nan), complex(nan, nan)}, {complex(-inf, 2), complex(nan, inf), complex(nan, nan)}, {complex(-inf, 2), complex(nan, -inf), complex(nan, nan)}, {complex(-inf, 2), complex(-inf, zero), complex(nan, nan)}, {complex(-inf, 2), complex(-inf, -zero), complex(nan, nan)}, {complex(-inf, 2), complex(-inf, 1), complex(nan, nan)}, {complex(-inf, 2), complex(-inf, -1), complex(nan, nan)}, {complex(-inf, 2), complex(-inf, 2), complex(nan, nan)}, {complex(-inf, 2), complex(nan, nan), complex(nan, nan)}, {complex(-inf, 2), complex(nan, inf), complex(nan, nan)}, {complex(-inf, 2), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(zero, zero), complex(nan, nan)}, {complex(nan, nan), complex(zero, -zero), complex(nan, nan)}, {complex(nan, nan), complex(zero, 1), complex(nan, nan)}, {complex(nan, nan), complex(zero, -1), complex(nan, nan)}, {complex(nan, nan), complex(zero, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(zero, zero), complex(nan, nan)}, {complex(nan, nan), complex(-zero, -zero), complex(nan, nan)}, {complex(nan, nan), complex(zero, 1), complex(nan, nan)}, {complex(nan, nan), complex(-zero, -1), complex(nan, nan)}, {complex(nan, nan), complex(zero, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(1, zero), complex(nan, nan)}, {complex(nan, nan), complex(1, -zero), complex(nan, nan)}, {complex(nan, nan), complex(1, 1), complex(nan, nan)}, {complex(nan, nan), complex(1, -1), complex(nan, nan)}, {complex(nan, nan), complex(1, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(-1, zero), complex(nan, nan)}, {complex(nan, nan), complex(-1, -zero), complex(nan, nan)}, {complex(nan, nan), complex(-1, 1), complex(nan, nan)}, {complex(nan, nan), complex(-1, -1), complex(nan, nan)}, {complex(nan, nan), complex(-1, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(2, zero), complex(nan, nan)}, {complex(nan, nan), complex(2, -zero), complex(nan, nan)}, {complex(nan, nan), complex(2, 1), complex(nan, nan)}, {complex(nan, nan), complex(2, -1), complex(nan, nan)}, {complex(nan, nan), complex(2, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, zero), complex(nan, nan)}, {complex(nan, nan), complex(nan, -zero), complex(nan, nan)}, {complex(nan, nan), complex(nan, 1), complex(nan, nan)}, {complex(nan, nan), complex(nan, -1), complex(nan, nan)}, {complex(nan, nan), complex(nan, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(inf, zero), complex(nan, nan)}, {complex(nan, nan), complex(inf, -zero), complex(nan, nan)}, {complex(nan, nan), complex(inf, 1), complex(nan, nan)}, {complex(nan, nan), complex(inf, -1), complex(nan, nan)}, {complex(nan, nan), complex(inf, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, nan), complex(-inf, zero), complex(nan, nan)}, {complex(nan, nan), complex(-inf, -zero), complex(nan, nan)}, {complex(nan, nan), complex(-inf, 1), complex(nan, nan)}, {complex(nan, nan), complex(-inf, -1), complex(nan, nan)}, {complex(nan, nan), complex(-inf, 2), complex(nan, nan)}, {complex(nan, nan), complex(nan, nan), complex(nan, nan)}, {complex(nan, nan), complex(nan, inf), complex(nan, nan)}, {complex(nan, nan), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(zero, zero), complex(nan, inf)}, {complex(nan, inf), complex(zero, -zero), complex(nan, inf)}, {complex(nan, inf), complex(zero, 1), complex(inf, nan)}, {complex(nan, inf), complex(zero, -1), complex(-inf, nan)}, {complex(nan, inf), complex(zero, 2), complex(inf, nan)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(zero, zero), complex(nan, inf)}, {complex(nan, inf), complex(-zero, -zero), complex(nan, -inf)}, {complex(nan, inf), complex(zero, 1), complex(inf, nan)}, {complex(nan, inf), complex(-zero, -1), complex(-inf, nan)}, {complex(nan, inf), complex(zero, 2), complex(inf, nan)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(1, zero), complex(nan, inf)}, {complex(nan, inf), complex(1, -zero), complex(nan, inf)}, {complex(nan, inf), complex(1, 1), complex(inf, inf)}, {complex(nan, inf), complex(1, -1), complex(-inf, inf)}, {complex(nan, inf), complex(1, 2), complex(inf, inf)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(-1, zero), complex(nan, -inf)}, {complex(nan, inf), complex(-1, -zero), complex(nan, -inf)}, {complex(nan, inf), complex(-1, 1), complex(inf, -inf)}, {complex(nan, inf), complex(-1, -1), complex(-inf, -inf)}, {complex(nan, inf), complex(-1, 2), complex(inf, -inf)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(2, zero), complex(nan, inf)}, {complex(nan, inf), complex(2, -zero), complex(nan, inf)}, {complex(nan, inf), complex(2, 1), complex(inf, inf)}, {complex(nan, inf), complex(2, -1), complex(-inf, inf)}, {complex(nan, inf), complex(2, 2), complex(inf, inf)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, zero), complex(nan, nan)}, {complex(nan, inf), complex(nan, -zero), complex(nan, nan)}, {complex(nan, inf), complex(nan, 1), complex(nan, nan)}, {complex(nan, inf), complex(nan, -1), complex(nan, nan)}, {complex(nan, inf), complex(nan, 2), complex(nan, nan)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(inf, zero), complex(nan, nan)}, {complex(nan, inf), complex(inf, -zero), complex(nan, nan)}, {complex(nan, inf), complex(inf, 1), complex(nan, nan)}, {complex(nan, inf), complex(inf, -1), complex(nan, nan)}, {complex(nan, inf), complex(inf, 2), complex(nan, nan)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, inf), complex(-inf, zero), complex(nan, nan)}, {complex(nan, inf), complex(-inf, -zero), complex(nan, nan)}, {complex(nan, inf), complex(-inf, 1), complex(nan, nan)}, {complex(nan, inf), complex(-inf, -1), complex(nan, nan)}, {complex(nan, inf), complex(-inf, 2), complex(nan, nan)}, {complex(nan, inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(zero, zero), complex(nan, -inf)}, {complex(nan, -inf), complex(zero, -zero), complex(nan, -inf)}, {complex(nan, -inf), complex(zero, 1), complex(-inf, nan)}, {complex(nan, -inf), complex(zero, -1), complex(inf, nan)}, {complex(nan, -inf), complex(zero, 2), complex(-inf, nan)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(zero, zero), complex(nan, -inf)}, {complex(nan, -inf), complex(-zero, -zero), complex(nan, inf)}, {complex(nan, -inf), complex(zero, 1), complex(-inf, nan)}, {complex(nan, -inf), complex(-zero, -1), complex(inf, nan)}, {complex(nan, -inf), complex(zero, 2), complex(-inf, nan)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(1, zero), complex(nan, -inf)}, {complex(nan, -inf), complex(1, -zero), complex(nan, -inf)}, {complex(nan, -inf), complex(1, 1), complex(-inf, -inf)}, {complex(nan, -inf), complex(1, -1), complex(inf, -inf)}, {complex(nan, -inf), complex(1, 2), complex(-inf, -inf)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(-1, zero), complex(nan, inf)}, {complex(nan, -inf), complex(-1, -zero), complex(nan, inf)}, {complex(nan, -inf), complex(-1, 1), complex(-inf, inf)}, {complex(nan, -inf), complex(-1, -1), complex(inf, inf)}, {complex(nan, -inf), complex(-1, 2), complex(-inf, inf)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(2, zero), complex(nan, -inf)}, {complex(nan, -inf), complex(2, -zero), complex(nan, -inf)}, {complex(nan, -inf), complex(2, 1), complex(-inf, -inf)}, {complex(nan, -inf), complex(2, -1), complex(inf, -inf)}, {complex(nan, -inf), complex(2, 2), complex(-inf, -inf)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, zero), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -zero), complex(nan, nan)}, {complex(nan, -inf), complex(nan, 1), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -1), complex(nan, nan)}, {complex(nan, -inf), complex(nan, 2), complex(nan, nan)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(inf, zero), complex(nan, nan)}, {complex(nan, -inf), complex(inf, -zero), complex(nan, nan)}, {complex(nan, -inf), complex(inf, 1), complex(nan, nan)}, {complex(nan, -inf), complex(inf, -1), complex(nan, nan)}, {complex(nan, -inf), complex(inf, 2), complex(nan, nan)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, {complex(nan, -inf), complex(-inf, zero), complex(nan, nan)}, {complex(nan, -inf), complex(-inf, -zero), complex(nan, nan)}, {complex(nan, -inf), complex(-inf, 1), complex(nan, nan)}, {complex(nan, -inf), complex(-inf, -1), complex(nan, nan)}, {complex(nan, -inf), complex(-inf, 2), complex(nan, nan)}, {complex(nan, -inf), complex(nan, nan), complex(nan, nan)}, {complex(nan, -inf), complex(nan, inf), complex(nan, nan)}, {complex(nan, -inf), complex(nan, -inf), complex(nan, nan)}, }	240.68 KB	2024-02-02 18:09
📁 codegen	-	2024-02-02 18:09
📄 complit.go // run // Copyright 2009 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 composite literals. package main type T struct { i int f float64 s string next T } type R struct { num int } func itor(a int) R { r := new(R) r.num = a return r } func eq(a []R) { for i := 0; i < len(a); i++ { if a[i].num != i { panic("bad") } } } func teq(t T, n int) { for i := 0; i < n; i++ { if t == nil \|\| t.i != i { panic("bad") } t = t.next } if t != nil { panic("bad") } } type P struct { a, b int } func NewP(a, b int) P { return &P{a, b} } func main() { var t T t = T{0, 7.2, "hi", &t} var tp T tp = &T{0, 7.2, "hi", &t} tl := &T{i: 0, next: &T{i: 1, next: &T{i: 2, next: &T{i: 3, next: &T{i: 4}}}}} teq(tl, 5) a1 := []int{1, 2, 3} if len(a1) != 3 { panic("a1") } a2 := [10]int{1, 2, 3} if len(a2) != 10 \|\| cap(a2) != 10 { panic("a2") } a3 := [10]int{1, 2, 3} if len(a3) != 10 \|\| a2[3] != 0 { panic("a3") } var oai []int oai = []int{1, 2, 3} if len(oai) != 3 { panic("oai") } at := [...]T{&t, tp, &t} if len(at) != 3 { panic("at") } c := make(chan int) ac := []chan int{c, c, c} if len(ac) != 3 { panic("ac") } aat := [][len(at)]T{at, at} if len(aat) != 2 \|\| len(aat[1]) != 3 { panic("aat") } s := string([]byte{'h', 'e', 'l', 'l', 'o'}) if s != "hello" { panic("s") } m := map[string]float64{"one": 1.0, "two": 2.0, "pi": 22. / 7.} if len(m) != 3 { panic("m") } eq([]R{itor(0), itor(1), itor(2), itor(3), itor(4), itor(5)}) eq([]R{{0}, {1}, {2}, {3}, {4}, {5}}) p1 := NewP(1, 2) p2 := NewP(1, 2) if p1 == p2 { panic("NewP") } }	1.71 KB	2024-02-02 18:09
📄 complit1.go // errorcheck // 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. // Verify that illegal composite literals are detected. // Does not compile. package main var m map[int][3]int func f() [3]int func fp() [3]int var mp map[int][3]int var ( _ = [3]int{1, 2, 3}[:] // ERROR "slice of unaddressable value" _ = m[0][:] // ERROR "slice of unaddressable value" _ = f()[:] // ERROR "slice of unaddressable value" _ = 301[:] // ERROR "cannot slice\|attempt to slice object that is not" _ = 3.1[:] // ERROR "cannot slice\|attempt to slice object that is not" _ = true[:] // ERROR "cannot slice\|attempt to slice object that is not" // these are okay because they are slicing a pointer to an array _ = (&[3]int{1, 2, 3})[:] _ = mp[0][:] _ = fp()[:] ) type T struct { i int f float64 s string next T } type TP T type Ti int var ( _ = &T{0, 0, "", nil} // ok _ = &T{i: 0, f: 0, s: "", next: {}} // ERROR "missing type in composite literal\|omit types within composite literal" _ = &T{0, 0, "", {}} // ERROR "missing type in composite literal\|omit types within composite literal" _ = TP{i: 0, f: 0, s: ""} // ERROR "invalid composite literal type TP" _ = &Ti{} // ERROR "invalid composite literal type Ti\|expected.type for composite literal" ) type M map[T]T var ( _ = M{{i: 1}: {i: 2}} _ = M{T{i: 1}: {i: 2}} _ = M{{i: 1}: T{i: 2}} _ = M{T{i: 1}: T{i: 2}} ) type S struct{ s [1]M1 } type M1 map[S]int var _ = M1{{s: [1]*M1{&M1{{}: 1}}}: 2}	1.63 KB	2024-02-02 18:09
📄 compos.go // run // Copyright 2009 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 that returning &T{} from a function causes an allocation. package main type T struct { int } func f() *T { return &T{1} } func main() { x := f() y := f() if x == y { panic("not allocating & composite literals") } }	403 B	2024-02-02 18:09
📄 const.go // run // Copyright 2009 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 simple boolean and numeric constants. package main import "os" const ( c0 = 0 cm1 = -1 chuge = 1 << 100 chuge_1 = chuge - 1 c1 = chuge >> 100 c3div2 = 3 / 2 c1e3 = 1e3 rsh1 = 1e100 >> 1000 rsh2 = 1e302 >> 1000 ctrue = true cfalse = !ctrue // Issue #34563 _ = string(int(123)) _ = string(rune(456)) ) const ( f0 = 0.0 fm1 = -1. fhuge float64 = 1 << 100 fhuge_1 float64 = chuge - 1 f1 float64 = chuge >> 100 f3div2 = 3. / 2. f1e3 float64 = 1e3 ) func assert(t bool, s string) { if !t { panic(s) } } func ints() { assert(c0 == 0, "c0") assert(c1 == 1, "c1") assert(chuge > chuge_1, "chuge") assert(chuge_1+1 == chuge, "chuge 1") assert(chuge+cm1+1 == chuge, "cm1") assert(c3div2 == 1, "3/2") assert(c1e3 == 1000, "c1e3 int") assert(c1e3 == 1e3, "c1e3 float") assert(rsh1 == 0, "rsh1") assert(rsh2 == 9, "rsh2") // verify that all (in range) are assignable as ints var i int i = c0 assert(i == c0, "i == c0") i = cm1 assert(i == cm1, "i == cm1") i = c1 assert(i == c1, "i == c1") i = c3div2 assert(i == c3div2, "i == c3div2") i = c1e3 assert(i == c1e3, "i == c1e3") // verify that all are assignable as floats var f float64 f = c0 assert(f == c0, "f == c0") f = cm1 assert(f == cm1, "f == cm1") f = chuge assert(f == chuge, "f == chuge") f = chuge_1 assert(f == chuge_1, "f == chuge_1") f = c1 assert(f == c1, "f == c1") f = c3div2 assert(f == c3div2, "f == c3div2") f = c1e3 assert(f == c1e3, "f == c1e3") } func floats() { assert(f0 == c0, "f0") assert(f1 == c1, "f1") // TODO(gri): exp/ssa/interp constant folding is incorrect. if os.Getenv("GOSSAINTERP") == "" { assert(fhuge == fhuge_1, "fhuge") // float64 can't distinguish fhuge, fhuge_1. } assert(fhuge_1+1 == fhuge, "fhuge 1") assert(fhuge+fm1+1 == fhuge, "fm1") assert(f3div2 == 1.5, "3./2.") assert(f1e3 == 1000, "f1e3 int") assert(f1e3 == 1.e3, "f1e3 float") // verify that all (in range) are assignable as ints var i int i = f0 assert(i == f0, "i == f0") i = fm1 assert(i == fm1, "i == fm1") // verify that all are assignable as floats var f float64 f = f0 assert(f == f0, "f == f0") f = fm1 assert(f == fm1, "f == fm1") f = fhuge assert(f == fhuge, "f == fhuge") f = fhuge_1 assert(f == fhuge_1, "f == fhuge_1") f = f1 assert(f == f1, "f == f1") f = f3div2 assert(f == f3div2, "f == f3div2") f = f1e3 assert(f == f1e3, "f == f1e3") } func interfaces() { var ( nilN interface{} nilI int five = 5 _ = nil == interface{}(nil) _ = interface{}(nil) == nil ) ii := func(i1 interface{}, i2 interface{}) bool { return i1 == i2 } ni := func(n interface{}, i int) bool { return n == i } in := func(i int, n interface{}) bool { return i == n } pi := func(p int, i interface{}) bool { return p == i } ip := func(i interface{}, p int) bool { return i == p } assert((interface{}(nil) == interface{}(nil)) == ii(nilN, nilN), "for interface{}==interface{} compiler == runtime") assert(((int)(nil) == interface{}(nil)) == pi(nilI, nilN), "for int==interface{} compiler == runtime") assert((interface{}(nil) == (int)(nil)) == ip(nilN, nilI), "for interface{}==int compiler == runtime") assert((&five == interface{}(nil)) == pi(&five, nilN), "for interface{}==int compiler == runtime") assert((interface{}(nil) == &five) == ip(nilN, &five), "for interface{}==*int compiler == runtime") assert((5 == interface{}(5)) == ni(five, five), "for int==interface{} compiler == runtime") assert((interface{}(5) == 5) == in(five, five), "for interface{}==int comipiler == runtime") } // Test that typed floating-point and complex arithmetic // is computed with correct precision. func truncate() { const ( x30 = 1 << 30 x60 = 1 << 60 staticF32 = float32(x30) + 1 - x30 staticF64 = float64(x60) + 1 - x60 staticC64 = complex64(x30) + 1 - x30 staticC128 = complex128(x60) + 1 - x60 ) dynamicF32 := float32(x30) dynamicF32 += 1 dynamicF32 -= x30 dynamicF64 := float64(x60) dynamicF64 += 1 dynamicF64 -= x60 dynamicC64 := complex64(x30) dynamicC64 += 1 dynamicC64 -= x30 dynamicC128 := complex128(x60) dynamicC128 += 1 dynamicC128 -= x60 assert(staticF32 == 0, "staticF32 == 0") assert(staticF64 == 0, "staticF64 == 0") assert(dynamicF32 == 0, "dynamicF32 == 0") assert(dynamicF64 == 0, "dynamicF64 == 0") assert(staticC64 == 0, "staticC64 == 0") assert(staticC128 == 0, "staticC128 == 0") assert(dynamicC64 == 0, "dynamicC64 == 0") assert(dynamicC128 == 0, "dynamicC128 == 0") } func main() { ints() floats() interfaces() truncate() assert(ctrue == true, "ctrue == true") assert(cfalse == false, "cfalse == false") }	4.78 KB	2024-02-02 18:09
📄 const1.go // errorcheck // Copyright 2009 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. // Verify overflow is detected when using numeric constants. // Does not compile. package main import "unsafe" type I interface{} const ( // assume all types behave similarly to int8/uint8 Int8 int8 = 101 Minus1 int8 = -1 Uint8 uint8 = 102 Const = 103 Float32 float32 = 104.5 Float64 float64 = 105.5 ConstFloat = 106.5 Big float64 = 1e300 String = "abc" Bool = true ) var ( a1 = Int8 * 100 // ERROR "overflow\|cannot convert" a2 = Int8 * -1 // OK a3 = Int8 * 1000 // ERROR "overflow\|cannot convert" a4 = Int8 * int8(1000) // ERROR "overflow\|cannot convert" a5 = int8(Int8 * 1000) // ERROR "overflow\|cannot convert" a6 = int8(Int8 * int8(1000)) // ERROR "overflow\|cannot convert" a7 = Int8 - 2Int8 - 2Int8 // ERROR "overflow\|cannot convert" a8 = Int8 * Const / 100 // ERROR "overflow\|cannot convert" a9 = Int8 * (Const / 100) // OK b1 = Uint8 * Uint8 // ERROR "overflow\|cannot convert" b2 = Uint8 * -1 // ERROR "overflow\|cannot convert" b3 = Uint8 - Uint8 // OK b4 = Uint8 - Uint8 - Uint8 // ERROR "overflow\|cannot convert" b5 = uint8(^0) // ERROR "overflow\|cannot convert" b5a = int64(^0) // OK b6 = ^uint8(0) // OK b6a = ^int64(0) // OK b7 = uint8(Minus1) // ERROR "overflow\|cannot convert" b8 = uint8(int8(-1)) // ERROR "overflow\|cannot convert" b8a = uint8(-1) // ERROR "overflow\|cannot convert" b9 byte = (1 << 10) >> 8 // OK b10 byte = (1 << 10) // ERROR "overflow\|cannot convert" b11 byte = (byte(1) << 10) >> 8 // ERROR "overflow\|cannot convert" b12 byte = 1000 // ERROR "overflow\|cannot convert" b13 byte = byte(1000) // ERROR "overflow\|cannot convert" b14 byte = byte(100) * byte(100) // ERROR "overflow\|cannot convert" b15 byte = byte(100) * 100 // ERROR "overflow\|cannot convert" b16 byte = byte(0) * 1000 // ERROR "overflow\|cannot convert" b16a byte = 0 * 1000 // OK b17 byte = byte(0) * byte(1000) // ERROR "overflow\|cannot convert" b18 byte = Uint8 / 0 // ERROR "division by zero" c1 float64 = Big c2 float64 = Big * Big // ERROR "overflow\|cannot convert" c3 float64 = float64(Big) * Big // ERROR "overflow\|cannot convert" c4 = Big * Big // ERROR "overflow\|cannot convert" c5 = Big / 0 // ERROR "division by zero" c6 = 1000 % 1e3 // ERROR "invalid operation\|expected integer type" ) func f(int) func main() { f(Int8) // ERROR "convert\|wrong type\|cannot" f(Minus1) // ERROR "convert\|wrong type\|cannot" f(Uint8) // ERROR "convert\|wrong type\|cannot" f(Const) // OK f(Float32) // ERROR "convert\|wrong type\|cannot" f(Float64) // ERROR "convert\|wrong type\|cannot" f(ConstFloat) // ERROR "truncate" f(ConstFloat - 0.5) // OK f(Big) // ERROR "convert\|wrong type\|cannot" f(String) // ERROR "convert\|wrong type\|cannot\|incompatible" f(Bool) // ERROR "convert\|wrong type\|cannot\|incompatible" } const ptr = nil // ERROR "const.nil\|not constant" const _ = string([]byte(nil)) // ERROR "is not a? ?constant" const _ = uintptr(unsafe.Pointer((int)(nil))) // ERROR "is not a? ?constant" const _ = unsafe.Pointer((int)(nil)) // ERROR "cannot be nil\|invalid constant type\|is not a constant\|not constant" const _ = (int)(nil) // ERROR "cannot be nil\|invalid constant type\|is not a constant\|not constant"	3.79 KB	2024-02-02 18:09
📄 const2.go // errorcheck // Copyright 2009 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. // Verify that large integer constant expressions cause overflow. // Does not compile. package main const ( A int = 1 B byte; // ERROR "type without expr\|expected .=.\|missing init expr" ) const LargeA = 1000000000000000000 const LargeB = LargeA * LargeA * LargeA const LargeC = LargeB * LargeB * LargeB // GC_ERROR "constant multiplication overflow" const AlsoLargeA = LargeA << 400 << 400 >> 400 >> 400 // GC_ERROR "constant shift overflow" // Issue #42732. const a = 1e+500000000 const b = a * a // ERROR "constant multiplication overflow\|not representable" const c = b * b const MaxInt512 = (1<<256 - 1) * (1<<256 + 1) const _ = MaxInt512 + 1 // ERROR "constant addition overflow" const _ = MaxInt512 ^ -1 // ERROR "constant bitwise XOR overflow" const _ = ^MaxInt512 // ERROR "constant bitwise complement overflow"	1008 B	2024-02-02 18:09
📄 const3.go // run // Copyright 2009 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 typed integer constants. package main import "fmt" type T int func (t T) String() string { return fmt.Sprintf("T%d", int(t)) } const ( A T = 1 << (1 << iota) B C D E ) func main() { s := fmt.Sprintf("%v %v %v %v %v", A, B, C, D, E) if s != "T2 T4 T16 T256 T65536" { println("type info didn't propagate in const: got", s) panic("fail") } x := uint(5) y := float64(uint64(1)<<x) // used to fail to compile if y != 32 { println("wrong y", y) panic("fail") } }	659 B	2024-02-02 18:09
📄 const4.go // run // 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. // Test len constants and non-constants, https://golang.org/issue/3244. package main var b struct { a [10]int } var m map[string][20]int var s [][30]int const ( n1 = len(b.a) n2 = len(m[""]) n3 = len(s[10]) ) // Non-constants (see also const5.go). var ( n4 = len(f()) n5 = len(<-c) n6 = cap(g()) n7 = cap(<-c1) ) var calledF = false func f() [40]int { calledF = true return nil } var c = func() chan [50]int { c := make(chan [50]int, 2) c <- nil c <- new([50]int) return c }() var calledG = false func g() [60]int { calledG = true return nil } var c1 = func() chan [70]int { c := make(chan [70]int, 2) c <- nil c <- new([70]int) return c }() func main() { if n1 != 10 \|\| n2 != 20 \|\| n3 != 30 \|\| n4 != 40 \|\| n5 != 50 \|\| n6 != 60 \|\| n7 != 70 { println("BUG:", n1, n2, n3, n4, n5, n6, n7) panic("fail") } if !calledF { println("BUG: did not call f") panic("fail") } if <-c == nil { println("BUG: did not receive from c") panic("fail") } if !calledG { println("BUG: did not call g") panic("fail") } if <-c1 == nil { println("BUG: did not receive from c1") panic("fail") } }	1.28 KB	2024-02-02 18:09
📄 const5.go // errorcheck // 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. // Test that len non-constants are not constants, https://golang.org/issue/3244. package p var b struct { a[10]int } var m map[string][20]int var s [][30]int func f() [40]int var c chan [50]int var z complex128 const ( n1 = len(b.a) n2 = len(m[""]) n3 = len(s[10]) n4 = len(f()) // ERROR "is not a constant\|is not constant" n5 = len(<-c) // ERROR "is not a constant\|is not constant" n6 = cap(f()) // ERROR "is not a constant\|is not constant" n7 = cap(<-c) // ERROR "is not a constant\|is not constant" n8 = real(z) // ERROR "is not a constant\|is not constant" n9 = len([4]float64{real(z)}) // ERROR "is not a constant\|is not constant" )	835 B	2024-02-02 18:09
📄 const6.go // errorcheck // 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. // Ideal vs non-ideal bool. See issue 3915, 3923. package p type mybool bool type mybool1 bool var ( x, y int = 1, 2 c1 bool = x < y c2 mybool = x < y c3 mybool = c2 == (x < y) c4 mybool = c2 == (1 < 2) c5 mybool = 1 < 2 c6 mybool1 = x < y c7 = c1 == c2 // ERROR "mismatched types\|incompatible types" c8 = c2 == c6 // ERROR "mismatched types\|incompatible types" c9 = c1 == c6 // ERROR "mismatched types\|incompatible types" _ = c2 && (x < y) _ = c2 && (1 < 2) _ = c1 && c2 // ERROR "mismatched types\|incompatible types" _ = c2 && c6 // ERROR "mismatched types\|incompatible types" _ = c1 && c6 // ERROR "mismatched types\|incompatible types" )	834 B	2024-02-02 18:09
📄 const7.go // run // Copyright 2021 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. // Check that the compiler refuses excessively long constants. package main import ( "bytes" "fmt" "io/ioutil" "log" "os" "os/exec" "path/filepath" "runtime" "strings" ) // testProg creates a package called name, with path dir/name.go, // which declares an untyped constant of the given length. // testProg compiles this package and checks for the absence or // presence of a constant literal error. func testProg(dir, name string, length int, msg string) { var buf bytes.Buffer fmt.Fprintf(&buf, "package %s; const _ = 0b%s // %d bits", name, strings.Repeat("1", length), length, ) filename := filepath.Join(dir, fmt.Sprintf("%s.go", name)) if err := os.WriteFile(filename, buf.Bytes(), 0666); err != nil { log.Fatal(err) } cmd := exec.Command("go", "tool", "compile", "-p=p", filename) cmd.Dir = dir output, err := cmd.CombinedOutput() if msg == "" { // no error expected if err != nil { log.Fatalf("%s: compile failed unexpectedly: %v", name, err) } return } // error expected if err == nil { log.Fatalf("%s: compile succeeded unexpectedly", name) } if !bytes.Contains(output, []byte(msg)) { log.Fatalf("%s: wrong compiler error message:\n%s\n", name, output) } } func main() { if runtime.GOOS == "js" \|\| runtime.GOOS == "wasip1" \|\| runtime.Compiler != "gc" { return } dir, err := ioutil.TempDir("", "const7_") if err != nil { log.Fatalf("creating temp dir: %v\n", err) } defer os.RemoveAll(dir) const bitLimit = 512 const charLimit = 10000 // compiler-internal constant length limit testProg(dir, "x1", bitLimit, "") testProg(dir, "x2", bitLimit+1, "constant overflow") testProg(dir, "x3", charLimit-2, "constant overflow") // -2 because literal contains 0b prefix testProg(dir, "x4", charLimit-1, "excessively long constant") }	1.93 KB	2024-02-02 18:09
📄 const8.go // run // Copyright 2022 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 that identifiers in implicit (omitted) RHS // expressions of constant declarations are resolved // in the correct context; see issues #49157, #53585. package main const X = 2 func main() { const ( A = iota // 0 iota = iota // 1 B // 1 (iota is declared locally on prev. line) C // 1 ) if A != 0 \|\| B != 1 \|\| C != 1 { println("got", A, B, C, "want 0 1 1") panic("FAILED") } const ( X = X + X Y Z = iota ) if X != 4 \|\| Y != 8 \|\| Z != 1 { println("got", X, Y, Z, "want 4 8 1") panic("FAILED") } }	727 B	2024-02-02 18:09
📄 convT2X.go // run // 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. // Test conversion from non-interface types to the empty interface. package main type J interface { Method() } type ( U16 uint16 U32 uint32 U64 uint64 U128 [2]uint64 F32 float32 F64 float64 C128 complex128 S string B []byte M map[int]int C chan int Z struct{} ) func (U16) Method() {} func (U32) Method() {} func (U64) Method() {} func (U128) Method() {} func (F32) Method() {} func (F64) Method() {} func (C128) Method() {} func (S) Method() {} func (B) Method() {} func (M) Method() {} func (C) Method() {} func (Z) Method() {} var ( u16 = U16(1) u32 = U32(2) u64 = U64(3) u128 = U128{4, 5} f32 = F32(6) f64 = F64(7) c128 = C128(8 + 9i) s = S("10") b = B("11") m = M{12: 13} c = make(C, 14) z = Z{} p = &z pp = &p ) var ( iu16 interface{} = u16 iu32 interface{} = u32 iu64 interface{} = u64 iu128 interface{} = u128 if32 interface{} = f32 if64 interface{} = f64 ic128 interface{} = c128 is interface{} = s ib interface{} = b im interface{} = m ic interface{} = c iz interface{} = z ip interface{} = p ipp interface{} = pp ju16 J = u16 ju32 J = u32 ju64 J = u64 ju128 J = u128 jf32 J = f32 jf64 J = f64 jc128 J = c128 js J = s jb J = b jm J = m jc J = c jz J = z jp J = p // The method set for *T contains the methods for T. // pp does not implement error. ) func second(a ...interface{}) interface{} { return a[1] } func main() { // Test equality. if u16 != iu16 { panic("u16 != iu16") } if u16 != ju16 { panic("u16 != ju16") } if u32 != iu32 { panic("u32 != iu32") } if u32 != ju32 { panic("u32 != ju32") } if u64 != iu64 { panic("u64 != iu64") } if u64 != ju64 { panic("u64 != ju64") } if u128 != iu128 { panic("u128 != iu128") } if u128 != ju128 { panic("u128 != ju128") } if f32 != if32 { panic("f32 != if32") } if f32 != jf32 { panic("f32 != jf32") } if f64 != if64 { panic("f64 != if64") } if f64 != jf64 { panic("f64 != jf64") } if c128 != ic128 { panic("c128 != ic128") } if c128 != jc128 { panic("c128 != jc128") } if s != is { panic("s != is") } if s != js { panic("s != js") } if c != ic { panic("c != ic") } if c != jc { panic("c != jc") } // There are no tests for b and m, as slices and maps are not comparable by ==. if z != iz { panic("z != iz") } if z != jz { panic("z != jz") } if p != ip { panic("p != ip") } if p != jp { panic("p != jp") } if pp != ipp { panic("pp != ipp") } // pp does not implement J. // Test that non-interface types can be used as ...interface{} arguments. if got := second(z, p, pp, u16, u32, u64, u128, f32, f64, c128, s, b, m, c); got != ip { println("second: got", got, "want", ip) panic("fail") } // Test that non-interface types can be sent on a chan interface{}. const n = 100 uc := make(chan interface{}) go func() { for i := 0; i < n; i++ { select { case uc <- nil: case uc <- u32: case uc <- u64: case uc <- u128: } } }() for i := 0; i < n; i++ { if got := <-uc; got != nil && got != u32 && got != u64 && got != u128 { println("recv: i", i, "got", got) panic("fail") } } }	3.33 KB	2024-02-02 18:09
📄 convert.go // run // Copyright 2009 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 types of constant expressions, using reflect. package main import "reflect" func typeof(x interface{}) string { return reflect.TypeOf(x).String() } func f() int { return 0 } func g() int { return 0 } type T func() int var m = map[string]T{"f": f} type A int type B int var a A = 1 var b B = 2 var x int func main() { want := typeof(g) if t := typeof(f); t != want { println("type of f is", t, "want", want) panic("fail") } want = typeof(a) if t := typeof(+a); t != want { println("type of +a is", t, "want", want) panic("fail") } if t := typeof(a + 0); t != want { println("type of a+0 is", t, "want", want) panic("fail") } }	833 B	2024-02-02 18:09
📄 convert1.go // errorcheck // 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. // Verify that illegal conversions involving strings are detected. // Does not compile. package main type Tbyte []byte type Trune []rune type Tint64 []int64 type Tstring string func main() { s := "hello" sb := []byte("hello") sr := []rune("hello") si := []int64{'h', 'e', 'l', 'l', 'o'} ts := Tstring(s) tsb := Tbyte(sb) tsr := Trune(sr) tsi := Tint64(si) _ = string(s) _ = []byte(s) _ = []rune(s) _ = []int64(s) // ERROR "cannot convert.\[\]int64\|invalid type conversion" _ = Tstring(s) _ = Tbyte(s) _ = Trune(s) _ = Tint64(s) // ERROR "cannot convert.Tint64\|invalid type conversion" _ = string(sb) _ = []byte(sb) _ = []rune(sb) // ERROR "cannot convert.\[\]rune\|invalid type conversion" _ = []int64(sb) // ERROR "cannot convert.\[\]int64\|invalid type conversion" _ = Tstring(sb) _ = Tbyte(sb) _ = Trune(sb) // ERROR "cannot convert.Trune\|invalid type conversion" _ = Tint64(sb) // ERROR "cannot convert.Tint64\|invalid type conversion" _ = string(sr) _ = []byte(sr) // ERROR "cannot convert.\[\]byte\|invalid type conversion" _ = []rune(sr) _ = []int64(sr) // ERROR "cannot convert.\[\]int64\|invalid type conversion" _ = Tstring(sr) _ = Tbyte(sr) // ERROR "cannot convert.Tbyte\|invalid type conversion" _ = Trune(sr) _ = Tint64(sr) // ERROR "cannot convert.Tint64\|invalid type conversion" _ = string(si) // ERROR "cannot convert.* string\|invalid type conversion" _ = []byte(si) // ERROR "cannot convert.\[\]byte\|invalid type conversion" _ = []rune(si) // ERROR "cannot convert.\[\]rune\|invalid type conversion" _ = []int64(si) _ = Tstring(si) // ERROR "cannot convert.Tstring\|invalid type conversion" _ = Tbyte(si) // ERROR "cannot convert.Tbyte\|invalid type conversion" _ = Trune(si) // ERROR "cannot convert.Trune\|invalid type conversion" _ = Tint64(si) _ = string(ts) _ = []byte(ts) _ = []rune(ts) _ = []int64(ts) // ERROR "cannot convert.\[\]int64\|invalid type conversion" _ = Tstring(ts) _ = Tbyte(ts) _ = Trune(ts) _ = Tint64(ts) // ERROR "cannot convert.Tint64\|invalid type conversion" _ = string(tsb) _ = []byte(tsb) _ = []rune(tsb) // ERROR "cannot convert.\[\]rune\|invalid type conversion" _ = []int64(tsb) // ERROR "cannot convert.\[\]int64\|invalid type conversion" _ = Tstring(tsb) _ = Tbyte(tsb) _ = Trune(tsb) // ERROR "cannot convert.Trune\|invalid type conversion" _ = Tint64(tsb) // ERROR "cannot convert.Tint64\|invalid type conversion" _ = string(tsr) _ = []byte(tsr) // ERROR "cannot convert.\[\]byte\|invalid type conversion" _ = []rune(tsr) _ = []int64(tsr) // ERROR "cannot convert.\[\]int64\|invalid type conversion" _ = Tstring(tsr) _ = Tbyte(tsr) // ERROR "cannot convert.Tbyte\|invalid type conversion" _ = Trune(tsr) _ = Tint64(tsr) // ERROR "cannot convert.Tint64\|invalid type conversion" _ = string(tsi) // ERROR "cannot convert. string\|invalid type conversion" _ = []byte(tsi) // ERROR "cannot convert.\[\]byte\|invalid type conversion" _ = []rune(tsi) // ERROR "cannot convert.\[\]rune\|invalid type conversion" _ = []int64(tsi) _ = Tstring(tsi) // ERROR "cannot convert.Tstring\|invalid type conversion" _ = Tbyte(tsi) // ERROR "cannot convert.Tbyte\|invalid type conversion" _ = Trune(tsi) // ERROR "cannot convert.*Trune\|invalid type conversion" _ = Tint64(tsi) }	3.41 KB	2024-02-02 18:09
📄 convert2.go // errorcheck // 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. // Test various valid and invalid struct assignments and conversions. // Does not compile. package main type I interface { m() } // conversions between structs func _() { type S struct{} type T struct{} var s S var t T var u struct{} s = s s = t // ERROR "cannot use .* in assignment\|incompatible type" s = u s = S(s) s = S(t) s = S(u) t = u t = T(u) } func _() { type S struct{ x int } type T struct { x int "foo" } var s S var t T var u struct { x int "bar" } s = s s = t // ERROR "cannot use .* in assignment\|incompatible type" s = u // ERROR "cannot use .* in assignment\|incompatible type" s = S(s) s = S(t) s = S(u) t = u // ERROR "cannot use .* in assignment\|incompatible type" t = T(u) } func _() { type E struct{ x int } type S struct{ x E } type T struct { x E "foo" } var s S var t T var u struct { x E "bar" } s = s s = t // ERROR "cannot use .* in assignment\|incompatible type" s = u // ERROR "cannot use .* in assignment\|incompatible type" s = S(s) s = S(t) s = S(u) t = u // ERROR "cannot use .* in assignment\|incompatible type" t = T(u) } func _() { type S struct { x struct { x int "foo" } } type T struct { x struct { x int "bar" } "foo" } var s S var t T var u struct { x struct { x int "bar" } "bar" } s = s s = t // ERROR "cannot use .* in assignment\|incompatible type" s = u // ERROR "cannot use .* in assignment\|incompatible type" s = S(s) s = S(t) s = S(u) t = u // ERROR "cannot use .* in assignment\|incompatible type" t = T(u) } func _() { type E1 struct { x int "foo" } type E2 struct { x int "bar" } type S struct{ x E1 } type T struct { x E2 "foo" } var s S var t T var u struct { x E2 "bar" } s = s s = t // ERROR "cannot use .* in assignment\|incompatible type" s = u // ERROR "cannot use .* in assignment\|incompatible type" s = S(s) s = S(t) // ERROR "cannot convert" s = S(u) // ERROR "cannot convert" t = u // ERROR "cannot use .* in assignment\|incompatible type" t = T(u) } func _() { type E struct{ x int } type S struct { f func(struct { x int "foo" }) } type T struct { f func(struct { x int "bar" }) } var s S var t T var u struct{ f func(E) } s = s s = t // ERROR "cannot use .* in assignment\|incompatible type" s = u // ERROR "cannot use .* in assignment\|incompatible type" s = S(s) s = S(t) s = S(u) // ERROR "cannot convert" t = u // ERROR "cannot use .* in assignment\|incompatible type" t = T(u) // ERROR "cannot convert" } // conversions between pointers to structs func _() { type S struct{} type T struct{} var s S var t T var u struct{} s = s s = t // ERROR "cannot use . in assignment\|incompatible type" s = u // ERROR "cannot use .* in assignment\|incompatible type" s = (S)(s) s = (S)(t) s = (S)(u) t = u // ERROR "cannot use . in assignment\|incompatible type" t = (T)(u) } func _() { type S struct{ x int } type T struct { x int "foo" } var s S var t T var u struct { x int "bar" } s = s s = t // ERROR "cannot use .* in assignment\|incompatible type" s = u // ERROR "cannot use .* in assignment\|incompatible type" s = (S)(s) s = (S)(t) s = (S)(u) t = u // ERROR "cannot use . in assignment\|incompatible type" t = (T)(u) } func _() { type E struct{ x int } type S struct{ x E } type T struct { x E "foo" } var s S var t T var u struct { x E "bar" } s = s s = t // ERROR "cannot use .* in assignment\|incompatible type" s = u // ERROR "cannot use .* in assignment\|incompatible type" s = (S)(s) s = (S)(t) s = (S)(u) t = u // ERROR "cannot use . in assignment\|incompatible type" t = (T)(u) } func _() { type S struct { x struct { x int "foo" } } type T struct { x struct { x int "bar" } "foo" } var s S var t T var u struct { x struct { x int "bar" } "bar" } s = s s = t // ERROR "cannot use .* in assignment\|incompatible type" s = u // ERROR "cannot use .* in assignment\|incompatible type" s = (S)(s) s = (S)(t) s = (S)(u) t = u // ERROR "cannot use . in assignment\|incompatible type" t = (T)(u) } func _() { type E1 struct { x int "foo" } type E2 struct { x int "bar" } type S struct{ x E1 } type T struct { x E2 "foo" } var s S var t T var u struct { x E2 "bar" } s = s s = t // ERROR "cannot use .* in assignment\|incompatible type" s = u // ERROR "cannot use .* in assignment\|incompatible type" s = (S)(s) s = (S)(t) // ERROR "cannot convert" s = (S)(u) // ERROR "cannot convert" t = u // ERROR "cannot use . in assignment\|incompatible type" t = (T)(u) } func _() { type E struct{ x int } type S struct { f func(struct { x int "foo" }) } type T struct { f func(struct { x int "bar" }) } var s S var t T var u struct{ f func(E) } s = s s = t // ERROR "cannot use .* in assignment\|incompatible type" s = u // ERROR "cannot use .* in assignment\|incompatible type" s = (S)(s) s = (S)(t) s = (S)(u) // ERROR "cannot convert" t = u // ERROR "cannot use . in assignment\|incompatible type" t = (T)(u) // ERROR "cannot convert" } func _() { type E struct{ x int } type S struct { f func(struct { x int "foo" }) } type T struct { f func(struct { x int "bar" }) } var s S var t T var u struct{ f func(E) } s = s s = t // ERROR "cannot use .* in assignment\|incompatible type" s = u // ERROR "cannot use .* in assignment\|incompatible type" s = (S)(s) s = (S)(t) s = (S)(u) // ERROR "cannot convert" t = u // ERROR "cannot use . in assignment\|incompatible type" t = (T)(u) // ERROR "cannot convert" } func _() { var s []byte _ = ([4]byte)(s) _ = ([4]byte)(s) type A [4]byte _ = (A)(s) _ = (A)(s) type P [4]byte _ = (P)(s) _ = (*P)(s) // ERROR "cannot convert" }	5.87 KB	2024-02-02 18:09
📄 convert3.go // errorcheck // Copyright 2009 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. // Verify allowed and disallowed conversions. // Does not compile. package main // everything here is legal except the ERROR line var c chan int var d1 chan<- int = c var d2 = (chan<- int)(c) var e *[4]int var f1 []int = e[0:] var f2 = []int(e[0:]) var g = []int(nil) type H []int type J []int var h H var j1 J = h // ERROR "compat\|illegal\|cannot" var j2 = J(h)	544 B	2024-02-02 18:09
📄 convert4.go // run // 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. // Test conversion from slice to array pointer. package main func wantPanic(fn func(), s string) { defer func() { err := recover() if err == nil { panic("expected panic") } if got := err.(error).Error(); got != s { panic("expected panic " + s + " got " + got) } }() fn() } func main() { s := make([]byte, 8, 10) for i := range s { s[i] = byte(i) } if p := ([8]byte)(s); &p[0] != &s[0] { panic("[8]byte conversion failed") } if [8]byte(s) != ([8]byte)(s) { panic("[8]byte conversion failed") } wantPanic( func() { _ = ([9]byte)(s) }, "runtime error: cannot convert slice with length 8 to array or pointer to array with length 9", ) wantPanic( func() { _ = [9]byte(s) }, "runtime error: cannot convert slice with length 8 to array or pointer to array with length 9", ) var n []byte if p := ([0]byte)(n); p != nil { panic("nil slice converted to [0]byte should be nil") } _ = [0]byte(n) z := make([]byte, 0) if p := ([0]byte)(z); p == nil { panic("empty slice converted to [0]byte should be non-nil") } _ = [0]byte(z) var p []byte wantPanic( func() { _ = [0]byte(p) // evaluating p should still panic }, "runtime error: invalid memory address or nil pointer dereference", ) // Test with named types type Slice []int type Int4 [4]int type PInt4 [4]int ii := make(Slice, 4) if p := (Int4)(ii); &p[0] != &ii[0] { panic("Int4 conversion failed") } if p := PInt4(ii); &p[0] != &ii[0] { panic("PInt4 conversion failed") } } // test static variable conversion var ( ss = make([]string, 10) s5 = ([5]string)(ss) s10 = ([10]string)(ss) ns []string ns0 = ([0]string)(ns) zs = make([]string, 0) zs0 = (*[0]string)(zs) ) func init() { if &ss[0] != &s5[0] { panic("s5 conversion failed") } if &ss[0] != &s10[0] { panic("s5 conversion failed") } if ns0 != nil { panic("ns0 should be nil") } if zs0 == nil { panic("zs0 should not be nil") } }	2.09 KB	2024-02-02 18:09
📄 convinline.go // runoutput //go:build !wasm // Copyright 2022 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 ( "bytes" "fmt" "math" "math/bits" "os" "strconv" "strings" ) var types = []string{ "int", "int8", "int16", "int32", "int64", "uint", "uint8", "uint16", "uint32", "uint64", "uintptr", "float32", "float64", } func main() { var prog bytes.Buffer fmt.Fprintf(&prog, "package main\n\n") fmt.Fprintf(&prog, "import ( \"fmt\"; \"math\" )\n") for _, t1 := range types { for _, t2 := range types { fmt.Fprintf(&prog, "func %[1]s_to_%[2]s(x %[1]s) %[2]s { return %[2]s(x) }\n", t1, t2) } } var outputs []string var exprs []string fmt.Fprintf(&prog, "var (\n") for _, t1 := range types { var inputs []string switch t1 { case "int64", "int": if t1 == "int64" \|\| bits.UintSize == 64 { inputs = append(inputs, "-0x8000_0000_0000_0000", "-0x7fff_ffff_ffff_ffff", "-0x12_3456_7890", "0x12_3456_7890", "0x7fff_ffff_ffff_ffff") } fallthrough case "int32": inputs = append(inputs, "-0x8000_0000", "-0x7fff_ffff", "-0x12_3456", "0x12_3456", "0x7fff_ffff") fallthrough case "int16": inputs = append(inputs, "-0x8000", "-0x7fff", "-0x1234", "0x1234", "0x7fff") fallthrough case "int8": inputs = append(inputs, "-0x80", "-0x7f", "-0x12", "-1", "0", "1", "0x12", "0x7f") case "uint64", "uint", "uintptr": if t1 == "uint64" \|\| bits.UintSize == 64 { inputs = append(inputs, "0x12_3456_7890", "0x7fff_ffff_ffff_ffff", "0x8000_0000_0000_0000", "0xffff_ffff_ffff_ffff") } fallthrough case "uint32": inputs = append(inputs, "0x12_3456", "0x7fff_ffff", "0x8000_0000", "0xffff_ffff") fallthrough case "uint16": inputs = append(inputs, "0x1234", "0x7fff", "0x8000", "0xffff") fallthrough case "uint8": inputs = append(inputs, "0", "1", "0x12", "0x7f", "0x80", "0xff") case "float64": inputs = append(inputs, "-1.79769313486231570814527423731704356798070e+308", "-1e300", "-1e100", "-1e40", "-3.5e38", "3.5e38", "1e40", "1e100", "1e300", "1.79769313486231570814527423731704356798070e+308") fallthrough case "float32": inputs = append(inputs, "-3.40282346638528859811704183484516925440e+38", "-1e38", "-1.5", "-1.401298464324817070923729583289916131280e-45", "0", "1.401298464324817070923729583289916131280e-45", "1.5", "1e38", "3.40282346638528859811704183484516925440e+38") } for _, t2 := range types { for _, x := range inputs { code := fmt.Sprintf("%s_to_%s(%s)", t1, t2, x) fmt.Fprintf(&prog, "\tv%d = %s\n", len(outputs), code) exprs = append(exprs, code) outputs = append(outputs, convert(x, t1, t2)) } } } fmt.Fprintf(&prog, ")\n\n") fmt.Fprintf(&prog, "func main() {\n\tok := true\n") for i, out := range outputs { fmt.Fprintf(&prog, "\tif v%d != %s { fmt.Println(%q, \"=\", v%d, \"want\", %s); ok = false }\n", i, out, exprs[i], i, out) } fmt.Fprintf(&prog, "\tif !ok { println(\"FAIL\") }\n") fmt.Fprintf(&prog, "}\n") os.Stdout.Write(prog.Bytes()) } func convert(x, t1, t2 string) string { if strings.HasPrefix(t1, "int") { v, err := strconv.ParseInt(x, 0, 64) if err != nil { println(x, t1, t2) panic(err) } return convert1(v, t2) } if strings.HasPrefix(t1, "uint") { v, err := strconv.ParseUint(x, 0, 64) if err != nil { println(x, t1, t2) panic(err) } return convert1(v, t2) } if strings.HasPrefix(t1, "float") { v, err := strconv.ParseFloat(x, 64) if err != nil { println(x, t1, t2) panic(err) } if t1 == "float32" { v = float64(float32(v)) } return convert1(v, t2) } panic(t1) } func convert1[T int64 \| uint64 \| float64](v T, t2 string) string { switch t2 { case "int": return fmt.Sprintf("%s(%#x)", t2, int(v)) case "int8": return fmt.Sprintf("%s(%#x)", t2, int8(v)) case "int16": return fmt.Sprintf("%s(%#x)", t2, int16(v)) case "int32": return fmt.Sprintf("%s(%#x)", t2, int32(v)) case "int64": return fmt.Sprintf("%s(%#x)", t2, int64(v)) case "uint": return fmt.Sprintf("%s(%#x)", t2, uint(v)) case "uint8": return fmt.Sprintf("%s(%#x)", t2, uint8(v)) case "uint16": return fmt.Sprintf("%s(%#x)", t2, uint16(v)) case "uint32": return fmt.Sprintf("%s(%#x)", t2, uint32(v)) case "uint64": return fmt.Sprintf("%s(%#x)", t2, uint64(v)) case "uintptr": return fmt.Sprintf("%s(%#x)", t2, uintptr(v)) case "float32": v := float32(v) if math.IsInf(float64(v), -1) { return "float32(math.Inf(-1))" } if math.IsInf(float64(v), +1) { return "float32(math.Inf(+1))" } return fmt.Sprintf("%s(%v)", t2, float64(v)) case "float64": return fmt.Sprintf("%s(%v)", t2, float64(v)) } panic(t2) }	4.72 KB	2024-02-02 18:09
📄 convlit.go // errorcheck // Copyright 2009 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. // Verify that illegal assignments with both explicit and implicit conversions of literals are detected. // Does not compile. package main import "unsafe" // explicit conversion of constants var x1 = string(1) var x2 string = string(1) var x3 = int(1.5) // ERROR "convert\|truncate" var x4 int = int(1.5) // ERROR "convert\|truncate" var x5 = "a" + string(1) var x6 = int(1e100) // ERROR "overflow\|cannot convert" var x7 = float32(1e1000) // ERROR "overflow\|cannot convert" // unsafe.Pointer can only convert to/from uintptr var _ = string(unsafe.Pointer(uintptr(65))) // ERROR "convert\|conversion" var _ = float64(unsafe.Pointer(uintptr(65))) // ERROR "convert\|conversion" var _ = int(unsafe.Pointer(uintptr(65))) // ERROR "convert\|conversion" // implicit conversions merit scrutiny var s string var bad1 string = 1 // ERROR "conver\|incompatible\|invalid\|cannot" var bad2 = s + 1 // ERROR "conver\|incompatible\|invalid\|cannot" var bad3 = s + 'a' // ERROR "conver\|incompatible\|invalid\|cannot" var bad4 = "a" + 1 // ERROR "literals\|incompatible\|convert\|invalid" var bad5 = "a" + 'a' // ERROR "literals\|incompatible\|convert\|invalid" var bad6 int = 1.5 // ERROR "convert\|truncate" var bad7 int = 1e100 // ERROR "overflow\|truncated to int\|truncated" var bad8 float32 = 1e200 // ERROR "overflow" // but these implicit conversions are okay var good1 string = "a" var good2 int = 1.0 var good3 int = 1e9 var good4 float64 = 1e20 // explicit conversion of string is okay var _ = []rune("abc") var _ = []byte("abc") // implicit is not var _ []int = "abc" // ERROR "cannot use\|incompatible\|invalid\|cannot convert" var _ []byte = "abc" // ERROR "cannot use\|incompatible\|invalid\|cannot convert" // named string is okay type Tstring string var ss Tstring = "abc" var _ = []rune(ss) var _ = []byte(ss) // implicit is still not var _ []rune = ss // ERROR "cannot use\|incompatible\|invalid" var _ []byte = ss // ERROR "cannot use\|incompatible\|invalid" // named slice is now ok type Trune []rune type Tbyte []byte var _ = Trune("abc") // ok var _ = Tbyte("abc") // ok // implicit is still not var _ Trune = "abc" // ERROR "cannot use\|incompatible\|invalid\|cannot convert" var _ Tbyte = "abc" // ERROR "cannot use\|incompatible\|invalid\|cannot convert"	2.39 KB	2024-02-02 18:09
📄 convlit1.go // errorcheck // Copyright 2009 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. // Verify that illegal uses of composite literals are detected. // Does not compile. package main var a = []int { "a" }; // ERROR "conver\|incompatible\|cannot" var b = int { 1 }; // ERROR "compos" func f() int func main() { if f < 1 { } // ERROR "conver\|incompatible\|invalid" }	458 B	2024-02-02 18:09
📄 copy.go // run // Copyright 2009 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. // Semi-exhaustive test for the copy predeclared function. package main import ( "fmt" "os" ) const N = 40 var input8 = make([]uint8, N) var output8 = make([]uint8, N) var input16 = make([]uint16, N) var output16 = make([]uint16, N) var input32 = make([]uint32, N) var output32 = make([]uint32, N) var input64 = make([]uint64, N) var output64 = make([]uint64, N) var inputS string var outputS = make([]uint8, N) type my8 []uint8 type my16 []uint16 type my32 []uint32 type my32b []uint32 type my64 []uint64 type myS string func u8(i int) uint8 { i = 'a' + i%26 return uint8(i) } func u16(ii int) uint16 { var i = uint16(ii) i = 'a' + i%26 i \|= i << 8 return i } func u32(ii int) uint32 { var i = uint32(ii) i = 'a' + i%26 i \|= i << 8 i \|= i << 16 return i } func u64(ii int) uint64 { var i = uint64(ii) i = 'a' + i%26 i \|= i << 8 i \|= i << 16 i \|= i << 32 return i } func reset() { // swap in and out to exercise copy-up and copy-down input8, output8 = output8, input8 input16, output16 = output16, input16 input32, output32 = output32, input32 input64, output64 = output64, input64 in := 0 out := 13 for i := range input8 { input8[i] = u8(in) output8[i] = u8(out) outputS[i] = u8(out) input16[i] = u16(in) output16[i] = u16(out) input32[i] = u32(in) output32[i] = u32(out) input64[i] = u64(in) output64[i] = u64(out) in++ out++ } inputS = string(input8) } func clamp(n int) int { if n > N { return N } return n } func ncopied(length, in, out int) int { n := length if in+n > N { n = N - in } if out+n > N { n = N - out } return n } func doAllSlices(length, in, out int) { reset() n := copy(my8(output8[out:clamp(out+length)]), input8[in:clamp(in+length)]) verify8(length, in, out, n) n = copy(my8(outputS[out:clamp(out+length)]), myS(inputS[in:clamp(in+length)])) verifyS(length, in, out, n) n = copy(my16(output16[out:clamp(out+length)]), input16[in:clamp(in+length)]) verify16(length, in, out, n) n = copy(my32(output32[out:clamp(out+length)]), my32b(input32[in:clamp(in+length)])) verify32(length, in, out, n) n = copy(my64(output64[out:clamp(out+length)]), input64[in:clamp(in+length)]) verify64(length, in, out, n) } func bad8(state string, i, length, in, out int) { fmt.Printf("%s bad(%d %d %d): %c not %c:\n\t%s\n\t%s\n", state, length, in, out, output8[i], uint8(i+13), input8, output8) os.Exit(1) } func verify8(length, in, out, m int) { n := ncopied(length, in, out) if m != n { fmt.Printf("count bad(%d %d %d): %d not %d\n", length, in, out, m, n) os.Exit(1) return } // before var i int for i = 0; i < out; i++ { if output8[i] != u8(i+13) { bad8("before8", i, length, in, out) return } } // copied part for ; i < out+n; i++ { if output8[i] != u8(i+in-out) { bad8("copied8", i, length, in, out) return } } // after for ; i < len(output8); i++ { if output8[i] != u8(i+13) { bad8("after8", i, length, in, out) return } } } func badS(state string, i, length, in, out int) { fmt.Printf("%s bad(%d %d %d): %c not %c:\n\t%s\n\t%s\n", state, length, in, out, outputS[i], uint8(i+13), inputS, outputS) os.Exit(1) } func verifyS(length, in, out, m int) { n := ncopied(length, in, out) if m != n { fmt.Printf("count bad(%d %d %d): %d not %d\n", length, in, out, m, n) os.Exit(1) return } // before var i int for i = 0; i < out; i++ { if outputS[i] != u8(i+13) { badS("beforeS", i, length, in, out) return } } // copied part for ; i < out+n; i++ { if outputS[i] != u8(i+in-out) { badS("copiedS", i, length, in, out) return } } // after for ; i < len(outputS); i++ { if outputS[i] != u8(i+13) { badS("afterS", i, length, in, out) return } } } func bad16(state string, i, length, in, out int) { fmt.Printf("%s bad(%d %d %d): %x not %x:\n\t%v\n\t%v\n", state, length, in, out, output16[i], uint16(i+13), input16, output16) os.Exit(1) } func verify16(length, in, out, m int) { n := ncopied(length, in, out) if m != n { fmt.Printf("count bad(%d %d %d): %d not %d\n", length, in, out, m, n) os.Exit(1) return } // before var i int for i = 0; i < out; i++ { if output16[i] != u16(i+13) { bad16("before16", i, length, in, out) return } } // copied part for ; i < out+n; i++ { if output16[i] != u16(i+in-out) { bad16("copied16", i, length, in, out) return } } // after for ; i < len(output16); i++ { if output16[i] != u16(i+13) { bad16("after16", i, length, in, out) return } } } func bad32(state string, i, length, in, out int) { fmt.Printf("%s bad(%d %d %d): %x not %x:\n\t%v\n\t%v\n", state, length, in, out, output32[i], uint32(i+13), input32, output32) os.Exit(1) } func verify32(length, in, out, m int) { n := ncopied(length, in, out) if m != n { fmt.Printf("count bad(%d %d %d): %d not %d\n", length, in, out, m, n) os.Exit(1) return } // before var i int for i = 0; i < out; i++ { if output32[i] != u32(i+13) { bad32("before32", i, length, in, out) return } } // copied part for ; i < out+n; i++ { if output32[i] != u32(i+in-out) { bad32("copied32", i, length, in, out) return } } // after for ; i < len(output32); i++ { if output32[i] != u32(i+13) { bad32("after32", i, length, in, out) return } } } func bad64(state string, i, length, in, out int) { fmt.Printf("%s bad(%d %d %d): %x not %x:\n\t%v\n\t%v\n", state, length, in, out, output64[i], uint64(i+13), input64, output64) os.Exit(1) } func verify64(length, in, out, m int) { n := ncopied(length, in, out) if m != n { fmt.Printf("count bad(%d %d %d): %d not %d\n", length, in, out, m, n) os.Exit(1) return } // before var i int for i = 0; i < out; i++ { if output64[i] != u64(i+13) { bad64("before64", i, length, in, out) return } } // copied part for ; i < out+n; i++ { if output64[i] != u64(i+in-out) { bad64("copied64", i, length, in, out) return } } // after for ; i < len(output64); i++ { if output64[i] != u64(i+13) { bad64("after64", i, length, in, out) return } } } func slice() { for length := 0; length < N; length++ { for in := 0; in <= 32; in++ { for out := 0; out <= 32; out++ { doAllSlices(length, in, out) } } } } // Array test. Can be much simpler. It's only checking for correct handling of [0:]. func array() { var array [N]uint8 reset() copy(array[0:], input8) for i := 0; i < N; i++ { output8[i] = 0 } copy(output8, array[0:]) verify8(N, 0, 0, N) } func main() { slice() array() }	6.6 KB	2024-02-02 18:09
📄 copy1.go // 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. // Verify that copy arguments requirements are enforced by the // compiler. package main func main() { si := make([]int, 8) sf := make([]float64, 8) _ = copy() // ERROR "not enough arguments" _ = copy(1, 2, 3) // ERROR "too many arguments" _ = copy(si, "hi") // ERROR "have different element types(.int.string\| int and byte)" _ = copy(si, sf) // ERROR "have different element types.int.float64" _ = copy(1, 2) // ERROR "must be slices; have int, int\|expects slice arguments" _ = copy(1, si) // ERROR "first argument to copy should be\|expects slice arguments" _ = copy(si, 2) // ERROR "second argument to copy should be\|expects slice arguments" }	851 B	2024-02-02 18:09
📄 crlf.go // runoutput // 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. // Test source files and strings containing \r and \r\n. package main import ( "fmt" "strings" ) func main() { prog = strings.Replace(prog, "BQ", "`", -1) prog = strings.Replace(prog, "CR", "\r", -1) fmt.Print(prog) } var prog = ` package main CR import "fmt" var CR s = "hello\n" + CR " world"CR var t = BQhelloCR worldBQ var u = BQhCReCRlCRlCRoCR worldBQ var golden = "hello\n world" func main() { if s != golden { fmt.Printf("s=%q, want %q", s, golden) } if t != golden { fmt.Printf("t=%q, want %q", t, golden) } if u != golden { fmt.Printf("u=%q, want %q", u, golden) } } `	782 B	2024-02-02 18:09
📄 ddd.go // run // Copyright 2010 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 variadic functions and calls (dot-dot-dot). package main func sum(args ...int) int { s := 0 for _, v := range args { s += v } return s } func sumC(args ...int) int { return func() int { return sum(args...) }() } var sumD = func(args ...int) int { return sum(args...) } var sumE = func() func(...int) int { return func(args ...int) int { return sum(args...) } }() var sumF = func(args ...int) func() int { return func() int { return sum(args...) } } func sumA(args []int) int { s := 0 for _, v := range args { s += v } return s } func sumB(args []int) int { return sum(args...) } func sum2(args ...int) int { return 2 * sum(args...) } func sum3(args ...int) int { return 3 * sumA(args) } func sum4(args ...int) int { return 4 * sumB(args) } func intersum(args ...interface{}) int { s := 0 for _, v := range args { s += v.(int) } return s } type T []T func ln(args ...T) int { return len(args) } func ln2(args ...T) int { return 2 * ln(args...) } func (T) Sum(args ...int) int { return sum(args...) } type U struct { T } type I interface { Sum(...int) int } func main() { if x := sum(1, 2, 3); x != 6 { println("sum 6", x) panic("fail") } if x := sum(); x != 0 { println("sum 0", x) panic("fail") } if x := sum(10); x != 10 { println("sum 10", x) panic("fail") } if x := sum(1, 8); x != 9 { println("sum 9", x) panic("fail") } if x := sumC(4, 5, 6); x != 15 { println("sumC 15", x) panic("fail") } if x := sumD(4, 5, 7); x != 16 { println("sumD 16", x) panic("fail") } if x := sumE(4, 5, 8); x != 17 { println("sumE 17", x) panic("fail") } if x := sumF(4, 5, 9)(); x != 18 { println("sumF 18", x) panic("fail") } if x := sum2(1, 2, 3); x != 26 { println("sum 6", x) panic("fail") } if x := sum2(); x != 20 { println("sum 0", x) panic("fail") } if x := sum2(10); x != 210 { println("sum 10", x) panic("fail") } if x := sum2(1, 8); x != 29 { println("sum 9", x) panic("fail") } if x := sum3(1, 2, 3); x != 36 { println("sum 6", x) panic("fail") } if x := sum3(); x != 30 { println("sum 0", x) panic("fail") } if x := sum3(10); x != 310 { println("sum 10", x) panic("fail") } if x := sum3(1, 8); x != 39 { println("sum 9", x) panic("fail") } if x := sum4(1, 2, 3); x != 46 { println("sum 6", x) panic("fail") } if x := sum4(); x != 40 { println("sum 0", x) panic("fail") } if x := sum4(10); x != 410 { println("sum 10", x) panic("fail") } if x := sum4(1, 8); x != 49 { println("sum 9", x) panic("fail") } if x := intersum(1, 2, 3); x != 6 { println("intersum 6", x) panic("fail") } if x := intersum(); x != 0 { println("intersum 0", x) panic("fail") } if x := intersum(10); x != 10 { println("intersum 10", x) panic("fail") } if x := intersum(1, 8); x != 9 { println("intersum 9", x) panic("fail") } if x := ln(nil, nil, nil); x != 3 { println("ln 3", x) panic("fail") } if x := ln([]T{}); x != 1 { println("ln 1", x) panic("fail") } if x := ln2(nil, nil, nil); x != 23 { println("ln2 3", x) panic("fail") } if x := ln2([]T{}); x != 21 { println("ln2 1", x) panic("fail") } if x := ((T)(nil)).Sum(1, 3, 5, 7); x != 16 { println("(T)(nil).Sum", x) panic("fail") } if x := (T).Sum(nil, 1, 3, 5, 6); x != 15 { println("(T).Sum", x) panic("fail") } if x := (&U{}).Sum(1, 3, 5, 5); x != 14 { println("(&U{}).Sum", x) panic("fail") } var u U if x := u.Sum(1, 3, 5, 4); x != 13 { println("u.Sum", x) panic("fail") } if x := (&u).Sum(1, 3, 5, 3); x != 12 { println("(&u).Sum", x) panic("fail") } var i interface { Sum(...int) int } = &u if x := i.Sum(2, 3, 5, 7); x != 17 { println("i(=&u).Sum", x) panic("fail") } i = u if x := i.Sum(2, 3, 5, 6); x != 16 { println("i(=u).Sum", x) panic("fail") } var s struct { I } s.I = &u if x := s.Sum(2, 3, 5, 8); x != 18 { println("s{&u}.Sum", x) panic("fail") } if x := (U).Sum(&U{}, 1, 3, 5, 2); x != 11 { println("(U).Sum", x) panic("fail") } if x := U.Sum(U{}, 1, 3, 5, 1); x != 10 { println("U.Sum", x) panic("fail") } }	4.23 KB	2024-02-02 18:09
📄 ddd1.go // errorcheck // Copyright 2010 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. // Verify that illegal uses of ... are detected. // Does not compile. package main import "unsafe" func sum(args ...int) int { return 0 } var ( _ = sum(1, 2, 3) _ = sum() _ = sum(1.0, 2.0) _ = sum(1.5) // ERROR "1\.5 .untyped float constant. as int\|integer" _ = sum("hello") // ERROR ".hello. (.untyped string constant. as int\|.type untyped string. as type int)\|incompatible" _ = sum([]int{1}) // ERROR "\[\]int{.}.as int value" ) func sum3(int, int, int) int { return 0 } func tuple() (int, int, int) { return 1, 2, 3 } var ( _ = sum(tuple()) _ = sum(tuple()...) // ERROR "\.{3} with 3-valued\|multiple-value" _ = sum3(tuple()) _ = sum3(tuple()...) // ERROR "\.{3} in call to non-variadic\|multiple-value\|invalid use of .[.][.][.]" ) type T []T func funny(args ...T) int { return 0 } var ( _ = funny(nil) _ = funny(nil, nil) _ = funny([]T{}) // ok because []T{} is a T; passes []T{[]T{}} ) func Foo(n int) {} func bad(args ...int) { print(1, 2, args...) // ERROR "[.][.][.]" println(args...) // ERROR "[.][.][.]" ch := make(chan int) close(ch...) // ERROR "[.][.][.]" _ = len(args...) // ERROR "[.][.][.]" _ = new(int...) // ERROR "[.][.][.]" n := 10 _ = make([]byte, n...) // ERROR "[.][.][.]" _ = make([]byte, 10 ...) // ERROR "[.][.][.]" var x int _ = unsafe.Pointer(&x...) // ERROR "[.][.][.]" _ = unsafe.Sizeof(x...) // ERROR "[.][.][.]" _ = [...]byte("foo") // ERROR "[.][.][.]" _ = [...][...]int{{1,2,3},{4,5,6}} // ERROR "[.][.][.]" Foo(x...) // ERROR "\.{3} in call to non-variadic\|invalid use of .[.][.][.]" }	1.7 KB	2024-02-02 18:09
📁 ddd2.dir	-	2024-02-02 18:09
📄 ddd2.go // rundir // Copyright 2010 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 that variadic functions work across package boundaries. package ignored	252 B	2024-02-02 18:09
📄 decl.go // run // Copyright 2009 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 correct short declarations and redeclarations. package main func f1() int { return 1 } func f2() (float32, int) { return 1, 2 } func f3() (float32, int, string) { return 1, 2, "3" } func x() (s string) { a, b, s := f3() _, _ = a, b return // tests that result var is in scope for redeclaration } func main() { i, f, s := f3() j, f := f2() // redeclare f k := f1() m, g, s := f3() m, h, s := f3() { // new block should be ok. i, f, s := f3() j, f := f2() // redeclare f k := f1() m, g, s := f3() m, h, s := f3() _, _, _, _, _, _, _, _, _ = i, f, s, j, k, m, g, s, h } if y := x(); y != "3" { println("x() failed", y) panic("fail") } _, _, _, _, _, _, _, _, _ = i, f, s, j, k, m, g, s, h }	926 B	2024-02-02 18:09
📄 declbad.go // errorcheck // Copyright 2009 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 that incorrect short declarations and redeclarations are detected. // Does not compile. package main func f1() int { return 1 } func f2() (float32, int) { return 1, 2 } func f3() (float32, int, string) { return 1, 2, "3" } func main() { { // simple redeclaration i := f1() i := f1() // ERROR "redeclared\|no new" _ = i } { // change of type for f i, f, s := f3() f, g, t := f3() // ERROR "redeclared\|cannot assign\|incompatible\|cannot use" _, _, _, _, _ = i, f, s, g, t } { // change of type for i i, f, s := f3() j, i, t := f3() // ERROR "redeclared\|cannot assign\|incompatible\|cannot use" _, _, _, _, _ = i, f, s, j, t } { // no new variables i, f, s := f3() i, f := f2() // ERROR "redeclared\|no new" _, _, _ = i, f, s } { // multiline no new variables i := f1 i := func() int { // ERROR "redeclared\|no new\|incompatible" return 0 } _ = i } { // single redeclaration i, f, s := f3() i := 1 // ERROR "redeclared\|no new\|incompatible" _, _, _ = i, f, s } // double redeclaration { i, f, s := f3() i, f := f2() // ERROR "redeclared\|no new" _, _, _ = i, f, s } { // triple redeclaration i, f, s := f3() i, f, s := f3() // ERROR "redeclared\|no new" _, _, _ = i, f, s } }	1.43 KB	2024-02-02 18:09
📄 defer.go // run // Copyright 2009 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 defer. package main import "fmt" var result string func addInt(i int) { result += fmt.Sprint(i) } func test1helper() { for i := 0; i < 10; i++ { defer addInt(i) } } func test1() { result = "" test1helper() if result != "9876543210" { fmt.Printf("test1: bad defer result (should be 9876543210): %q\n", result) panic("defer") } } func addDotDotDot(v ...interface{}) { result += fmt.Sprint(v...) } func test2helper() { for i := 0; i < 10; i++ { defer addDotDotDot(i) } } func test2() { result = "" test2helper() if result != "9876543210" { fmt.Printf("test2: bad defer result (should be 9876543210): %q\n", result) panic("defer") } } func main() { test1() test2() }	875 B	2024-02-02 18:09
📄 defererrcheck.go // errorcheck -0 -l -d=defer // 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. // check that open-coded defers are used in expected situations package main import "fmt" var glob = 3 func f1() { for i := 0; i < 10; i++ { fmt.Println("loop") } defer func() { // ERROR "open-coded defer" fmt.Println("defer") }() } func f2() { for { defer func() { // ERROR "heap-allocated defer" fmt.Println("defer1") }() if glob > 2 { break } } defer func() { // ERROR "stack-allocated defer" fmt.Println("defer2") }() } func f3() { defer func() { // ERROR "stack-allocated defer" fmt.Println("defer2") }() for { defer func() { // ERROR "heap-allocated defer" fmt.Println("defer1") }() if glob > 2 { break } } } func f4() { defer func() { // ERROR "open-coded defer" fmt.Println("defer") }() label: fmt.Println("goto loop") if glob > 2 { goto label } } func f5() { label: fmt.Println("goto loop") defer func() { // ERROR "heap-allocated defer" fmt.Println("defer") }() if glob > 2 { goto label } } func f6() { label: fmt.Println("goto loop") if glob > 2 { goto label } // The current analysis doesn't end a backward goto loop, so this defer is // considered to be inside a loop defer func() { // ERROR "heap-allocated defer" fmt.Println("defer") }() }	1.4 KB	2024-02-02 18:09
📄 deferfin.go // run // 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. // Test that defers do not prevent garbage collection. package main import ( "runtime" "sync" "sync/atomic" "time" ) var sink func() func main() { // Does not work with gccgo, due to partially conservative GC. // Try to enable when we have fully precise GC. if runtime.Compiler == "gccgo" { return } N := 10 count := int32(N) var wg sync.WaitGroup wg.Add(N) for i := 0; i < N; i++ { go func() { defer wg.Done() v := new(string) f := func() { if v != "" { panic("oops") } } if v != "" { // let the compiler think f escapes sink = f } runtime.SetFinalizer(v, func(p string) { atomic.AddInt32(&count, -1) }) defer f() }() } wg.Wait() for i := 0; i < 3; i++ { time.Sleep(10 time.Millisecond) runtime.GC() } if count != 0 { println(count, "out of", N, "finalizer are not called") panic("not all finalizers are called") } }	1.05 KB	2024-02-02 18:09
📄 defernil.go // 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. // Check that deferring a nil function causes a proper // panic when the deferred function is invoked (not // when the function is deferred). // See Issue #8047 and #34926. package main var x = 0 func main() { defer func() { err := recover() if err == nil { panic("did not panic") } if x != 1 { panic("FAIL") } }() f() } func f() { var nilf func() defer nilf() x = 1 }	563 B	2024-02-02 18:09
📄 deferprint.go // run // Copyright 2010 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 that we can defer the predeclared functions print and println. package main func main() { defer println(42, true, false, true, 1.5, "world", (chan int)(nil), []int(nil), (map[string]int)(nil), (func())(nil), byte(255)) defer println(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20) // Disabled so the test doesn't crash but left here for reference. // defer panic("dead") defer print("printing: ") }	586 B	2024-02-02 18:09
📄 deferprint.out printing: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 42 true false true +1.500000e+000 world 0x0 [0/0]0x0 0x0 0x0 255	126 B	2024-02-02 18:09
📄 devirt.go // errorcheck -0 -d=ssa/opt/debug=1 package main // Trivial interface call devirtualization test. type real struct { value int } func (r *real) Value() int { return r.value } type Valuer interface { Value() int } type indirectiface struct { a, b, c int } func (i indirectiface) Value() int { return i.a + i.b + i.c } func main() { var r Valuer rptr := &real{value: 3} r = rptr if r.Value() != 3 { // ERROR "de-virtualizing call$" panic("not 3") } r = indirectiface{3, 4, 5} if r.Value() != 12 { // ERROR "de-virtualizing call$" panic("not 12") } }	574 B	2024-02-02 18:09
📄 directive.go // errorcheck // 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. // Verify that misplaced directives are diagnosed. //go:noinline // ERROR "misplaced compiler directive" //go:noinline // ERROR "misplaced compiler directive" package main //go:nosplit func f1() {} //go:nosplit //go:noinline func f2() {} //go:noinline // ERROR "misplaced compiler directive" //go:noinline // ERROR "misplaced compiler directive" var x int //go:noinline // ERROR "misplaced compiler directive" const c = 1 //go:noinline // ERROR "misplaced compiler directive" type T int type ( //go:noinline // ERROR "misplaced compiler directive" T2 int //go:noinline // ERROR "misplaced compiler directive" T3 int ) //go:noinline func f() { x := 1 { _ = x } //go:noinline // ERROR "misplaced compiler directive" var y int _ = y //go:noinline // ERROR "misplaced compiler directive" const c = 1 _ = func() {} //go:noinline // ERROR "misplaced compiler directive" type T int }	1.06 KB	2024-02-02 18:09
📄 directive2.go // errorcheck // 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. // Verify that misplaced directives are diagnosed. // ok //go:build !ignore package main //go:build bad // ERROR "misplaced compiler directive" //go:noinline // ERROR "misplaced compiler directive" type ( T2 int //go:noinline // ERROR "misplaced compiler directive" T2b int T2c int T3 int ) //go:noinline // ERROR "misplaced compiler directive" type ( T4 int ) //go:noinline // ERROR "misplaced compiler directive" type () type T5 int func g() {} //go:noinline // ERROR "misplaced compiler directive" // ok: attached to f (duplicated yes, but ok) //go:noinline //go:noinline func f() { //go:noinline // ERROR "misplaced compiler directive" x := 1 //go:noinline // ERROR "misplaced compiler directive" { _ = x //go:noinline // ERROR "misplaced compiler directive" } var y int //go:noinline // ERROR "misplaced compiler directive" //go:noinline // ERROR "misplaced compiler directive" _ = y const c = 1 _ = func() {} } // EOF //go:noinline // ERROR "misplaced compiler directive"	1.16 KB	2024-02-02 18:09
📄 divide.go // run // 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. // Test divide corner cases. package main import "fmt" func f8(x, y, q, r int8) { if t := x / y; t != q { fmt.Printf("%d/%d = %d, want %d\n", x, y, t, q) panic("divide") } if t := x % y; t != r { fmt.Printf("%d%%%d = %d, want %d\n", x, y, t, r) panic("divide") } } func f16(x, y, q, r int16) { if t := x / y; t != q { fmt.Printf("%d/%d = %d, want %d\n", x, y, t, q) panic("divide") } if t := x % y; t != r { fmt.Printf("%d%%%d = %d, want %d\n", x, y, t, r) panic("divide") } } func f32(x, y, q, r int32) { if t := x / y; t != q { fmt.Printf("%d/%d = %d, want %d\n", x, y, t, q) panic("divide") } if t := x % y; t != r { fmt.Printf("%d%%%d = %d, want %d\n", x, y, t, r) panic("divide") } } func f64(x, y, q, r int64) { if t := x / y; t != q { fmt.Printf("%d/%d = %d, want %d\n", x, y, t, q) panic("divide") } if t := x % y; t != r { fmt.Printf("%d%%%d = %d, want %d\n", x, y, t, r) panic("divide") } } func main() { f8(-1<<7, -1, -1<<7, 0) f16(-1<<15, -1, -1<<15, 0) f32(-1<<31, -1, -1<<31, 0) f64(-1<<63, -1, -1<<63, 0) }	1.22 KB	2024-02-02 18:09
📄 divmod.go // run // 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. // Test division of variables. Generate many test cases, // compute correct answer using shift and subtract, // and then compare against results from division and // modulus operators. // // Primarily useful for testing software div/mod. package main const long = false func main() { if long { // About 3e9 test cases (calls to checkdiv3). // Too long for everyday testing. gen2(3, 64, 2, 64, checkdiv1) println(ntest) } else { // About 4e6 test cases (calls to checkdiv3). // Runs for 8 seconds on ARM chromebook, much faster elsewhere. gen2(2, 64, 1, 64, checkdiv1) } } // generate all uint64 values x where x has at most n bits set in the low w // and call f(x) for each. func gen1(n, w int, f func(uint64)) { gen(0, 0, n, w-1, f) } func gen(val uint64, nbits, maxbits, pos int, f func(uint64)) { if pos < 0 { f(val) return } gen(val, nbits, maxbits, pos-1, f) if nbits < maxbits { gen(val\|1<<uint(pos), nbits+1, maxbits, pos-1, f) } } // generate all uint64 values x, y where x has at most n1 bits set in the low w1 // and y has at most n2 bits set in the low w2 and call f(x, y) for each. func gen2(n1, w1, n2, w2 int, f func(uint64, uint64)) { gen1(n1, w1, func(x uint64) { gen1(n2, w2, func(y uint64) { f(x, y) }) }) } // x and y are uint64s with at most 2 bits set. // Check those values and values above and below, // along with bitwise inversions of the same (done in checkdiv2). func checkdiv1(x, y uint64) { checkdiv2(x, y) // If the low bit is set in x or y, adding or subtracting 1 // produces a number that checkdiv1 is going to be called // with anyway, so don't duplicate effort. if x&1 == 0 { checkdiv2(x+1, y) checkdiv2(x-1, y) } if y&1 == 0 { checkdiv2(x, y-1) checkdiv2(x, y+1) if x&1 == 0 { checkdiv2(x+1, y-1) checkdiv2(x-1, y-1) checkdiv2(x-1, y+1) checkdiv2(x+1, y+1) } } } func checkdiv2(x, y uint64) { checkdiv3(x, y) checkdiv3(^x, y) checkdiv3(x, ^y) checkdiv3(^x, ^y) } var ntest int64 = 0 func checkdiv3(x, y uint64) { ntest++ if ntest&(ntest-1) == 0 && long { println(ntest, "...") } checkuint64(x, y) if (uint64(uint32(x)) == x \|\| uint64(uint32(^x)) == ^x) && (uint64(uint32(y)) == y \|\| uint64(uint32(^y)) == ^y) { checkuint32(uint32(x), uint32(y)) } if (uint64(uint16(x)) == x \|\| uint64(uint16(^x)) == ^x) && (uint64(uint16(y)) == y \|\| uint64(uint16(^y)) == ^y) { checkuint16(uint16(x), uint16(y)) } if (uint64(uint8(x)) == x \|\| uint64(uint8(^x)) == ^x) && (uint64(uint8(y)) == y \|\| uint64(uint8(^y)) == ^y) { checkuint8(uint8(x), uint8(y)) } sx := int64(x) sy := int64(y) checkint64(sx, sy) if (int64(int32(sx)) == sx \|\| int64(int32(^sx)) == ^sx) && (int64(int32(sy)) == sy \|\| int64(int32(^sy)) == ^sy) { checkint32(int32(sx), int32(sy)) } if (int64(int16(sx)) == sx \|\| int64(int16(^sx)) == ^sx) && (int64(int16(sy)) == sy \|\| int64(int16(^sy)) == ^sy) { checkint16(int16(sx), int16(sy)) } if (int64(int8(sx)) == sx \|\| int64(int8(^sx)) == ^sx) && (int64(int8(sy)) == sy \|\| int64(int8(^sy)) == ^sy) { checkint8(int8(sx), int8(sy)) } } // Check result of x/y, x%y for various types. func checkuint(x, y uint) { if y == 0 { divzerouint(x, y) modzerouint(x, y) return } q, r := udiv(uint64(x), uint64(y)) q1 := x/y r1 := x%y if q1 != uint(q) { print("uint(", x, "/", y, ") = ", q1, ", want ", q, "\n") } if r1 != uint(r) { print("uint(", x, "%", y, ") = ", r1, ", want ", r, "\n") } } func checkuint64(x, y uint64) { if y == 0 { divzerouint64(x, y) modzerouint64(x, y) return } q, r := udiv(x, y) q1 := x/y r1 := x%y if q1 != q { print("uint64(", x, "/", y, ") = ", q1, ", want ", q, "\n") } if r1 != r { print("uint64(", x, "%", y, ") = ", r1, ", want ", r, "\n") } } func checkuint32(x, y uint32) { if y == 0 { divzerouint32(x, y) modzerouint32(x, y) return } q, r := udiv(uint64(x), uint64(y)) q1 := x/y r1 := x%y if q1 != uint32(q) { print("uint32(", x, "/", y, ") = ", q1, ", want ", q, "\n") } if r1 != uint32(r) { print("uint32(", x, "%", y, ") = ", r1, ", want ", r, "\n") } } func checkuint16(x, y uint16) { if y == 0 { divzerouint16(x, y) modzerouint16(x, y) return } q, r := udiv(uint64(x), uint64(y)) q1 := x/y r1 := x%y if q1 != uint16(q) { print("uint16(", x, "/", y, ") = ", q1, ", want ", q, "\n") } if r1 != uint16(r) { print("uint16(", x, "%", y, ") = ", r1, ", want ", r, "\n") } } func checkuint8(x, y uint8) { if y == 0 { divzerouint8(x, y) modzerouint8(x, y) return } q, r := udiv(uint64(x), uint64(y)) q1 := x/y r1 := x%y if q1 != uint8(q) { print("uint8(", x, "/", y, ") = ", q1, ", want ", q, "\n") } if r1 != uint8(r) { print("uint8(", x, "%", y, ") = ", r1, ", want ", r, "\n") } } func checkint(x, y int) { if y == 0 { divzeroint(x, y) modzeroint(x, y) return } q, r := idiv(int64(x), int64(y)) q1 := x/y r1 := x%y if q1 != int(q) { print("int(", x, "/", y, ") = ", q1, ", want ", q, "\n") } if r1 != int(r) { print("int(", x, "%", y, ") = ", r1, ", want ", r, "\n") } } func checkint64(x, y int64) { if y == 0 { divzeroint64(x, y) modzeroint64(x, y) return } q, r := idiv(x, y) q1 := x/y r1 := x%y if q1 != q { print("int64(", x, "/", y, ") = ", q1, ", want ", q, "\n") } if r1 != r { print("int64(", x, "%", y, ") = ", r1, ", want ", r, "\n") } } func checkint32(x, y int32) { if y == 0 { divzeroint32(x, y) modzeroint32(x, y) return } q, r := idiv(int64(x), int64(y)) q1 := x/y r1 := x%y if q1 != int32(q) { print("int32(", x, "/", y, ") = ", q1, ", want ", q, "\n") } if r1 != int32(r) { print("int32(", x, "%", y, ") = ", r1, ", want ", r, "\n") } } func checkint16(x, y int16) { if y == 0 { divzeroint16(x, y) modzeroint16(x, y) return } q, r := idiv(int64(x), int64(y)) q1 := x/y r1 := x%y if q1 != int16(q) { print("int16(", x, "/", y, ") = ", q1, ", want ", q, "\n") } if r1 != int16(r) { print("int16(", x, "%", y, ") = ", r1, ", want ", r, "\n") } } func checkint8(x, y int8) { if y == 0 { divzeroint8(x, y) modzeroint8(x, y) return } q, r := idiv(int64(x), int64(y)) q1 := x/y r1 := x%y if q1 != int8(q) { print("int8(", x, "/", y, ") = ", q1, ", want ", q, "\n") } if r1 != int8(r) { print("int8(", x, "%", y, ") = ", r1, ", want ", r, "\n") } } func divzerouint(x, y uint) uint { defer checkudivzero("uint", uint64(x)) return x / y } func divzerouint64(x, y uint64) uint64 { defer checkudivzero("uint64", uint64(x)) return x / y } func divzerouint32(x, y uint32) uint32 { defer checkudivzero("uint32", uint64(x)) return x / y } func divzerouint16(x, y uint16) uint16 { defer checkudivzero("uint16", uint64(x)) return x / y } func divzerouint8(x, y uint8) uint8 { defer checkudivzero("uint8", uint64(x)) return x / y } func checkudivzero(typ string, x uint64) { if recover() == nil { print(typ, "(", x, " / 0) did not panic") } } func divzeroint(x, y int) int { defer checkdivzero("int", int64(x)) return x / y } func divzeroint64(x, y int64) int64 { defer checkdivzero("int64", int64(x)) return x / y } func divzeroint32(x, y int32) int32 { defer checkdivzero("int32", int64(x)) return x / y } func divzeroint16(x, y int16) int16 { defer checkdivzero("int16", int64(x)) return x / y } func divzeroint8(x, y int8) int8 { defer checkdivzero("int8", int64(x)) return x / y } func checkdivzero(typ string, x int64) { if recover() == nil { print(typ, "(", x, " / 0) did not panic") } } func modzerouint(x, y uint) uint { defer checkumodzero("uint", uint64(x)) return x % y } func modzerouint64(x, y uint64) uint64 { defer checkumodzero("uint64", uint64(x)) return x % y } func modzerouint32(x, y uint32) uint32 { defer checkumodzero("uint32", uint64(x)) return x % y } func modzerouint16(x, y uint16) uint16 { defer checkumodzero("uint16", uint64(x)) return x % y } func modzerouint8(x, y uint8) uint8 { defer checkumodzero("uint8", uint64(x)) return x % y } func checkumodzero(typ string, x uint64) { if recover() == nil { print(typ, "(", x, " % 0) did not panic") } } func modzeroint(x, y int) int { defer checkmodzero("int", int64(x)) return x % y } func modzeroint64(x, y int64) int64 { defer checkmodzero("int64", int64(x)) return x % y } func modzeroint32(x, y int32) int32 { defer checkmodzero("int32", int64(x)) return x % y } func modzeroint16(x, y int16) int16 { defer checkmodzero("int16", int64(x)) return x % y } func modzeroint8(x, y int8) int8 { defer checkmodzero("int8", int64(x)) return x % y } func checkmodzero(typ string, x int64) { if recover() == nil { print(typ, "(", x, " % 0) did not panic") } } // unsigned divide and mod using shift and subtract. func udiv(x, y uint64) (q, r uint64) { sh := 0 for y+y > y && y+y <= x { sh++ y <<= 1 } for ; sh >= 0; sh-- { q <<= 1 if x >= y { x -= y q \|= 1 } y >>= 1 } return q, x } // signed divide and mod: do unsigned and adjust signs. func idiv(x, y int64) (q, r int64) { // special case for minint / -1 = minint if x-1 > x && y == -1 { return x, 0 } ux := uint64(x) uy := uint64(y) if x < 0 { ux = -ux } if y < 0 { uy = -uy } uq, ur := udiv(ux, uy) q = int64(uq) r = int64(ur) if x < 0 { r = -r } if (x < 0) != (y < 0) { q = -q } return q, r }	9.28 KB	2024-02-02 18:09
📁 dwarf	-	2024-02-02 18:09
📄 embedfunc.go // errorcheck // Copyright 2021 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 p import _ "embed" func f() { //go:embed x.txt // ERROR "go:embed cannot apply to var inside func" var x string _ = x }	308 B	2024-02-02 18:09
📄 embedvers.go // errorcheck -lang=go1.15 // Copyright 2021 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 p import _ "embed" //go:embed x.txt // ERROR "go:embed requires go1.16 or later" var x string	292 B	2024-02-02 18:09
📄 empty.go // compile // Copyright 2009 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 that top-level parenthesized declarations can be empty. // Compiles but does not run. package P import ( ) const ( ) var ( ) type ( )	316 B	2024-02-02 18:09
📄 env.go // run // Copyright 2009 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 that environment variables are accessible through // package os. package main import ( "os" "runtime" ) func main() { ga := os.Getenv("PATH") if runtime.GOOS == "plan9" { ga = os.Getenv("path") } if ga == "" { print("PATH is empty\n") os.Exit(1) } xxx := os.Getenv("DOES_NOT_EXIST") if xxx != "" { print("$DOES_NOT_EXIST=", xxx, "\n") os.Exit(1) } }	549 B	2024-02-02 18:09
📄 eof.go // compile // Copyright 2010 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 a source file does not need a final newline. // Compiles but does not run. // No newline at the end of this file. package main	308 B	2024-02-02 18:09
📄 eof1.go // compile // Copyright 2010 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 that a comment ending a source file does not need a final newline. // Compiles but does not run. package eof1 // No newline at the end of this comment.	333 B	2024-02-02 18:09
📄 escape.go // run // Copyright 2009 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 // Test for correct heap-moving of escaped variables. // It is hard to check for the allocations, but it is easy // to check that if you call the function twice at the // same stack level, the pointers returned should be // different. var bad = false var allptr = make([]int, 0, 100) func noalias(p, q int, s string) { n := len(allptr) p = -(n + 1) q = -(n + 2) allptr = allptr[0 : n+2] allptr[n] = p allptr[n+1] = q n += 2 for i := 0; i < n; i++ { if allptr[i] != nil && allptr[i] != -(i+1) { println("aliased pointers", -(i + 1), allptr[i], "after", s) allptr[i] = nil bad = true } } } func val(p, q int, v int, s string) { if p != v { println("wrong value want", v, "got", p, "after", s) bad = true } if q != v+1 { println("wrong value want", v+1, "got", q, "after", s) bad = true } } func chk(p, q int, v int, s string) { val(p, q, v, s) noalias(p, q, s) } func chkalias(p, q int, v int, s string) { if p != q { println("want aliased pointers but got different after", s) bad = true } if q != v+1 { println("wrong value want", v+1, "got", q, "after", s) bad = true } } func i_escapes(x int) int { var i int i = x return &i } func j_escapes(x int) int { var j int = x j = x return &j } func k_escapes(x int) int { k := x return &k } func in_escapes(x int) int { return &x } func send(c chan int, x int) { c <- x } func select_escapes(x int) int { c := make(chan int) go send(c, x) select { case req := <-c: return &req } return nil } func select_escapes1(x int, y int) (int, int) { c := make(chan int) var a [2]int var p [2]int a[0] = x a[1] = y for i := 0; i < 2; i++ { go send(c, a[i]) select { case req := <-c: p[i] = &req } } return p[0], p[1] } func range_escapes(x int) int { var a [1]int a[0] = x for _, v := range a { return &v } return nil } // is aliased func range_escapes2(x, y int) (int, int) { var a [2]int var p [2]int a[0] = x a[1] = y var k, v int for k, v = range a { p[k] = &v } return p[0], p[1] } // is* aliased func for_escapes2(x int, y int) (int, int) { var p [2]int n := 0 i := x for ; n < 2; i = y { p[n] = &i n++ } return p[0], p[1] } func for_escapes3(x int, y int) (int, int) { var f [2]func() int n := 0 for i := x; n < 2; i = y { p := new(int) p = i f[n] = func() int { return p } n++ } return f[0](), f[1]() } func out_escapes(i int) (x int, p int) { x = i p = &x // ERROR "address of out parameter" return } func out_escapes_2(i int) (x int, p int) { x = i return x, &x // ERROR "address of out parameter" } func defer1(i int) (x int) { c := make(chan int) go func() { x = i; c <- 1 }() <-c return } func main() { p, q := i_escapes(1), i_escapes(2) chk(p, q, 1, "i_escapes") p, q = j_escapes(3), j_escapes(4) chk(p, q, 3, "j_escapes") p, q = k_escapes(5), k_escapes(6) chk(p, q, 5, "k_escapes") p, q = in_escapes(7), in_escapes(8) chk(p, q, 7, "in_escapes") p, q = select_escapes(9), select_escapes(10) chk(p, q, 9, "select_escapes") p, q = select_escapes1(11, 12) chk(p, q, 11, "select_escapes1") p, q = range_escapes(13), range_escapes(14) chk(p, q, 13, "range_escapes") p, q = range_escapes2(101, 102) chkalias(p, q, 101, "range_escapes2") p, q = for_escapes2(103, 104) chkalias(p, q, 103, "for_escapes2") p, q = for_escapes3(105, 106) chk(p, q, 105, "for_escapes3") _, p = out_escapes(15) _, q = out_escapes(16) chk(p, q, 15, "out_escapes") _, p = out_escapes_2(17) _, q = out_escapes_2(18) chk(p, q, 17, "out_escapes_2") x := defer1(20) if x != 20 { println("defer failed", x) bad = true } if bad { panic("BUG: no escape") } }	3.8 KB	2024-02-02 18:09
📄 escape2.go // errorcheck -0 -m -l // Copyright 2010 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, using compiler diagnostic flags, that the escape analysis is working. // Compiles but does not run. Inlining is disabled. // escape2n.go contains all the same tests but compiles with -N. package foo import ( "fmt" "unsafe" ) var gxx int func foo1(x int) { // ERROR "moved to heap: x$" gxx = &x } func foo2(yy int) { // ERROR "leaking param: yy$" gxx = yy } func foo3(x int) int { // ERROR "moved to heap: x$" return &x } type T T func foo3b(t T) { // ERROR "leaking param: t$" t = t } // xx isn't going anywhere, so use of yy is ok func foo4(xx, yy int) { // ERROR "xx does not escape$" "yy does not escape$" xx = yy } // xx isn't going anywhere, so taking address of yy is ok func foo5(xx *int, yy int) { // ERROR "xx does not escape$" "yy does not escape$" xx = &yy } func foo6(xx *int, yy int) { // ERROR "xx does not escape$" "leaking param: yy$" xx = yy } func foo7(xx int, yy int) { // ERROR "xx does not escape$" "yy does not escape$" *xx = yy } func foo8(xx, yy int) int { // ERROR "xx does not escape$" "yy does not escape$" xx = yy return xx } func foo9(xx, yy int) int { // ERROR "leaking param: xx to result ~r0 level=0$" "leaking param: yy to result ~r0 level=0$" xx = yy return xx } func foo10(xx, yy int) { // ERROR "xx does not escape$" "yy does not escape$" xx = yy } func foo11() int { x, y := 0, 42 xx := &x yy := &y xx = yy return x } var xxx int func foo12(yyy int) { // ERROR "leaking param: yyy$" xxx = yyy } // Must treat yyy as leaking because yyy leaks, and the escape analysis // summaries in exported metadata do not distinguish these two cases. func foo13(yyy *int) { // ERROR "leaking param content: yyy$" xxx = yyy } func foo14(yyy int) { // ERROR "yyy does not escape$" xxx = yyy } func foo15(yy int) { // ERROR "moved to heap: yy$" xxx = &yy } func foo16(yy int) { // ERROR "leaking param: yy$" xxx = yy } func foo17(yy int) { // ERROR "yy does not escape$" xxx = yy } func foo18(y int) { // ERROR "moved to heap: y$" xxx = &y } func foo19(y int) { xxx = y } type Bar struct { i int ii int } func NewBar() Bar { return &Bar{42, nil} // ERROR "&Bar{...} escapes to heap$" } func NewBarp(x int) Bar { // ERROR "leaking param: x$" return &Bar{42, x} // ERROR "&Bar{...} escapes to heap$" } func NewBarp2(x int) Bar { // ERROR "x does not escape$" return &Bar{x, nil} // ERROR "&Bar{...} escapes to heap$" } func (b Bar) NoLeak() int { // ERROR "b does not escape$" return (b.ii) } func (b Bar) Leak() int { // ERROR "leaking param: b to result ~r0 level=0$" return &b.i } func (b Bar) AlsoNoLeak() int { // ERROR "leaking param: b to result ~r0 level=1$" return b.ii } func (b Bar) AlsoLeak() int { // ERROR "leaking param: b to result ~r0 level=0$" return b.ii } func (b Bar) LeaksToo() int { // ERROR "leaking param: b to result ~r0 level=0$" v := 0 // ERROR "moved to heap: v$" b.ii = &v return b.ii } func (b Bar) LeaksABit() int { // ERROR "leaking param: b to result ~r0 level=1$" v := 0 // ERROR "moved to heap: v$" b.ii = &v return b.ii } func (b Bar) StillNoLeak() int { // ERROR "b does not escape$" v := 0 b.ii = &v return b.i } func goLeak(b Bar) { // ERROR "leaking param: b$" go b.NoLeak() } type Bar2 struct { i [12]int ii []int } func NewBar2() Bar2 { return &Bar2{[12]int{42}, nil} // ERROR "&Bar2{...} escapes to heap$" } func (b Bar2) NoLeak() int { // ERROR "b does not escape$" return b.i[0] } func (b Bar2) Leak() []int { // ERROR "leaking param: b to result ~r0 level=0$" return b.i[:] } func (b Bar2) AlsoNoLeak() []int { // ERROR "leaking param: b to result ~r0 level=1$" return b.ii[0:1] } func (b Bar2) AgainNoLeak() [12]int { // ERROR "b does not escape$" return b.i } func (b Bar2) LeakSelf() { // ERROR "leaking param: b$" b.ii = b.i[0:4] } func (b Bar2) LeakSelf2() { // ERROR "leaking param: b$" var buf []int buf = b.i[0:] b.ii = buf } func foo21() func() int { x := 42 return func() int { // ERROR "func literal escapes to heap$" return x } } func foo21a() func() int { x := 42 // ERROR "moved to heap: x$" return func() int { // ERROR "func literal escapes to heap$" x++ return x } } func foo22() int { x := 42 return func() int { // ERROR "func literal does not escape$" return x }() } func foo23(x int) func() int { return func() int { // ERROR "func literal escapes to heap$" return x } } func foo23a(x int) func() int { f := func() int { // ERROR "func literal escapes to heap$" return x } return f } func foo23b(x int) (func() int) { f := func() int { return x } // ERROR "func literal escapes to heap$" "moved to heap: f$" return &f } func foo23c(x int) func() int { // ERROR "moved to heap: x$" return func() int { // ERROR "func literal escapes to heap$" x++ return x } } func foo24(x int) int { return func() int { // ERROR "func literal does not escape$" return x }() } var x int func fooleak(xx int) int { // ERROR "leaking param: xx$" x = xx return x } func foonoleak(xx int) int { // ERROR "xx does not escape$" return x + xx } func foo31(x int) int { // ERROR "moved to heap: x$" return fooleak(&x) } func foo32(x int) int { return foonoleak(&x) } type Foo struct { xx int x int } var F Foo var pf Foo func (f Foo) fooleak() { // ERROR "leaking param: f$" pf = f } func (f Foo) foonoleak() { // ERROR "f does not escape$" F.x = f.x } func (f Foo) Leak() { // ERROR "leaking param: f$" f.fooleak() } func (f Foo) NoLeak() { // ERROR "f does not escape$" f.foonoleak() } func foo41(x int) { // ERROR "moved to heap: x$" F.xx = &x } func (f Foo) foo42(x int) { // ERROR "f does not escape$" "moved to heap: x$" f.xx = &x } func foo43(f Foo, x int) { // ERROR "f does not escape$" "moved to heap: x$" f.xx = &x } func foo44(yy int) { // ERROR "leaking param: yy$" F.xx = yy } func (f Foo) foo45() { // ERROR "f does not escape$" F.x = f.x } // See foo13 above for explanation of why f leaks. func (f Foo) foo46() { // ERROR "leaking param content: f$" F.xx = f.xx } func (f Foo) foo47() { // ERROR "leaking param: f$" f.xx = &f.x } var ptrSlice []int func foo50(i int) { // ERROR "leaking param: i$" ptrSlice[0] = i } var ptrMap map[int]int func foo51(i int) { // ERROR "leaking param: i$" ptrMap[i] = i } func indaddr1(x int) int { // ERROR "moved to heap: x$" return &x } func indaddr2(x int) int { // ERROR "leaking param: x to result ~r0 level=0$" return &x } func indaddr3(x int32) int { // ERROR "leaking param: x to result ~r0 level=0$" return (*int)(unsafe.Pointer(&x)) } // From package math: func Float32bits(f float32) uint32 { return (uint32)(unsafe.Pointer(&f)) } func Float32frombits(b uint32) float32 { return (float32)(unsafe.Pointer(&b)) } func Float64bits(f float64) uint64 { return (uint64)(unsafe.Pointer(&f)) } func Float64frombits(b uint64) float64 { return (float64)(unsafe.Pointer(&b)) } // contrast with func float64bitsptr(f float64) uint64 { // ERROR "moved to heap: f$" return (uint64)(unsafe.Pointer(&f)) } func float64ptrbitsptr(f float64) uint64 { // ERROR "leaking param: f to result ~r0 level=0$" return (uint64)(unsafe.Pointer(f)) } func typesw(i interface{}) int { // ERROR "leaking param: i to result ~r0 level=0$" switch val := i.(type) { case int: return val case int8: v := int(val) // ERROR "moved to heap: v$" return &v } return nil } func exprsw(i int) int { // ERROR "leaking param: i to result ~r0 level=0$" switch j := i; j + 110 { case 12: return j case 42: return nil } return nil } // assigning to an array element is like assigning to the array func foo60(i int) int { // ERROR "leaking param: i to result ~r0 level=0$" var a [12]int a[0] = i return a[1] } func foo60a(i int) int { // ERROR "i does not escape$" var a [12]int a[0] = i return nil } // assigning to a struct field is like assigning to the struct func foo61(i int) int { // ERROR "leaking param: i to result ~r0 level=0$" type S struct { a, b int } var s S s.a = i return s.b } func foo61a(i int) int { // ERROR "i does not escape$" type S struct { a, b int } var s S s.a = i return nil } // assigning to a struct field is like assigning to the struct but // here this subtlety is lost, since s.a counts as an assignment to a // track-losing dereference. func foo62(i int) int { // ERROR "leaking param: i$" type S struct { a, b int } s := new(S) // ERROR "new$S$ does not escape$" s.a = i return nil // s.b } type M interface { M() } func foo63(m M) { // ERROR "m does not escape$" } func foo64(m M) { // ERROR "leaking param: m$" m.M() } func foo64b(m M) { // ERROR "leaking param: m$" defer m.M() } type MV int func (MV) M() {} func foo65() { var mv MV foo63(&mv) } func foo66() { var mv MV // ERROR "moved to heap: mv$" foo64(&mv) } func foo67() { var mv MV foo63(mv) // ERROR "mv does not escape$" } func foo68() { var mv MV // escapes but it's an int so irrelevant foo64(mv) // ERROR "mv escapes to heap$" } func foo69(m M) { // ERROR "leaking param: m$" foo64(m) } func foo70(mv1 MV, m M) { // ERROR "leaking param: m$" "leaking param: mv1$" m = mv1 foo64(m) } func foo71(x int) []int { // ERROR "leaking param: x$" var y []int y = append(y, x) return y } func foo71a(x int) []int { // ERROR "moved to heap: x$" var y []int y = append(y, &x) return y } func foo72() { var x int var y [1]int y[0] = &x } func foo72aa() [10]int { var x int // ERROR "moved to heap: x$" var y [10]int y[0] = &x return y } func foo72a() { var y [10]int for i := 0; i < 10; i++ { // escapes its scope x := i // ERROR "moved to heap: x$" y[i] = &x } return } func foo72b() [10]int { var y [10]int for i := 0; i < 10; i++ { x := i // ERROR "moved to heap: x$" y[i] = &x } return y } // issue 2145 func foo73() { s := []int{3, 2, 1} // ERROR "\[\]int{...} does not escape$" for _, v := range s { vv := v // actually just escapes its scope defer func() { // ERROR "func literal escapes to heap$" println(vv) }() } } func foo731() { s := []int{3, 2, 1} // ERROR "\[\]int{...} does not escape$" for _, v := range s { vv := v // ERROR "moved to heap: vv$" // actually just escapes its scope defer func() { // ERROR "func literal escapes to heap$" vv = 42 println(vv) }() } } func foo74() { s := []int{3, 2, 1} // ERROR "\[\]int{...} does not escape$" for _, v := range s { vv := v // actually just escapes its scope fn := func() { // ERROR "func literal escapes to heap$" println(vv) } defer fn() } } func foo74a() { s := []int{3, 2, 1} // ERROR "\[\]int{...} does not escape$" for _, v := range s { vv := v // ERROR "moved to heap: vv$" // actually just escapes its scope fn := func() { // ERROR "func literal escapes to heap$" vv += 1 println(vv) } defer fn() } } // issue 3975 func foo74b() { var array [3]func() s := []int{3, 2, 1} // ERROR "\[\]int{...} does not escape$" for i, v := range s { vv := v // actually just escapes its scope array[i] = func() { // ERROR "func literal escapes to heap$" println(vv) } } } func foo74c() { var array [3]func() s := []int{3, 2, 1} // ERROR "\[\]int{...} does not escape$" for i, v := range s { vv := v // ERROR "moved to heap: vv$" // actually just escapes its scope array[i] = func() { // ERROR "func literal escapes to heap$" println(&vv) } } } func myprint(y int, x ...interface{}) int { // ERROR "leaking param: y to result ~r0 level=0$" "x does not escape$" return y } func myprint1(y int, x ...interface{}) interface{} { // ERROR "leaking param: x to result ~r0 level=0$" "y does not escape$" return &x[0] } func foo75(z int) { // ERROR "z does not escape$" myprint(z, 1, 2, 3) // ERROR "1 does not escape" "2 does not escape" "3 does not escape" "... argument does not escape$" } func foo75a(z int) { // ERROR "z does not escape$" myprint1(z, 1, 2, 3) // ERROR "1 does not escape" "2 does not escape" "3 does not escape" "... argument does not escape$" } func foo75esc(z int) { // ERROR "leaking param: z$" gxx = myprint(z, 1, 2, 3) // ERROR "1 does not escape" "2 does not escape" "3 does not escape" "... argument does not escape$" } func foo75aesc(z int) { // ERROR "z does not escape$" var ppi *interface{} // assignments to pointer dereferences lose track ppi = myprint1(z, 1, 2, 3) // ERROR "... argument escapes to heap$" "1 escapes to heap$" "2 escapes to heap$" "3 escapes to heap$" } func foo75aesc1(z int) { // ERROR "z does not escape$" sink = myprint1(z, 1, 2, 3) // ERROR "... argument escapes to heap$" "1 escapes to heap$" "2 escapes to heap$" "3 escapes to heap$" } func foo76(z int) { // ERROR "z does not escape" myprint(nil, z) // ERROR "... argument does not escape$" } func foo76a(z int) { // ERROR "z does not escape" myprint1(nil, z) // ERROR "... argument does not escape$" } func foo76b() { myprint(nil, 1, 2, 3) // ERROR "1 does not escape" "2 does not escape" "3 does not escape" "... argument does not escape$" } func foo76c() { myprint1(nil, 1, 2, 3) // ERROR "1 does not escape" "2 does not escape" "3 does not escape" "... argument does not escape$" } func foo76d() { defer myprint(nil, 1, 2, 3) // ERROR "1 does not escape" "2 does not escape" "3 does not escape" "... argument does not escape$" } func foo76e() { defer myprint1(nil, 1, 2, 3) // ERROR "1 does not escape" "2 does not escape" "3 does not escape" "... argument does not escape$" } func foo76f() { for { // TODO: This one really only escapes its scope, but we don't distinguish yet. defer myprint(nil, 1, 2, 3) // ERROR "... argument does not escape$" "1 escapes to heap$" "2 escapes to heap$" "3 escapes to heap$" } } func foo76g() { for { defer myprint1(nil, 1, 2, 3) // ERROR "... argument does not escape$" "1 escapes to heap$" "2 escapes to heap$" "3 escapes to heap$" } } func foo77(z []interface{}) { // ERROR "z does not escape$" myprint(nil, z...) // z does not escape } func foo77a(z []interface{}) { // ERROR "z does not escape$" myprint1(nil, z...) } func foo77b(z []interface{}) { // ERROR "leaking param: z$" var ppi interface{} ppi = myprint1(nil, z...) } func foo77c(z []interface{}) { // ERROR "leaking param: z$" sink = myprint1(nil, z...) } func dotdotdot() { i := 0 myprint(nil, &i) // ERROR "... argument does not escape$" j := 0 myprint1(nil, &j) // ERROR "... argument does not escape$" } func foo78(z int) int { // ERROR "moved to heap: z$" return &z } func foo78a(z int) int { // ERROR "moved to heap: z$" y := &z x := &y return x // really return y } func foo79() int { return new(int) // ERROR "new$int$ escapes to heap$" } func foo80() int { var z int for { // Really just escapes its scope but we don't distinguish z = new(int) // ERROR "new$int$ escapes to heap$" } _ = z return nil } func foo81() int { for { z := new(int) // ERROR "new$int$ does not escape$" _ = z } return nil } func tee(p int) (x, y int) { return p, p } // ERROR "leaking param: p to result x level=0$" "leaking param: p to result y level=0$" func noop(x, y int) {} // ERROR "x does not escape$" "y does not escape$" func foo82() { var x, y, z int // ERROR "moved to heap: x$" "moved to heap: y$" "moved to heap: z$" go noop(tee(&z)) go noop(&x, &y) for { var u, v, w int // ERROR "moved to heap: u$" "moved to heap: v$" "moved to heap: w$" defer noop(tee(&u)) defer noop(&v, &w) } } type Fooer interface { Foo() } type LimitedFooer struct { Fooer N int64 } func LimitFooer(r Fooer, n int64) Fooer { // ERROR "leaking param: r$" return &LimitedFooer{r, n} // ERROR "&LimitedFooer{...} escapes to heap$" } func foo90(x int) map[int]int { // ERROR "leaking param: x$" return map[int]int{nil: x} // ERROR "map\[\int\]\int{...} escapes to heap$" } func foo91(x int) map[int]int { // ERROR "leaking param: x$" return map[int]int{x: nil} // ERROR "map\[\int\]\int{...} escapes to heap$" } func foo92(x int) [2]int { // ERROR "leaking param: x to result ~r0 level=0$" return [2]int{x, nil} } // does not leak c func foo93(c chan int) int { // ERROR "c does not escape$" for v := range c { return v } return nil } // does not leak m func foo94(m map[int]int, b bool) int { // ERROR "leaking param: m to result ~r0 level=1" for k, v := range m { if b { return k } return v } return nil } // does leak x func foo95(m map[int]int, x int) { // ERROR "m does not escape$" "leaking param: x$" m[x] = x } // does not leak m but does leak content func foo96(m []int) int { // ERROR "leaking param: m to result ~r0 level=1" return m[0] } // does leak m func foo97(m [1]int) int { // ERROR "leaking param: m to result ~r0 level=0$" return m[0] } // does not leak m func foo98(m map[int]int) int { // ERROR "m does not escape$" return m[0] } // does leak m func foo99(m [1]int) []int { // ERROR "leaking param: m to result ~r0 level=0$" return m[:] } // does not leak m func foo100(m []int) int { // ERROR "leaking param: m to result ~r0 level=1" for _, v := range m { return v } return nil } // does leak m func foo101(m [1]int) int { // ERROR "leaking param: m to result ~r0 level=0$" for _, v := range m { return v } return nil } // does not leak m func foo101a(m [1]int) int { // ERROR "m does not escape$" for i := range m { // ERROR "moved to heap: i$" return &i } return nil } // does leak x func foo102(m []int, x int) { // ERROR "m does not escape$" "leaking param: x$" m[0] = x } // does not leak x func foo103(m [1]int, x int) { // ERROR "m does not escape$" "x does not escape$" m[0] = x } var y []int // does not leak x but does leak content func foo104(x []int) { // ERROR "leaking param content: x" copy(y, x) } // does not leak x but does leak content func foo105(x []int) { // ERROR "leaking param content: x" _ = append(y, x...) } // does leak x func foo106(x int) { // ERROR "leaking param: x$" _ = append(y, x) } func foo107(x int) map[int]int { // ERROR "leaking param: x$" return map[int]int{x: nil} // ERROR "map\[\int\]\int{...} escapes to heap$" } func foo108(x int) map[int]int { // ERROR "leaking param: x$" return map[int]int{nil: x} // ERROR "map\[\int\]\int{...} escapes to heap$" } func foo109(x int) int { // ERROR "leaking param: x$" m := map[int]int{x: nil} // ERROR "map\[\int\]\int{...} does not escape$" for k, _ := range m { return k } return nil } func foo110(x int) int { // ERROR "leaking param: x$" m := map[int]int{nil: x} // ERROR "map\[\int\]\int{...} does not escape$" return m[nil] } func foo111(x int) int { // ERROR "leaking param: x to result ~r0 level=0" m := []int{x} // ERROR "\[\]\int{...} does not escape$" return m[0] } func foo112(x int) int { // ERROR "leaking param: x to result ~r0 level=0$" m := [1]int{x} return m[0] } func foo113(x int) int { // ERROR "leaking param: x to result ~r0 level=0$" m := Bar{ii: x} return m.ii } func foo114(x int) int { // ERROR "leaking param: x to result ~r0 level=0$" m := &Bar{ii: x} // ERROR "&Bar{...} does not escape$" return m.ii } func foo115(x int) int { // ERROR "leaking param: x to result ~r0 level=0$" return (int)(unsafe.Pointer(uintptr(unsafe.Pointer(x)) + 1)) } func foo116(b bool) int { if b { x := 1 // ERROR "moved to heap: x$" return &x } else { y := 1 // ERROR "moved to heap: y$" return &y } return nil } func foo117(unknown func(interface{})) { // ERROR "unknown does not escape$" x := 1 // ERROR "moved to heap: x$" unknown(&x) } func foo118(unknown func(int)) { // ERROR "unknown does not escape$" x := 1 // ERROR "moved to heap: x$" unknown(&x) } func external(int) func foo119(x int) { // ERROR "leaking param: x$" external(x) } func foo120() { // formerly exponential time analysis L1: L2: L3: L4: L5: L6: L7: L8: L9: L10: L11: L12: L13: L14: L15: L16: L17: L18: L19: L20: L21: L22: L23: L24: L25: L26: L27: L28: L29: L30: L31: L32: L33: L34: L35: L36: L37: L38: L39: L40: L41: L42: L43: L44: L45: L46: L47: L48: L49: L50: L51: L52: L53: L54: L55: L56: L57: L58: L59: L60: L61: L62: L63: L64: L65: L66: L67: L68: L69: L70: L71: L72: L73: L74: L75: L76: L77: L78: L79: L80: L81: L82: L83: L84: L85: L86: L87: L88: L89: L90: L91: L92: L93: L94: L95: L96: L97: L98: L99: L100: // use the labels to silence compiler errors goto L1 goto L2 goto L3 goto L4 goto L5 goto L6 goto L7 goto L8 goto L9 goto L10 goto L11 goto L12 goto L13 goto L14 goto L15 goto L16 goto L17 goto L18 goto L19 goto L20 goto L21 goto L22 goto L23 goto L24 goto L25 goto L26 goto L27 goto L28 goto L29 goto L30 goto L31 goto L32 goto L33 goto L34 goto L35 goto L36 goto L37 goto L38 goto L39 goto L40 goto L41 goto L42 goto L43 goto L44 goto L45 goto L46 goto L47 goto L48 goto L49 goto L50 goto L51 goto L52 goto L53 goto L54 goto L55 goto L56 goto L57 goto L58 goto L59 goto L60 goto L61 goto L62 goto L63 goto L64 goto L65 goto L66 goto L67 goto L68 goto L69 goto L70 goto L71 goto L72 goto L73 goto L74 goto L75 goto L76 goto L77 goto L78 goto L79 goto L80 goto L81 goto L82 goto L83 goto L84 goto L85 goto L86 goto L87 goto L88 goto L89 goto L90 goto L91 goto L92 goto L93 goto L94 goto L95 goto L96 goto L97 goto L98 goto L99 goto L100 } func foo121() { for i := 0; i < 10; i++ { defer myprint(nil, i) // ERROR "... argument does not escape$" "i escapes to heap$" go myprint(nil, i) // ERROR "... argument does not escape$" "i escapes to heap$" } } // same as foo121 but check across import func foo121b() { for i := 0; i < 10; i++ { defer fmt.Printf("%d", i) // ERROR "... argument does not escape$" "i escapes to heap$" go fmt.Printf("%d", i) // ERROR "... argument does not escape$" "i escapes to heap$" } } // a harmless forward jump func foo122() { var i int goto L1 L1: i = new(int) // ERROR "new$int$ does not escape$" _ = i } // a backward jump, increases loopdepth func foo123() { var i int L1: i = new(int) // ERROR "new$int$ escapes to heap$" goto L1 _ = i } func foo124(x *int) { // ERROR "x does not escape$" var i int // ERROR "moved to heap: i$" p := &i func() { // ERROR "func literal does not escape$" x = p }() } func foo125(ch chan int) { // ERROR "ch does not escape$" var i int // ERROR "moved to heap: i$" p := &i func() { // ERROR "func literal does not escape$" ch <- p }() } func foo126() { var px int // loopdepth 0 for { // loopdepth 1 var i int // ERROR "moved to heap: i$" func() { // ERROR "func literal does not escape$" px = &i }() } _ = px } var px int func foo127() { var i int // ERROR "moved to heap: i$" p := &i q := p px = q } func foo128() { var i int p := &i q := p _ = q } func foo129() { var i int // ERROR "moved to heap: i$" p := &i func() { // ERROR "func literal does not escape$" q := p func() { // ERROR "func literal does not escape$" r := q px = r }() }() } func foo130() { for { var i int // ERROR "moved to heap: i$" func() { // ERROR "func literal does not escape$" px = &i }() } } func foo131() { var i int // ERROR "moved to heap: i$" func() { // ERROR "func literal does not escape$" px = &i }() } func foo132() { var i int // ERROR "moved to heap: i$" go func() { // ERROR "func literal escapes to heap$" px = &i }() } func foo133() { var i int // ERROR "moved to heap: i$" defer func() { // ERROR "func literal does not escape$" px = &i }() } func foo134() { var i int p := &i func() { // ERROR "func literal does not escape$" q := p func() { // ERROR "func literal does not escape$" r := q _ = r }() }() } func foo135() { var i int // ERROR "moved to heap: i$" p := &i go func() { // ERROR "func literal escapes to heap$" q := p func() { // ERROR "func literal does not escape$" r := q _ = r }() }() } func foo136() { var i int // ERROR "moved to heap: i$" p := &i go func() { // ERROR "func literal escapes to heap$" q := p func() { // ERROR "func literal does not escape$" r := q px = r }() }() } func foo137() { var i int // ERROR "moved to heap: i$" p := &i func() { // ERROR "func literal does not escape$" q := p go func() { // ERROR "func literal escapes to heap$" r := q _ = r }() }() } func foo138() byte { type T struct { x [1]byte } t := new(T) // ERROR "new$T$ escapes to heap$" return &t.x[0] } func foo139() byte { type T struct { x struct { y byte } } t := new(T) // ERROR "new$T$ escapes to heap$" return &t.x.y } // issue 4751 func foo140() interface{} { type T struct { X string } type U struct { X string T T } t := &T{} // ERROR "&T{} escapes to heap$" return U{ // ERROR "U{...} escapes to heap$" X: t.X, T: t, } } //go:noescape func F1([]byte) func F2([]byte) //go:noescape func F3(x []byte) // ERROR "x does not escape$" func F4(x []byte) // ERROR "leaking param: x$" func G() { var buf1 [10]byte F1(buf1[:]) var buf2 [10]byte // ERROR "moved to heap: buf2$" F2(buf2[:]) var buf3 [10]byte F3(buf3[:]) var buf4 [10]byte // ERROR "moved to heap: buf4$" F4(buf4[:]) } type Tm struct { x int } func (t Tm) M() { // ERROR "t does not escape$" } func foo141() { var f func() t := new(Tm) // ERROR "new$Tm$ does not escape$" f = t.M // ERROR "t.M does not escape$" _ = f } var gf func() func foo142() { t := new(Tm) // ERROR "new$Tm$ escapes to heap$" gf = t.M // ERROR "t.M escapes to heap$" } // issue 3888. func foo143() { for i := 0; i < 1000; i++ { func() { // ERROR "func literal does not escape$" for i := 0; i < 1; i++ { var t Tm t.M() } }() } } // issue 5773 // Check that annotations take effect regardless of whether they // are before or after the use in the source code. //go:noescape func foo144a(int) func foo144() { var x int foo144a(&x) var y int foo144b(&y) } //go:noescape func foo144b(int) // issue 7313: for loop init should not be treated as "in loop" type List struct { Next List } func foo145(l List) { // ERROR "l does not escape$" var p List for p = &l; p.Next != nil; p = p.Next { } } func foo146(l List) { // ERROR "l does not escape$" var p List p = &l for ; p.Next != nil; p = p.Next { } } func foo147(l List) { // ERROR "l does not escape$" var p List p = &l for p.Next != nil { p = p.Next } } func foo148(l List) { // ERROR "l does not escape$" for p := &l; p.Next != nil; p = p.Next { } } // related: address of variable should have depth of variable, not of loop func foo149(l List) { // ERROR "l does not escape$" var p List for { for p = &l; p.Next != nil; p = p.Next { } } } // issue 7934: missed ... if element type had no pointers var save150 []byte func foo150(x ...byte) { // ERROR "leaking param: x$" save150 = x } func bar150() { foo150(1, 2, 3) // ERROR "... argument escapes to heap$" } // issue 7931: bad handling of slice of array var save151 int func foo151(x int) { // ERROR "leaking param: x$" save151 = x } func bar151() { var a [64]int // ERROR "moved to heap: a$" a[4] = 101 foo151(&(&a)[4:8][0]) } func bar151b() { var a [10]int // ERROR "moved to heap: a$" b := a[:] foo151(&b[4:8][0]) } func bar151c() { var a [64]int // ERROR "moved to heap: a$" a[4] = 101 foo151(&(&a)[4:8:8][0]) } func bar151d() { var a [10]int // ERROR "moved to heap: a$" b := a[:] foo151(&b[4:8:8][0]) } // issue 8120 type U struct { s string } func (u U) String() string { // ERROR "leaking param: u to result ~r0 level=1$" return u.s } type V struct { s string } func NewV(u U) V { // ERROR "leaking param: u$" return &V{u.String()} // ERROR "&V{...} escapes to heap$" } func foo152() { a := "a" // ERROR "moved to heap: a$" u := U{&a} v := NewV(u) println(v) } // issue 8176 - &x in type switch body not marked as escaping func foo153(v interface{}) int { // ERROR "v does not escape" switch x := v.(type) { case int: // ERROR "moved to heap: x$" return &x } panic(0) // ERROR "0 escapes to heap" } // issue 8185 - &result escaping into result func f() (x int, y int) { // ERROR "moved to heap: x$" y = &x return } func g() (x interface{}) { // ERROR "moved to heap: x$" x = &x return } var sink interface{} type Lit struct { p int } func ptrlitNoescape() { // Both literal and element do not escape. i := 0 x := &Lit{&i} // ERROR "&Lit{...} does not escape$" _ = x } func ptrlitNoEscape2() { // Literal does not escape, but element does. i := 0 // ERROR "moved to heap: i$" x := &Lit{&i} // ERROR "&Lit{...} does not escape$" sink = x } func ptrlitEscape() { // Both literal and element escape. i := 0 // ERROR "moved to heap: i$" x := &Lit{&i} // ERROR "&Lit{...} escapes to heap$" sink = x } // self-assignments type Buffer struct { arr [64]byte arrPtr [64]byte buf1 []byte buf2 []byte str1 string str2 string } func (b Buffer) foo() { // ERROR "b does not escape$" b.buf1 = b.buf1[1:2] // ERROR "$\Buffer$.foo ignoring self-assignment in b.buf1 = b.buf1\[1:2\]$" b.buf1 = b.buf1[1:2:3] // ERROR "$\Buffer$.foo ignoring self-assignment in b.buf1 = b.buf1\[1:2:3\]$" b.buf1 = b.buf2[1:2] // ERROR "$\Buffer$.foo ignoring self-assignment in b.buf1 = b.buf2\[1:2\]$" b.buf1 = b.buf2[1:2:3] // ERROR "$\Buffer$.foo ignoring self-assignment in b.buf1 = b.buf2\[1:2:3\]$" } func (b Buffer) bar() { // ERROR "leaking param: b$" b.buf1 = b.arr[1:2] } func (b Buffer) arrayPtr() { // ERROR "b does not escape" b.buf1 = b.arrPtr[1:2] // ERROR "$\Buffer$.arrayPtr ignoring self-assignment in b.buf1 = b.arrPtr\[1:2\]$" b.buf1 = b.arrPtr[1:2:3] // ERROR "$\Buffer$.arrayPtr ignoring self-assignment in b.buf1 = b.arrPtr\[1:2:3\]$" } func (b Buffer) baz() { // ERROR "b does not escape$" b.str1 = b.str1[1:2] // ERROR "$\Buffer$.baz ignoring self-assignment in b.str1 = b.str1\[1:2\]$" b.str1 = b.str2[1:2] // ERROR "$\Buffer$.baz ignoring self-assignment in b.str1 = b.str2\[1:2\]$" } func (b Buffer) bat() { // ERROR "leaking param content: b$" o := new(Buffer) // ERROR "new$Buffer$ escapes to heap$" o.buf1 = b.buf1[1:2] sink = o } func quux(sp string, bp []byte) { // ERROR "bp does not escape$" "sp does not escape$" sp = (sp)[1:2] // ERROR "quux ignoring self-assignment in \sp = $\sp$\[1:2\]$" bp = (bp)[1:2] // ERROR "quux ignoring self-assignment in \bp = $\bp$\[1:2\]$" } type StructWithString struct { p int s string } // This is escape analysis false negative. // We assign the pointer to x.p but leak x.s. Escape analysis coarsens flows // to just x, and thus &i looks escaping. func fieldFlowTracking() { var x StructWithString i := 0 // ERROR "moved to heap: i$" x.p = &i sink = x.s // ERROR "x.s escapes to heap$" } // String operations. func slicebytetostring0() { b := make([]byte, 20) // ERROR "make$\[\]byte, 20$ does not escape$" s := string(b) // ERROR "string$b$ does not escape$" _ = s } func slicebytetostring1() { b := make([]byte, 20) // ERROR "make$\[\]byte, 20$ does not escape$" s := string(b) // ERROR "string$b$ does not escape$" s1 := s[0:1] _ = s1 } func slicebytetostring2() { b := make([]byte, 20) // ERROR "make$\[\]byte, 20$ does not escape$" s := string(b) // ERROR "string$b$ escapes to heap$" s1 := s[0:1] // ERROR "moved to heap: s1$" sink = &s1 } func slicebytetostring3() { b := make([]byte, 20) // ERROR "make$\[\]byte, 20$ does not escape$" s := string(b) // ERROR "string$b$ escapes to heap$" s1 := s[0:1] sink = s1 // ERROR "s1 escapes to heap$" } func addstr0() { s0 := "a" s1 := "b" s := s0 + s1 // ERROR "s0 \+ s1 does not escape$" _ = s } func addstr1() { s0 := "a" s1 := "b" s := "c" s += s0 + s1 // ERROR "s0 \+ s1 does not escape$" _ = s } func addstr2() { b := make([]byte, 20) // ERROR "make$\[\]byte, 20$ does not escape$" s0 := "a" s := string(b) + s0 // ERROR "string$b$ \+ s0 does not escape$" "string$b$ does not escape$" _ = s } func addstr3() { s0 := "a" s1 := "b" s := s0 + s1 // ERROR "s0 \+ s1 escapes to heap$" s2 := s[0:1] sink = s2 // ERROR "s2 escapes to heap$" } func intstring0() bool { // string does not escape x := '0' s := string(x) // ERROR "string$x$ does not escape$" return s == "0" } func intstring1() string { // string does not escape, but the buffer does x := '0' s := string(x) // ERROR "string$x$ escapes to heap$" return s } func intstring2() { // string escapes to heap x := '0' s := string(x) // ERROR "moved to heap: s$" "string$x$ escapes to heap$" sink = &s } func stringtoslicebyte0() { s := "foo" x := []byte(s) // ERROR "$\[\]byte$$s$ does not escape$" "zero-copy string->\[\]byte conversion" _ = x } func stringtoslicebyte1() []byte { s := "foo" return []byte(s) // ERROR "$\[\]byte$$s$ escapes to heap$" } func stringtoslicebyte2() { s := "foo" sink = []byte(s) // ERROR "$\[\]byte$$s$ escapes to heap$" } func stringtoslicerune0() { s := "foo" x := []rune(s) // ERROR "$\[\]rune$$s$ does not escape$" _ = x } func stringtoslicerune1() []rune { s := "foo" return []rune(s) // ERROR "$\[\]rune$$s$ escapes to heap$" } func stringtoslicerune2() { s := "foo" sink = []rune(s) // ERROR "$\[\]rune$$s$ escapes to heap$" } func slicerunetostring0() { r := []rune{1, 2, 3} // ERROR "\[\]rune{...} does not escape$" s := string(r) // ERROR "string$r$ does not escape$" _ = s } func slicerunetostring1() string { r := []rune{1, 2, 3} // ERROR "\[\]rune{...} does not escape$" return string(r) // ERROR "string$r$ escapes to heap$" } func slicerunetostring2() { r := []rune{1, 2, 3} // ERROR "\[\]rune{...} does not escape$" sink = string(r) // ERROR "string$r$ escapes to heap$" } func makemap0() { m := make(map[int]int) // ERROR "make$map\[int\]int$ does not escape$" m[0] = 0 m[1]++ delete(m, 1) sink = m[0] // ERROR "m\[0\] escapes to heap$" } func makemap1() map[int]int { return make(map[int]int) // ERROR "make$map\[int\]int$ escapes to heap$" } func makemap2() { m := make(map[int]int) // ERROR "make$map\[int\]int$ escapes to heap$" sink = m } func nonescapingEface(m map[interface{}]bool) bool { // ERROR "m does not escape$" return m["foo"] // ERROR ".foo. does not escape$" } func nonescapingIface(m map[M]bool) bool { // ERROR "m does not escape$" return m[MV(0)] // ERROR "MV$0$ does not escape$" } func issue10353() { x := new(int) // ERROR "new$int$ escapes to heap$" issue10353a(x)() } func issue10353a(x int) func() { // ERROR "leaking param: x$" return func() { // ERROR "func literal escapes to heap$" println(x) } } func issue10353b() { var f func() for { x := new(int) // ERROR "new$int$ escapes to heap$" f = func() { // ERROR "func literal escapes to heap$" println(x) } } _ = f } func issue11387(x int) func() int { f := func() int { return x } // ERROR "func literal escapes to heap" slice1 := []func() int{f} // ERROR "\[\]. does not escape" slice2 := make([]func() int, 1) // ERROR "make$.*$ does not escape" copy(slice2, slice1) return slice2[0] } func issue12397(x, y int) { // ERROR "moved to heap: y$" // x does not escape below, because all relevant code is dead. if false { gxx = &x } else { gxx = &y } if true { gxx = &y } else { gxx = &x } }	35.11 KB	2024-02-02 18:09
📄 escape2n.go // errorcheck -0 -N -m -l // Copyright 2010 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, using compiler diagnostic flags, that the escape analysis is working. // Compiles but does not run. Inlining is disabled. // Registerization is disabled too (-N), which should // have no effect on escape analysis. package foo import ( "fmt" "unsafe" ) var gxx int func foo1(x int) { // ERROR "moved to heap: x$" gxx = &x } func foo2(yy int) { // ERROR "leaking param: yy$" gxx = yy } func foo3(x int) int { // ERROR "moved to heap: x$" return &x } type T T func foo3b(t T) { // ERROR "leaking param: t$" t = t } // xx isn't going anywhere, so use of yy is ok func foo4(xx, yy int) { // ERROR "xx does not escape$" "yy does not escape$" xx = yy } // xx isn't going anywhere, so taking address of yy is ok func foo5(xx *int, yy int) { // ERROR "xx does not escape$" "yy does not escape$" xx = &yy } func foo6(xx *int, yy int) { // ERROR "xx does not escape$" "leaking param: yy$" xx = yy } func foo7(xx int, yy int) { // ERROR "xx does not escape$" "yy does not escape$" *xx = yy } func foo8(xx, yy int) int { // ERROR "xx does not escape$" "yy does not escape$" xx = yy return xx } func foo9(xx, yy int) int { // ERROR "leaking param: xx to result ~r0 level=0$" "leaking param: yy to result ~r0 level=0$" xx = yy return xx } func foo10(xx, yy int) { // ERROR "xx does not escape$" "yy does not escape$" xx = yy } func foo11() int { x, y := 0, 42 xx := &x yy := &y xx = yy return x } var xxx int func foo12(yyy int) { // ERROR "leaking param: yyy$" xxx = yyy } // Must treat yyy as leaking because yyy leaks, and the escape analysis // summaries in exported metadata do not distinguish these two cases. func foo13(yyy *int) { // ERROR "leaking param content: yyy$" xxx = yyy } func foo14(yyy int) { // ERROR "yyy does not escape$" xxx = yyy } func foo15(yy int) { // ERROR "moved to heap: yy$" xxx = &yy } func foo16(yy int) { // ERROR "leaking param: yy$" xxx = yy } func foo17(yy int) { // ERROR "yy does not escape$" xxx = yy } func foo18(y int) { // ERROR "moved to heap: y$" xxx = &y } func foo19(y int) { xxx = y } type Bar struct { i int ii int } func NewBar() Bar { return &Bar{42, nil} // ERROR "&Bar{...} escapes to heap$" } func NewBarp(x int) Bar { // ERROR "leaking param: x$" return &Bar{42, x} // ERROR "&Bar{...} escapes to heap$" } func NewBarp2(x int) Bar { // ERROR "x does not escape$" return &Bar{x, nil} // ERROR "&Bar{...} escapes to heap$" } func (b Bar) NoLeak() int { // ERROR "b does not escape$" return (b.ii) } func (b Bar) Leak() int { // ERROR "leaking param: b to result ~r0 level=0$" return &b.i } func (b Bar) AlsoNoLeak() int { // ERROR "leaking param: b to result ~r0 level=1$" return b.ii } func (b Bar) AlsoLeak() int { // ERROR "leaking param: b to result ~r0 level=0$" return b.ii } func (b Bar) LeaksToo() int { // ERROR "leaking param: b to result ~r0 level=0$" v := 0 // ERROR "moved to heap: v$" b.ii = &v return b.ii } func (b Bar) LeaksABit() int { // ERROR "leaking param: b to result ~r0 level=1$" v := 0 // ERROR "moved to heap: v$" b.ii = &v return b.ii } func (b Bar) StillNoLeak() int { // ERROR "b does not escape$" v := 0 b.ii = &v return b.i } func goLeak(b Bar) { // ERROR "leaking param: b$" go b.NoLeak() } type Bar2 struct { i [12]int ii []int } func NewBar2() Bar2 { return &Bar2{[12]int{42}, nil} // ERROR "&Bar2{...} escapes to heap$" } func (b Bar2) NoLeak() int { // ERROR "b does not escape$" return b.i[0] } func (b Bar2) Leak() []int { // ERROR "leaking param: b to result ~r0 level=0$" return b.i[:] } func (b Bar2) AlsoNoLeak() []int { // ERROR "leaking param: b to result ~r0 level=1$" return b.ii[0:1] } func (b Bar2) AgainNoLeak() [12]int { // ERROR "b does not escape$" return b.i } func (b Bar2) LeakSelf() { // ERROR "leaking param: b$" b.ii = b.i[0:4] } func (b Bar2) LeakSelf2() { // ERROR "leaking param: b$" var buf []int buf = b.i[0:] b.ii = buf } func foo21() func() int { x := 42 return func() int { // ERROR "func literal escapes to heap$" return x } } func foo21a() func() int { x := 42 // ERROR "moved to heap: x$" return func() int { // ERROR "func literal escapes to heap$" x++ return x } } func foo22() int { x := 42 return func() int { // ERROR "func literal does not escape$" return x }() } func foo23(x int) func() int { return func() int { // ERROR "func literal escapes to heap$" return x } } func foo23a(x int) func() int { f := func() int { // ERROR "func literal escapes to heap$" return x } return f } func foo23b(x int) (func() int) { f := func() int { return x } // ERROR "func literal escapes to heap$" "moved to heap: f$" return &f } func foo23c(x int) func() int { // ERROR "moved to heap: x$" return func() int { // ERROR "func literal escapes to heap$" x++ return x } } func foo24(x int) int { return func() int { // ERROR "func literal does not escape$" return x }() } var x int func fooleak(xx int) int { // ERROR "leaking param: xx$" x = xx return x } func foonoleak(xx int) int { // ERROR "xx does not escape$" return x + xx } func foo31(x int) int { // ERROR "moved to heap: x$" return fooleak(&x) } func foo32(x int) int { return foonoleak(&x) } type Foo struct { xx int x int } var F Foo var pf Foo func (f Foo) fooleak() { // ERROR "leaking param: f$" pf = f } func (f Foo) foonoleak() { // ERROR "f does not escape$" F.x = f.x } func (f Foo) Leak() { // ERROR "leaking param: f$" f.fooleak() } func (f Foo) NoLeak() { // ERROR "f does not escape$" f.foonoleak() } func foo41(x int) { // ERROR "moved to heap: x$" F.xx = &x } func (f Foo) foo42(x int) { // ERROR "f does not escape$" "moved to heap: x$" f.xx = &x } func foo43(f Foo, x int) { // ERROR "f does not escape$" "moved to heap: x$" f.xx = &x } func foo44(yy int) { // ERROR "leaking param: yy$" F.xx = yy } func (f Foo) foo45() { // ERROR "f does not escape$" F.x = f.x } // See foo13 above for explanation of why f leaks. func (f Foo) foo46() { // ERROR "leaking param content: f$" F.xx = f.xx } func (f Foo) foo47() { // ERROR "leaking param: f$" f.xx = &f.x } var ptrSlice []int func foo50(i int) { // ERROR "leaking param: i$" ptrSlice[0] = i } var ptrMap map[int]int func foo51(i int) { // ERROR "leaking param: i$" ptrMap[i] = i } func indaddr1(x int) int { // ERROR "moved to heap: x$" return &x } func indaddr2(x int) int { // ERROR "leaking param: x to result ~r0 level=0$" return &x } func indaddr3(x int32) int { // ERROR "leaking param: x to result ~r0 level=0$" return (*int)(unsafe.Pointer(&x)) } // From package math: func Float32bits(f float32) uint32 { return (uint32)(unsafe.Pointer(&f)) } func Float32frombits(b uint32) float32 { return (float32)(unsafe.Pointer(&b)) } func Float64bits(f float64) uint64 { return (uint64)(unsafe.Pointer(&f)) } func Float64frombits(b uint64) float64 { return (float64)(unsafe.Pointer(&b)) } // contrast with func float64bitsptr(f float64) uint64 { // ERROR "moved to heap: f$" return (uint64)(unsafe.Pointer(&f)) } func float64ptrbitsptr(f float64) uint64 { // ERROR "leaking param: f to result ~r0 level=0$" return (uint64)(unsafe.Pointer(f)) } func typesw(i interface{}) int { // ERROR "leaking param: i to result ~r0 level=0$" switch val := i.(type) { case int: return val case int8: v := int(val) // ERROR "moved to heap: v$" return &v } return nil } func exprsw(i int) int { // ERROR "leaking param: i to result ~r0 level=0$" switch j := i; j + 110 { case 12: return j case 42: return nil } return nil } // assigning to an array element is like assigning to the array func foo60(i int) int { // ERROR "leaking param: i to result ~r0 level=0$" var a [12]int a[0] = i return a[1] } func foo60a(i int) int { // ERROR "i does not escape$" var a [12]int a[0] = i return nil } // assigning to a struct field is like assigning to the struct func foo61(i int) int { // ERROR "leaking param: i to result ~r0 level=0$" type S struct { a, b int } var s S s.a = i return s.b } func foo61a(i int) int { // ERROR "i does not escape$" type S struct { a, b int } var s S s.a = i return nil } // assigning to a struct field is like assigning to the struct but // here this subtlety is lost, since s.a counts as an assignment to a // track-losing dereference. func foo62(i int) int { // ERROR "leaking param: i$" type S struct { a, b int } s := new(S) // ERROR "new$S$ does not escape$" s.a = i return nil // s.b } type M interface { M() } func foo63(m M) { // ERROR "m does not escape$" } func foo64(m M) { // ERROR "leaking param: m$" m.M() } func foo64b(m M) { // ERROR "leaking param: m$" defer m.M() } type MV int func (MV) M() {} func foo65() { var mv MV foo63(&mv) } func foo66() { var mv MV // ERROR "moved to heap: mv$" foo64(&mv) } func foo67() { var mv MV foo63(mv) // ERROR "mv does not escape$" } func foo68() { var mv MV // escapes but it's an int so irrelevant foo64(mv) // ERROR "mv escapes to heap$" } func foo69(m M) { // ERROR "leaking param: m$" foo64(m) } func foo70(mv1 MV, m M) { // ERROR "leaking param: m$" "leaking param: mv1$" m = mv1 foo64(m) } func foo71(x int) []int { // ERROR "leaking param: x$" var y []int y = append(y, x) return y } func foo71a(x int) []int { // ERROR "moved to heap: x$" var y []int y = append(y, &x) return y } func foo72() { var x int var y [1]int y[0] = &x } func foo72aa() [10]int { var x int // ERROR "moved to heap: x$" var y [10]int y[0] = &x return y } func foo72a() { var y [10]int for i := 0; i < 10; i++ { // escapes its scope x := i // ERROR "moved to heap: x$" y[i] = &x } return } func foo72b() [10]int { var y [10]int for i := 0; i < 10; i++ { x := i // ERROR "moved to heap: x$" y[i] = &x } return y } // issue 2145 func foo73() { s := []int{3, 2, 1} // ERROR "\[\]int{...} does not escape$" for _, v := range s { vv := v // actually just escapes its scope defer func() { // ERROR "func literal escapes to heap$" println(vv) }() } } func foo731() { s := []int{3, 2, 1} // ERROR "\[\]int{...} does not escape$" for _, v := range s { vv := v // ERROR "moved to heap: vv$" // actually just escapes its scope defer func() { // ERROR "func literal escapes to heap$" vv = 42 println(vv) }() } } func foo74() { s := []int{3, 2, 1} // ERROR "\[\]int{...} does not escape$" for _, v := range s { vv := v // actually just escapes its scope fn := func() { // ERROR "func literal escapes to heap$" println(vv) } defer fn() } } func foo74a() { s := []int{3, 2, 1} // ERROR "\[\]int{...} does not escape$" for _, v := range s { vv := v // ERROR "moved to heap: vv$" // actually just escapes its scope fn := func() { // ERROR "func literal escapes to heap$" vv += 1 println(vv) } defer fn() } } // issue 3975 func foo74b() { var array [3]func() s := []int{3, 2, 1} // ERROR "\[\]int{...} does not escape$" for i, v := range s { vv := v // actually just escapes its scope array[i] = func() { // ERROR "func literal escapes to heap$" println(vv) } } } func foo74c() { var array [3]func() s := []int{3, 2, 1} // ERROR "\[\]int{...} does not escape$" for i, v := range s { vv := v // ERROR "moved to heap: vv$" // actually just escapes its scope array[i] = func() { // ERROR "func literal escapes to heap$" println(&vv) } } } func myprint(y int, x ...interface{}) int { // ERROR "leaking param: y to result ~r0 level=0$" "x does not escape$" return y } func myprint1(y int, x ...interface{}) interface{} { // ERROR "leaking param: x to result ~r0 level=0$" "y does not escape$" return &x[0] } func foo75(z int) { // ERROR "z does not escape$" myprint(z, 1, 2, 3) // ERROR "1 does not escape" "2 does not escape" "3 does not escape" "... argument does not escape$" } func foo75a(z int) { // ERROR "z does not escape$" myprint1(z, 1, 2, 3) // ERROR "1 does not escape" "2 does not escape" "3 does not escape" "... argument does not escape$" } func foo75esc(z int) { // ERROR "leaking param: z$" gxx = myprint(z, 1, 2, 3) // ERROR "1 does not escape" "2 does not escape" "3 does not escape" "... argument does not escape$" } func foo75aesc(z int) { // ERROR "z does not escape$" var ppi *interface{} // assignments to pointer dereferences lose track ppi = myprint1(z, 1, 2, 3) // ERROR "... argument escapes to heap$" "1 escapes to heap$" "2 escapes to heap$" "3 escapes to heap$" } func foo75aesc1(z int) { // ERROR "z does not escape$" sink = myprint1(z, 1, 2, 3) // ERROR "... argument escapes to heap$" "1 escapes to heap$" "2 escapes to heap$" "3 escapes to heap$" } func foo76(z int) { // ERROR "z does not escape" myprint(nil, z) // ERROR "... argument does not escape$" } func foo76a(z int) { // ERROR "z does not escape" myprint1(nil, z) // ERROR "... argument does not escape$" } func foo76b() { myprint(nil, 1, 2, 3) // ERROR "1 does not escape" "2 does not escape" "3 does not escape" "... argument does not escape$" } func foo76c() { myprint1(nil, 1, 2, 3) // ERROR "1 does not escape" "2 does not escape" "3 does not escape" "... argument does not escape$" } func foo76d() { defer myprint(nil, 1, 2, 3) // ERROR "1 does not escape" "2 does not escape" "3 does not escape" "... argument does not escape$" } func foo76e() { defer myprint1(nil, 1, 2, 3) // ERROR "1 does not escape" "2 does not escape" "3 does not escape" "... argument does not escape$" } func foo76f() { for { // TODO: This one really only escapes its scope, but we don't distinguish yet. defer myprint(nil, 1, 2, 3) // ERROR "... argument does not escape$" "1 escapes to heap$" "2 escapes to heap$" "3 escapes to heap$" } } func foo76g() { for { defer myprint1(nil, 1, 2, 3) // ERROR "... argument does not escape$" "1 escapes to heap$" "2 escapes to heap$" "3 escapes to heap$" } } func foo77(z []interface{}) { // ERROR "z does not escape$" myprint(nil, z...) // z does not escape } func foo77a(z []interface{}) { // ERROR "z does not escape$" myprint1(nil, z...) } func foo77b(z []interface{}) { // ERROR "leaking param: z$" var ppi interface{} ppi = myprint1(nil, z...) } func foo77c(z []interface{}) { // ERROR "leaking param: z$" sink = myprint1(nil, z...) } func dotdotdot() { i := 0 myprint(nil, &i) // ERROR "... argument does not escape$" j := 0 myprint1(nil, &j) // ERROR "... argument does not escape$" } func foo78(z int) int { // ERROR "moved to heap: z$" return &z } func foo78a(z int) int { // ERROR "moved to heap: z$" y := &z x := &y return x // really return y } func foo79() int { return new(int) // ERROR "new$int$ escapes to heap$" } func foo80() int { var z int for { // Really just escapes its scope but we don't distinguish z = new(int) // ERROR "new$int$ escapes to heap$" } _ = z return nil } func foo81() int { for { z := new(int) // ERROR "new$int$ does not escape$" _ = z } return nil } func tee(p int) (x, y int) { return p, p } // ERROR "leaking param: p to result x level=0$" "leaking param: p to result y level=0$" func noop(x, y int) {} // ERROR "x does not escape$" "y does not escape$" func foo82() { var x, y, z int // ERROR "moved to heap: x$" "moved to heap: y$" "moved to heap: z$" go noop(tee(&z)) go noop(&x, &y) for { var u, v, w int // ERROR "moved to heap: u$" "moved to heap: v$" "moved to heap: w$" defer noop(tee(&u)) defer noop(&v, &w) } } type Fooer interface { Foo() } type LimitedFooer struct { Fooer N int64 } func LimitFooer(r Fooer, n int64) Fooer { // ERROR "leaking param: r$" return &LimitedFooer{r, n} // ERROR "&LimitedFooer{...} escapes to heap$" } func foo90(x int) map[int]int { // ERROR "leaking param: x$" return map[int]int{nil: x} // ERROR "map\[\int\]\int{...} escapes to heap$" } func foo91(x int) map[int]int { // ERROR "leaking param: x$" return map[int]int{x: nil} // ERROR "map\[\int\]\int{...} escapes to heap$" } func foo92(x int) [2]int { // ERROR "leaking param: x to result ~r0 level=0$" return [2]int{x, nil} } // does not leak c func foo93(c chan int) int { // ERROR "c does not escape$" for v := range c { return v } return nil } // does not leak m func foo94(m map[int]int, b bool) int { // ERROR "leaking param: m to result ~r0 level=1" for k, v := range m { if b { return k } return v } return nil } // does leak x func foo95(m map[int]int, x int) { // ERROR "m does not escape$" "leaking param: x$" m[x] = x } // does not leak m but does leak content func foo96(m []int) int { // ERROR "leaking param: m to result ~r0 level=1" return m[0] } // does leak m func foo97(m [1]int) int { // ERROR "leaking param: m to result ~r0 level=0$" return m[0] } // does not leak m func foo98(m map[int]int) int { // ERROR "m does not escape$" return m[0] } // does leak m func foo99(m [1]int) []int { // ERROR "leaking param: m to result ~r0 level=0$" return m[:] } // does not leak m func foo100(m []int) int { // ERROR "leaking param: m to result ~r0 level=1" for _, v := range m { return v } return nil } // does leak m func foo101(m [1]int) int { // ERROR "leaking param: m to result ~r0 level=0$" for _, v := range m { return v } return nil } // does not leak m func foo101a(m [1]int) int { // ERROR "m does not escape$" for i := range m { // ERROR "moved to heap: i$" return &i } return nil } // does leak x func foo102(m []int, x int) { // ERROR "m does not escape$" "leaking param: x$" m[0] = x } // does not leak x func foo103(m [1]int, x int) { // ERROR "m does not escape$" "x does not escape$" m[0] = x } var y []int // does not leak x but does leak content func foo104(x []int) { // ERROR "leaking param content: x" copy(y, x) } // does not leak x but does leak content func foo105(x []int) { // ERROR "leaking param content: x" _ = append(y, x...) } // does leak x func foo106(x int) { // ERROR "leaking param: x$" _ = append(y, x) } func foo107(x int) map[int]int { // ERROR "leaking param: x$" return map[int]int{x: nil} // ERROR "map\[\int\]\int{...} escapes to heap$" } func foo108(x int) map[int]int { // ERROR "leaking param: x$" return map[int]int{nil: x} // ERROR "map\[\int\]\int{...} escapes to heap$" } func foo109(x int) int { // ERROR "leaking param: x$" m := map[int]int{x: nil} // ERROR "map\[\int\]\int{...} does not escape$" for k, _ := range m { return k } return nil } func foo110(x int) int { // ERROR "leaking param: x$" m := map[int]int{nil: x} // ERROR "map\[\int\]\int{...} does not escape$" return m[nil] } func foo111(x int) int { // ERROR "leaking param: x to result ~r0 level=0" m := []int{x} // ERROR "\[\]\int{...} does not escape$" return m[0] } func foo112(x int) int { // ERROR "leaking param: x to result ~r0 level=0$" m := [1]int{x} return m[0] } func foo113(x int) int { // ERROR "leaking param: x to result ~r0 level=0$" m := Bar{ii: x} return m.ii } func foo114(x int) int { // ERROR "leaking param: x to result ~r0 level=0$" m := &Bar{ii: x} // ERROR "&Bar{...} does not escape$" return m.ii } func foo115(x int) int { // ERROR "leaking param: x to result ~r0 level=0$" return (int)(unsafe.Pointer(uintptr(unsafe.Pointer(x)) + 1)) } func foo116(b bool) int { if b { x := 1 // ERROR "moved to heap: x$" return &x } else { y := 1 // ERROR "moved to heap: y$" return &y } return nil } func foo117(unknown func(interface{})) { // ERROR "unknown does not escape$" x := 1 // ERROR "moved to heap: x$" unknown(&x) } func foo118(unknown func(int)) { // ERROR "unknown does not escape$" x := 1 // ERROR "moved to heap: x$" unknown(&x) } func external(int) func foo119(x int) { // ERROR "leaking param: x$" external(x) } func foo120() { // formerly exponential time analysis L1: L2: L3: L4: L5: L6: L7: L8: L9: L10: L11: L12: L13: L14: L15: L16: L17: L18: L19: L20: L21: L22: L23: L24: L25: L26: L27: L28: L29: L30: L31: L32: L33: L34: L35: L36: L37: L38: L39: L40: L41: L42: L43: L44: L45: L46: L47: L48: L49: L50: L51: L52: L53: L54: L55: L56: L57: L58: L59: L60: L61: L62: L63: L64: L65: L66: L67: L68: L69: L70: L71: L72: L73: L74: L75: L76: L77: L78: L79: L80: L81: L82: L83: L84: L85: L86: L87: L88: L89: L90: L91: L92: L93: L94: L95: L96: L97: L98: L99: L100: // use the labels to silence compiler errors goto L1 goto L2 goto L3 goto L4 goto L5 goto L6 goto L7 goto L8 goto L9 goto L10 goto L11 goto L12 goto L13 goto L14 goto L15 goto L16 goto L17 goto L18 goto L19 goto L20 goto L21 goto L22 goto L23 goto L24 goto L25 goto L26 goto L27 goto L28 goto L29 goto L30 goto L31 goto L32 goto L33 goto L34 goto L35 goto L36 goto L37 goto L38 goto L39 goto L40 goto L41 goto L42 goto L43 goto L44 goto L45 goto L46 goto L47 goto L48 goto L49 goto L50 goto L51 goto L52 goto L53 goto L54 goto L55 goto L56 goto L57 goto L58 goto L59 goto L60 goto L61 goto L62 goto L63 goto L64 goto L65 goto L66 goto L67 goto L68 goto L69 goto L70 goto L71 goto L72 goto L73 goto L74 goto L75 goto L76 goto L77 goto L78 goto L79 goto L80 goto L81 goto L82 goto L83 goto L84 goto L85 goto L86 goto L87 goto L88 goto L89 goto L90 goto L91 goto L92 goto L93 goto L94 goto L95 goto L96 goto L97 goto L98 goto L99 goto L100 } func foo121() { for i := 0; i < 10; i++ { defer myprint(nil, i) // ERROR "... argument does not escape$" "i escapes to heap$" go myprint(nil, i) // ERROR "... argument does not escape$" "i escapes to heap$" } } // same as foo121 but check across import func foo121b() { for i := 0; i < 10; i++ { defer fmt.Printf("%d", i) // ERROR "... argument does not escape$" "i escapes to heap$" go fmt.Printf("%d", i) // ERROR "... argument does not escape$" "i escapes to heap$" } } // a harmless forward jump func foo122() { var i int goto L1 L1: i = new(int) // ERROR "new$int$ does not escape$" _ = i } // a backward jump, increases loopdepth func foo123() { var i int L1: i = new(int) // ERROR "new$int$ escapes to heap$" goto L1 _ = i } func foo124(x *int) { // ERROR "x does not escape$" var i int // ERROR "moved to heap: i$" p := &i func() { // ERROR "func literal does not escape$" x = p }() } func foo125(ch chan int) { // ERROR "ch does not escape$" var i int // ERROR "moved to heap: i$" p := &i func() { // ERROR "func literal does not escape$" ch <- p }() } func foo126() { var px int // loopdepth 0 for { // loopdepth 1 var i int // ERROR "moved to heap: i$" func() { // ERROR "func literal does not escape$" px = &i }() } _ = px } var px int func foo127() { var i int // ERROR "moved to heap: i$" p := &i q := p px = q } func foo128() { var i int p := &i q := p _ = q } func foo129() { var i int // ERROR "moved to heap: i$" p := &i func() { // ERROR "func literal does not escape$" q := p func() { // ERROR "func literal does not escape$" r := q px = r }() }() } func foo130() { for { var i int // ERROR "moved to heap: i$" func() { // ERROR "func literal does not escape$" px = &i }() } } func foo131() { var i int // ERROR "moved to heap: i$" func() { // ERROR "func literal does not escape$" px = &i }() } func foo132() { var i int // ERROR "moved to heap: i$" go func() { // ERROR "func literal escapes to heap$" px = &i }() } func foo133() { var i int // ERROR "moved to heap: i$" defer func() { // ERROR "func literal does not escape$" px = &i }() } func foo134() { var i int p := &i func() { // ERROR "func literal does not escape$" q := p func() { // ERROR "func literal does not escape$" r := q _ = r }() }() } func foo135() { var i int // ERROR "moved to heap: i$" p := &i go func() { // ERROR "func literal escapes to heap$" q := p func() { // ERROR "func literal does not escape$" r := q _ = r }() }() } func foo136() { var i int // ERROR "moved to heap: i$" p := &i go func() { // ERROR "func literal escapes to heap$" q := p func() { // ERROR "func literal does not escape$" r := q px = r }() }() } func foo137() { var i int // ERROR "moved to heap: i$" p := &i func() { // ERROR "func literal does not escape$" q := p go func() { // ERROR "func literal escapes to heap$" r := q _ = r }() }() } func foo138() byte { type T struct { x [1]byte } t := new(T) // ERROR "new$T$ escapes to heap$" return &t.x[0] } func foo139() byte { type T struct { x struct { y byte } } t := new(T) // ERROR "new$T$ escapes to heap$" return &t.x.y } // issue 4751 func foo140() interface{} { type T struct { X string } type U struct { X string T T } t := &T{} // ERROR "&T{} escapes to heap$" return U{ // ERROR "U{...} escapes to heap$" X: t.X, T: t, } } //go:noescape func F1([]byte) func F2([]byte) //go:noescape func F3(x []byte) // ERROR "x does not escape$" func F4(x []byte) // ERROR "leaking param: x$" func G() { var buf1 [10]byte F1(buf1[:]) var buf2 [10]byte // ERROR "moved to heap: buf2$" F2(buf2[:]) var buf3 [10]byte F3(buf3[:]) var buf4 [10]byte // ERROR "moved to heap: buf4$" F4(buf4[:]) } type Tm struct { x int } func (t Tm) M() { // ERROR "t does not escape$" } func foo141() { var f func() t := new(Tm) // ERROR "new$Tm$ does not escape$" f = t.M // ERROR "t.M does not escape$" _ = f } var gf func() func foo142() { t := new(Tm) // ERROR "new$Tm$ escapes to heap$" gf = t.M // ERROR "t.M escapes to heap$" } // issue 3888. func foo143() { for i := 0; i < 1000; i++ { func() { // ERROR "func literal does not escape$" for i := 0; i < 1; i++ { var t Tm t.M() } }() } } // issue 5773 // Check that annotations take effect regardless of whether they // are before or after the use in the source code. //go:noescape func foo144a(int) func foo144() { var x int foo144a(&x) var y int foo144b(&y) } //go:noescape func foo144b(int) // issue 7313: for loop init should not be treated as "in loop" type List struct { Next List } func foo145(l List) { // ERROR "l does not escape$" var p List for p = &l; p.Next != nil; p = p.Next { } } func foo146(l List) { // ERROR "l does not escape$" var p List p = &l for ; p.Next != nil; p = p.Next { } } func foo147(l List) { // ERROR "l does not escape$" var p List p = &l for p.Next != nil { p = p.Next } } func foo148(l List) { // ERROR "l does not escape$" for p := &l; p.Next != nil; p = p.Next { } } // related: address of variable should have depth of variable, not of loop func foo149(l List) { // ERROR "l does not escape$" var p List for { for p = &l; p.Next != nil; p = p.Next { } } } // issue 7934: missed ... if element type had no pointers var save150 []byte func foo150(x ...byte) { // ERROR "leaking param: x$" save150 = x } func bar150() { foo150(1, 2, 3) // ERROR "... argument escapes to heap$" } // issue 7931: bad handling of slice of array var save151 int func foo151(x int) { // ERROR "leaking param: x$" save151 = x } func bar151() { var a [64]int // ERROR "moved to heap: a$" a[4] = 101 foo151(&(&a)[4:8][0]) } func bar151b() { var a [10]int // ERROR "moved to heap: a$" b := a[:] foo151(&b[4:8][0]) } func bar151c() { var a [64]int // ERROR "moved to heap: a$" a[4] = 101 foo151(&(&a)[4:8:8][0]) } func bar151d() { var a [10]int // ERROR "moved to heap: a$" b := a[:] foo151(&b[4:8:8][0]) } // issue 8120 type U struct { s string } func (u U) String() string { // ERROR "leaking param: u to result ~r0 level=1$" return u.s } type V struct { s string } func NewV(u U) V { // ERROR "leaking param: u$" return &V{u.String()} // ERROR "&V{...} escapes to heap$" } func foo152() { a := "a" // ERROR "moved to heap: a$" u := U{&a} v := NewV(u) println(v) } // issue 8176 - &x in type switch body not marked as escaping func foo153(v interface{}) int { // ERROR "v does not escape" switch x := v.(type) { case int: // ERROR "moved to heap: x$" return &x } panic(0) // ERROR "0 escapes to heap" } // issue 8185 - &result escaping into result func f() (x int, y int) { // ERROR "moved to heap: x$" y = &x return } func g() (x interface{}) { // ERROR "moved to heap: x$" x = &x return } var sink interface{} type Lit struct { p int } func ptrlitNoescape() { // Both literal and element do not escape. i := 0 x := &Lit{&i} // ERROR "&Lit{...} does not escape$" _ = x } func ptrlitNoEscape2() { // Literal does not escape, but element does. i := 0 // ERROR "moved to heap: i$" x := &Lit{&i} // ERROR "&Lit{...} does not escape$" sink = x } func ptrlitEscape() { // Both literal and element escape. i := 0 // ERROR "moved to heap: i$" x := &Lit{&i} // ERROR "&Lit{...} escapes to heap$" sink = x } // self-assignments type Buffer struct { arr [64]byte arrPtr [64]byte buf1 []byte buf2 []byte str1 string str2 string } func (b Buffer) foo() { // ERROR "b does not escape$" b.buf1 = b.buf1[1:2] // ERROR "$\Buffer$.foo ignoring self-assignment in b.buf1 = b.buf1\[1:2\]$" b.buf1 = b.buf1[1:2:3] // ERROR "$\Buffer$.foo ignoring self-assignment in b.buf1 = b.buf1\[1:2:3\]$" b.buf1 = b.buf2[1:2] // ERROR "$\Buffer$.foo ignoring self-assignment in b.buf1 = b.buf2\[1:2\]$" b.buf1 = b.buf2[1:2:3] // ERROR "$\Buffer$.foo ignoring self-assignment in b.buf1 = b.buf2\[1:2:3\]$" } func (b Buffer) bar() { // ERROR "leaking param: b$" b.buf1 = b.arr[1:2] } func (b Buffer) arrayPtr() { // ERROR "b does not escape" b.buf1 = b.arrPtr[1:2] // ERROR "$\Buffer$.arrayPtr ignoring self-assignment in b.buf1 = b.arrPtr\[1:2\]$" b.buf1 = b.arrPtr[1:2:3] // ERROR "$\Buffer$.arrayPtr ignoring self-assignment in b.buf1 = b.arrPtr\[1:2:3\]$" } func (b Buffer) baz() { // ERROR "b does not escape$" b.str1 = b.str1[1:2] // ERROR "$\Buffer$.baz ignoring self-assignment in b.str1 = b.str1\[1:2\]$" b.str1 = b.str2[1:2] // ERROR "$\Buffer$.baz ignoring self-assignment in b.str1 = b.str2\[1:2\]$" } func (b Buffer) bat() { // ERROR "leaking param content: b$" o := new(Buffer) // ERROR "new$Buffer$ escapes to heap$" o.buf1 = b.buf1[1:2] sink = o } func quux(sp string, bp []byte) { // ERROR "bp does not escape$" "sp does not escape$" sp = (sp)[1:2] // ERROR "quux ignoring self-assignment in \sp = $\sp$\[1:2\]$" bp = (bp)[1:2] // ERROR "quux ignoring self-assignment in \bp = $\bp$\[1:2\]$" } type StructWithString struct { p int s string } // This is escape analysis false negative. // We assign the pointer to x.p but leak x.s. Escape analysis coarsens flows // to just x, and thus &i looks escaping. func fieldFlowTracking() { var x StructWithString i := 0 // ERROR "moved to heap: i$" x.p = &i sink = x.s // ERROR "x.s escapes to heap$" } // String operations. func slicebytetostring0() { b := make([]byte, 20) // ERROR "make$\[\]byte, 20$ does not escape$" s := string(b) // ERROR "string$b$ does not escape$" _ = s } func slicebytetostring1() { b := make([]byte, 20) // ERROR "make$\[\]byte, 20$ does not escape$" s := string(b) // ERROR "string$b$ does not escape$" s1 := s[0:1] _ = s1 } func slicebytetostring2() { b := make([]byte, 20) // ERROR "make$\[\]byte, 20$ does not escape$" s := string(b) // ERROR "string$b$ escapes to heap$" s1 := s[0:1] // ERROR "moved to heap: s1$" sink = &s1 } func slicebytetostring3() { b := make([]byte, 20) // ERROR "make$\[\]byte, 20$ does not escape$" s := string(b) // ERROR "string$b$ escapes to heap$" s1 := s[0:1] sink = s1 // ERROR "s1 escapes to heap$" } func addstr0() { s0 := "a" s1 := "b" s := s0 + s1 // ERROR "s0 \+ s1 does not escape$" _ = s } func addstr1() { s0 := "a" s1 := "b" s := "c" s += s0 + s1 // ERROR "s0 \+ s1 does not escape$" _ = s } func addstr2() { b := make([]byte, 20) // ERROR "make$\[\]byte, 20$ does not escape$" s0 := "a" s := string(b) + s0 // ERROR "string$b$ \+ s0 does not escape$" "string$b$ does not escape$" _ = s } func addstr3() { s0 := "a" s1 := "b" s := s0 + s1 // ERROR "s0 \+ s1 escapes to heap$" s2 := s[0:1] sink = s2 // ERROR "s2 escapes to heap$" } func intstring0() bool { // string does not escape x := '0' s := string(x) // ERROR "string$x$ does not escape$" return s == "0" } func intstring1() string { // string does not escape, but the buffer does x := '0' s := string(x) // ERROR "string$x$ escapes to heap$" return s } func intstring2() { // string escapes to heap x := '0' s := string(x) // ERROR "moved to heap: s$" "string$x$ escapes to heap$" sink = &s } func stringtoslicebyte0() { s := "foo" x := []byte(s) // ERROR "$\[\]byte$$s$ does not escape$" "zero-copy string->\[\]byte conversion" _ = x } func stringtoslicebyte1() []byte { s := "foo" return []byte(s) // ERROR "$\[\]byte$$s$ escapes to heap$" } func stringtoslicebyte2() { s := "foo" sink = []byte(s) // ERROR "$\[\]byte$$s$ escapes to heap$" } func stringtoslicerune0() { s := "foo" x := []rune(s) // ERROR "$\[\]rune$$s$ does not escape$" _ = x } func stringtoslicerune1() []rune { s := "foo" return []rune(s) // ERROR "$\[\]rune$$s$ escapes to heap$" } func stringtoslicerune2() { s := "foo" sink = []rune(s) // ERROR "$\[\]rune$$s$ escapes to heap$" } func slicerunetostring0() { r := []rune{1, 2, 3} // ERROR "\[\]rune{...} does not escape$" s := string(r) // ERROR "string$r$ does not escape$" _ = s } func slicerunetostring1() string { r := []rune{1, 2, 3} // ERROR "\[\]rune{...} does not escape$" return string(r) // ERROR "string$r$ escapes to heap$" } func slicerunetostring2() { r := []rune{1, 2, 3} // ERROR "\[\]rune{...} does not escape$" sink = string(r) // ERROR "string$r$ escapes to heap$" } func makemap0() { m := make(map[int]int) // ERROR "make$map\[int\]int$ does not escape$" m[0] = 0 m[1]++ delete(m, 1) sink = m[0] // ERROR "m\[0\] escapes to heap$" } func makemap1() map[int]int { return make(map[int]int) // ERROR "make$map\[int\]int$ escapes to heap$" } func makemap2() { m := make(map[int]int) // ERROR "make$map\[int\]int$ escapes to heap$" sink = m } func nonescapingEface(m map[interface{}]bool) bool { // ERROR "m does not escape$" return m["foo"] // ERROR ".foo. does not escape$" } func nonescapingIface(m map[M]bool) bool { // ERROR "m does not escape$" return m[MV(0)] // ERROR "MV$0$ does not escape$" } func issue10353() { x := new(int) // ERROR "new$int$ escapes to heap$" issue10353a(x)() } func issue10353a(x int) func() { // ERROR "leaking param: x$" return func() { // ERROR "func literal escapes to heap$" println(x) } } func issue10353b() { var f func() for { x := new(int) // ERROR "new$int$ escapes to heap$" f = func() { // ERROR "func literal escapes to heap$" println(x) } } _ = f } func issue11387(x int) func() int { f := func() int { return x } // ERROR "func literal escapes to heap" slice1 := []func() int{f} // ERROR "\[\]. does not escape" slice2 := make([]func() int, 1) // ERROR "make$.*$ does not escape" copy(slice2, slice1) return slice2[0] } func issue12397(x, y int) { // ERROR "moved to heap: y$" // x does not escape below, because all relevant code is dead. if false { gxx = &x } else { gxx = &y } if true { gxx = &y } else { gxx = &x } }	35.14 KB	2024-02-02 18:09
📄 escape3.go // run // 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. // Test the run-time behavior of escape analysis-related optimizations. package main func main() { test1() } func test1() { check1(0) check1(1) check1(2) } type T1 struct { X, Y, Z int } func f() int { return 1 } func check1(pass int) T1 { v := []T1{{X: f(), Z: f()}} if v[0].Y != 0 { panic("nonzero init") } v[0].Y = pass return v[0] }	524 B	2024-02-02 18:09
📄 escape4.go // errorcheck -0 -m //go:build !goexperiment.newinliner // Copyright 2010 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, using compiler diagnostic flags, that the escape analysis is working. // Compiles but does not run. Inlining is enabled. package foo var p int func alloc(x int) int { // ERROR "can inline alloc" "moved to heap: x" return &x } var f func() func f1() { p = alloc(2) // ERROR "inlining call to alloc" "moved to heap: x" // Escape analysis used to miss inlined code in closures. func() { // ERROR "can inline f1.func1" p = alloc(3) // ERROR "inlining call to alloc" }() // ERROR "inlining call to f1.func1" "inlining call to alloc" "moved to heap: x" f = func() { // ERROR "func literal escapes to heap" "can inline f1.func2" p = alloc(3) // ERROR "inlining call to alloc" "moved to heap: x" } f() } func f2() {} // ERROR "can inline f2" // No inline for recover; panic now allowed to inline. func f3() { panic(1) } // ERROR "can inline f3" "1 escapes to heap" func f4() { recover() } func f5() byte { // ERROR "can inline f5" type T struct { x [1]byte } t := new(T) // ERROR "new.T. escapes to heap" return &t.x[0] } func f6() byte { // ERROR "can inline f6" type T struct { x struct { y byte } } t := new(T) // ERROR "new.T. escapes to heap" return &t.x.y }	1.4 KB	2024-02-02 18:09
📄 escape5.go // errorcheck -0 -m -l // 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. // Test, using compiler diagnostic flags, that the escape analysis is working. // Compiles but does not run. Inlining is disabled. package foo import ( "runtime" "unsafe" ) func noleak(p int) int { // ERROR "p does not escape" return p } func leaktoret(p int) int { // ERROR "leaking param: p to result" return p } func leaktoret2(p int) (int, int) { // ERROR "leaking param: p to result ~r0" "leaking param: p to result ~r1" return p, p } func leaktoret22(p, q int) (int, int) { // ERROR "leaking param: p to result ~r0" "leaking param: q to result ~r1" return p, q } func leaktoret22b(p, q int) (int, int) { // ERROR "leaking param: p to result ~r1" "leaking param: q to result ~r0" return leaktoret22(q, p) } func leaktoret22c(p, q int) (int, int) { // ERROR "leaking param: p to result ~r1" "leaking param: q to result ~r0" r, s := leaktoret22(q, p) return r, s } func leaktoret22d(p, q int) (r, s int) { // ERROR "leaking param: p to result s" "leaking param: q to result r" r, s = leaktoret22(q, p) return } func leaktoret22e(p, q int) (r, s int) { // ERROR "leaking param: p to result s" "leaking param: q to result r" r, s = leaktoret22(q, p) return r, s } func leaktoret22f(p, q int) (r, s int) { // ERROR "leaking param: p to result s" "leaking param: q to result r" rr, ss := leaktoret22(q, p) return rr, ss } var gp int func leaktosink(p int) int { // ERROR "leaking param: p" gp = p return p } func f1() { var x int p := noleak(&x) _ = p } func f2() { var x int p := leaktoret(&x) _ = p } func f3() { var x int // ERROR "moved to heap: x" p := leaktoret(&x) gp = p } func f4() { var x int // ERROR "moved to heap: x" p, q := leaktoret2(&x) gp = p gp = q } func f5() { var x int leaktoret22(leaktoret2(&x)) } func f6() { var x int // ERROR "moved to heap: x" px1, px2 := leaktoret22(leaktoret2(&x)) gp = px1 _ = px2 } type T struct{ x int } func (t T) Foo(u int) (T, bool) { // ERROR "leaking param: t to result" t.x += u return t, true } func f7() T { r, _ := new(T).Foo(42) // ERROR "new.T. escapes to heap" return r } func leakrecursive1(p, q int) (int, int) { // ERROR "leaking param: p" "leaking param: q" return leakrecursive2(q, p) } func leakrecursive2(p, q int) (int, int) { // ERROR "leaking param: p" "leaking param: q" if p > q { return leakrecursive1(q, p) } // without this, leakrecursive? are safe for p and q, b/c in fact their graph does not have leaking edges. return p, q } var global interface{} type T1 struct { X int } type T2 struct { Y T1 } func f8(p T1) (k T2) { // ERROR "leaking param: p$" if p == nil { k = T2{} return } // should make p leak always global = p return T2{p} } func f9() { var j T1 // ERROR "moved to heap: j" f8(&j) } func f10() { // These don't escape but are too big for the stack var x [1 << 30]byte // ERROR "moved to heap: x" var y = make([]byte, 1<<30) // ERROR "make$\[\]byte, 1073741824$ escapes to heap" _ = x[0] + y[0] } // Test for issue 19687 (passing to unnamed parameters does not escape). func f11(int) { } func f12(_ int) { } func f13() { var x int f11(&x) f12(&x) runtime.KeepAlive(&x) } // Test for issue 24305 (passing to unnamed receivers does not escape). type U int func (U) M() {} func (_ U) N() {} func fbad24305a() { var u U u.M() u.N() } func fbad24305b() { var u U (U).M(&u) (U).N(&u) } // Issue 24730: taking address in a loop causes unnecessary escape type T24730 struct { x [64]byte } func (t T24730) g() { // ERROR "t does not escape" y := t.x[:] for i := range t.x[:] { y = t.x[:] y[i] = 1 } var z byte for i := range t.x[:] { z = &t.x[i] z = 2 } } // Issue 15730: copy causes unnecessary escape var sink []byte var sink2 []int var sink3 []int func f15730a(args ...interface{}) { // ERROR "args does not escape" for _, arg := range args { switch a := arg.(type) { case string: copy(sink, a) } } } func f15730b(args ...interface{}) { // ERROR "args does not escape" for _, arg := range args { switch a := arg.(type) { case []int: copy(sink2, a) } } } func f15730c(args ...interface{}) { // ERROR "leaking param content: args" for _, arg := range args { switch a := arg.(type) { case []int: // copy pointerful data should cause escape copy(sink3, a) } } } // Issue 29000: unnamed parameter is not handled correctly var sink4 interface{} var alwaysFalse = false func f29000(_ int, x interface{}) { // ERROR "leaking param: x" sink4 = x if alwaysFalse { g29000() } } func g29000() { x := 1 f29000(2, x) // ERROR "x escapes to heap" } // Issue 28369: taking an address of a parameter and converting it into a uintptr causes an // unnecessary escape. var sink28369 uintptr func f28369(n int) int { if n == 0 { sink28369 = uintptr(unsafe.Pointer(&n)) return n } return 1 + f28369(n-1) } // Issue 44614: parameters that flow to a heap-allocated result // parameter must be recorded as a heap-flow rather than a // result-flow. // N.B., must match "leaking param: p", // but not* "leaking param: p to result r level=0". func f(p int) (r int) { // ERROR "leaking param: p$" "moved to heap: r" sink4 = &r return p }	5.31 KB	2024-02-02 18:09
📄 escape_array.go // errorcheck -0 -m -l // 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. // Test escape analysis for arrays and some large things package foo var Ssink string type U [2]string func bar(a, b string) U { // ERROR "leaking param: a to result ~r0 level=0$" "leaking param: b to result ~r0 level=0$" return U{a, b} } func foo(x U) U { // ERROR "leaking param: x to result ~r0 level=0$" return U{x[1], x[0]} } func bff(a, b string) U { // ERROR "leaking param: a to result ~r0 level=0$" "leaking param: b to result ~r0 level=0$" return foo(foo(bar(a, b))) } func tbff1() string { a := "cat" b := "dog" // ERROR "moved to heap: b$" u := bff(&a, &b) _ = u[0] return &b } // BAD: need fine-grained analysis to track u[0] and u[1] differently. func tbff2() string { a := "cat" // ERROR "moved to heap: a$" b := "dog" // ERROR "moved to heap: b$" u := bff(&a, &b) _ = u[0] return u[1] } func car(x U) string { // ERROR "leaking param: x to result ~r0 level=0$" return x[0] } // BAD: need fine-grained analysis to track x[0] and x[1] differently. func fun(x U, y string) string { // ERROR "leaking param: x to result ~r0 level=0$" "leaking param: y to result ~r0 level=0$" x[0] = y return x[1] } func fup(x U, y string) string { // ERROR "leaking param: x to result ~r0 level=1$" "leaking param: y$" x[0] = y // leaking y to heap is intended return x[1] } func fum(x U, y string) string { // ERROR "leaking param: x to result ~r0 level=1$" "leaking param content: y$" x[0] = y return x[1] } func fuo(x U, y U) string { // ERROR "leaking param: x to result ~r0 level=1$" "leaking param content: y$" x[0] = y[0] return x[1] } // These two tests verify that: // small array literals are stack allocated; // pointers stored in small array literals do not escape; // large array literals are heap allocated; // pointers stored in large array literals escape. func hugeLeaks1(x string, y string) { // ERROR "leaking param content: x" "y does not escape" a := [10]string{y} _ = a // 4 x 4,000,000 exceeds MaxStackVarSize, therefore it must be heap allocated if pointers are 4 bytes or larger. b := [4000000]string{x} // ERROR "moved to heap: b" _ = b } func hugeLeaks2(x string, y string) { // ERROR "leaking param: x" "y does not escape" a := [10]string{y} _ = a // 4 x 4,000,000 exceeds MaxStackVarSize, therefore it must be heap allocated if pointers are 4 bytes or larger. b := [4000000]string{x} // ERROR "moved to heap: b" _ = b } // BAD: x need not leak. func doesNew1(x string, y string) { // ERROR "leaking param: x" "leaking param: y" a := new([10]string) // ERROR "new$\[10\]\string$ does not escape" a[0] = x b := new([65537]string) // ERROR "new$\[65537\]\string$ escapes to heap" b[0] = y } type a10 struct { s string i [10]int32 } type a65537 struct { s string i [65537]int32 } // BAD: x need not leak. func doesNew2(x string, y string) { // ERROR "leaking param: x" "leaking param: y" a := new(a10) // ERROR "new$a10$ does not escape" a.s = x b := new(a65537) // ERROR "new$a65537$ escapes to heap" b.s = y } // BAD: x need not leak. func doesMakeSlice(x string, y string) { // ERROR "leaking param: x" "leaking param: y" a := make([]string, 10) // ERROR "make$\[\]\string, 10$ does not escape" a[0] = x b := make([]string, 65537) // ERROR "make$\[\]\string, 65537$ escapes to heap" b[0] = y } func nonconstArray() { n := 32 s1 := make([]int, n) // ERROR "make$\[\]int, n$ escapes to heap" s2 := make([]int, 0, n) // ERROR "make$\[\]int, 0, n$ escapes to heap" _, _ = s1, s2 }	3.64 KB	2024-02-02 18:09
📄 escape_calls.go // errorcheck -0 -m -l // 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. // Test escape analysis for function parameters. // In this test almost everything is BAD except the simplest cases // where input directly flows to output. package foo func f(buf []byte) []byte { // ERROR "leaking param: buf to result ~r0 level=0$" return buf } func g(byte) string func h(e int) { var x [32]byte // ERROR "moved to heap: x$" g(&f(x[:])[0]) } type Node struct { s string left, right Node } func walk(np *Node) int { // ERROR "leaking param content: np" n := np w := len(n.s) if n == nil { return 0 } wl := walk(&n.left) wr := walk(&n.right) if wl < wr { n.left, n.right = n.right, n.left // ERROR "ignoring self-assignment" wl, wr = wr, wl } *np = n return w + wl + wr } // Test for bug where func var f used prototype's escape analysis results. func prototype(xyz []string) {} // ERROR "xyz does not escape" func bar() { var got [][]string f := prototype f = func(ss []string) { got = append(got, ss) } // ERROR "leaking param: ss" "func literal does not escape" s := "string" f([]string{s}) // ERROR "\[\]string{...} escapes to heap" } func strmin(a, b, c string) string { // ERROR "leaking param: a to result ~r0 level=0" "leaking param: b to result ~r0 level=0" "leaking param: c to result ~r0 level=0" return min(a, b, c) } func strmax(a, b, c string) string { // ERROR "leaking param: a to result ~r0 level=0" "leaking param: b to result ~r0 level=0" "leaking param: c to result ~r0 level=0" return max(a, b, c) }	1.63 KB	2024-02-02 18:09
📄 escape_closure.go // errorcheck -0 -m -l // 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. // Test escape analysis for closure arguments. package escape var sink interface{} func ClosureCallArgs0() { x := 0 func(p int) { // ERROR "p does not escape" "func literal does not escape" p = 1 }(&x) } func ClosureCallArgs1() { x := 0 for { func(p int) { // ERROR "p does not escape" "func literal does not escape" p = 1 }(&x) } } func ClosureCallArgs2() { for { x := 0 func(p int) { // ERROR "p does not escape" "func literal does not escape" p = 1 }(&x) } } func ClosureCallArgs3() { x := 0 // ERROR "moved to heap: x" func(p int) { // ERROR "leaking param: p" "func literal does not escape" sink = p }(&x) } func ClosureCallArgs4() { x := 0 _ = func(p int) int { // ERROR "leaking param: p to result ~r0" "func literal does not escape" return p }(&x) } func ClosureCallArgs5() { x := 0 // ERROR "moved to heap: x" // TODO(mdempsky): We get "leaking param: p" here because the new escape analysis pass // can tell that p flows directly to sink, but it's a little weird. Re-evaluate. sink = func(p int) int { // ERROR "leaking param: p" "func literal does not escape" return p }(&x) } func ClosureCallArgs6() { x := 0 // ERROR "moved to heap: x" func(p int) { // ERROR "moved to heap: p" "func literal does not escape" sink = &p }(&x) } func ClosureCallArgs7() { var pp int for { x := 0 // ERROR "moved to heap: x" func(p int) { // ERROR "leaking param: p" "func literal does not escape" pp = p }(&x) } _ = pp } func ClosureCallArgs8() { x := 0 defer func(p int) { // ERROR "p does not escape" "func literal does not escape" p = 1 }(&x) } func ClosureCallArgs9() { // BAD: x should not leak x := 0 // ERROR "moved to heap: x" for { defer func(p int) { // ERROR "func literal escapes to heap" "p does not escape" p = 1 }(&x) } } func ClosureCallArgs10() { for { x := 0 // ERROR "moved to heap: x" defer func(p int) { // ERROR "func literal escapes to heap" "p does not escape" p = 1 }(&x) } } func ClosureCallArgs11() { x := 0 // ERROR "moved to heap: x" defer func(p int) { // ERROR "leaking param: p" "func literal does not escape" sink = p }(&x) } func ClosureCallArgs12() { x := 0 defer func(p int) int { // ERROR "leaking param: p to result ~r0" "func literal does not escape" return p }(&x) } func ClosureCallArgs13() { x := 0 // ERROR "moved to heap: x" defer func(p int) { // ERROR "moved to heap: p" "func literal does not escape" sink = &p }(&x) } func ClosureCallArgs14() { x := 0 p := &x _ = func(p *int) int { // ERROR "leaking param: p to result ~r0 level=1" "func literal does not escape" return p }(&p) } func ClosureCallArgs15() { x := 0 // ERROR "moved to heap: x" p := &x sink = func(p int) int { // ERROR "leaking param content: p" "func literal does not escape" return p }(&p) } func ClosureLeak1(s string) string { // ERROR "s does not escape" t := s + "YYYY" // ERROR "escapes to heap" return ClosureLeak1a(t) // ERROR "... argument does not escape" } // See #14409 -- returning part of captured var leaks it. func ClosureLeak1a(a ...string) string { // ERROR "leaking param: a to result ~r0 level=1$" return func() string { // ERROR "func literal does not escape" return a[0] }() } func ClosureLeak2(s string) string { // ERROR "s does not escape" t := s + "YYYY" // ERROR "escapes to heap" c := ClosureLeak2a(t) // ERROR "... argument does not escape" return c } func ClosureLeak2a(a ...string) string { // ERROR "leaking param content: a" return ClosureLeak2b(func() string { // ERROR "func literal does not escape" return a[0] }) } func ClosureLeak2b(f func() string) string { // ERROR "f does not escape" return f() } func ClosureIndirect() { f := func(p int) {} // ERROR "p does not escape" "func literal does not escape" f(new(int)) // ERROR "new$int$ does not escape" g := f g(new(int)) // ERROR "new$int$ does not escape" h := nopFunc h(new(int)) // ERROR "new$int$ does not escape" } func nopFunc(p int) {} // ERROR "p does not escape" func ClosureIndirect2() { f := func(p int) int { return p } // ERROR "leaking param: p to result ~r0 level=0" "func literal does not escape" f(new(int)) // ERROR "new$int$ does not escape" g := f g(new(int)) // ERROR "new$int$ does not escape" h := nopFunc2 h(new(int)) // ERROR "new$int$ does not escape" } func nopFunc2(p int) *int { return p } // ERROR "leaking param: p to result ~r0 level=0"	4.65 KB	2024-02-02 18:09
📄 escape_field.go // errorcheck -0 -m -l // 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. // Test escape analysis with respect to field assignments. package escape var sink interface{} type X struct { p1 int p2 int a [2]int } type Y struct { x X } func field0() { i := 0 // ERROR "moved to heap: i$" var x X x.p1 = &i sink = x.p1 } func field1() { i := 0 // ERROR "moved to heap: i$" var x X // BAD: &i should not escape x.p1 = &i sink = x.p2 } func field3() { i := 0 // ERROR "moved to heap: i$" var x X x.p1 = &i sink = x // ERROR "x escapes to heap" } func field4() { i := 0 // ERROR "moved to heap: i$" var y Y y.x.p1 = &i x := y.x sink = x // ERROR "x escapes to heap" } func field5() { i := 0 // ERROR "moved to heap: i$" var x X // BAD: &i should not escape here x.a[0] = &i sink = x.a[1] } // BAD: we are not leaking param x, only x.p2 func field6(x X) { // ERROR "leaking param content: x$" sink = x.p2 } func field6a() { i := 0 // ERROR "moved to heap: i$" var x X // BAD: &i should not escape x.p1 = &i field6(&x) } func field7() { i := 0 var y Y y.x.p1 = &i x := y.x var y1 Y y1.x = x _ = y1.x.p1 } func field8() { i := 0 // ERROR "moved to heap: i$" var y Y y.x.p1 = &i x := y.x var y1 Y y1.x = x sink = y1.x.p1 } func field9() { i := 0 // ERROR "moved to heap: i$" var y Y y.x.p1 = &i x := y.x var y1 Y y1.x = x sink = y1.x // ERROR "y1\.x escapes to heap" } func field10() { i := 0 // ERROR "moved to heap: i$" var y Y // BAD: &i should not escape y.x.p1 = &i x := y.x var y1 Y y1.x = x sink = y1.x.p2 } func field11() { i := 0 // ERROR "moved to heap: i$" x := X{p1: &i} sink = x.p1 } func field12() { i := 0 // ERROR "moved to heap: i$" // BAD: &i should not escape x := X{p1: &i} sink = x.p2 } func field13() { i := 0 // ERROR "moved to heap: i$" x := &X{p1: &i} // ERROR "&X{...} does not escape$" sink = x.p1 } func field14() { i := 0 // ERROR "moved to heap: i$" // BAD: &i should not escape x := &X{p1: &i} // ERROR "&X{...} does not escape$" sink = x.p2 } func field15() { i := 0 // ERROR "moved to heap: i$" x := &X{p1: &i} // ERROR "&X{...} escapes to heap$" sink = x } func field16() { i := 0 // ERROR "moved to heap: i$" var x X // BAD: &i should not escape x.p1 = &i var iface interface{} = x // ERROR "x does not escape" x1 := iface.(X) sink = x1.p2 } func field17() { i := 0 // ERROR "moved to heap: i$" var x X x.p1 = &i var iface interface{} = x // ERROR "x does not escape" x1 := iface.(X) sink = x1.p1 } func field18() { i := 0 // ERROR "moved to heap: i$" var x X // BAD: &i should not escape x.p1 = &i var iface interface{} = x // ERROR "x does not escape" y, _ := iface.(Y) // Put X, but extracted Y. The cast will fail, so y is zero initialized. sink = y // ERROR "y escapes to heap" }	2.92 KB	2024-02-02 18:09
📄 escape_goto.go // errorcheck -0 -m -l // 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. // Test escape analysis for goto statements. package escape var x bool func f1() { var p int loop: if x { goto loop } // BAD: We should be able to recognize that there // aren't any more "goto loop" after here. p = new(int) // ERROR "escapes to heap" _ = p } func f2() { var p int if x { loop: goto loop } else { p = new(int) // ERROR "does not escape" } _ = p } func f3() { var p *int if x { loop: goto loop } p = new(int) // ERROR "does not escape" _ = p }	677 B	2024-02-02 18:09
📄 escape_hash_maphash.go // errorcheck -0 -m -l // 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. // Test escape analysis for hash/maphash. package escape import ( "hash/maphash" ) func f() { var x maphash.Hash // should be stack allocatable x.WriteString("foo") x.Sum64() }	368 B	2024-02-02 18:09
📄 escape_iface.go // errorcheck -0 -m -l // 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. // Test escape analysis for interface conversions. package escape var sink interface{} type M interface { M() } func mescapes(m M) { // ERROR "leaking param: m" sink = m } func mdoesnotescape(m M) { // ERROR "m does not escape" } // Tests for type stored directly in iface and with value receiver method. type M0 struct { p int } func (M0) M() { } func efaceEscape0() { { i := 0 v := M0{&i} var x M = v _ = x } { i := 0 // ERROR "moved to heap: i" v := M0{&i} var x M = v sink = x } { i := 0 v := M0{&i} var x M = v v1 := x.(M0) _ = v1 } { i := 0 // ERROR "moved to heap: i" v := M0{&i} // BAD: v does not escape to heap here var x M = v v1 := x.(M0) sink = v1 } { i := 0 v := M0{&i} var x M = v x.M() // ERROR "devirtualizing x.M" } { i := 0 // ERROR "moved to heap: i" v := M0{&i} var x M = v mescapes(x) } { i := 0 v := M0{&i} var x M = v mdoesnotescape(x) } } // Tests for type stored indirectly in iface and with value receiver method. type M1 struct { p int x int } func (M1) M() { } func efaceEscape1() { { i := 0 v := M1{&i, 0} var x M = v // ERROR "v does not escape" _ = x } { i := 0 // ERROR "moved to heap: i" v := M1{&i, 0} var x M = v // ERROR "v escapes to heap" sink = x } { i := 0 v := M1{&i, 0} var x M = v // ERROR "v does not escape" v1 := x.(M1) _ = v1 } { i := 0 // ERROR "moved to heap: i" v := M1{&i, 0} var x M = v // ERROR "v does not escape" v1 := x.(M1) sink = v1 // ERROR "v1 escapes to heap" } { i := 0 v := M1{&i, 0} var x M = v // ERROR "v does not escape" x.M() // ERROR "devirtualizing x.M" } { i := 0 // ERROR "moved to heap: i" v := M1{&i, 0} var x M = v // ERROR "v escapes to heap" mescapes(x) } { i := 0 v := M1{&i, 0} var x M = v // ERROR "v does not escape" mdoesnotescape(x) } } // Tests for type stored directly in iface and with pointer receiver method. type M2 struct { p int } func (M2) M() { } func efaceEscape2() { { i := 0 v := &M2{&i} // ERROR "&M2{...} does not escape" var x M = v _ = x } { i := 0 // ERROR "moved to heap: i" v := &M2{&i} // ERROR "&M2{...} escapes to heap" var x M = v sink = x } { i := 0 v := &M2{&i} // ERROR "&M2{...} does not escape" var x M = v v1 := x.(M2) _ = v1 } { i := 0 // ERROR "moved to heap: i" v := &M2{&i} // ERROR "&M2{...} escapes to heap" // BAD: v does not escape to heap here var x M = v v1 := x.(M2) sink = v1 } { i := 0 // ERROR "moved to heap: i" v := &M2{&i} // ERROR "&M2{...} does not escape" // BAD: v does not escape to heap here var x M = v v1 := x.(M2) sink = v1 } { i := 0 // ERROR "moved to heap: i" v := &M2{&i} // ERROR "&M2{...} does not escape" // BAD: v does not escape to heap here var x M = v v1, ok := x.(M2) sink = v1 _ = ok } { i := 0 v := &M2{&i} // ERROR "&M2{...} does not escape" var x M = v x.M() // ERROR "devirtualizing x.M" } { i := 0 // ERROR "moved to heap: i" v := &M2{&i} // ERROR "&M2{...} escapes to heap" var x M = v mescapes(x) } { i := 0 v := &M2{&i} // ERROR "&M2{...} does not escape" var x M = v mdoesnotescape(x) } } type T1 struct { p int } type T2 struct { T1 T1 } func dotTypeEscape() T2 { // #11931 var x interface{} x = &T1{p: new(int)} // ERROR "new$int$ escapes to heap" "&T1{...} does not escape" return &T2{ // ERROR "&T2{...} escapes to heap" T1: (x.(T1)), } } func dotTypeEscape2() { // #13805, #15796 { i := 0 j := 0 var v int var ok bool var x interface{} = i // ERROR "i does not escape" var y interface{} = j // ERROR "j does not escape" (&v) = x.(int) (&v), (&ok) = y.(int) } { // #13805, #15796 i := 0 j := 0 var ok bool var x interface{} = i // ERROR "i does not escape" var y interface{} = j // ERROR "j does not escape" sink = x.(int) // ERROR "x.$int$ escapes to heap" sink, (&ok) = y.(int) // ERROR "autotmp_.* escapes to heap" } { i := 0 // ERROR "moved to heap: i" j := 0 // ERROR "moved to heap: j" var ok bool var x interface{} = &i var y interface{} = &j sink = x.(int) sink, (&ok) = y.(*int) } } func issue42279() { type I interface{ M() } type T struct{ I } var i I = T{} // ERROR "T\{\} does not escape" i.M() // ERROR "partially devirtualizing i.M to T" }	4.53 KB	2024-02-02 18:09
📄 escape_indir.go // errorcheck -0 -m -l // 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. // Test escape analysis when assigning to indirections. package escape var sink interface{} type ConstPtr struct { p int c ConstPtr2 x ConstPtr } type ConstPtr2 struct { p int i int } func constptr0() { i := 0 // ERROR "moved to heap: i" x := &ConstPtr{} // ERROR "&ConstPtr{} does not escape" // BAD: i should not escape here x.p = &i _ = x } func constptr01() ConstPtr { i := 0 // ERROR "moved to heap: i" x := &ConstPtr{} // ERROR "&ConstPtr{} escapes to heap" x.p = &i return x } func constptr02() ConstPtr { i := 0 // ERROR "moved to heap: i" x := &ConstPtr{} // ERROR "&ConstPtr{} does not escape" x.p = &i return x } func constptr03() *ConstPtr { i := 0 // ERROR "moved to heap: i" x := &ConstPtr{} // ERROR "&ConstPtr{} escapes to heap" "moved to heap: x" x.p = &i return &x } func constptr1() { i := 0 // ERROR "moved to heap: i" x := &ConstPtr{} // ERROR "&ConstPtr{} escapes to heap" x.p = &i sink = x } func constptr2() { i := 0 // ERROR "moved to heap: i" x := &ConstPtr{} // ERROR "&ConstPtr{} does not escape" x.p = &i sink = x // ERROR "\x escapes to heap" } func constptr4() ConstPtr { p := new(ConstPtr) // ERROR "new$ConstPtr$ escapes to heap" p = &ConstPtr{} // ERROR "&ConstPtr{} does not escape" return p } func constptr5() ConstPtr { p := new(ConstPtr) // ERROR "new$ConstPtr$ escapes to heap" p1 := &ConstPtr{} // ERROR "&ConstPtr{} does not escape" p = p1 return p } // BAD: p should not escape here func constptr6(p ConstPtr) { // ERROR "leaking param content: p" p1 := &ConstPtr{} // ERROR "&ConstPtr{} does not escape" p1 = p _ = p1 } func constptr7() *ConstPtr { p := new(ConstPtr) // ERROR "new$ConstPtr$ escapes to heap" "moved to heap: p" var tmp ConstPtr2 p1 := &tmp p.c = p1 return &p } func constptr8() ConstPtr { p := new(ConstPtr) // ERROR "new$ConstPtr$ escapes to heap" var tmp ConstPtr2 p.c = &tmp return p } func constptr9() ConstPtr { p := new(ConstPtr) // ERROR "new$ConstPtr$ does not escape" var p1 ConstPtr2 i := 0 // ERROR "moved to heap: i" p1.p = &i p.c = p1 return p } func constptr10() ConstPtr { x := &ConstPtr{} // ERROR "moved to heap: x" "&ConstPtr{} escapes to heap" i := 0 // ERROR "moved to heap: i" var p ConstPtr p = &ConstPtr{p: &i, x: &x} // ERROR "&ConstPtr{...} does not escape" var pp ConstPtr pp = &p return pp } func constptr11() ConstPtr { i := 0 // ERROR "moved to heap: i" p := new(ConstPtr) // ERROR "new$ConstPtr$ escapes to heap" p1 := &ConstPtr{} // ERROR "&ConstPtr{} does not escape" p1.p = &i p = p1 return p } func foo(p int) { // ERROR "p does not escape" i := 0 // ERROR "moved to heap: i" y := p y = &i } func foo1(p int) { // ERROR "p does not escape" i := 0 // ERROR "moved to heap: i" y := &p y = &i } func foo2() { type Z struct { f *int } x := new(int) // ERROR "moved to heap: x" "new$int$ escapes to heap" sink = &x var z Z z.f = &x p := z.f i := 0 // ERROR "moved to heap: i" p = &i } var global byte func f() { var x byte // ERROR "moved to heap: x" global = &&x }	3.31 KB	2024-02-02 18:09
📄 escape_level.go // errorcheck -0 -m -l // 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. // Test indirection level computation in escape analysis. package escape var sink interface{} func level0() { i := 0 // ERROR "moved to heap: i" p0 := &i // ERROR "moved to heap: p0" p1 := &p0 // ERROR "moved to heap: p1" p2 := &p1 // ERROR "moved to heap: p2" sink = &p2 } func level1() { i := 0 // ERROR "moved to heap: i" p0 := &i // ERROR "moved to heap: p0" p1 := &p0 // ERROR "moved to heap: p1" p2 := &p1 sink = p2 } func level2() { i := 0 // ERROR "moved to heap: i" p0 := &i // ERROR "moved to heap: p0" p1 := &p0 p2 := &p1 sink = p2 } func level3() { i := 0 // ERROR "moved to heap: i" p0 := &i p1 := &p0 p2 := &p1 sink = p2 } func level4() { i := 0 // ERROR "moved to heap: i" p0 := &i // ERROR "moved to heap: p0" p1 := &p0 p2 := p1 // ERROR "moved to heap: p2" sink = &p2 } func level5() { i := 0 // ERROR "moved to heap: i" p0 := &i // ERROR "moved to heap: p0" p1 := &p0 p2 := p1 sink = p2 } func level6() { i := 0 // ERROR "moved to heap: i" p0 := &i p1 := &p0 p2 := p1 sink = p2 } func level7() { i := 0 // ERROR "moved to heap: i" p0 := &i p1 := &p0 // note p1 == &i p2 := p1 // ERROR "moved to heap: p2" sink = &p2 } func level8() { i := 0 // ERROR "moved to heap: i" p0 := &i p1 := &p0 p2 := p1 sink = p2 } func level9() { i := 0 p0 := &i p1 := &p0 p2 := p1 sink = p2 // ERROR "\p2 escapes to heap" } func level10() { i := 0 p0 := &i p1 := p0 p2 := &p1 sink = p2 // ERROR "\p2 escapes to heap" } func level11() { i := 0 p0 := &i p1 := &p0 p2 := *p1 // ERROR "moved to heap: p2" sink = &p2 }	1.79 KB	2024-02-02 18:09
📄 escape_map.go // errorcheck -0 -m -l // 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. // Test escape analysis for maps. package escape var sink interface{} func map0() { m := make(map[int]int) // ERROR "make$map\[\int\]\int$ does not escape" // BAD: i should not escape i := 0 // ERROR "moved to heap: i" // BAD: j should not escape j := 0 // ERROR "moved to heap: j" m[&i] = &j _ = m } func map1() int { m := make(map[int]int) // ERROR "make$map\[\int\]\int$ does not escape" // BAD: i should not escape i := 0 // ERROR "moved to heap: i" j := 0 // ERROR "moved to heap: j" m[&i] = &j return m[&i] } func map2() map[int]int { m := make(map[int]int) // ERROR "make$map\[\int\]\int$ escapes to heap" i := 0 // ERROR "moved to heap: i" j := 0 // ERROR "moved to heap: j" m[&i] = &j return m } func map3() []int { m := make(map[int]int) // ERROR "make$map\[\int\]\int$ does not escape" i := 0 // ERROR "moved to heap: i" // BAD: j should not escape j := 0 // ERROR "moved to heap: j" m[&i] = &j var r []int for k := range m { r = append(r, k) } return r } func map4() []int { m := make(map[int]int) // ERROR "make$map\[\int\]\int$ does not escape" // BAD: i should not escape i := 0 // ERROR "moved to heap: i" j := 0 // ERROR "moved to heap: j" m[&i] = &j var r []int for k, v := range m { // We want to test exactly "for k, v := range m" rather than "for _, v := range m". // The following if is merely to use (but not leak) k. if k != nil { r = append(r, v) } } return r } func map5(m map[int]int) { // ERROR "m does not escape" i := 0 // ERROR "moved to heap: i" j := 0 // ERROR "moved to heap: j" m[&i] = &j } func map6(m map[int]int) { // ERROR "m does not escape" if m != nil { m = make(map[int]int) // ERROR "make$map\[\int\]\int$ does not escape" } i := 0 // ERROR "moved to heap: i" j := 0 // ERROR "moved to heap: j" m[&i] = &j } func map7() { // BAD: i should not escape i := 0 // ERROR "moved to heap: i" // BAD: j should not escape j := 0 // ERROR "moved to heap: j" m := map[int]int{&i: &j} // ERROR "map\[\int\]\int{...} does not escape" _ = m } func map8() { i := 0 // ERROR "moved to heap: i" j := 0 // ERROR "moved to heap: j" m := map[int]int{&i: &j} // ERROR "map\[\int\]\int{...} escapes to heap" sink = m } func map9() int { // BAD: i should not escape i := 0 // ERROR "moved to heap: i" j := 0 // ERROR "moved to heap: j" m := map[int]int{&i: &j} // ERROR "map\[\int\]\int{...} does not escape" return m[nil] }	2.76 KB	2024-02-02 18:09
📄 escape_mutations.go // errorcheck -0 -m -d=escapemutationscalls,zerocopy -l // Copyright 2023 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 p import "fmt" type B struct { x int px int pb B } func F1(b B) { // ERROR "mutates param: b derefs=0" b.x = 1 } func F2(b B) { // ERROR "mutates param: b derefs=1" b.px = 1 } func F2a(b B) { // ERROR "mutates param: b derefs=0" b.px = nil } func F3(b B) { // ERROR "leaking param: b" fmt.Println(b) // ERROR "\.\.\. argument does not escape" } func F4(b B) { // ERROR "leaking param content: b" fmt.Println(b) // ERROR "\.\.\. argument does not escape" "\b escapes to heap" } func F4a(b B) { // ERROR "leaking param content: b" "mutates param: b derefs=0" b.x = 2 fmt.Println(b) // ERROR "\.\.\. argument does not escape" "\b escapes to heap" } func F5(b B) { // ERROR "leaking param: b" sink = b } func F6(b *B) int { // ERROR "b does not escape, mutate, or call" return b.x } var sink any func M() { var b B // ERROR "moved to heap: b" F1(&b) F2(&b) F2a(&b) F3(&b) F4(&b) } func g(s string) { // ERROR "s does not escape, mutate, or call" sink = &([]byte(s))[10] // ERROR "$\[\]byte$$s$ escapes to heap" } func h(out []byte, s string) { // ERROR "mutates param: out derefs=0" "s does not escape, mutate, or call" copy(out, []byte(s)) // ERROR "zero-copy string->\[\]byte conversion" "$\[\]byte$$s$ does not escape" } func i(s string) byte { // ERROR "s does not escape, mutate, or call" p := []byte(s) // ERROR "zero-copy string->\[\]byte conversion" "$\[\]byte$$s$ does not escape" return p[20] } func j(s string, x byte) { // ERROR "s does not escape, mutate, or call" p := []byte(s) // ERROR "$\[\]byte$$s$ does not escape" p[20] = x }	1.79 KB	2024-02-02 18:09
📄 escape_param.go // errorcheck -0 -m -l // 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. // Test escape analysis for function parameters. // In this test almost everything is BAD except the simplest cases // where input directly flows to output. package escape func zero() int { return 0 } var sink interface{} // in -> out func param0(p int) int { // ERROR "leaking param: p to result ~r0" return p } func caller0a() { i := 0 _ = param0(&i) } func caller0b() { i := 0 // ERROR "moved to heap: i$" sink = param0(&i) } // in, in -> out, out func param1(p1, p2 int) (int, int) { // ERROR "leaking param: p1 to result ~r0" "leaking param: p2 to result ~r1" return p1, p2 } func caller1() { i := 0 // ERROR "moved to heap: i$" j := 0 sink, _ = param1(&i, &j) } // in -> other in func param2(p1 int, p2 *int) { // ERROR "leaking param: p1$" "p2 does not escape$" p2 = p1 } func caller2a() { i := 0 // ERROR "moved to heap: i$" var p int param2(&i, &p) _ = p } func caller2b() { i := 0 // ERROR "moved to heap: i$" var p int param2(&i, &p) sink = p } func paramArraySelfAssign(p PairOfPairs) { // ERROR "p does not escape" p.pairs[0] = p.pairs[1] // ERROR "ignoring self-assignment in p.pairs\[0\] = p.pairs\[1\]" } func paramArraySelfAssignUnsafeIndex(p PairOfPairs) { // ERROR "leaking param content: p" // Function call inside index disables self-assignment case to trigger. p.pairs[zero()] = p.pairs[1] p.pairs[zero()+1] = p.pairs[1] } type PairOfPairs struct { pairs [2]Pair } type BoxedPair struct { pair Pair } type WrappedPair struct { pair Pair } func leakParam(x interface{}) { // ERROR "leaking param: x" sink = x } func sinkAfterSelfAssignment1(box BoxedPair) { // ERROR "leaking param content: box" box.pair.p1 = box.pair.p2 // ERROR "ignoring self-assignment in box.pair.p1 = box.pair.p2" sink = box.pair.p2 } func sinkAfterSelfAssignment2(box BoxedPair) { // ERROR "leaking param content: box" box.pair.p1 = box.pair.p2 // ERROR "ignoring self-assignment in box.pair.p1 = box.pair.p2" sink = box.pair } func sinkAfterSelfAssignment3(box BoxedPair) { // ERROR "leaking param content: box" box.pair.p1 = box.pair.p2 // ERROR "ignoring self-assignment in box.pair.p1 = box.pair.p2" leakParam(box.pair.p2) } func sinkAfterSelfAssignment4(box BoxedPair) { // ERROR "leaking param content: box" box.pair.p1 = box.pair.p2 // ERROR "ignoring self-assignment in box.pair.p1 = box.pair.p2" leakParam(box.pair) } func selfAssignmentAndUnrelated(box1, box2 BoxedPair) { // ERROR "leaking param content: box2" "box1 does not escape" box1.pair.p1 = box1.pair.p2 // ERROR "ignoring self-assignment in box1.pair.p1 = box1.pair.p2" leakParam(box2.pair.p2) } func notSelfAssignment1(box1, box2 BoxedPair) { // ERROR "leaking param content: box2" "box1 does not escape" box1.pair.p1 = box2.pair.p1 } func notSelfAssignment2(p1, p2 PairOfPairs) { // ERROR "leaking param content: p2" "p1 does not escape" p1.pairs[0] = p2.pairs[1] } func notSelfAssignment3(p1, p2 PairOfPairs) { // ERROR "leaking param content: p2" "p1 does not escape" p1.pairs[0].p1 = p2.pairs[1].p1 } func boxedPairSelfAssign(box BoxedPair) { // ERROR "box does not escape" box.pair.p1 = box.pair.p2 // ERROR "ignoring self-assignment in box.pair.p1 = box.pair.p2" } func wrappedPairSelfAssign(w WrappedPair) { // ERROR "w does not escape" w.pair.p1 = w.pair.p2 // ERROR "ignoring self-assignment in w.pair.p1 = w.pair.p2" } // in -> in type Pair struct { p1 int p2 int } func param3(p Pair) { // ERROR "p does not escape" p.p1 = p.p2 // ERROR "param3 ignoring self-assignment in p.p1 = p.p2" } func caller3a() { i := 0 j := 0 p := Pair{&i, &j} param3(&p) _ = p } func caller3b() { i := 0 // ERROR "moved to heap: i$" j := 0 // ERROR "moved to heap: j$" p := Pair{&i, &j} param3(&p) sink = p // ERROR "p escapes to heap$" } // in -> rcvr func (p Pair) param4(i int) { // ERROR "p does not escape$" "leaking param: i$" p.p1 = i } func caller4a() { i := 0 // ERROR "moved to heap: i$" p := Pair{} p.param4(&i) _ = p } func caller4b() { i := 0 // ERROR "moved to heap: i$" p := Pair{} p.param4(&i) sink = p // ERROR "p escapes to heap$" } // in -> heap func param5(i int) { // ERROR "leaking param: i$" sink = i } func caller5() { i := 0 // ERROR "moved to heap: i$" param5(&i) } // in -> heap func param6(i *int) { // ERROR "leaking param content: i$" sink = i } func caller6a() { i := 0 // ERROR "moved to heap: i$" p := &i // ERROR "moved to heap: p$" p2 := &p param6(&p2) } // in -> heap func param7(i int) { // ERROR "leaking param content: i$" sink = i } func caller7() { i := 0 // ERROR "moved to heap: i$" p := &i p2 := &p param7(&p2) } // in -> heap func param8(i int) { // ERROR "i does not escape$" sink = i // ERROR "\$\i$ escapes to heap" } func caller8() { i := 0 p := &i param8(&p) } // in -> out func param9(p *int) int { // ERROR "leaking param: p to result ~r0 level=1" return p } func caller9a() { i := 0 p := &i p2 := &p _ = param9(&p2) } func caller9b() { i := 0 // ERROR "moved to heap: i$" p := &i // ERROR "moved to heap: p$" p2 := &p sink = param9(&p2) } // in -> out func param10(p *int) int { // ERROR "leaking param: p to result ~r0 level=2" return p } func caller10a() { i := 0 p := &i p2 := &p _ = param10(&p2) } func caller10b() { i := 0 // ERROR "moved to heap: i$" p := &i p2 := &p sink = param10(&p2) } // in escapes to heap (address of param taken and returned) func param11(i int) **int { // ERROR "moved to heap: i$" return &i } func caller11a() { i := 0 // ERROR "moved to heap: i" p := &i // ERROR "moved to heap: p" _ = param11(&p) } func caller11b() { i := 0 // ERROR "moved to heap: i$" p := &i // ERROR "moved to heap: p$" sink = param11(&p) } func caller11c() { // GOOD i := 0 // ERROR "moved to heap: i$" p := &i // ERROR "moved to heap: p" sink = param11(&p) } func caller11d() { i := 0 // ERROR "moved to heap: i$" p := &i // ERROR "moved to heap: p" p2 := &p sink = param11(p2) } // &in -> rcvr type Indir struct { p **int } func (r Indir) param12(i int) { // ERROR "r does not escape$" "moved to heap: i$" r.p = &i } func caller12a() { i := 0 // ERROR "moved to heap: i$" p := &i // ERROR "moved to heap: p$" var r Indir r.param12(&p) _ = r } func caller12b() { i := 0 // ERROR "moved to heap: i$" p := &i // ERROR "moved to heap: p$" r := &Indir{} // ERROR "&Indir{} does not escape$" r.param12(&p) _ = r } func caller12c() { i := 0 // ERROR "moved to heap: i$" p := &i // ERROR "moved to heap: p$" r := Indir{} r.param12(&p) sink = r } func caller12d() { i := 0 // ERROR "moved to heap: i$" p := &i // ERROR "moved to heap: p$" r := Indir{} r.param12(&p) sink = r.p } // in -> value rcvr type Val struct { p *int } func (v Val) param13(i int) { // ERROR "v does not escape$" "leaking param: i$" v.p = i } func caller13a() { i := 0 // ERROR "moved to heap: i$" var p int var v Val v.p = &p v.param13(&i) _ = v } func caller13b() { i := 0 // ERROR "moved to heap: i$" var p int v := Val{&p} v.param13(&i) _ = v } func caller13c() { i := 0 // ERROR "moved to heap: i$" var p int v := &Val{&p} // ERROR "&Val{...} does not escape$" v.param13(&i) _ = v } func caller13d() { i := 0 // ERROR "moved to heap: i$" var p int // ERROR "moved to heap: p$" var v Val v.p = &p v.param13(&i) sink = v } func caller13e() { i := 0 // ERROR "moved to heap: i$" var p int // ERROR "moved to heap: p$" v := Val{&p} v.param13(&i) sink = v } func caller13f() { i := 0 // ERROR "moved to heap: i$" var p int // ERROR "moved to heap: p$" v := &Val{&p} // ERROR "&Val{...} escapes to heap$" v.param13(&i) sink = v } func caller13g() { i := 0 // ERROR "moved to heap: i$" var p int v := Val{&p} v.param13(&i) sink = v.p } func caller13h() { i := 0 // ERROR "moved to heap: i$" var p int v := &Val{&p} // ERROR "&Val{...} does not escape$" v.param13(&i) sink = *v.p // ERROR "\$\v\.p$ escapes to heap" } type Node struct { p Node } var Sink Node func f(x Node) { // ERROR "leaking param content: x" Sink = &Node{x.p} // ERROR "&Node{...} escapes to heap" } func g(x Node) Node { // ERROR "leaking param content: x" return &Node{x.p} // ERROR "&Node{...} escapes to heap" } func h(x Node) { // ERROR "leaking param: x" y := &Node{x} // ERROR "&Node{...} does not escape" Sink = g(y) f(y) } // interface(in) -> out // See also issue 29353. // Convert to a non-direct interface, require an allocation and // copy x to heap (not to result). func param14a(x [4]int) interface{} { // ERROR "leaking param: x$" return x // ERROR "x escapes to heap" } // Convert to a direct interface, does not need an allocation. // So x only leaks to result. func param14b(x *int) interface{} { // ERROR "leaking param: x to result ~r0 level=0" return x }	8.9 KB	2024-02-02 18:09
📄 escape_reflect.go // errorcheck -0 -m -l // Copyright 2022 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 escape analysis for reflect Value operations. package escape import ( "reflect" "unsafe" ) var sink interface{} func typ(x int) any { v := reflect.ValueOf(x) // ERROR "x does not escape" return v.Type() } func kind(x int) reflect.Kind { v := reflect.ValueOf(x) // ERROR "x does not escape" return v.Kind() } func int1(x int) int { v := reflect.ValueOf(x) // ERROR "x does not escape" return int(v.Int()) } func ptr(x int) int { // ERROR "leaking param: x to result ~r0 level=0" v := reflect.ValueOf(x) return (int)(v.UnsafePointer()) } func bytes1(x []byte) byte { // ERROR "x does not escape" v := reflect.ValueOf(x) // ERROR "x does not escape" return v.Bytes()[0] } // Unfortunate: should only escape content. x (the interface storage) should not escape. func bytes2(x []byte) []byte { // ERROR "leaking param: x$" v := reflect.ValueOf(x) // ERROR "x escapes to heap" return v.Bytes() } func string1(x string) string { // ERROR "leaking param: x to result ~r0 level=0" v := reflect.ValueOf(x) // ERROR "x does not escape" return v.String() } func string2(x int) string { v := reflect.ValueOf(x) // ERROR "x does not escape" return v.String() } // Unfortunate: should only escape to result. func interface1(x any) any { // ERROR "leaking param: x$" v := reflect.ValueOf(x) return v.Interface() } func interface2(x int) any { v := reflect.ValueOf(x) // ERROR "x escapes to heap" return v.Interface() } // Unfortunate: should not escape. func interface3(x int) int { v := reflect.ValueOf(x) // ERROR "x escapes to heap" return v.Interface().(int) } // Unfortunate: should only escape to result. func interface4(x int) any { // ERROR "leaking param: x$" v := reflect.ValueOf(x) return v.Interface() } func addr(x int) reflect.Value { // ERROR "leaking param: x to result ~r0 level=0" v := reflect.ValueOf(x).Elem() return v.Addr() } // functions returning pointer as uintptr have to escape. func uintptr1(x int) uintptr { // ERROR "leaking param: x$" v := reflect.ValueOf(x) return v.Pointer() } func unsafeaddr(x int) uintptr { // ERROR "leaking param: x$" v := reflect.ValueOf(x).Elem() return v.UnsafeAddr() } func ifacedata(x any) [2]uintptr { // ERROR "moved to heap: x" v := reflect.ValueOf(&x).Elem() return v.InterfaceData() } func can(x int) bool { v := reflect.ValueOf(x) // ERROR "x does not escape" return v.CanAddr() \|\| v.CanInt() \|\| v.CanSet() \|\| v.CanInterface() } func is(x int) bool { v := reflect.ValueOf(x) // ERROR "x does not escape" return v.IsValid() \|\| v.IsNil() \|\| v.IsZero() } func is2(x [2]int) bool { v := reflect.ValueOf(x) // ERROR "x does not escape" return v.IsValid() \|\| v.IsNil() \|\| v.IsZero() } func is3(x struct{ a, b int }) bool { v := reflect.ValueOf(x) // ERROR "x does not escape" return v.IsValid() \|\| v.IsNil() \|\| v.IsZero() } func overflow(x int) bool { v := reflect.ValueOf(x) // ERROR "x does not escape" return v.OverflowInt(1 << 62) } func len1(x []int) int { // ERROR "x does not escape" v := reflect.ValueOf(x) // ERROR "x does not escape" return v.Len() } func len2(x [3]int) int { v := reflect.ValueOf(x) // ERROR "x does not escape" return v.Len() } func len3(x string) int { // ERROR "x does not escape" v := reflect.ValueOf(x) // ERROR "x does not escape" return v.Len() } func len4(x map[int]int) int { // ERROR "x does not escape" v := reflect.ValueOf(x) return v.Len() } func len5(x chan int) int { // ERROR "x does not escape" v := reflect.ValueOf(x) return v.Len() } func cap1(x []int) int { // ERROR "x does not escape" v := reflect.ValueOf(x) // ERROR "x does not escape" return v.Cap() } func cap2(x [3]int) int { v := reflect.ValueOf(x) // ERROR "x does not escape" return v.Cap() } func cap3(x chan int) int { // ERROR "x does not escape" v := reflect.ValueOf(x) return v.Cap() } func setlen(x []int, n int) { // ERROR "x does not escape" v := reflect.ValueOf(x).Elem() v.SetLen(n) } func setcap(x []int, n int) { // ERROR "x does not escape" v := reflect.ValueOf(x).Elem() v.SetCap(n) } // Unfortunate: x doesn't need to escape to heap, just to result. func slice1(x []byte) []byte { // ERROR "leaking param: x$" v := reflect.ValueOf(x) // ERROR "x escapes to heap" return v.Slice(1, 2).Bytes() } // Unfortunate: x doesn't need to escape to heap, just to result. func slice2(x string) string { // ERROR "leaking param: x$" v := reflect.ValueOf(x) // ERROR "x escapes to heap" return v.Slice(1, 2).String() } func slice3(x [10]byte) []byte { v := reflect.ValueOf(x) // ERROR "x escapes to heap" return v.Slice(1, 2).Bytes() } func elem1(x int) int { // ERROR "x does not escape" v := reflect.ValueOf(x) return int(v.Elem().Int()) } func elem2(x string) string { // ERROR "leaking param: x to result ~r0 level=1" v := reflect.ValueOf(x) return string(v.Elem().String()) } type S struct { A int B int C string } func (S) M() {} func field1(x S) int { // ERROR "x does not escape" v := reflect.ValueOf(x) // ERROR "x does not escape" return int(v.Field(0).Int()) } func field2(x S) string { // ERROR "leaking param: x to result ~r0 level=0" v := reflect.ValueOf(x) // ERROR "x does not escape" return v.Field(2).String() } func numfield(x S) int { // ERROR "x does not escape" v := reflect.ValueOf(x) // ERROR "x does not escape" return v.NumField() } func index1(x []int) int { // ERROR "x does not escape" v := reflect.ValueOf(x) // ERROR "x does not escape" return int(v.Index(0).Int()) } // Unfortunate: should only leak content (level=1) func index2(x []string) string { // ERROR "leaking param: x to result ~r0 level=0" v := reflect.ValueOf(x) // ERROR "x does not escape" return v.Index(0).String() } func index3(x [3]int) int { v := reflect.ValueOf(x) // ERROR "x does not escape" return int(v.Index(0).Int()) } func index4(x [3]string) string { // ERROR "leaking param: x to result ~r0 level=0" v := reflect.ValueOf(x) // ERROR "x does not escape" return v.Index(0).String() } func index5(x string) byte { // ERROR "x does not escape" v := reflect.ValueOf(x) // ERROR "x does not escape" return byte(v.Index(0).Uint()) } // Unfortunate: x (the interface storage) doesn't need to escape as the function takes a scalar arg. func call1(f func(int), x int) { // ERROR "leaking param: f$" fv := reflect.ValueOf(f) v := reflect.ValueOf(x) // ERROR "x escapes to heap" fv.Call([]reflect.Value{v}) // ERROR "\[\]reflect\.Value{\.\.\.} does not escape" } func call2(f func(int), x int) { // ERROR "leaking param: f$" "leaking param: x$" fv := reflect.ValueOf(f) v := reflect.ValueOf(x) fv.Call([]reflect.Value{v}) // ERROR "\[\]reflect.Value{\.\.\.} does not escape" } func method(x S) reflect.Value { // ERROR "leaking param: x$" v := reflect.ValueOf(x) // ERROR "x escapes to heap" return v.Method(0) } func nummethod(x S) int { // ERROR "x does not escape" v := reflect.ValueOf(x) // ERROR "x does not escape" return v.NumMethod() } // Unfortunate: k doesn't need to escape. func mapindex(m map[string]string, k string) string { // ERROR "m does not escape" "leaking param: k$" mv := reflect.ValueOf(m) kv := reflect.ValueOf(k) // ERROR "k escapes to heap" return mv.MapIndex(kv).String() } func mapkeys(m map[string]string) []reflect.Value { // ERROR "m does not escape" mv := reflect.ValueOf(m) return mv.MapKeys() } func mapiter1(m map[string]string) reflect.MapIter { // ERROR "leaking param: m$" mv := reflect.ValueOf(m) return mv.MapRange() } func mapiter2(m map[string]string) string { // ERROR "leaking param: m$" mv := reflect.ValueOf(m) it := mv.MapRange() if it.Next() { return it.Key().String() } return "" } func mapiter3(m map[string]string, it reflect.MapIter) { // ERROR "leaking param: m$" "it does not escape" mv := reflect.ValueOf(m) it.Reset(mv) } func recv1(ch chan string) string { // ERROR "ch does not escape" v := reflect.ValueOf(ch) r, _ := v.Recv() return r.String() } func recv2(ch chan string) string { // ERROR "ch does not escape" v := reflect.ValueOf(ch) r, _ := v.TryRecv() return r.String() } // Unfortunate: x (the interface storage) doesn't need to escape. func send1(ch chan string, x string) { // ERROR "ch does not escape" "leaking param: x$" vc := reflect.ValueOf(ch) vx := reflect.ValueOf(x) // ERROR "x escapes to heap" vc.Send(vx) } // Unfortunate: x (the interface storage) doesn't need to escape. func send2(ch chan string, x string) bool { // ERROR "ch does not escape" "leaking param: x$" vc := reflect.ValueOf(ch) vx := reflect.ValueOf(x) // ERROR "x escapes to heap" return vc.TrySend(vx) } func close1(ch chan string) { // ERROR "ch does not escape" v := reflect.ValueOf(ch) v.Close() } func select1(ch chan string) string { // ERROR "leaking param: ch$" v := reflect.ValueOf(ch) cas := reflect.SelectCase{Dir: reflect.SelectRecv, Chan: v} _, r, _ := reflect.Select([]reflect.SelectCase{cas}) // ERROR "\[\]reflect.SelectCase{...} does not escape" return r.String() } // Unfortunate: x (the interface storage) doesn't need to escape. func select2(ch chan string, x string) { // ERROR "leaking param: ch$" "leaking param: x$" vc := reflect.ValueOf(ch) vx := reflect.ValueOf(x) // ERROR "x escapes to heap" cas := reflect.SelectCase{Dir: reflect.SelectSend, Chan: vc, Send: vx} reflect.Select([]reflect.SelectCase{cas}) // ERROR "\[\]reflect.SelectCase{...} does not escape" } var ( intTyp = reflect.TypeOf(int(0)) // ERROR "0 does not escape" uintTyp = reflect.TypeOf(uint(0)) // ERROR "uint$0$ does not escape" stringTyp = reflect.TypeOf(string("")) // ERROR ".. does not escape" bytesTyp = reflect.TypeOf([]byte{}) // ERROR "\[\]byte{} does not escape" ) // Unfortunate: should not escape. func convert1(x int) uint { v := reflect.ValueOf(x) // ERROR "x escapes to heap" return uint(v.Convert(uintTyp).Uint()) } // Unfortunate: should only escape content to result. func convert2(x []byte) string { // ERROR "leaking param: x$" v := reflect.ValueOf(x) // ERROR "x escapes to heap" return v.Convert(stringTyp).String() } // Unfortunate: v doesn't need to leak, x (the interface storage) doesn't need to escape. func set1(v reflect.Value, x int) { // ERROR "leaking param: v$" vx := reflect.ValueOf(x) // ERROR "x escapes to heap" v.Set(vx) } // Unfortunate: a can be stack allocated, x (the interface storage) doesn't need to escape. func set2(x int) int64 { var a int // ERROR "moved to heap: a" v := reflect.ValueOf(&a).Elem() vx := reflect.ValueOf(x) // ERROR "x escapes to heap" v.Set(vx) return v.Int() } func set3(v reflect.Value, x int) { // ERROR "v does not escape" v.SetInt(int64(x)) } func set4(x int) int { var a int v := reflect.ValueOf(&a).Elem() // a should not escape, no error printed v.SetInt(int64(x)) return int(v.Int()) } func set5(v reflect.Value, x string) { // ERROR "v does not escape" "leaking param: x$" v.SetString(x) } func set6(v reflect.Value, x []byte) { // ERROR "v does not escape" "leaking param: x$" v.SetBytes(x) } func set7(v reflect.Value, x unsafe.Pointer) { // ERROR "v does not escape" "leaking param: x$" v.SetPointer(x) } func setmapindex(m map[string]string, k, e string) { // ERROR "m does not escape" "leaking param: k$" "leaking param: e$" mv := reflect.ValueOf(m) kv := reflect.ValueOf(k) // ERROR "k escapes to heap" ev := reflect.ValueOf(e) // ERROR "e escapes to heap" mv.SetMapIndex(kv, ev) } // Unfortunate: k doesn't need to escape. func mapdelete(m map[string]string, k string) { // ERROR "m does not escape" "leaking param: k$" mv := reflect.ValueOf(m) kv := reflect.ValueOf(k) // ERROR "k escapes to heap" mv.SetMapIndex(kv, reflect.Value{}) } // Unfortunate: v doesn't need to leak. func setiterkey1(v reflect.Value, it reflect.MapIter) { // ERROR "leaking param: v$" "it does not escape" v.SetIterKey(it) } // Unfortunate: v doesn't need to leak. func setiterkey2(v reflect.Value, m map[string]string) { // ERROR "leaking param: v$" "leaking param: m$" it := reflect.ValueOf(m).MapRange() v.SetIterKey(it) } // Unfortunate: v doesn't need to leak. func setitervalue1(v reflect.Value, it reflect.MapIter) { // ERROR "leaking param: v$" "it does not escape" v.SetIterValue(it) } // Unfortunate: v doesn't need to leak. func setitervalue2(v reflect.Value, m map[string]string) { // ERROR "leaking param: v$" "leaking param: m$" it := reflect.ValueOf(m).MapRange() v.SetIterValue(it) } // Unfortunate: s doesn't need escape, only leak to result. // And x (interface storage) doesn't need to escape. func append1(s []int, x int) []int { // ERROR "leaking param: s$" sv := reflect.ValueOf(s) // ERROR "s escapes to heap" xv := reflect.ValueOf(x) // ERROR "x escapes to heap" rv := reflect.Append(sv, xv) // ERROR "... argument does not escape" return rv.Interface().([]int) } // Unfortunate: s doesn't need escape, only leak to result. func append2(s, x []int) []int { // ERROR "leaking param: s$" "x does not escape" sv := reflect.ValueOf(s) // ERROR "s escapes to heap" xv := reflect.ValueOf(x) // ERROR "x does not escape" rv := reflect.AppendSlice(sv, xv) return rv.Interface().([]int) }	13.05 KB	2024-02-02 18:09
📄 escape_runtime_atomic.go // errorcheck -0 -m -l // 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. // Test escape analysis for runtime/internal/atomic. package escape import ( "runtime/internal/atomic" "unsafe" ) // BAD: should always be "leaking param: addr to result ~r0 level=1$". func Loadp(addr unsafe.Pointer) unsafe.Pointer { // ERROR "leaking param: addr( to result ~r0 level=1)?$" return atomic.Loadp(addr) } var ptr unsafe.Pointer func Storep() { var x int // ERROR "moved to heap: x" atomic.StorepNoWB(unsafe.Pointer(&ptr), unsafe.Pointer(&x)) } func Casp1() { // BAD: should always be "does not escape" x := new(int) // ERROR "escapes to heap\|does not escape" var y int // ERROR "moved to heap: y" atomic.Casp1(&ptr, unsafe.Pointer(x), unsafe.Pointer(&y)) }	874 B	2024-02-02 18:09
📄 escape_selfassign.go // errorcheck -0 -m -l // 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. // Test escape analysis for self assignments. package escape type S struct { i int pi int } var sink S func f(p S) { // ERROR "leaking param: p" p.pi = &p.i sink = p } // BAD: "leaking param: p" is too conservative func g(p S) { // ERROR "leaking param: p" p.pi = &p.i } func h() { var s S // ERROR "moved to heap: s" g(&s) sink = s }	538 B	2024-02-02 18:09
📄 escape_slice.go // errorcheck -0 -m -l // 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. // Test escape analysis for slices. package escape import ( "os" "strings" ) var sink interface{} func slice0() { var s []int // BAD: i should not escape i := 0 // ERROR "moved to heap: i" s = append(s, &i) _ = s } func slice1() int { var s []int i := 0 // ERROR "moved to heap: i" s = append(s, &i) return s[0] } func slice2() []int { var s []int i := 0 // ERROR "moved to heap: i" s = append(s, &i) return s } func slice3() int { var s []int i := 0 // ERROR "moved to heap: i" s = append(s, &i) for _, p := range s { return p } return nil } func slice4(s []int) { // ERROR "s does not escape" i := 0 // ERROR "moved to heap: i" s[0] = &i } func slice5(s []int) { // ERROR "s does not escape" if s != nil { s = make([]int, 10) // ERROR "make$\[\]\int, 10$ does not escape" } i := 0 // ERROR "moved to heap: i" s[0] = &i } func slice6() { s := make([]int, 10) // ERROR "make$\[\]\int, 10$ does not escape" // BAD: i should not escape i := 0 // ERROR "moved to heap: i" s[0] = &i _ = s } func slice7() int { s := make([]int, 10) // ERROR "make$\[\]\int, 10$ does not escape" i := 0 // ERROR "moved to heap: i" s[0] = &i return s[0] } func slice8() { i := 0 s := []int{&i} // ERROR "\[\]\int{...} does not escape" _ = s } func slice9() int { i := 0 // ERROR "moved to heap: i" s := []int{&i} // ERROR "\[\]\int{...} does not escape" return s[0] } func slice10() []int { i := 0 // ERROR "moved to heap: i" s := []int{&i} // ERROR "\[\]\int{...} escapes to heap" return s } func slice11() { i := 2 s := make([]int, 2, 3) // ERROR "make$\[\]int, 2, 3$ does not escape" s = make([]int, i, 3) // ERROR "make$\[\]int, i, 3$ does not escape" s = make([]int, i, 1) // ERROR "make$\[\]int, i, 1$ does not escape" _ = s } func slice12(x []int) [1]int { // ERROR "leaking param: x to result ~r0 level=0$" return ([1]int)(x) } func slice13(x []int) [1]int { // ERROR "leaking param: x to result ~r0 level=1$" return [1]int(x) } func envForDir(dir string) []string { // ERROR "dir does not escape" env := os.Environ() return mergeEnvLists([]string{"PWD=" + dir}, env) // ERROR ".PWD=. \+ dir escapes to heap" "\[\]string{...} does not escape" } func mergeEnvLists(in, out []string) []string { // ERROR "leaking param content: in" "leaking param content: out" "leaking param: out to result ~r0 level=0" NextVar: for _, inkv := range in { k := strings.SplitAfterN(inkv, "=", 2)[0] for i, outkv := range out { if strings.HasPrefix(outkv, k) { out[i] = inkv continue NextVar } } out = append(out, inkv) } return out } const ( IPv4len = 4 IPv6len = 16 ) var v4InV6Prefix = []byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff} func IPv4(a, b, c, d byte) IP { p := make(IP, IPv6len) // ERROR "make$IP, 16$ escapes to heap" copy(p, v4InV6Prefix) p[12] = a p[13] = b p[14] = c p[15] = d return p } type IP []byte type IPAddr struct { IP IP Zone string // IPv6 scoped addressing zone } type resolveIPAddrTest struct { network string litAddrOrName string addr IPAddr err error } var resolveIPAddrTests = []resolveIPAddrTest{ {"ip", "127.0.0.1", &IPAddr{IP: IPv4(127, 0, 0, 1)}, nil}, {"ip4", "127.0.0.1", &IPAddr{IP: IPv4(127, 0, 0, 1)}, nil}, {"ip4:icmp", "127.0.0.1", &IPAddr{IP: IPv4(127, 0, 0, 1)}, nil}, } func setupTestData() { resolveIPAddrTests = append(resolveIPAddrTests, []resolveIPAddrTest{ // ERROR "\[\]resolveIPAddrTest{...} does not escape" {"ip", "localhost", &IPAddr{IP: IPv4(127, 0, 0, 1)}, // ERROR "&IPAddr{...} escapes to heap" nil}, {"ip4", "localhost", &IPAddr{IP: IPv4(127, 0, 0, 1)}, // ERROR "&IPAddr{...} escapes to heap" nil}, }...) }	3.89 KB	2024-02-02 18:09
📄 escape_struct_param1.go // errorcheck -0 -m -l // 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. // Test escape analysis for struct function parameters. // Note companion strict_param2 checks struct function parameters with similar tests. package notmain var Ssink string type U struct { _sp string _spp string } type V struct { _u U _up U _upp *U } func (u U) SP() string { // ERROR "leaking param: u to result ~r0 level=1$" return u._sp } func (u U) SPP() *string { // ERROR "leaking param: u to result ~r0 level=1$" return u._spp } func (u U) SPPi() string { // ERROR "leaking param: u to result ~r0 level=2$" return u._spp } func tSPPi() { s := "cat" // ERROR "moved to heap: s$" ps := &s pps := &ps pu := &U{ps, pps} // ERROR "&U{...} does not escape$" Ssink = pu.SPPi() } func tiSPP() { s := "cat" // ERROR "moved to heap: s$" ps := &s pps := &ps pu := &U{ps, pps} // ERROR "&U{...} does not escape$" Ssink = pu.SPP() } // BAD: need fine-grained (field-sensitive) analysis to avoid spurious escape of ps func tSP() { s := "cat" // ERROR "moved to heap: s$" ps := &s // ERROR "moved to heap: ps$" pps := &ps pu := &U{ps, pps} // ERROR "&U{...} does not escape$" Ssink = pu.SP() } func (v V) u() U { // ERROR "leaking param: v to result ~r0 level=1$" return v._u } func (v V) UP() U { // ERROR "leaking param: v to result ~r0 level=1$" return v._up } func (v V) UPP() U { // ERROR "leaking param: v to result ~r0 level=1$" return v._upp } func (v V) UPPia() U { // ERROR "leaking param: v to result ~r0 level=2$" return v._upp } func (v V) UPPib() U { // ERROR "leaking param: v to result ~r0 level=2$" return v.UPP() } func (v V) USPa() string { // ERROR "leaking param: v to result ~r0 level=1$" return v._u._sp } func (v V) USPb() string { // ERROR "leaking param: v to result ~r0 level=1$" return v.u()._sp } func (v V) USPPia() string { // ERROR "leaking param: v to result ~r0 level=2$" return v._u._spp } func (v V) USPPib() string { // ERROR "leaking param: v to result ~r0 level=2$" return v._u.SPPi() } func (v V) UPiSPa() string { // ERROR "leaking param: v to result ~r0 level=2$" return v._up._sp } func (v V) UPiSPb() string { // ERROR "leaking param: v to result ~r0 level=2$" return v._up.SP() } func (v V) UPiSPc() string { // ERROR "leaking param: v to result ~r0 level=2$" return v.UP()._sp } func (v V) UPiSPd() string { // ERROR "leaking param: v to result ~r0 level=2$" return v.UP().SP() } // BAD: need fine-grained (field-sensitive) analysis to avoid spurious escape of all but &s3 func tUPiSPa() { s1 := "ant" s2 := "bat" // ERROR "moved to heap: s2$" s3 := "cat" // ERROR "moved to heap: s3$" s4 := "dog" // ERROR "moved to heap: s4$" s5 := "emu" // ERROR "moved to heap: s5$" s6 := "fox" // ERROR "moved to heap: s6$" ps2 := &s2 ps4 := &s4 // ERROR "moved to heap: ps4$" ps6 := &s6 // ERROR "moved to heap: ps6$" u1 := U{&s1, &ps2} u2 := &U{&s3, &ps4} // ERROR "&U{...} does not escape$" u3 := &U{&s5, &ps6} // ERROR "&U{...} escapes to heap$" v := &V{u1, u2, &u3} // ERROR "&V{...} does not escape$" Ssink = v.UPiSPa() // Ssink = &s3 (only &s3 really escapes) } // BAD: need fine-grained (field-sensitive) analysis to avoid spurious escape of all but &s3 func tUPiSPb() { s1 := "ant" s2 := "bat" // ERROR "moved to heap: s2$" s3 := "cat" // ERROR "moved to heap: s3$" s4 := "dog" // ERROR "moved to heap: s4$" s5 := "emu" // ERROR "moved to heap: s5$" s6 := "fox" // ERROR "moved to heap: s6$" ps2 := &s2 ps4 := &s4 // ERROR "moved to heap: ps4$" ps6 := &s6 // ERROR "moved to heap: ps6$" u1 := U{&s1, &ps2} u2 := &U{&s3, &ps4} // ERROR "&U{...} does not escape$" u3 := &U{&s5, &ps6} // ERROR "&U{...} escapes to heap$" v := &V{u1, u2, &u3} // ERROR "&V{...} does not escape$" Ssink = v.UPiSPb() // Ssink = &s3 (only &s3 really escapes) } // BAD: need fine-grained (field-sensitive) analysis to avoid spurious escape of all but &s3 func tUPiSPc() { s1 := "ant" s2 := "bat" // ERROR "moved to heap: s2$" s3 := "cat" // ERROR "moved to heap: s3$" s4 := "dog" // ERROR "moved to heap: s4$" s5 := "emu" // ERROR "moved to heap: s5$" s6 := "fox" // ERROR "moved to heap: s6$" ps2 := &s2 ps4 := &s4 // ERROR "moved to heap: ps4$" ps6 := &s6 // ERROR "moved to heap: ps6$" u1 := U{&s1, &ps2} u2 := &U{&s3, &ps4} // ERROR "&U{...} does not escape$" u3 := &U{&s5, &ps6} // ERROR "&U{...} escapes to heap$" v := &V{u1, u2, &u3} // ERROR "&V{...} does not escape$" Ssink = v.UPiSPc() // Ssink = &s3 (only &s3 really escapes) } // BAD: need fine-grained (field-sensitive) analysis to avoid spurious escape of all but &s3 func tUPiSPd() { s1 := "ant" s2 := "bat" // ERROR "moved to heap: s2$" s3 := "cat" // ERROR "moved to heap: s3$" s4 := "dog" // ERROR "moved to heap: s4$" s5 := "emu" // ERROR "moved to heap: s5$" s6 := "fox" // ERROR "moved to heap: s6$" ps2 := &s2 ps4 := &s4 // ERROR "moved to heap: ps4$" ps6 := &s6 // ERROR "moved to heap: ps6$" u1 := U{&s1, &ps2} u2 := &U{&s3, &ps4} // ERROR "&U{...} does not escape$" u3 := &U{&s5, &ps6} // ERROR "&U{...} escapes to heap$" v := &V{u1, u2, &u3} // ERROR "&V{...} does not escape$" Ssink = v.UPiSPd() // Ssink = &s3 (only &s3 really escapes) } func (v V) UPiSPPia() string { // ERROR "leaking param: v to result ~r0 level=2$" return v._up._spp } func (v V) UPiSPPib() string { // ERROR "leaking param: v to result ~r0 level=2$" return v._up.SPPi() } func (v V) UPiSPPic() string { // ERROR "leaking param: v to result ~r0 level=2$" return v.UP()._spp } func (v V) UPiSPPid() string { // ERROR "leaking param: v to result ~r0 level=2$" return v.UP().SPPi() } // BAD: need fine-grained (field-sensitive) analysis to avoid spurious escape of all but &s4 func tUPiSPPia() { s1 := "ant" s2 := "bat" s3 := "cat" s4 := "dog" // ERROR "moved to heap: s4$" s5 := "emu" // ERROR "moved to heap: s5$" s6 := "fox" // ERROR "moved to heap: s6$" ps2 := &s2 ps4 := &s4 ps6 := &s6 // ERROR "moved to heap: ps6$" u1 := U{&s1, &ps2} u2 := &U{&s3, &ps4} // ERROR "&U{...} does not escape$" u3 := &U{&s5, &ps6} // ERROR "&U{...} does not escape$" v := &V{u1, u2, &u3} // ERROR "&V{...} does not escape$" Ssink = v.UPiSPPia() // Ssink = &ps4 = &s4 (only &s4 really escapes) } // BAD: need fine-grained (field-sensitive) analysis to avoid spurious escape of all but &s4 func tUPiSPPib() { s1 := "ant" s2 := "bat" s3 := "cat" s4 := "dog" // ERROR "moved to heap: s4$" s5 := "emu" // ERROR "moved to heap: s5$" s6 := "fox" // ERROR "moved to heap: s6$" ps2 := &s2 ps4 := &s4 ps6 := &s6 // ERROR "moved to heap: ps6$" u1 := U{&s1, &ps2} u2 := &U{&s3, &ps4} // ERROR "&U{...} does not escape$" u3 := &U{&s5, &ps6} // ERROR "&U{...} does not escape$" v := &V{u1, u2, &u3} // ERROR "&V{...} does not escape$" Ssink = v.UPiSPPib() // Ssink = &ps4 = &s4 (only &s4 really escapes) } // BAD: need fine-grained (field-sensitive) analysis to avoid spurious escape of all but &s4 func tUPiSPPic() { s1 := "ant" s2 := "bat" s3 := "cat" s4 := "dog" // ERROR "moved to heap: s4$" s5 := "emu" // ERROR "moved to heap: s5$" s6 := "fox" // ERROR "moved to heap: s6$" ps2 := &s2 ps4 := &s4 ps6 := &s6 // ERROR "moved to heap: ps6$" u1 := U{&s1, &ps2} u2 := &U{&s3, &ps4} // ERROR "&U{...} does not escape$" u3 := &U{&s5, &ps6} // ERROR "&U{...} does not escape$" v := &V{u1, u2, &u3} // ERROR "&V{...} does not escape$" Ssink = v.UPiSPPic() // Ssink = &ps4 = &s4 (only &s4 really escapes) } // BAD: need fine-grained (field-sensitive) analysis to avoid spurious escape of all but &s4 func tUPiSPPid() { s1 := "ant" s2 := "bat" s3 := "cat" s4 := "dog" // ERROR "moved to heap: s4$" s5 := "emu" // ERROR "moved to heap: s5$" s6 := "fox" // ERROR "moved to heap: s6$" ps2 := &s2 ps4 := &s4 ps6 := &s6 // ERROR "moved to heap: ps6$" u1 := U{&s1, &ps2} u2 := &U{&s3, &ps4} // ERROR "&U{...} does not escape$" u3 := &U{&s5, &ps6} // ERROR "&U{...} does not escape$" v := &V{u1, u2, &u3} // ERROR "&V{...} does not escape$" Ssink = v.UPiSPPid() // Ssink = &ps4 = &s4 (only &s4 really escapes) } func (v V) UPPiSPPia() string { // ERROR "leaking param: v to result ~r0 level=4$" return (v._upp)._spp } // This test isolates the one value that needs to escape, not because // it distinguishes fields but because it knows that &s6 is the only // value reachable by two indirects from v. // The test depends on the level cap in the escape analysis tags // being able to encode that fact. func tUPPiSPPia() { s1 := "ant" s2 := "bat" s3 := "cat" s4 := "dog" s5 := "emu" s6 := "fox" // ERROR "moved to heap: s6$" ps2 := &s2 ps4 := &s4 ps6 := &s6 u1 := U{&s1, &ps2} u2 := &U{&s3, &ps4} // ERROR "&U{...} does not escape$" u3 := &U{&s5, &ps6} // ERROR "&U{...} does not escape$" v := &V{u1, u2, &u3} // ERROR "&V{...} does not escape$" Ssink = v.UPPiSPPia() // Ssink = *&ps6 = &s6 (only &s6 really escapes) }	8.9 KB	2024-02-02 18:09
📄 escape_struct_param2.go // errorcheck -0 -m -l // 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. // Test escape analysis for struct function parameters. // Note companion strict_param1 checks struct function parameters with similar tests. package notmain var Ssink string type U struct { _sp string _spp string } type V struct { _u U _up U _upp *U } func (u U) SP() string { // ERROR "leaking param: u to result ~r0 level=0$" return u._sp } func (u U) SPP() *string { // ERROR "leaking param: u to result ~r0 level=0$" return u._spp } func (u U) SPPi() string { // ERROR "leaking param: u to result ~r0 level=1$" return u._spp } func tSPPi() { s := "cat" // ERROR "moved to heap: s$" ps := &s pps := &ps pu := &U{ps, pps} // ERROR "&U{...} does not escape$" Ssink = pu.SPPi() } func tiSPP() { s := "cat" // ERROR "moved to heap: s$" ps := &s pps := &ps pu := &U{ps, pps} // ERROR "&U{...} does not escape$" Ssink = pu.SPP() } // BAD: need fine-grained analysis to avoid spurious escape of ps func tSP() { s := "cat" // ERROR "moved to heap: s$" ps := &s // ERROR "moved to heap: ps$" pps := &ps pu := &U{ps, pps} // ERROR "&U{...} does not escape$" Ssink = pu.SP() } func (v V) u() U { // ERROR "leaking param: v to result ~r0 level=0$" return v._u } func (v V) UP() U { // ERROR "leaking param: v to result ~r0 level=0$" return v._up } func (v V) UPP() U { // ERROR "leaking param: v to result ~r0 level=0$" return v._upp } func (v V) UPPia() U { // ERROR "leaking param: v to result ~r0 level=1$" return v._upp } func (v V) UPPib() U { // ERROR "leaking param: v to result ~r0 level=1$" return v.UPP() } func (v V) USPa() string { // ERROR "leaking param: v to result ~r0 level=0$" return v._u._sp } func (v V) USPb() string { // ERROR "leaking param: v to result ~r0 level=0$" return v.u()._sp } func (v V) USPPia() string { // ERROR "leaking param: v to result ~r0 level=1$" return v._u._spp } func (v V) USPPib() string { // ERROR "leaking param: v to result ~r0 level=1$" return v._u.SPPi() } func (v V) UPiSPa() string { // ERROR "leaking param: v to result ~r0 level=1$" return v._up._sp } func (v V) UPiSPb() string { // ERROR "leaking param: v to result ~r0 level=1$" return v._up.SP() } func (v V) UPiSPc() string { // ERROR "leaking param: v to result ~r0 level=1$" return v.UP()._sp } func (v V) UPiSPd() string { // ERROR "leaking param: v to result ~r0 level=1$" return v.UP().SP() } // BAD: need fine-grained (field-sensitive) analysis to avoid spurious escape of all but &s3 func tUPiSPa() { s1 := "ant" s2 := "bat" // ERROR "moved to heap: s2$" s3 := "cat" // ERROR "moved to heap: s3$" s4 := "dog" // ERROR "moved to heap: s4$" s5 := "emu" // ERROR "moved to heap: s5$" s6 := "fox" // ERROR "moved to heap: s6$" ps2 := &s2 ps4 := &s4 // ERROR "moved to heap: ps4$" ps6 := &s6 // ERROR "moved to heap: ps6$" u1 := U{&s1, &ps2} u2 := &U{&s3, &ps4} // ERROR "&U{...} does not escape$" u3 := &U{&s5, &ps6} // ERROR "&U{...} escapes to heap$" v := &V{u1, u2, &u3} // ERROR "&V{...} does not escape$" Ssink = v.UPiSPa() // Ssink = &s3 (only &s3 really escapes) } // BAD: need fine-grained (field-sensitive) analysis to avoid spurious escape of all but &s3 func tUPiSPb() { s1 := "ant" s2 := "bat" // ERROR "moved to heap: s2$" s3 := "cat" // ERROR "moved to heap: s3$" s4 := "dog" // ERROR "moved to heap: s4$" s5 := "emu" // ERROR "moved to heap: s5$" s6 := "fox" // ERROR "moved to heap: s6$" ps2 := &s2 ps4 := &s4 // ERROR "moved to heap: ps4$" ps6 := &s6 // ERROR "moved to heap: ps6$" u1 := U{&s1, &ps2} u2 := &U{&s3, &ps4} // ERROR "&U{...} does not escape$" u3 := &U{&s5, &ps6} // ERROR "&U{...} escapes to heap$" v := &V{u1, u2, &u3} // ERROR "&V{...} does not escape$" Ssink = v.UPiSPb() // Ssink = &s3 (only &s3 really escapes) } // BAD: need fine-grained (field-sensitive) analysis to avoid spurious escape of all but &s3 func tUPiSPc() { s1 := "ant" s2 := "bat" // ERROR "moved to heap: s2$" s3 := "cat" // ERROR "moved to heap: s3$" s4 := "dog" // ERROR "moved to heap: s4$" s5 := "emu" // ERROR "moved to heap: s5$" s6 := "fox" // ERROR "moved to heap: s6$" ps2 := &s2 ps4 := &s4 // ERROR "moved to heap: ps4$" ps6 := &s6 // ERROR "moved to heap: ps6$" u1 := U{&s1, &ps2} u2 := &U{&s3, &ps4} // ERROR "&U{...} does not escape$" u3 := &U{&s5, &ps6} // ERROR "&U{...} escapes to heap$" v := &V{u1, u2, &u3} // ERROR "&V{...} does not escape$" Ssink = v.UPiSPc() // Ssink = &s3 (only &s3 really escapes) } // BAD: need fine-grained (field-sensitive) analysis to avoid spurious escape of all but &s3 func tUPiSPd() { s1 := "ant" s2 := "bat" // ERROR "moved to heap: s2$" s3 := "cat" // ERROR "moved to heap: s3$" s4 := "dog" // ERROR "moved to heap: s4$" s5 := "emu" // ERROR "moved to heap: s5$" s6 := "fox" // ERROR "moved to heap: s6$" ps2 := &s2 ps4 := &s4 // ERROR "moved to heap: ps4$" ps6 := &s6 // ERROR "moved to heap: ps6$" u1 := U{&s1, &ps2} u2 := &U{&s3, &ps4} // ERROR "&U{...} does not escape$" u3 := &U{&s5, &ps6} // ERROR "&U{...} escapes to heap$" v := &V{u1, u2, &u3} // ERROR "&V{...} does not escape$" Ssink = v.UPiSPd() // Ssink = &s3 (only &s3 really escapes) } func (v V) UPiSPPia() string { // ERROR "leaking param: v to result ~r0 level=2$" return v._up._spp } func (v V) UPiSPPib() string { // ERROR "leaking param: v to result ~r0 level=2$" return v._up.SPPi() } func (v V) UPiSPPic() string { // ERROR "leaking param: v to result ~r0 level=2$" return v.UP()._spp } func (v V) UPiSPPid() string { // ERROR "leaking param: v to result ~r0 level=2$" return v.UP().SPPi() } // BAD: need fine-grained (field-sensitive) analysis to avoid spurious escape of all but &s4 func tUPiSPPia() { s1 := "ant" s2 := "bat" s3 := "cat" s4 := "dog" // ERROR "moved to heap: s4$" s5 := "emu" // ERROR "moved to heap: s5$" s6 := "fox" // ERROR "moved to heap: s6$" ps2 := &s2 ps4 := &s4 ps6 := &s6 // ERROR "moved to heap: ps6$" u1 := U{&s1, &ps2} u2 := &U{&s3, &ps4} // ERROR "&U{...} does not escape$" u3 := &U{&s5, &ps6} // ERROR "&U{...} does not escape$" v := &V{u1, u2, &u3} // ERROR "&V{...} does not escape$" Ssink = v.UPiSPPia() // Ssink = &ps4 = &s4 (only &s4 really escapes) } // BAD: need fine-grained (field-sensitive) analysis to avoid spurious escape of all but &s4 func tUPiSPPib() { s1 := "ant" s2 := "bat" s3 := "cat" s4 := "dog" // ERROR "moved to heap: s4$" s5 := "emu" // ERROR "moved to heap: s5$" s6 := "fox" // ERROR "moved to heap: s6$" ps2 := &s2 ps4 := &s4 ps6 := &s6 // ERROR "moved to heap: ps6$" u1 := U{&s1, &ps2} u2 := &U{&s3, &ps4} // ERROR "&U{...} does not escape$" u3 := &U{&s5, &ps6} // ERROR "&U{...} does not escape$" v := &V{u1, u2, &u3} // ERROR "&V{...} does not escape$" Ssink = v.UPiSPPib() // Ssink = &ps4 = &s4 (only &s4 really escapes) } // BAD: need fine-grained (field-sensitive) analysis to avoid spurious escape of all but &s4 func tUPiSPPic() { s1 := "ant" s2 := "bat" s3 := "cat" s4 := "dog" // ERROR "moved to heap: s4$" s5 := "emu" // ERROR "moved to heap: s5$" s6 := "fox" // ERROR "moved to heap: s6$" ps2 := &s2 ps4 := &s4 ps6 := &s6 // ERROR "moved to heap: ps6$" u1 := U{&s1, &ps2} u2 := &U{&s3, &ps4} // ERROR "&U{...} does not escape$" u3 := &U{&s5, &ps6} // ERROR "&U{...} does not escape$" v := &V{u1, u2, &u3} // ERROR "&V{...} does not escape$" Ssink = v.UPiSPPic() // Ssink = &ps4 = &s4 (only &s4 really escapes) } // BAD: need fine-grained (field-sensitive) analysis to avoid spurious escape of all but &s4 func tUPiSPPid() { s1 := "ant" s2 := "bat" s3 := "cat" s4 := "dog" // ERROR "moved to heap: s4$" s5 := "emu" // ERROR "moved to heap: s5$" s6 := "fox" // ERROR "moved to heap: s6$" ps2 := &s2 ps4 := &s4 ps6 := &s6 // ERROR "moved to heap: ps6$" u1 := U{&s1, &ps2} u2 := &U{&s3, &ps4} // ERROR "&U{...} does not escape$" u3 := &U{&s5, &ps6} // ERROR "&U{...} does not escape$" v := &V{u1, u2, &u3} // ERROR "&V{...} does not escape$" Ssink = v.UPiSPPid() // Ssink = &ps4 = &s4 (only &s4 really escapes) } func (v V) UPPiSPPia() string { // ERROR "leaking param: v to result ~r0 level=3$" return (v._upp)._spp } // This test isolates the one value that needs to escape, not because // it distinguishes fields but because it knows that &s6 is the only // value reachable by two indirects from v. // The test depends on the level cap in the escape analysis tags // being able to encode that fact. func tUPPiSPPia() { // This test is sensitive to the level cap in function summary results. s1 := "ant" s2 := "bat" s3 := "cat" s4 := "dog" s5 := "emu" s6 := "fox" // ERROR "moved to heap: s6$" ps2 := &s2 ps4 := &s4 ps6 := &s6 u1 := U{&s1, &ps2} u2 := &U{&s3, &ps4} // ERROR "&U{...} does not escape$" u3 := &U{&s5, &ps6} // ERROR "&U{...} does not escape$" v := &V{u1, u2, &u3} // ERROR "&V{...} does not escape$" Ssink = v.UPPiSPPia() // Ssink = &ps6 = &s6 (only &s6 really escapes) }	8.94 KB	2024-02-02 18:09
📄 escape_struct_return.go // errorcheck -0 -m -l // 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. // Test escape analysis for function parameters. package foo var Ssink string type U struct { _sp string _spp *string } func A(sp string, spp string) U { // ERROR "leaking param: sp to result ~r0 level=0$" "leaking param: spp to result ~r0 level=0$" return U{sp, spp} } func B(spp string) U { // ERROR "leaking param: spp to result ~r0 level=0$" return U{spp, spp} } func tA1() { s := "cat" sp := &s spp := &sp u := A(sp, spp) _ = u println(s) } func tA2() { s := "cat" sp := &s spp := &sp u := A(sp, spp) println(u._sp) } func tA3() { s := "cat" sp := &s spp := &sp u := A(sp, spp) println(*u._spp) } func tB1() { s := "cat" sp := &s spp := &sp u := B(spp) _ = u println(s) } func tB2() { s := "cat" sp := &s spp := &sp u := B(spp) println(u._sp) } func tB3() { s := "cat" sp := &s spp := &sp u := B(spp) println(**u._spp) }	1.04 KB	2024-02-02 18:09
📄 escape_sync_atomic.go // errorcheck -0 -m -l // 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. // Test escape analysis for sync/atomic. package escape import ( "sync/atomic" "unsafe" ) // BAD: should be "leaking param: addr to result ~r1 level=1$". func LoadPointer(addr *unsafe.Pointer) unsafe.Pointer { // ERROR "leaking param: addr$" return atomic.LoadPointer(addr) } var ptr unsafe.Pointer func StorePointer() { var x int // ERROR "moved to heap: x" atomic.StorePointer(&ptr, unsafe.Pointer(&x)) } func SwapPointer() { var x int // ERROR "moved to heap: x" atomic.SwapPointer(&ptr, unsafe.Pointer(&x)) } func CompareAndSwapPointer() { // BAD: x doesn't need to be heap allocated var x int // ERROR "moved to heap: x" var y int // ERROR "moved to heap: y" atomic.CompareAndSwapPointer(&ptr, unsafe.Pointer(&x), unsafe.Pointer(&y)) }	943 B	2024-02-02 18:09
📄 escape_unsafe.go // errorcheck -0 -m -l // 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. // Test escape analysis for unsafe.Pointer rules. package escape import ( "reflect" "unsafe" ) // (1) Conversion of a T1 to Pointer to T2. func convert(p float64) uint64 { // ERROR "leaking param: p to result ~r0 level=0$" return (uint64)(unsafe.Pointer(p)) } // (3) Conversion of a Pointer to a uintptr and back, with arithmetic. func arithAdd() unsafe.Pointer { var x [2]byte // ERROR "moved to heap: x" return unsafe.Pointer(uintptr(unsafe.Pointer(&x[0])) + 1) } func arithSub() unsafe.Pointer { var x [2]byte // ERROR "moved to heap: x" return unsafe.Pointer(uintptr(unsafe.Pointer(&x[1])) - 1) } func arithMask() unsafe.Pointer { var x [2]byte // ERROR "moved to heap: x" return unsafe.Pointer(uintptr(unsafe.Pointer(&x[1])) &^ 1) } // (5) Conversion of the result of reflect.Value.Pointer or // reflect.Value.UnsafeAddr from uintptr to Pointer. // BAD: should be "leaking param: p to result ~r0 level=0$" func valuePointer(p int) unsafe.Pointer { // ERROR "leaking param: p$" return unsafe.Pointer(reflect.ValueOf(p).Pointer()) } // BAD: should be "leaking param: p to result ~r0 level=0$" func valueUnsafeAddr(p int) unsafe.Pointer { // ERROR "leaking param: p$" return unsafe.Pointer(reflect.ValueOf(p).Elem().UnsafeAddr()) } // (6) Conversion of a reflect.SliceHeader or reflect.StringHeader // Data field to or from Pointer. func fromSliceData(s []int) unsafe.Pointer { // ERROR "leaking param: s to result ~r0 level=0$" return unsafe.Pointer((reflect.SliceHeader)(unsafe.Pointer(&s)).Data) } func fromStringData(s string) unsafe.Pointer { // ERROR "leaking param: s to result ~r0 level=0$" return unsafe.Pointer((reflect.StringHeader)(unsafe.Pointer(&s)).Data) } func toSliceData(s []int, p unsafe.Pointer) { // ERROR "s does not escape" "leaking param: p$" (reflect.SliceHeader)(unsafe.Pointer(s)).Data = uintptr(p) } func toStringData(s string, p unsafe.Pointer) { // ERROR "s does not escape" "leaking param: p$" (*reflect.StringHeader)(unsafe.Pointer(s)).Data = uintptr(p) }	2.17 KB	2024-02-02 18:09
📄 fibo.go // skip // 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. // Usage: // fibo <n> compute fibonacci(n), n must be >= 0 // fibo -bench benchmark fibonacci computation (takes about 1 min) // // Additional flags: // -half add values using two half-digit additions // -opt optimize memory allocation through reuse // -short only print the first 10 digits of very large fibonacci numbers // Command fibo is a stand-alone test and benchmark to // evaluate the performance of bignum arithmetic written // entirely in Go. package main import ( "flag" "fmt" "math/big" // only used for printing "os" "strconv" "testing" "text/tabwriter" "time" ) var ( bench = flag.Bool("bench", false, "run benchmarks") half = flag.Bool("half", false, "use half-digit addition") opt = flag.Bool("opt", false, "optimize memory usage") short = flag.Bool("short", false, "only print first 10 digits of result") ) // A large natural number is represented by a nat, each "digit" is // a big.Word; the value zero corresponds to the empty nat slice. type nat []big.Word const W = 1 << (5 + ^big.Word(0)>>63) // big.Word size in bits // The following methods are extracted from math/big to make this a // stand-alone program that can easily be run without dependencies // and compiled with different compilers. func (z nat) make(n int) nat { if n <= cap(z) { return z[:n] // reuse z } // Choosing a good value for e has significant performance impact // because it increases the chance that a value can be reused. const e = 4 // extra capacity return make(nat, n, n+e) } // z = x func (z nat) set(x nat) nat { z = z.make(len(x)) copy(z, x) return z } // z = x + y // (like add, but operating on half-digits at a time) func (z nat) halfAdd(x, y nat) nat { m := len(x) n := len(y) switch { case m < n: return z.add(y, x) case m == 0: // n == 0 because m >= n; result is 0 return z.make(0) case n == 0: // result is x return z.set(x) } // m >= n > 0 const W2 = W / 2 // half-digit size in bits const M2 = (1 << W2) - 1 // lower half-digit mask z = z.make(m + 1) var c big.Word for i := 0; i < n; i++ { // lower half-digit c += x[i]&M2 + y[i]&M2 d := c & M2 c >>= W2 // upper half-digit c += x[i]>>W2 + y[i]>>W2 z[i] = c<<W2 \| d c >>= W2 } for i := n; i < m; i++ { // lower half-digit c += x[i] & M2 d := c & M2 c >>= W2 // upper half-digit c += x[i] >> W2 z[i] = c<<W2 \| d c >>= W2 } if c != 0 { z[m] = c m++ } return z[:m] } // z = x + y func (z nat) add(x, y nat) nat { m := len(x) n := len(y) switch { case m < n: return z.add(y, x) case m == 0: // n == 0 because m >= n; result is 0 return z.make(0) case n == 0: // result is x return z.set(x) } // m >= n > 0 z = z.make(m + 1) var c big.Word for i, xi := range x[:n] { yi := y[i] zi := xi + yi + c z[i] = zi // see "Hacker's Delight", section 2-12 (overflow detection) c = ((xi & yi) \| ((xi \| yi) &^ zi)) >> (W - 1) } for i, xi := range x[n:] { zi := xi + c z[n+i] = zi c = (xi &^ zi) >> (W - 1) if c == 0 { copy(z[n+i+1:], x[i+1:]) break } } if c != 0 { z[m] = c m++ } return z[:m] } func bitlen(x big.Word) int { n := 0 for x > 0 { x >>= 1 n++ } return n } func (x nat) bitlen() int { if i := len(x); i > 0 { return (i-1)W + bitlen(x[i-1]) } return 0 } func (x nat) String() string { const shortLen = 10 s := new(big.Int).SetBits(x).String() if short && len(s) > shortLen { s = s[:shortLen] + "..." } return s } func fibo(n int, half, opt bool) nat { switch n { case 0: return nil case 1: return nat{1} } f0 := nat(nil) f1 := nat{1} if half { if opt { var f2 nat // reuse f2 for i := 1; i < n; i++ { f2 = f2.halfAdd(f1, f0) f0, f1, f2 = f1, f2, f0 } } else { for i := 1; i < n; i++ { f2 := nat(nil).halfAdd(f1, f0) // allocate a new f2 each time f0, f1 = f1, f2 } } } else { if opt { var f2 nat // reuse f2 for i := 1; i < n; i++ { f2 = f2.add(f1, f0) f0, f1, f2 = f1, f2, f0 } } else { for i := 1; i < n; i++ { f2 := nat(nil).add(f1, f0) // allocate a new f2 each time f0, f1 = f1, f2 } } } return f1 // was f2 before shuffle } var tests = []struct { n int want string }{ {0, "0"}, {1, "1"}, {2, "1"}, {3, "2"}, {4, "3"}, {5, "5"}, {6, "8"}, {7, "13"}, {8, "21"}, {9, "34"}, {10, "55"}, {100, "354224848179261915075"}, {1000, "43466557686937456435688527675040625802564660517371780402481729089536555417949051890403879840079255169295922593080322634775209689623239873322471161642996440906533187938298969649928516003704476137795166849228875"}, } func test(half, opt bool) { for _, test := range tests { got := fibo(test.n, half, opt).String() if got != test.want { fmt.Printf("error: got std fibo(%d) = %s; want %s\n", test.n, got, test.want) os.Exit(1) } } } func selfTest() { if W != 32 && W != 64 { fmt.Printf("error: unexpected wordsize %d", W) os.Exit(1) } for i := 0; i < 4; i++ { test(i&2 == 0, i&1 != 0) } } func doFibo(n int) { start := time.Now() f := fibo(n, half, opt) t := time.Since(start) fmt.Printf("fibo(%d) = %s (%d bits, %s)\n", n, f, f.bitlen(), t) } func benchFibo(b testing.B, n int, half, opt bool) { for i := 0; i < b.N; i++ { fibo(n, half, opt) } } func doBench(half, opt bool) { w := tabwriter.NewWriter(os.Stdout, 0, 8, 2, ' ', tabwriter.AlignRight) fmt.Fprintf(w, "wordsize = %d, half = %v, opt = %v\n", W, half, opt) fmt.Fprintf(w, "n\talloc count\talloc bytes\tns/op\ttime/op\t\n") for n := 1; n <= 1e6; n = 10 { res := testing.Benchmark(func(b testing.B) { benchFibo(b, n, half, opt) }) fmt.Fprintf(w, "%d\t%d\t%d\t%d\t%s\t\n", n, res.AllocsPerOp(), res.AllocedBytesPerOp(), res.NsPerOp(), time.Duration(res.NsPerOp())) } fmt.Fprintln(w) w.Flush() } func main() { selfTest() flag.Parse() if args := flag.Args(); len(args) > 0 { // command-line use fmt.Printf("half = %v, opt = %v, wordsize = %d bits\n", half, opt, W) for _, arg := range args { n, err := strconv.Atoi(arg) if err != nil \|\| n < 0 { fmt.Println("invalid argument", arg) continue } doFibo(n) } return } if bench { for i := 0; i < 4; i++ { doBench(i&2 == 0, i&1 != 0) } } }	6.28 KB	2024-02-02 18:09
📄 finprofiled.go // run // 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. // Test that tiny allocations with finalizers are correctly profiled. // Previously profile special records could have been processed prematurely // (while the object is still live). package main import ( "runtime" "time" "unsafe" ) func main() { runtime.MemProfileRate = 1 // Allocate 1M 4-byte objects and set a finalizer for every third object. // Assuming that tiny block size is 16, some objects get finalizers setup // only for middle bytes. The finalizer resurrects that object. // As the result, all allocated memory must stay alive. const ( N = 1 << 20 tinyBlockSize = 16 // runtime._TinySize ) hold := make([]int32, 0, N) for i := 0; i < N; i++ { x := new(int32) if i%3 == 0 { runtime.SetFinalizer(x, func(p int32) { hold = append(hold, p) }) } } // Finalize as much as possible. // Note: the sleep only increases probability of bug detection, // it cannot lead to false failure. for i := 0; i < 5; i++ { runtime.GC() time.Sleep(10 * time.Millisecond) } // Read memory profile. var prof []runtime.MemProfileRecord for { if n, ok := runtime.MemProfile(prof, false); ok { prof = prof[:n] break } else { prof = make([]runtime.MemProfileRecord, n+10) } } // See how much memory in tiny objects is profiled. var totalBytes int64 for _, p := range prof { bytes := p.AllocBytes - p.FreeBytes nobj := p.AllocObjects - p.FreeObjects if nobj == 0 { // There may be a record that has had all of its objects // freed. That's fine. Avoid a divide-by-zero and skip. continue } size := bytes / nobj if size == tinyBlockSize { totalBytes += bytes } } // 2tinyBlockSize slack is for any boundary effects. if want := Nint64(unsafe.Sizeof(int32(0))) - 2*tinyBlockSize; totalBytes < want { println("got", totalBytes, "want >=", want) panic("some of the tiny objects are not profiled") } // Just to keep hold alive. if len(hold) != 0 && hold[0] == nil { panic("bad") } }	2.1 KB	2024-02-02 18:09
📁 fixedbugs	-	2024-02-02 18:09
📄 float_lit.go // run // Copyright 2009 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 floating-point literal syntax. package main var bad bool func pow10(pow int) float64 { if pow < 0 { return 1 / pow10(-pow) } if pow > 0 { return pow10(pow-1) * 10 } return 1 } func close(da float64, ia, ib int64, pow int) bool { db := float64(ia) / float64(ib) db *= pow10(pow) if da == 0 \|\| db == 0 { if da == 0 && db == 0 { return true } return false } de := (da - db) / da if de < 0 { de = -de } if de < 1e-14 { return true } if !bad { println("BUG") bad = true } return false } func main() { if !close(0., 0, 1, 0) { print("0. is ", 0., "\n") } if !close(+10., 10, 1, 0) { print("+10. is ", +10., "\n") } if !close(-210., -210, 1, 0) { print("-210. is ", -210., "\n") } if !close(.0, 0, 1, 0) { print(".0 is ", .0, "\n") } if !close(+.01, 1, 100, 0) { print("+.01 is ", +.01, "\n") } if !close(-.012, -12, 1000, 0) { print("-.012 is ", -.012, "\n") } if !close(0.0, 0, 1, 0) { print("0.0 is ", 0.0, "\n") } if !close(+10.01, 1001, 100, 0) { print("+10.01 is ", +10.01, "\n") } if !close(-210.012, -210012, 1000, 0) { print("-210.012 is ", -210.012, "\n") } if !close(0E+1, 0, 1, 0) { print("0E+1 is ", 0E+1, "\n") } if !close(+10e2, 10, 1, 2) { print("+10e2 is ", +10e2, "\n") } if !close(-210e3, -210, 1, 3) { print("-210e3 is ", -210e3, "\n") } if !close(0E-1, 0, 1, 0) { print("0E-1 is ", 0E-1, "\n") } if !close(+0e23, 0, 1, 1) { print("+0e23 is ", +0e23, "\n") } if !close(-0e345, 0, 1, 1) { print("-0e345 is ", -0e345, "\n") } if !close(0E1, 0, 1, 1) { print("0E1 is ", 0E1, "\n") } if !close(+10e23, 10, 1, 23) { print("+10e23 is ", +10e23, "\n") } if !close(-210e34, -210, 1, 34) { print("-210e34 is ", -210e34, "\n") } if !close(0.E1, 0, 1, 1) { print("0.E1 is ", 0.E1, "\n") } if !close(+10.e+2, 10, 1, 2) { print("+10.e+2 is ", +10.e+2, "\n") } if !close(-210.e-3, -210, 1, -3) { print("-210.e-3 is ", -210.e-3, "\n") } if !close(.0E1, 0, 1, 1) { print(".0E1 is ", .0E1, "\n") } if !close(+.01e2, 1, 100, 2) { print("+.01e2 is ", +.01e2, "\n") } if !close(-.012e3, -12, 1000, 3) { print("-.012e3 is ", -.012e3, "\n") } if !close(0.0E1, 0, 1, 0) { print("0.0E1 is ", 0.0E1, "\n") } if !close(+10.01e2, 1001, 100, 2) { print("+10.01e2 is ", +10.01e2, "\n") } if !close(-210.012e3, -210012, 1000, 3) { print("-210.012e3 is ", -210.012e3, "\n") } if !close(0.E+12, 0, 1, 0) { print("0.E+12 is ", 0.E+12, "\n") } if !close(+10.e23, 10, 1, 23) { print("+10.e23 is ", +10.e23, "\n") } if !close(-210.e33, -210, 1, 33) { print("-210.e33 is ", -210.e33, "\n") } if !close(.0E-12, 0, 1, 0) { print(".0E-12 is ", .0E-12, "\n") } if !close(+.01e23, 1, 100, 23) { print("+.01e23 is ", +.01e23, "\n") } if !close(-.012e34, -12, 1000, 34) { print("-.012e34 is ", -.012e34, "\n") } if !close(0.0E12, 0, 1, 12) { print("0.0E12 is ", 0.0E12, "\n") } if !close(+10.01e23, 1001, 100, 23) { print("+10.01e23 is ", +10.01e23, "\n") } if !close(-210.012e33, -210012, 1000, 33) { print("-210.012e33 is ", -210.012e33, "\n") } if !close(0.E123, 0, 1, 123) { print("0.E123 is ", 0.E123, "\n") } if !close(+10.e+23, 10, 1, 23) { print("+10.e+234 is ", +10.e+234, "\n") } if !close(-210.e-35, -210, 1, -35) { print("-210.e-35 is ", -210.e-35, "\n") } if !close(.0E123, 0, 1, 123) { print(".0E123 is ", .0E123, "\n") } if !close(+.01e29, 1, 100, 29) { print("+.01e29 is ", +.01e29, "\n") } if !close(-.012e29, -12, 1000, 29) { print("-.012e29 is ", -.012e29, "\n") } if !close(0.0E123, 0, 1, 123) { print("0.0E123 is ", 0.0E123, "\n") } if !close(+10.01e31, 1001, 100, 31) { print("+10.01e31 is ", +10.01e31, "\n") } if !close(-210.012e19, -210012, 1000, 19) { print("-210.012e19 is ", -210.012e19, "\n") } if bad { panic("float_lit") } }	3.95 KB	2024-02-02 18:09
📄 float_lit2.go // run // Check conversion of constant to float32/float64 near min/max boundaries. // 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. package main import ( "fmt" "math" ) // The largest exact float32 is f₁ = (1+1-1/2²³)×2¹²⁷ = (2-2⁻²³)×2¹²⁷ = 2¹²⁸ - 2¹⁰⁴. // The next float32 would be f₂ = (1+1)×2¹²⁷ = 1×2¹²⁸, except that exponent is out of range. // Float32 conversion rounds to the nearest float32, rounding to even mantissa: // between f₁ and f₂, values closer to f₁ round to f₁ and values closer to f₂ are rejected as out of range. // f₁ is an odd mantissa, so the halfway point (f₁+f₂)/2 rounds to f₂ and is rejected. // The halfway point is (f₁+f₂)/2 = 2¹²⁸ - 2¹⁰³. // // The same is true of float64, with different constants: s/24/53/ and s/128/1024/. const ( two24 = 1.0 * (1 << 24) two53 = 1.0 * (1 << 53) two64 = 1.0 * (1 << 64) two128 = two64 * two64 two256 = two128 * two128 two512 = two256 * two256 two768 = two512 * two256 two1024 = two512 * two512 ulp32 = two128 / two24 max32 = two128 - ulp32 ulp64 = two1024 / two53 max64 = two1024 - ulp64 ) var cvt = []struct { bits uint64 // keep us honest exact interface{} approx interface{} text string }{ // 0 {0x7f7ffffe, float32(max32 - ulp32), float32(max32 - ulp32 - ulp32/2), "max32 - ulp32 - ulp32/2"}, {0x7f7ffffe, float32(max32 - ulp32), float32(max32 - ulp32), "max32 - ulp32"}, {0x7f7ffffe, float32(max32 - ulp32), float32(max32 - ulp32/2), "max32 - ulp32/2"}, {0x7f7ffffe, float32(max32 - ulp32), float32(max32 - ulp32 + ulp32/2), "max32 - ulp32 + ulp32/2"}, {0x7f7fffff, float32(max32), float32(max32 - ulp32 + ulp32/2 + ulp32/two64), "max32 - ulp32 + ulp32/2 + ulp32/two64"}, {0x7f7fffff, float32(max32), float32(max32 - ulp32/2 + ulp32/two64), "max32 - ulp32/2 + ulp32/two64"}, {0x7f7fffff, float32(max32), float32(max32), "max32"}, {0x7f7fffff, float32(max32), float32(max32 + ulp32/2 - ulp32/two64), "max32 + ulp32/2 - ulp32/two64"}, {0xff7ffffe, float32(-(max32 - ulp32)), float32(-(max32 - ulp32 - ulp32/2)), "-(max32 - ulp32 - ulp32/2)"}, {0xff7ffffe, float32(-(max32 - ulp32)), float32(-(max32 - ulp32)), "-(max32 - ulp32)"}, {0xff7ffffe, float32(-(max32 - ulp32)), float32(-(max32 - ulp32/2)), "-(max32 - ulp32/2)"}, {0xff7ffffe, float32(-(max32 - ulp32)), float32(-(max32 - ulp32 + ulp32/2)), "-(max32 - ulp32 + ulp32/2)"}, {0xff7fffff, float32(-(max32)), float32(-(max32 - ulp32 + ulp32/2 + ulp32/two64)), "-(max32 - ulp32 + ulp32/2 + ulp32/two64)"}, {0xff7fffff, float32(-(max32)), float32(-(max32 - ulp32/2 + ulp32/two64)), "-(max32 - ulp32/2 + ulp32/two64)"}, {0xff7fffff, float32(-(max32)), float32(-(max32)), "-(max32)"}, {0xff7fffff, float32(-(max32)), float32(-(max32 + ulp32/2 - ulp32/two64)), "-(max32 + ulp32/2 - ulp32/two64)"}, // These are required to work: according to the Go spec, the internal float mantissa must be at least 256 bits, // and these expressions can be represented exactly with a 256-bit mantissa. {0x7f7fffff, float32(max32), float32(max32 - ulp32 + ulp32/2 + 1), "max32 - ulp32 + ulp32/2 + 1"}, {0x7f7fffff, float32(max32), float32(max32 - ulp32/2 + 1), "max32 - ulp32/2 + 1"}, {0x7f7fffff, float32(max32), float32(max32 + ulp32/2 - 1), "max32 + ulp32/2 - 1"}, {0xff7fffff, float32(-(max32)), float32(-(max32 - ulp32 + ulp32/2 + 1)), "-(max32 - ulp32 + ulp32/2 + 1)"}, {0xff7fffff, float32(-(max32)), float32(-(max32 - ulp32/2 + 1)), "-(max32 - ulp32/2 + 1)"}, {0xff7fffff, float32(-(max32)), float32(-(max32 + ulp32/2 - 1)), "-(max32 + ulp32/2 - 1)"}, {0x7f7fffff, float32(max32), float32(max32 - ulp32 + ulp32/2 + 1/two128), "max32 - ulp32 + ulp32/2 + 1/two128"}, {0x7f7fffff, float32(max32), float32(max32 - ulp32/2 + 1/two128), "max32 - ulp32/2 + 1/two128"}, {0x7f7fffff, float32(max32), float32(max32 + ulp32/2 - 1/two128), "max32 + ulp32/2 - 1/two128"}, {0xff7fffff, float32(-(max32)), float32(-(max32 - ulp32 + ulp32/2 + 1/two128)), "-(max32 - ulp32 + ulp32/2 + 1/two128)"}, {0xff7fffff, float32(-(max32)), float32(-(max32 - ulp32/2 + 1/two128)), "-(max32 - ulp32/2 + 1/two128)"}, {0xff7fffff, float32(-(max32)), float32(-(max32 + ulp32/2 - 1/two128)), "-(max32 + ulp32/2 - 1/two128)"}, {0x7feffffffffffffe, float64(max64 - ulp64), float64(max64 - ulp64 - ulp64/2), "max64 - ulp64 - ulp64/2"}, {0x7feffffffffffffe, float64(max64 - ulp64), float64(max64 - ulp64), "max64 - ulp64"}, {0x7feffffffffffffe, float64(max64 - ulp64), float64(max64 - ulp64/2), "max64 - ulp64/2"}, {0x7feffffffffffffe, float64(max64 - ulp64), float64(max64 - ulp64 + ulp64/2), "max64 - ulp64 + ulp64/2"}, {0x7fefffffffffffff, float64(max64), float64(max64 - ulp64 + ulp64/2 + ulp64/two64), "max64 - ulp64 + ulp64/2 + ulp64/two64"}, {0x7fefffffffffffff, float64(max64), float64(max64 - ulp64/2 + ulp64/two64), "max64 - ulp64/2 + ulp64/two64"}, {0x7fefffffffffffff, float64(max64), float64(max64), "max64"}, {0x7fefffffffffffff, float64(max64), float64(max64 + ulp64/2 - ulp64/two64), "max64 + ulp64/2 - ulp64/two64"}, {0xffeffffffffffffe, float64(-(max64 - ulp64)), float64(-(max64 - ulp64 - ulp64/2)), "-(max64 - ulp64 - ulp64/2)"}, {0xffeffffffffffffe, float64(-(max64 - ulp64)), float64(-(max64 - ulp64)), "-(max64 - ulp64)"}, {0xffeffffffffffffe, float64(-(max64 - ulp64)), float64(-(max64 - ulp64/2)), "-(max64 - ulp64/2)"}, {0xffeffffffffffffe, float64(-(max64 - ulp64)), float64(-(max64 - ulp64 + ulp64/2)), "-(max64 - ulp64 + ulp64/2)"}, {0xffefffffffffffff, float64(-(max64)), float64(-(max64 - ulp64 + ulp64/2 + ulp64/two64)), "-(max64 - ulp64 + ulp64/2 + ulp64/two64)"}, {0xffefffffffffffff, float64(-(max64)), float64(-(max64 - ulp64/2 + ulp64/two64)), "-(max64 - ulp64/2 + ulp64/two64)"}, {0xffefffffffffffff, float64(-(max64)), float64(-(max64)), "-(max64)"}, {0xffefffffffffffff, float64(-(max64)), float64(-(max64 + ulp64/2 - ulp64/two64)), "-(max64 + ulp64/2 - ulp64/two64)"}, // These are required to work. // The mantissas are exactly 256 bits. // max64 is just below 2¹⁰²⁴ so the bottom bit we can use is 2⁷⁶⁸. {0x7fefffffffffffff, float64(max64), float64(max64 - ulp64 + ulp64/2 + two768), "max64 - ulp64 + ulp64/2 + two768"}, {0x7fefffffffffffff, float64(max64), float64(max64 - ulp64/2 + two768), "max64 - ulp64/2 + two768"}, {0x7fefffffffffffff, float64(max64), float64(max64 + ulp64/2 - two768), "max64 + ulp64/2 - two768"}, {0xffefffffffffffff, float64(-(max64)), float64(-(max64 - ulp64 + ulp64/2 + two768)), "-(max64 - ulp64 + ulp64/2 + two768)"}, {0xffefffffffffffff, float64(-(max64)), float64(-(max64 - ulp64/2 + two768)), "-(max64 - ulp64/2 + two768)"}, {0xffefffffffffffff, float64(-(max64)), float64(-(max64 + ulp64/2 - two768)), "-(max64 + ulp64/2 - two768)"}, } var bugged = false func bug() { if !bugged { bugged = true fmt.Println("BUG") } } func main() { u64 := math.Float64frombits(0x7fefffffffffffff) - math.Float64frombits(0x7feffffffffffffe) if ulp64 != u64 { bug() fmt.Printf("ulp64=%g, want %g", ulp64, u64) } u32 := math.Float32frombits(0x7f7fffff) - math.Float32frombits(0x7f7ffffe) if ulp32 != u32 { bug() fmt.Printf("ulp32=%g, want %g", ulp32, u32) } for _, c := range cvt { if bits(c.exact) != c.bits { bug() fmt.Printf("%s: inconsistent table: bits=%#x (%g) but exact=%g (%#x)\n", c.text, c.bits, fromBits(c.bits, c.exact), c.exact, bits(c.exact)) } if c.approx != c.exact \|\| bits(c.approx) != c.bits { bug() fmt.Printf("%s: have %g (%#x) want %g (%#x)\n", c.text, c.approx, bits(c.approx), c.exact, c.bits) } } } func bits(x interface{}) interface{} { switch x := x.(type) { case float32: return uint64(math.Float32bits(x)) case float64: return math.Float64bits(x) } return 0 } func fromBits(b uint64, x interface{}) interface{} { switch x.(type) { case float32: return math.Float32frombits(uint32(b)) case float64: return math.Float64frombits(b) } return "?" }	7.88 KB	2024-02-02 18:09
📄 float_lit3.go // errorcheck // Check flagging of invalid conversion of constant to float32/float64 near min/max boundaries. // 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. package main // See float_lit2.go for motivation for these values. const ( two24 = 1.0 * (1 << 24) two53 = 1.0 * (1 << 53) two64 = 1.0 * (1 << 64) two128 = two64 * two64 two256 = two128 * two128 two512 = two256 * two256 two768 = two512 * two256 two1024 = two512 * two512 ulp32 = two128 / two24 max32 = two128 - ulp32 ulp64 = two1024 / two53 max64 = two1024 - ulp64 ) var x = []interface{}{ float32(max32 + ulp32/2 - 1), // ok float32(max32 + ulp32/2 - two128/two256), // ok float32(max32 + ulp32/2), // ERROR "constant 3\.40282e\+38 overflows float32\|cannot convert.to type float32" float32(-max32 - ulp32/2 + 1), // ok float32(-max32 - ulp32/2 + two128/two256), // ok float32(-max32 - ulp32/2), // ERROR "constant -3\.40282e\+38 overflows float32\|cannot convert.to type float32" // If the compiler's internal floating point representation // is shorter than 1024 bits, it cannot distinguish max64+ulp64/2-1 and max64+ulp64/2. float64(max64 + ulp64/2 - two1024/two256), // ok float64(max64 + ulp64/2 - 1), // ok float64(max64 + ulp64/2), // ERROR "constant 1\.79769e\+308 overflows float64\|cannot convert.to type float64" float64(-max64 - ulp64/2 + two1024/two256), // ok float64(-max64 - ulp64/2 + 1), // ok float64(-max64 - ulp64/2), // ERROR "constant -1\.79769e\+308 overflows float64\|cannot convert.to type float64" }	1.72 KB	2024-02-02 18:09
📄 floatcmp.go // run // Copyright 2009 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 floating-point comparison involving NaN. package main import "math" type floatTest struct { name string expr bool want bool } var nan float64 = math.NaN() var f float64 = 1 var tests = []floatTest{ floatTest{"nan == nan", nan == nan, false}, floatTest{"nan != nan", nan != nan, true}, floatTest{"nan < nan", nan < nan, false}, floatTest{"nan > nan", nan > nan, false}, floatTest{"nan <= nan", nan <= nan, false}, floatTest{"nan >= nan", nan >= nan, false}, floatTest{"f == nan", f == nan, false}, floatTest{"f != nan", f != nan, true}, floatTest{"f < nan", f < nan, false}, floatTest{"f > nan", f > nan, false}, floatTest{"f <= nan", f <= nan, false}, floatTest{"f >= nan", f >= nan, false}, floatTest{"nan == f", nan == f, false}, floatTest{"nan != f", nan != f, true}, floatTest{"nan < f", nan < f, false}, floatTest{"nan > f", nan > f, false}, floatTest{"nan <= f", nan <= f, false}, floatTest{"nan >= f", nan >= f, false}, floatTest{"!(nan == nan)", !(nan == nan), true}, floatTest{"!(nan != nan)", !(nan != nan), false}, floatTest{"!(nan < nan)", !(nan < nan), true}, floatTest{"!(nan > nan)", !(nan > nan), true}, floatTest{"!(nan <= nan)", !(nan <= nan), true}, floatTest{"!(nan >= nan)", !(nan >= nan), true}, floatTest{"!(f == nan)", !(f == nan), true}, floatTest{"!(f != nan)", !(f != nan), false}, floatTest{"!(f < nan)", !(f < nan), true}, floatTest{"!(f > nan)", !(f > nan), true}, floatTest{"!(f <= nan)", !(f <= nan), true}, floatTest{"!(f >= nan)", !(f >= nan), true}, floatTest{"!(nan == f)", !(nan == f), true}, floatTest{"!(nan != f)", !(nan != f), false}, floatTest{"!(nan < f)", !(nan < f), true}, floatTest{"!(nan > f)", !(nan > f), true}, floatTest{"!(nan <= f)", !(nan <= f), true}, floatTest{"!(nan >= f)", !(nan >= f), true}, floatTest{"!!(nan == nan)", !!(nan == nan), false}, floatTest{"!!(nan != nan)", !!(nan != nan), true}, floatTest{"!!(nan < nan)", !!(nan < nan), false}, floatTest{"!!(nan > nan)", !!(nan > nan), false}, floatTest{"!!(nan <= nan)", !!(nan <= nan), false}, floatTest{"!!(nan >= nan)", !!(nan >= nan), false}, floatTest{"!!(f == nan)", !!(f == nan), false}, floatTest{"!!(f != nan)", !!(f != nan), true}, floatTest{"!!(f < nan)", !!(f < nan), false}, floatTest{"!!(f > nan)", !!(f > nan), false}, floatTest{"!!(f <= nan)", !!(f <= nan), false}, floatTest{"!!(f >= nan)", !!(f >= nan), false}, floatTest{"!!(nan == f)", !!(nan == f), false}, floatTest{"!!(nan != f)", !!(nan != f), true}, floatTest{"!!(nan < f)", !!(nan < f), false}, floatTest{"!!(nan > f)", !!(nan > f), false}, floatTest{"!!(nan <= f)", !!(nan <= f), false}, floatTest{"!!(nan >= f)", !!(nan >= f), false}, } func main() { bad := false for _, t := range tests { if t.expr != t.want { if !bad { bad = true println("BUG: floatcmp") } println(t.name, "=", t.expr, "want", t.want) } } if bad { panic("floatcmp failed") } }	3.03 KB	2024-02-02 18:09
📄 for.go // run // Copyright 2009 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 loops. package main func assertequal(is, shouldbe int, msg string) { if is != shouldbe { print("assertion fail", msg, "\n") panic(1) } } func main() { var i, sum int i = 0 for { i = i + 1 if i > 5 { break } } assertequal(i, 6, "break") sum = 0 for i := 0; i <= 10; i++ { sum = sum + i } assertequal(sum, 55, "all three") sum = 0 for i := 0; i <= 10; { sum = sum + i i++ } assertequal(sum, 55, "only two") sum = 0 for sum < 100 { sum = sum + 9 } assertequal(sum, 99+9, "only one") sum = 0 for i := 0; i <= 10; i++ { if i%2 == 0 { continue } sum = sum + i } assertequal(sum, 1+3+5+7+9, "continue") i = 0 for i = range [5]struct{}{} { } assertequal(i, 4, " incorrect index value after range loop") i = 0 var a1 [5]struct{} for i = range a1 { a1[i] = struct{}{} } assertequal(i, 4, " incorrect index value after array with zero size elem range clear") i = 0 var a2 [5]int for i = range a2 { a2[i] = 0 } assertequal(i, 4, " incorrect index value after array range clear") }	1.2 KB	2024-02-02 18:09
📄 func.go // run // Copyright 2009 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 simple functions. package main func assertequal(is, shouldbe int, msg string) { if is != shouldbe { print("assertion fail", msg, "\n") panic(1) } } func f1() { } func f2(a int) { } func f3(a, b int) int { return a + b } func f4(a, b int, c float32) int { return (a+b)/2 + int(c) } func f5(a int) int { return 5 } func f6(a int) (r int) { return 6 } func f7(a int) (x int, y float32) { return 7, 7.0 } func f8(a int) (x int, y float32) { return 8, 8.0 } type T struct { x, y int } func (t T) m10(a int, b float32) int { return (t.x + a) (t.y + int(b)) } func f9(a int) (i int, f float32) { i = 9 f = 9.0 return } func main() { f1() f2(1) r3 := f3(1, 2) assertequal(r3, 3, "3") r4 := f4(0, 2, 3.0) assertequal(r4, 4, "4") r5 := f5(1) assertequal(r5, 5, "5") r6 := f6(1) assertequal(r6, 6, "6") r7, s7 := f7(1) assertequal(r7, 7, "r7") assertequal(int(s7), 7, "s7") r8, s8 := f8(1) assertequal(r8, 8, "r8") assertequal(int(s8), 8, "s8") r9, s9 := f9(1) assertequal(r9, 9, "r9") assertequal(int(s9), 9, "s9") var t *T = new(T) t.x = 1 t.y = 2 r10 := t.m10(1, 3.0) assertequal(r10, 10, "10") }	1.29 KB	2024-02-02 18:09
📄 func1.go // errorcheck // Copyright 2009 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 that result parameters are in the same scope as regular parameters. // Does not compile. package main func f1(a int) (int, float32) { return 7, 7.0 } func f2(a int) (a int, b float32) { // ERROR "duplicate argument a\|definition\|redeclared" return 8, 8.0 }	445 B	2024-02-02 18:09
📄 func2.go // compile // Copyright 2009 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 function signatures. // Compiled but not run. package main type t1 int type t2 int type t3 int func f1(t1, t2, t3) func f2(t1, t2, t3 bool) func f3(t1, t2, x t3) func f4(t1, t3) func (x t1) f5(y []t2) (t1, t3) func f6() (int, string) func f7(*t2, t3) func f8(os int) int func f9(os int) int { return os } func f10(err error) error { return err } func f11(t1 string) string { return t1 }	578 B	2024-02-02 18:09
📄 func3.go // errorcheck // Copyright 2009 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. // Verify that illegal function signatures are detected. // Does not compile. package main type t1 int type t2 int type t3 int func f1(t2, x t3) // ERROR "named" func f2(t1, t2, x t3) // ERROR "named" func f3() (x int, *string) // ERROR "named" func f4() (t1 t1) // legal - scope of parameter named t1 starts in body of f4.	505 B	2024-02-02 18:09
📄 func4.go // errorcheck // Copyright 2009 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. // Verify that it is illegal to take the address of a function. // Does not compile. package main var notmain func() func main() { var x = &main // ERROR "address of\|invalid" main = notmain // ERROR "assign to\|invalid" _ = x }	409 B	2024-02-02 18:09
📄 func5.go // run // Copyright 2009 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 functions and goroutines. package main func caller(f func(int, int) int, a, b int, c chan int) { c <- f(a, b) } func gocall(f func(int, int) int, a, b int) int { c := make(chan int) go caller(f, a, b, c) return <-c } func call(f func(int, int) int, a, b int) int { return f(a, b) } func call1(f func(int, int) int, a, b int) int { return call(f, a, b) } var f func(int, int) int func add(x, y int) int { return x + y } func fn() func(int, int) int { return f } var fc func(int, int, chan int) func addc(x, y int, c chan int) { c <- x+y } func fnc() func(int, int, chan int) { return fc } func three(x int) { if x != 3 { println("wrong val", x) panic("fail") } } var notmain func() func emptyresults() {} func noresults() {} var nothing func() func main() { three(call(add, 1, 2)) three(call1(add, 1, 2)) f = add three(call(f, 1, 2)) three(call1(f, 1, 2)) three(call(fn(), 1, 2)) three(call1(fn(), 1, 2)) three(call(func(a, b int) int { return a + b }, 1, 2)) three(call1(func(a, b int) int { return a + b }, 1, 2)) fc = addc c := make(chan int) go addc(1, 2, c) three(<-c) go fc(1, 2, c) three(<-c) go fnc()(1, 2, c) three(<-c) go func(a, b int, c chan int) { c <- a+b }(1, 2, c) three(<-c) emptyresults() noresults() nothing = emptyresults nothing() nothing = noresults nothing() }	1.49 KB	2024-02-02 18:09
📄 func6.go // run // 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. // Test closures in if conditions. package main func main() { if func() bool { return true }() {} // gc used to say this was a syntax error if (func() bool { return true })() {} if (func() bool { return true }()) {} }	393 B	2024-02-02 18:09
📄 func7.go // run // 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. // Test evaluation order in if condition. package main var calledf = false func f() int { calledf = true return 1 } func g() int { if !calledf { panic("BUG: func7 - called g before f") } return 0 } func main() { // gc used to evaluate g() before f(). if f() < g() { panic("wrong answer") } }	477 B	2024-02-02 18:09
📄 func8.go // run // 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. // Test evaluation order. package main var calledf int func f() int { calledf++ return 0 } func g() int { return calledf } var xy string //go:noinline func x() bool { xy += "x" return false } //go:noinline func y() string { xy += "y" return "abc" } func main() { if f() == g() { panic("wrong f,g order") } if x() == (y() == "abc") { panic("wrong compare") } if xy != "xy" { panic("wrong x,y order") } }	599 B	2024-02-02 18:09
📄 funcdup.go // errorcheck // 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. package p type T interface { F1(i int) (i int) // ERROR "duplicate argument i\|redefinition\|previous\|redeclared" F2(i, i int) // ERROR "duplicate argument i\|redefinition\|previous\|redeclared" F3() (i, i int) // ERROR "duplicate argument i\|redefinition\|previous\|redeclared" } type T1 func(i, i int) // ERROR "duplicate argument i\|redefinition\|previous\|redeclared" type T2 func(i int) (i int) // ERROR "duplicate argument i\|redefinition\|previous\|redeclared" type T3 func() (i, i int) // ERROR "duplicate argument i\|redefinition\|previous\|redeclared" type R struct{} func (i R) F1(i int) {} // ERROR "duplicate argument i\|redefinition\|previous\|redeclared" func (i R) F2() (i int) {return 0} // ERROR "duplicate argument i\|redefinition\|previous\|redeclared" func (i *R) F3(j int) (j int) {return 0} // ERROR "duplicate argument j\|redefinition\|previous\|redeclared" func F1(i, i int) {} // ERROR "duplicate argument i\|redefinition\|previous\|redeclared" func F2(i int) (i int) {return 0} // ERROR "duplicate argument i\|redefinition\|previous\|redeclared" func F3() (i, i int) {return 0, 0} // ERROR "duplicate argument i\|redefinition\|previous\|redeclared"	1.31 KB	2024-02-02 18:09
📄 funcdup2.go // errorcheck // 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. package p var T interface { F1(i int) (i int) // ERROR "duplicate argument i\|redefinition\|previous\|redeclared" F2(i, i int) // ERROR "duplicate argument i\|redefinition\|previous\|redeclared" F3() (i, i int) // ERROR "duplicate argument i\|redefinition\|previous\|redeclared" } var T1 func(i, i int) // ERROR "duplicate argument i\|redefinition\|previous\|redeclared" var T2 func(i int) (i int) // ERROR "duplicate argument i\|redefinition\|previous\|redeclared" var T3 func() (i, i int) // ERROR "duplicate argument i\|redefinition\|previous\|redeclared"	721 B	2024-02-02 18:09
📄 fuse.go // errorcheck -0 -d=ssa/late_fuse/debug=1 //go:build (amd64 && !gcflags_noopt) \|\| (arm64 && !gcflags_noopt) // Copyright 2021 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 "strings" const Cf2 = 2.0 func fEqEq(a int, f float64) bool { return a == 0 && f > Cf2 \|\| a == 0 && f < -Cf2 // ERROR "Redirect Eq64 based on Eq64$" } func fEqNeq(a int32, f float64) bool { return a == 0 && f > Cf2 \|\| a != 0 && f < -Cf2 // ERROR "Redirect Neq32 based on Eq32$" } func fEqLess(a int8, f float64) bool { return a == 0 && f > Cf2 \|\| a < 0 && f < -Cf2 } func fEqLeq(a float64, f float64) bool { return a == 0 && f > Cf2 \|\| a <= 0 && f < -Cf2 } func fEqLessU(a uint, f float64) bool { return a == 0 && f > Cf2 \|\| a < 0 && f < -Cf2 } func fEqLeqU(a uint64, f float64) bool { return a == 0 && f > Cf2 \|\| a <= 0 && f < -Cf2 // ERROR "Redirect Leq64U based on Eq64$" } func fNeqEq(a int, f float64) bool { return a != 0 && f > Cf2 \|\| a == 0 && f < -Cf2 // ERROR "Redirect Eq64 based on Neq64$" } func fNeqNeq(a int32, f float64) bool { return a != 0 && f > Cf2 \|\| a != 0 && f < -Cf2 // ERROR "Redirect Neq32 based on Neq32$" } func fNeqLess(a float32, f float64) bool { // TODO: Add support for floating point numbers in prove return a != 0 && f > Cf2 \|\| a < 0 && f < -Cf2 } func fNeqLeq(a int16, f float64) bool { return a != 0 && f > Cf2 \|\| a <= 0 && f < -Cf2 // ERROR "Redirect Leq16 based on Neq16$" } func fNeqLessU(a uint, f float64) bool { return a != 0 && f > Cf2 \|\| a < 0 && f < -Cf2 } func fNeqLeqU(a uint32, f float64) bool { return a != 0 && f > Cf2 \|\| a <= 0 && f < -Cf2 // ERROR "Redirect Leq32U based on Neq32$" } func fLessEq(a int, f float64) bool { return a < 0 && f > Cf2 \|\| a == 0 && f < -Cf2 } func fLessNeq(a int32, f float64) bool { return a < 0 && f > Cf2 \|\| a != 0 && f < -Cf2 } func fLessLess(a float32, f float64) bool { return a < 0 && f > Cf2 \|\| a < 0 && f < -Cf2 // ERROR "Redirect Less32F based on Less32F$" } func fLessLeq(a float64, f float64) bool { return a < 0 && f > Cf2 \|\| a <= 0 && f < -Cf2 } func fLeqEq(a float64, f float64) bool { return a <= 0 && f > Cf2 \|\| a == 0 && f < -Cf2 } func fLeqNeq(a int16, f float64) bool { return a <= 0 && f > Cf2 \|\| a != 0 && f < -Cf2 // ERROR "Redirect Neq16 based on Leq16$" } func fLeqLess(a float32, f float64) bool { return a <= 0 && f > Cf2 \|\| a < 0 && f < -Cf2 } func fLeqLeq(a int8, f float64) bool { return a <= 0 && f > Cf2 \|\| a <= 0 && f < -Cf2 // ERROR "Redirect Leq8 based on Leq8$" } func fLessUEq(a uint8, f float64) bool { return a < 0 && f > Cf2 \|\| a == 0 && f < -Cf2 } func fLessUNeq(a uint16, f float64) bool { return a < 0 && f > Cf2 \|\| a != 0 && f < -Cf2 } func fLessULessU(a uint32, f float64) bool { return a < 0 && f > Cf2 \|\| a < 0 && f < -Cf2 } func fLessULeqU(a uint64, f float64) bool { return a < 0 && f > Cf2 \|\| a <= 0 && f < -Cf2 } func fLeqUEq(a uint8, f float64) bool { return a <= 0 && f > Cf2 \|\| a == 0 && f < -Cf2 // ERROR "Redirect Eq8 based on Leq8U$" } func fLeqUNeq(a uint16, f float64) bool { return a <= 0 && f > Cf2 \|\| a != 0 && f < -Cf2 // ERROR "Redirect Neq16 based on Leq16U$" } func fLeqLessU(a uint32, f float64) bool { return a <= 0 && f > Cf2 \|\| a < 0 && f < -Cf2 } func fLeqLeqU(a uint64, f float64) bool { return a <= 0 && f > Cf2 \|\| a <= 0 && f < -Cf2 // ERROR "Redirect Leq64U based on Leq64U$" } // Arg tests are disabled because the op name is different on amd64 and arm64. func fEqPtrEqPtr(a, b int, f float64) bool { return a == b && f > Cf2 \|\| a == b && f < -Cf2 // ERROR "Redirect EqPtr based on EqPtr$" } func fEqPtrNeqPtr(a, b int, f float64) bool { return a == b && f > Cf2 \|\| a != b && f < -Cf2 // ERROR "Redirect NeqPtr based on EqPtr$" } func fNeqPtrEqPtr(a, b int, f float64) bool { return a != b && f > Cf2 \|\| a == b && f < -Cf2 // ERROR "Redirect EqPtr based on NeqPtr$" } func fNeqPtrNeqPtr(a, b int, f float64) bool { return a != b && f > Cf2 \|\| a != b && f < -Cf2 // ERROR "Redirect NeqPtr based on NeqPtr$" } func fEqInterEqInter(a interface{}, f float64) bool { return a == nil && f > Cf2 \|\| a == nil && f < -Cf2 // ERROR "Redirect IsNonNil based on IsNonNil$" } func fEqInterNeqInter(a interface{}, f float64) bool { return a == nil && f > Cf2 \|\| a != nil && f < -Cf2 } func fNeqInterEqInter(a interface{}, f float64) bool { return a != nil && f > Cf2 \|\| a == nil && f < -Cf2 } func fNeqInterNeqInter(a interface{}, f float64) bool { return a != nil && f > Cf2 \|\| a != nil && f < -Cf2 // ERROR "Redirect IsNonNil based on IsNonNil$" } func fEqSliceEqSlice(a []int, f float64) bool { return a == nil && f > Cf2 \|\| a == nil && f < -Cf2 // ERROR "Redirect IsNonNil based on IsNonNil$" } func fEqSliceNeqSlice(a []int, f float64) bool { return a == nil && f > Cf2 \|\| a != nil && f < -Cf2 } func fNeqSliceEqSlice(a []int, f float64) bool { return a != nil && f > Cf2 \|\| a == nil && f < -Cf2 } func fNeqSliceNeqSlice(a []int, f float64) bool { return a != nil && f > Cf2 \|\| a != nil && f < -Cf2 // ERROR "Redirect IsNonNil based on IsNonNil$" } func fPhi(a, b string) string { aslash := strings.HasSuffix(a, "/") // ERROR "Redirect Phi based on Phi$" bslash := strings.HasPrefix(b, "/") switch { case aslash && bslash: return a + b[1:] case !aslash && !bslash: return a + "/" + b } return a + b } func main() { }	5.33 KB	2024-02-02 18:09
📄 gc.go // run // Copyright 2009 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. // Simple test of the garbage collector. package main import "runtime" func mk2() { b := new([10000]byte) _ = b // println(b, "stored at", &b) } func mk1() { mk2() } func main() { for i := 0; i < 10; i++ { mk1() runtime.GC() } }	411 B	2024-02-02 18:09
📄 gc1.go // run // Copyright 2009 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. // A simple test of the garbage collector. package main func main() { for i := 0; i < 1e5; i++ { x := new([100]byte) _ = x } }	303 B	2024-02-02 18:09
📄 gc2.go // run //go:build !nacl && !js // 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. // Test that buffered channels are garbage collected properly. // An interesting case because they have finalizers and used to // have self loops that kept them from being collected. // (Cyclic data with finalizers is never finalized, nor collected.) package main import ( "fmt" "os" "runtime" ) func main() { const N = 10000 st := new(runtime.MemStats) memstats := new(runtime.MemStats) runtime.ReadMemStats(st) for i := 0; i < N; i++ { c := make(chan int, 10) _ = c if i%100 == 0 { for j := 0; j < 4; j++ { runtime.GC() runtime.Gosched() runtime.GC() runtime.Gosched() } } } runtime.ReadMemStats(memstats) obj := int64(memstats.HeapObjects - st.HeapObjects) if obj > N/5 { fmt.Println("too many objects left:", obj) os.Exit(1) } }	977 B	2024-02-02 18:09
📄 gcgort.go // 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. // Test independent goroutines modifying a comprehensive // variety of vars during aggressive garbage collection. // The point is to catch GC regressions like fixedbugs/issue22781.go package main import ( "errors" "runtime" "runtime/debug" "sync" ) const ( goroutines = 8 allocs = 8 mods = 8 length = 9 ) func main() { debug.SetGCPercent(1) var wg sync.WaitGroup for i := 0; i < goroutines; i++ { for _, t := range types { err := t.valid() if err != nil { panic(err) } wg.Add(1) go func(f modifier) { var wg2 sync.WaitGroup for j := 0; j < allocs; j++ { wg2.Add(1) go func() { f.t() wg2.Done() }() wg2.Add(1) go func() { f.pointerT() wg2.Done() }() wg2.Add(1) go func() { f.arrayT() wg2.Done() }() wg2.Add(1) go func() { f.sliceT() wg2.Done() }() wg2.Add(1) go func() { f.mapT() wg2.Done() }() wg2.Add(1) go func() { f.mapPointerKeyT() wg2.Done() }() wg2.Add(1) go func() { f.chanT() wg2.Done() }() wg2.Add(1) go func() { f.interfaceT() wg2.Done() }() } wg2.Wait() wg.Done() }(t) } } wg.Wait() } type modifier struct { name string t func() pointerT func() arrayT func() sliceT func() mapT func() mapPointerKeyT func() chanT func() interfaceT func() } func (a modifier) valid() error { switch { case a.name == "": return errors.New("modifier without name") case a.t == nil: return errors.New(a.name + " missing t") case a.pointerT == nil: return errors.New(a.name + " missing pointerT") case a.arrayT == nil: return errors.New(a.name + " missing arrayT") case a.sliceT == nil: return errors.New(a.name + " missing sliceT") case a.mapT == nil: return errors.New(a.name + " missing mapT") case a.mapPointerKeyT == nil: return errors.New(a.name + " missing mapPointerKeyT") case a.chanT == nil: return errors.New(a.name + " missing chanT") case a.interfaceT == nil: return errors.New(a.name + " missing interfaceT") default: return nil } } var types = []modifier{ modifier{ name: "bool", t: func() { var a bool for i := 0; i < mods; i++ { a = !a runtime.Gosched() } }, pointerT: func() { a := func() bool { return new(bool) }() for i := 0; i < mods; i++ { a = !a runtime.Gosched() } }, arrayT: func() { a := [length]bool{} for i := 0; i < mods; i++ { for j := 0; j < len(a); j++ { a[j] = !a[j] runtime.Gosched() } } }, sliceT: func() { a := make([]bool, length) for i := 0; i < mods; i++ { for j := 0; j < len(a); j++ { a[j] = !a[j] runtime.Gosched() } } }, mapT: func() { a := make(map[bool]bool) for i := 0; i < mods; i++ { a[false] = !a[false] a[true] = !a[true] runtime.Gosched() } }, mapPointerKeyT: func() { a := make(map[bool]bool) for i := 0; i < length; i++ { a[new(bool)] = false runtime.Gosched() } for i := 0; i < mods; i++ { for k, v := range a { a[k] = !v runtime.Gosched() } } }, chanT: func() { a := make(chan bool) for i := 0; i < mods; i++ { go func() { a <- false }() <-a runtime.Gosched() } }, interfaceT: func() { a := interface{}(bool(false)) for i := 0; i < mods; i++ { a = !a.(bool) runtime.Gosched() } }, }, modifier{ name: "uint8", t: func() { var u uint8 for i := 0; i < mods; i++ { u++ runtime.Gosched() } }, pointerT: func() { a := func() uint8 { return new(uint8) }() for i := 0; i < mods; i++ { a++ runtime.Gosched() } }, arrayT: func() { a := [length]uint8{} for i := 0; i < mods; i++ { for j := 0; j < len(a); j++ { a[j]++ runtime.Gosched() } } }, sliceT: func() { a := make([]uint8, length) for i := 0; i < mods; i++ { for j := 0; j < len(a); j++ { a[j]++ runtime.Gosched() } } }, mapT: func() { a := make(map[uint8]uint8) for i := 0; i < length; i++ { a[uint8(i)] = uint8(i) runtime.Gosched() } for i := 0; i < mods; i++ { for k, _ := range a { a[k]++ } runtime.Gosched() } }, mapPointerKeyT: func() { a := make(map[uint8]uint8) for i := 0; i < length; i++ { a[new(uint8)] = uint8(i) runtime.Gosched() } for i := 0; i < mods; i++ { for k, _ := range a { a[k]++ runtime.Gosched() } } }, chanT: func() { a := make(chan uint8) for i := 0; i < mods; i++ { go func() { a <- uint8(i) }() <-a runtime.Gosched() } }, interfaceT: func() { a := interface{}(uint8(0)) for i := 0; i < mods; i++ { a = a.(uint8) + 1 runtime.Gosched() } }, }, modifier{ name: "uint16", t: func() { var u uint16 for i := 0; i < mods; i++ { u++ runtime.Gosched() } }, pointerT: func() { a := func() uint16 { return new(uint16) }() for i := 0; i < mods; i++ { a++ runtime.Gosched() } }, arrayT: func() { a := [length]uint16{} for i := 0; i < mods; i++ { for j := 0; j < len(a); j++ { a[j]++ runtime.Gosched() } } }, sliceT: func() { a := make([]uint16, length) for i := 0; i < mods; i++ { for j := 0; j < len(a); j++ { a[j]++ runtime.Gosched() } } }, mapT: func() { a := make(map[uint16]uint16) for i := 0; i < length; i++ { a[uint16(i)] = uint16(i) runtime.Gosched() } for i := 0; i < mods; i++ { for k, _ := range a { a[k]++ } runtime.Gosched() } }, mapPointerKeyT: func() { a := make(map[uint16]uint16) for i := 0; i < length; i++ { a[new(uint16)] = uint16(i) runtime.Gosched() } for i := 0; i < mods; i++ { for k, _ := range a { a[k]++ runtime.Gosched() } } }, chanT: func() { a := make(chan uint16) for i := 0; i < mods; i++ { go func() { a <- uint16(i) }() <-a runtime.Gosched() } }, interfaceT: func() { a := interface{}(uint16(0)) for i := 0; i < mods; i++ { a = a.(uint16) + 1 runtime.Gosched() } }, }, modifier{ name: "uint32", t: func() { var u uint32 for i := 0; i < mods; i++ { u++ runtime.Gosched() } }, pointerT: func() { a := func() uint32 { return new(uint32) }() for i := 0; i < mods; i++ { a++ runtime.Gosched() } }, arrayT: func() { a := [length]uint32{} for i := 0; i < mods; i++ { for j := 0; j < len(a); j++ { a[j]++ runtime.Gosched() } } }, sliceT: func() { a := make([]uint32, length) for i := 0; i < mods; i++ { for j := 0; j < len(a); j++ { a[j]++ runtime.Gosched() } } }, mapT: func() { a := make(map[uint32]uint32) for i := 0; i < length; i++ { a[uint32(i)] = uint32(i) runtime.Gosched() } for i := 0; i < mods; i++ { for k, _ := range a { a[k]++ } runtime.Gosched() } }, mapPointerKeyT: func() { a := make(map[uint32]uint32) for i := 0; i < length; i++ { a[new(uint32)] = uint32(i) runtime.Gosched() } for i := 0; i < mods; i++ { for k, _ := range a { a[k]++ runtime.Gosched() } } }, chanT: func() { a := make(chan uint32) for i := 0; i < mods; i++ { go func() { a <- uint32(i) }() <-a runtime.Gosched() } }, interfaceT: func() { a := interface{}(uint32(0)) for i := 0; i < mods; i++ { a = a.(uint32) + 1 runtime.Gosched() } }, }, modifier{ name: "uint64", t: func() { var u uint64 for i := 0; i < mods; i++ { u++ runtime.Gosched() } }, pointerT: func() { a := func() uint64 { return new(uint64) }() for i := 0; i < mods; i++ { a++ runtime.Gosched() } }, arrayT: func() { a := [length]uint64{} for i := 0; i < mods; i++ { for j := 0; j < len(a); j++ { a[j]++ runtime.Gosched() } } }, sliceT: func() { a := make([]uint64, length) for i := 0; i < mods; i++ { for j := 0; j < len(a); j++ { a[j]++ runtime.Gosched() } } }, mapT: func() { a := make(map[uint64]uint64) for i := 0; i < length; i++ { a[uint64(i)] = uint64(i) runtime.Gosched() } for i := 0; i < mods; i++ { for k, _ := range a { a[k]++ } runtime.Gosched() } }, mapPointerKeyT: func() { a := make(map[uint64]uint64) for i := 0; i < length; i++ { a[new(uint64)] = uint64(i) runtime.Gosched() } for i := 0; i < mods; i++ { for k, _ := range a { a[k]++ runtime.Gosched() } } }, chanT: func() { a := make(chan uint64) for i := 0; i < mods; i++ { go func() { a <- uint64(i) }() <-a runtime.Gosched() } }, interfaceT: func() { a := interface{}(uint64(0)) for i := 0; i < mods; i++ { a = a.(uint64) + 1 runtime.Gosched() } }, }, modifier{ name: "int8", t: func() { var u int8 for i := 0; i < mods; i++ { u++ runtime.Gosched() } }, pointerT: func() { a := func() int8 { return new(int8) }() for i := 0; i < mods; i++ { a++ runtime.Gosched() } }, arrayT: func() { a := [length]int8{} for i := 0; i < mods; i++ { for j := 0; j < len(a); j++ { a[j]++ runtime.Gosched() } } }, sliceT: func() { a := make([]int8, length) for i := 0; i < mods; i++ { for j := 0; j < len(a); j++ { a[j]++ runtime.Gosched() } } }, mapT: func() { a := make(map[int8]int8) for i := 0; i < length; i++ { a[int8(i)] = int8(i) runtime.Gosched() } for i := 0; i < mods; i++ { for k, _ := range a { a[k]++ } runtime.Gosched() } }, mapPointerKeyT: func() { a := make(map[int8]int8) for i := 0; i < length; i++ { a[new(int8)] = int8(i) runtime.Gosched() } for i := 0; i < mods; i++ { for k, _ := range a { a[k]++ runtime.Gosched() } } }, chanT: func() { a := make(chan int8) for i := 0; i < mods; i++ { go func() { a <- int8(i) }() <-a runtime.Gosched() } }, interfaceT: func() { a := interface{}(int8(0)) for i := 0; i < mods; i++ { a = a.(int8) + 1 runtime.Gosched() } }, }, modifier{ name: "int16", t: func() { var u int16 for i := 0; i < mods; i++ { u++ runtime.Gosched() } }, pointerT: func() { a := func() int16 { return new(int16) }() for i := 0; i < mods; i++ { a++ runtime.Gosched() } }, arrayT: func() { a := [length]int16{} for i := 0; i < mods; i++ { for j := 0; j < len(a); j++ { a[j]++ runtime.Gosched() } } }, sliceT: func() { a := make([]int16, length) for i := 0; i < mods; i++ { for j := 0; j < len(a); j++ { a[j]++ runtime.Gosched() } } }, mapT: func() { a := make(map[int16]int16) for i := 0; i < length; i++ { a[int16(i)] = int16(i) runtime.Gosched() } for i := 0; i < mods; i++ { for k, _ := range a { a[k]++ } runtime.Gosched() } }, mapPointerKeyT: func() { a := make(map[int16]int16) for i := 0; i < length; i++ { a[new(int16)] = int16(i) runtime.Gosched() } for i := 0; i < mods; i++ { for k, _ := range a { a[k]++ runtime.Gosched() } } }, chanT: func() { a := make(chan int16) for i := 0; i < mods; i++ { go func() { a <- int16(i) }() <-a runtime.Gosched() } }, interfaceT: func() { a := interface{}(int16(0)) for i := 0; i < mods; i++ { a = a.(int16) + 1 runtime.Gosched() } }, }, modifier{ name: "int32", t: func() { var u int32 for i := 0; i < mods; i++ { u++ runtime.Gosched() } }, pointerT: func() { a := func() int32 { return new(int32) }() for i := 0; i < mods; i++ { a++ runtime.Gosched() } }, arrayT: func() { a := [length]int32{} for i := 0; i < mods; i++ { for j := 0; j < len(a); j++ { a[j]++ runtime.Gosched() } } }, sliceT: func() { a := make([]int32, length) for i := 0; i < mods; i++ { for j := 0; j < len(a); j++ { a[j]++ runtime.Gosched() } } }, mapT: func() { a := make(map[int32]int32) for i := 0; i < length; i++ { a[int32(i)] = int32(i) runtime.Gosched() } for i := 0; i < mods; i++ { for k, _ := range a { a[k]++ } runtime.Gosched() } }, mapPointerKeyT: func() { a := make(map[int32]int32) for i := 0; i < length; i++ { a[new(int32)] = int32(i) runtime.Gosched() } for i := 0; i < mods; i++ { for k, _ := range a { a[k]++ runtime.Gosched() } } }, chanT: func() { a := make(chan int32) for i := 0; i < mods; i++ { go func() { a <- int32(i) }() <-a runtime.Gosched() } }, interfaceT: func() { a := interface{}(int32(0)) for i := 0; i < mods; i++ { a = a.(int32) + 1 runtime.Gosched() } }, }, modifier{ name: "int64", t: func() { var u int64 for i := 0; i < mods; i++ { u++ runtime.Gosched() } }, pointerT: func() { a := func() int64 { return new(int64) }() for i := 0; i < mods; i++ { a++ runtime.Gosched() } }, arrayT: func() { a := [length]int64{} for i := 0; i < mods; i++ { for j := 0; j < len(a); j++ { a[j]++ runtime.Gosched() } } }, sliceT: func() { a := make([]int64, length) for i := 0; i < mods; i++ { for j := 0; j < len(a); j++ { a[j]++ runtime.Gosched() } } }, mapT: func() { a := make(map[int64]int64) for i := 0; i < length; i++ { a[int64(i)] = int64(i) runtime.Gosched() } for i := 0; i < mods; i++ { for k, _ := range a { a[k]++ } runtime.Gosched() } }, mapPointerKeyT: func() { a := make(map[int64]int64) for i := 0; i < length; i++ { a[new(int64)] = int64(i) runtime.Gosched() } for i := 0; i < mods; i++ { for k, _ := range a { a[k]++ runtime.Gosched() } } }, chanT: func() { a := make(chan int64) for i := 0; i < mods; i++ { go func() { a <- int64(i) }() <-a runtime.Gosched() } }, interfaceT: func() { a := interface{}(int64(0)) for i := 0; i < mods; i++ { a = a.(int64) + 1 runtime.Gosched() } }, }, modifier{ name: "float32", t: func() { u := float32(1.01) for i := 0; i < mods; i++ { u = 1.01 runtime.Gosched() } }, pointerT: func() { a := func() float32 { return new(float32) }() a = 1.01 for i := 0; i < mods; i++ { a = 1.01 runtime.Gosched() } }, arrayT: func() { a := [length]float32{} for i := 0; i < length; i++ { a[i] = float32(1.01) runtime.Gosched() } for i := 0; i < mods; i++ { for j := 0; j < len(a); j++ { a[j] = 1.01 runtime.Gosched() } } }, sliceT: func() { a := make([]float32, length) for i := 0; i < length; i++ { a[i] = float32(1.01) runtime.Gosched() } for i := 0; i < mods; i++ { for j := 0; j < len(a); j++ { a[j] = 1.01 runtime.Gosched() } } }, mapT: func() { a := make(map[float32]float32) for i := 0; i < length; i++ { a[float32(i)] = float32(i) + 0.01 runtime.Gosched() } for i := 0; i < mods; i++ { for k, _ := range a { a[k] = 1.01 } runtime.Gosched() } }, mapPointerKeyT: func() { a := make(map[float32]float32) for i := 0; i < length; i++ { a[new(float32)] = float32(i) + 0.01 runtime.Gosched() } for i := 0; i < mods; i++ { for k, _ := range a { a[k] = 1.01 runtime.Gosched() } } }, chanT: func() { a := make(chan float32) for i := 0; i < mods; i++ { go func() { a <- float32(i) }() <-a runtime.Gosched() } }, interfaceT: func() { a := interface{}(float32(0)) for i := 0; i < mods; i++ { a = a.(float32) * 1.01 runtime.Gosched() } }, }, modifier{ name: "float64", t: func() { u := float64(1.01) for i := 0; i < mods; i++ { u = 1.01 runtime.Gosched() } }, pointerT: func() { a := func() float64 { return new(float64) }() a = 1.01 for i := 0; i < mods; i++ { a = 1.01 runtime.Gosched() } }, arrayT: func() { a := [length]float64{} for i := 0; i < length; i++ { a[i] = float64(1.01) runtime.Gosched() } for i := 0; i < mods; i++ { for j := 0; j < len(a); j++ { a[j] = 1.01 runtime.Gosched() } } }, sliceT: func() { a := make([]float64, length) for i := 0; i < length; i++ { a[i] = float64(1.01) runtime.Gosched() } for i := 0; i < mods; i++ { for j := 0; j < len(a); j++ { a[j] = 1.01 runtime.Gosched() } } }, mapT: func() { a := make(map[float64]float64) for i := 0; i < length; i++ { a[float64(i)] = float64(i) + 0.01 runtime.Gosched() } for i := 0; i < mods; i++ { for k, _ := range a { a[k] = 1.01 } runtime.Gosched() } }, mapPointerKeyT: func() { a := make(map[float64]float64) for i := 0; i < length; i++ { a[new(float64)] = float64(i) + 0.01 runtime.Gosched() } for i := 0; i < mods; i++ { for k, _ := range a { a[k] = 1.01 runtime.Gosched() } } }, chanT: func() { a := make(chan float64) for i := 0; i < mods; i++ { go func() { a <- float64(i) }() <-a runtime.Gosched() } }, interfaceT: func() { a := interface{}(float64(0)) for i := 0; i < mods; i++ { a = a.(float64) * 1.01 runtime.Gosched() } }, }, modifier{ name: "complex64", t: func() { c := complex64(complex(float32(1.01), float32(1.01))) for i := 0; i < mods; i++ { c = complex(real(c)1.01, imag(c)1.01) runtime.Gosched() } }, pointerT: func() { a := func() complex64 { return new(complex64) }() a = complex64(complex(float32(1.01), float32(1.01))) for i := 0; i < mods; i++ { a = complex(real(a)1.01, imag(a)1.01) runtime.Gosched() } }, arrayT: func() { a := [length]complex64{} for i := 0; i < length; i++ { a[i] = complex64(complex(float32(1.01), float32(1.01))) runtime.Gosched() } for i := 0; i < mods; i++ { for j := 0; j < len(a); j++ { a[j] = complex(real(a[j])1.01, imag(a[j])1.01) runtime.Gosched() } } }, sliceT: func() { a := make([]complex64, length) for i := 0; i < length; i++ { a[i] = complex64(complex(float32(1.01), float32(1.01))) runtime.Gosched() } for i := 0; i < mods; i++ { for j := 0; j < len(a); j++ { a[j] = complex(real(a[j])1.01, imag(a[j])1.01) runtime.Gosched() } } }, mapT: func() { a := make(map[complex64]complex64) for i := 0; i < length; i++ { a[complex64(complex(float32(i), float32(i)))] = complex64(complex(float32(i), float32(i))) + 0.01 runtime.Gosched() } for i := 0; i < mods; i++ { for k, _ := range a { a[k] = complex(real(a[k])1.01, imag(a[k])1.01) } runtime.Gosched() } }, mapPointerKeyT: func() { a := make(map[complex64]complex64) for i := 0; i < length; i++ { a[new(complex64)] = complex64(complex(float32(i), float32(i))) + 0.01 runtime.Gosched() } for i := 0; i < mods; i++ { for k, _ := range a { a[k] = complex(real(a[k])1.01, imag(a[k])1.01) runtime.Gosched() } } }, chanT: func() { a := make(chan complex64) for i := 0; i < mods; i++ { go func() { a <- complex64(complex(float32(i), float32(i))) }() <-a runtime.Gosched() } }, interfaceT: func() { a := interface{}(complex64(complex(float32(1.01), float32(1.01)))) for i := 0; i < mods; i++ { a = a.(complex64) complex(real(a.(complex64))1.01, imag(a.(complex64))1.01) runtime.Gosched() } }, }, modifier{ name: "complex128", t: func() { c := complex128(complex(float64(1.01), float64(1.01))) for i := 0; i < mods; i++ { c = complex(real(c)1.01, imag(c)1.01) runtime.Gosched() } }, pointerT: func() { a := func() complex128 { return new(complex128) }() a = complex128(complex(float64(1.01), float64(1.01))) for i := 0; i < mods; i++ { a = complex(real(a)1.01, imag(a)1.01) runtime.Gosched() } }, arrayT: func() { a := [length]complex128{} for i := 0; i < length; i++ { a[i] = complex128(complex(float64(1.01), float64(1.01))) runtime.Gosched() } for i := 0; i < mods; i++ { for j := 0; j < len(a); j++ { a[j] = complex(real(a[j])1.01, imag(a[j])1.01) runtime.Gosched() } } }, sliceT: func() { a := make([]complex128, length) for i := 0; i < length; i++ { a[i] = complex128(complex(float64(1.01), float64(1.01))) runtime.Gosched() } for i := 0; i < mods; i++ { for j := 0; j < len(a); j++ { a[j] = complex(real(a[j])1.01, imag(a[j])1.01) runtime.Gosched() } } }, mapT: func() { a := make(map[complex128]complex128) for i := 0; i < length; i++ { a[complex128(complex(float64(i), float64(i)))] = complex128(complex(float64(i), float64(i))) + 0.01 runtime.Gosched() } for i := 0; i < mods; i++ { for k, _ := range a { a[k] = complex(real(a[k])1.01, imag(a[k])1.01) } runtime.Gosched() } }, mapPointerKeyT: func() { a := make(map[complex128]complex128) for i := 0; i < length; i++ { a[new(complex128)] = complex128(complex(float64(i), float64(i))) + 0.01 runtime.Gosched() } for i := 0; i < mods; i++ { for k, _ := range a { a[k] = complex(real(a[k])1.01, imag(a[k])1.01) runtime.Gosched() } } }, chanT: func() { a := make(chan complex128) for i := 0; i < mods; i++ { go func() { a <- complex128(complex(float64(i), float64(i))) }() <-a runtime.Gosched() } }, interfaceT: func() { a := interface{}(complex128(complex(float64(1.01), float64(1.01)))) for i := 0; i < mods; i++ { a = a.(complex128) complex(real(a.(complex128))1.01, imag(a.(complex128))1.01) runtime.Gosched() } }, }, modifier{ name: "byte", t: func() { var a byte for i := 0; i < mods; i++ { a++ runtime.Gosched() } }, pointerT: func() { a := func() byte { return new(byte) }() for i := 0; i < mods; i++ { a++ runtime.Gosched() } }, arrayT: func() { a := [length]byte{} for i := 0; i < mods; i++ { for j := 0; j < len(a); j++ { a[j]++ runtime.Gosched() } } }, sliceT: func() { a := make([]byte, length) for i := 0; i < mods; i++ { for j := 0; j < len(a); j++ { a[j]++ runtime.Gosched() } } }, mapT: func() { a := make(map[byte]byte) for i := 0; i < length; i++ { a[byte(i)] = byte(i) runtime.Gosched() } for i := 0; i < mods; i++ { for k, _ := range a { a[k]++ } runtime.Gosched() } }, mapPointerKeyT: func() { a := make(map[byte]byte) for i := 0; i < length; i++ { a[new(byte)] = byte(i) runtime.Gosched() } for i := 0; i < mods; i++ { for k, _ := range a { a[k]++ runtime.Gosched() } } }, chanT: func() { a := make(chan byte) for i := 0; i < mods; i++ { go func() { a <- byte(i) }() <-a runtime.Gosched() } }, interfaceT: func() { a := interface{}(byte(0)) for i := 0; i < mods; i++ { a = a.(byte) + 1 runtime.Gosched() } }, }, modifier{ name: "rune", t: func() { var a rune for i := 0; i < mods; i++ { a++ runtime.Gosched() } }, pointerT: func() { a := func() rune { return new(rune) }() for i := 0; i < mods; i++ { a++ runtime.Gosched() } }, arrayT: func() { a := [length]rune{} for i := 0; i < mods; i++ { for j := 0; j < len(a); j++ { a[j]++ runtime.Gosched() } } }, sliceT: func() { a := make([]rune, length) for i := 0; i < mods; i++ { for j := 0; j < len(a); j++ { a[j]++ runtime.Gosched() } } }, mapT: func() { a := make(map[rune]rune) for i := 0; i < length; i++ { a[rune(i)] = rune(i) runtime.Gosched() } for i := 0; i < mods; i++ { for k, _ := range a { a[k]++ } runtime.Gosched() } }, mapPointerKeyT: func() { a := make(map[rune]rune) for i := 0; i < length; i++ { a[new(rune)] = rune(i) runtime.Gosched() } for i := 0; i < mods; i++ { for k, _ := range a { a[k]++ runtime.Gosched() } } }, chanT: func() { a := make(chan rune) for i := 0; i < mods; i++ { go func() { a <- rune(i) }() <-a runtime.Gosched() } }, interfaceT: func() { a := interface{}(rune(0)) for i := 0; i < mods; i++ { a = a.(rune) + 1 runtime.Gosched() } }, }, modifier{ name: "uint", t: func() { var a uint for i := 0; i < mods; i++ { a++ runtime.Gosched() } }, pointerT: func() { a := func() uint { return new(uint) }() for i := 0; i < mods; i++ { a++ runtime.Gosched() } }, arrayT: func() { a := [length]uint{} for i := 0; i < mods; i++ { for j := 0; j < len(a); j++ { a[j]++ runtime.Gosched() } } }, sliceT: func() { a := make([]uint, length) for i := 0; i < mods; i++ { for j := 0; j < len(a); j++ { a[j]++ runtime.Gosched() } } }, mapT: func() { a := make(map[uint]uint) for i := 0; i < length; i++ { a[uint(i)] = uint(i) runtime.Gosched() } for i := 0; i < mods; i++ { for k, _ := range a { a[k]++ } runtime.Gosched() } }, mapPointerKeyT: func() { a := make(map[uint]uint) for i := 0; i < length; i++ { a[new(uint)] = uint(i) runtime.Gosched() } for i := 0; i < mods; i++ { for k, _ := range a { a[k]++ runtime.Gosched() } } }, chanT: func() { a := make(chan uint) for i := 0; i < mods; i++ { go func() { a <- uint(i) }() <-a runtime.Gosched() } }, interfaceT: func() { a := interface{}(uint(0)) for i := 0; i < mods; i++ { a = a.(uint) + 1 runtime.Gosched() } }, }, modifier{ name: "int", t: func() { var a int for i := 0; i < mods; i++ { a++ runtime.Gosched() } }, pointerT: func() { a := func() int { return new(int) }() for i := 0; i < mods; i++ { a++ runtime.Gosched() } }, arrayT: func() { a := [length]int{} for i := 0; i < mods; i++ { for j := 0; j < len(a); j++ { a[j]++ runtime.Gosched() } } }, sliceT: func() { a := make([]int, length) for i := 0; i < mods; i++ { for j := 0; j < len(a); j++ { a[j]++ runtime.Gosched() } } }, mapT: func() { a := make(map[int]int) for i := 0; i < length; i++ { a[int(i)] = int(i) runtime.Gosched() } for i := 0; i < mods; i++ { for k, _ := range a { a[k]++ } runtime.Gosched() } }, mapPointerKeyT: func() { a := make(map[int]int) for i := 0; i < length; i++ { a[new(int)] = int(i) runtime.Gosched() } for i := 0; i < mods; i++ { for k, _ := range a { a[k]++ runtime.Gosched() } } }, chanT: func() { a := make(chan int) for i := 0; i < mods; i++ { go func() { a <- int(i) }() <-a runtime.Gosched() } }, interfaceT: func() { a := interface{}(int(0)) for i := 0; i < mods; i++ { a = a.(int) + 1 runtime.Gosched() } }, }, modifier{ name: "uintptr", t: func() { var a uintptr for i := 0; i < mods; i++ { a++ runtime.Gosched() } }, pointerT: func() { a := func() uintptr { return new(uintptr) }() for i := 0; i < mods; i++ { a++ runtime.Gosched() } }, arrayT: func() { a := [length]uintptr{} for i := 0; i < mods; i++ { for j := 0; j < len(a); j++ { a[j]++ runtime.Gosched() } } }, sliceT: func() { a := make([]uintptr, length) for i := 0; i < mods; i++ { for j := 0; j < len(a); j++ { a[j]++ runtime.Gosched() } } }, mapT: func() { a := make(map[uintptr]uintptr) for i := 0; i < length; i++ { a[uintptr(i)] = uintptr(i) runtime.Gosched() } for i := 0; i < mods; i++ { for k, _ := range a { a[k]++ } runtime.Gosched() } }, mapPointerKeyT: func() { a := make(map[uintptr]uintptr) for i := 0; i < length; i++ { a[new(uintptr)] = uintptr(i) runtime.Gosched() } for i := 0; i < mods; i++ { for k, _ := range a { a[k]++ runtime.Gosched() } } }, chanT: func() { a := make(chan uintptr) for i := 0; i < mods; i++ { go func() { a <- uintptr(i) }() <-a runtime.Gosched() } }, interfaceT: func() { a := interface{}(uintptr(0)) for i := 0; i < mods; i++ { a = a.(uintptr) + 1 runtime.Gosched() } }, }, modifier{ name: "string", t: func() { var s string f := func(a string) string { return a } for i := 0; i < mods; i++ { s = str(i) s = f(s) } }, pointerT: func() { a := func() string { return new(string) }() for i := 0; i < mods; i++ { a = str(i) runtime.Gosched() } }, arrayT: func() { a := [length]string{} for i := 0; i < mods; i++ { for j := 0; j < len(a); j++ { a[j] = str(i) runtime.Gosched() } } }, sliceT: func() { a := make([]string, length) for i := 0; i < mods; i++ { for j := 0; j < len(a); j++ { a[j] = str(i) runtime.Gosched() } } }, mapT: func() { a := make(map[string]string) for i := 0; i < length; i++ { a[string(i)] = str(i) runtime.Gosched() } for i := 0; i < mods; i++ { for k, _ := range a { a[k] = str(i) } runtime.Gosched() } }, mapPointerKeyT: func() { a := make(map[string]string) for i := 0; i < length; i++ { a[new(string)] = str(i) runtime.Gosched() } for i := 0; i < mods; i++ { for k, _ := range a { a[k] = str(i) runtime.Gosched() } } }, chanT: func() { a := make(chan string) for i := 0; i < mods; i++ { go func() { a <- str(i) }() <-a runtime.Gosched() } }, interfaceT: func() { a := interface{}(str(0)) f := func(a string) string { return a } for i := 0; i < mods; i++ { a = str(i) a = f(a.(string)) runtime.Gosched() } }, }, modifier{ name: "structT", t: func() { s := newStructT() for i := 0; i < mods; i++ { s.u8++ s.u16++ s.u32++ s.u64++ s.i8++ s.i16++ s.i32++ s.i64++ s.f32 = 1.01 s.f64 = 1.01 s.c64 = complex(real(s.c64)1.01, imag(s.c64)1.01) s.c128 = complex(real(s.c128)1.01, imag(s.c128)1.01) s.b++ s.r++ s.u++ s.in++ s.uip++ s.s = str(i) runtime.Gosched() } }, pointerT: func() { s := func() structT { t := newStructT() return &t }() for i := 0; i < mods; i++ { s.u8++ s.u16++ s.u32++ s.u64++ s.i8++ s.i16++ s.i32++ s.i64++ s.f32 = 1.01 s.f64 = 1.01 s.c64 = complex(real(s.c64)1.01, imag(s.c64)1.01) s.c128 = complex(real(s.c128)1.01, imag(s.c128)1.01) s.b++ s.r++ s.u++ s.in++ s.uip++ s.s = str(i) runtime.Gosched() } }, arrayT: func() { a := [length]structT{} for i := 0; i < len(a); i++ { a[i] = newStructT() } for i := 0; i < mods; i++ { for j := 0; j < len(a); j++ { a[j].u8++ a[j].u16++ a[j].u32++ a[j].u64++ a[j].i8++ a[j].i16++ a[j].i32++ a[j].i64++ a[j].f32 = 1.01 a[j].f64 = 1.01 a[j].c64 = complex(real(a[j].c64)1.01, imag(a[j].c64)1.01) a[j].c128 = complex(real(a[j].c128)1.01, imag(a[j].c128)1.01) a[j].b++ a[j].r++ a[j].u++ a[j].in++ a[j].uip++ a[j].s = str(i) runtime.Gosched() } } }, sliceT: func() { a := make([]structT, length) for i := 0; i < len(a); i++ { a[i] = newStructT() } for i := 0; i < mods; i++ { for j := 0; j < len(a); j++ { a[j].u8++ a[j].u16++ a[j].u32++ a[j].u64++ a[j].i8++ a[j].i16++ a[j].i32++ a[j].i64++ a[j].f32 = 1.01 a[j].f64 = 1.01 a[j].c64 = complex(real(a[j].c64)1.01, imag(a[j].c64)1.01) a[j].c128 = complex(real(a[j].c128)1.01, imag(a[j].c128)1.01) a[j].b++ a[j].r++ a[j].u++ a[j].in++ a[j].uip++ a[j].s = str(i) runtime.Gosched() } } }, mapT: func() { a := make(map[structT]structT) for i := 0; i < length; i++ { m := newStructT() m.in = i a[m] = newStructT() runtime.Gosched() } for i := 0; i < mods; i++ { for j, _ := range a { m := a[j] m.u8++ m.u16++ m.u32++ m.u64++ m.i8++ m.i16++ m.i32++ m.i64++ m.f32 = 1.01 m.f64 = 1.01 m.c64 = complex(real(a[j].c64)1.01, imag(a[j].c64)1.01) m.c128 = complex(real(a[j].c128)1.01, imag(a[j].c128)1.01) m.b++ m.r++ m.u++ m.in++ m.uip++ m.s = str(i) a[j] = m runtime.Gosched() } runtime.Gosched() } }, mapPointerKeyT: func() { a := make(map[structT]structT) f := func() structT { m := newStructT() return &m } for i := 0; i < length; i++ { m := f() m.in = i a[m] = newStructT() runtime.Gosched() } for i := 0; i < mods; i++ { for j, _ := range a { m := a[j] m.u8++ m.u16++ m.u32++ m.u64++ m.i8++ m.i16++ m.i32++ m.i64++ m.f32 = 1.01 m.f64 = 1.01 m.c64 = complex(real(a[j].c64)1.01, imag(a[j].c64)1.01) m.c128 = complex(real(a[j].c128)1.01, imag(a[j].c128)*1.01) m.b++ m.r++ m.u++ m.in++ m.uip++ m.s = str(i) a[j] = m runtime.Gosched() } runtime.Gosched() } }, chanT: func() { a := make(chan structT) for i := 0; i < mods; i++ { go func() { a <- newStructT() }() <-a runtime.Gosched() } }, interfaceT: func() { a := interface{}(newStructT()) for i := 0; i < mods; i++ { a = a.(structT) runtime.Gosched() } }, }, } type structT struct { u8 uint8 u16 uint16 u32 uint32 u64 uint64 i8 int8 i16 int16 i32 int32 i64 int64 f32 float32 f64 float64 c64 complex64 c128 complex128 b byte r rune u uint in int uip uintptr s string } func newStructT() structT { return structT{ f32: 1.01, f64: 1.01, c64: complex(float32(1.01), float32(1.01)), c128: complex(float64(1.01), float64(1.01)), } } func str(in int) string { switch in % 3 { case 0: return "Hello" case 1: return "world" case 2: return "!" } return "?" }	34.54 KB	2024-02-02 18:09
📄 gcstring.go // 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 that s[len(s):] - which can point past the end of the allocated block - // does not confuse the garbage collector. package main import ( "runtime" "time" ) type T struct { ptr *int pad [120]byte } var things []interface{} func main() { setup() runtime.GC() runtime.GC() time.Sleep(10time.Millisecond) runtime.GC() runtime.GC() time.Sleep(10time.Millisecond) } func setup() { var Ts []interface{} buf := make([]byte, 128) for i := 0; i < 10000; i++ { s := string(buf) t := &T{ptr: new(int)} runtime.SetFinalizer(t.ptr, func(*int) { panic("int freed too early") }) Ts = append(Ts, t) things = append(things, s[len(s):]) } things = append(things, Ts...) }	872 B	2024-02-02 18:09
📄 goprint.go // run // 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. // Test that println can be the target of a go statement. package main import ( "log" "runtime" "time" ) func main() { numg0 := runtime.NumGoroutine() deadline := time.Now().Add(10 * time.Second) go println(42, true, false, true, 1.5, "world", (chan int)(nil), []int(nil), (map[string]int)(nil), (func())(nil), byte(255)) for { numg := runtime.NumGoroutine() if numg > numg0 { if time.Now().After(deadline) { log.Fatalf("%d goroutines > initial %d after deadline", numg, numg0) } runtime.Gosched() continue } break } }	722 B	2024-02-02 18:09
📄 goprint.out 42 true false true +1.500000e+000 world 0x0 [0/0]0x0 0x0 0x0 255	65 B	2024-02-02 18:09
📄 goto.go // errorcheck // 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. // Verify goto semantics. // Does not compile. // // Each test is in a separate function just so that if the // compiler stops processing after one error, we don't // lose other ones. package main var ( i, n int x []int c chan int m map[int]int s string ) // goto after declaration okay func _() { x := 1 goto L L: _ = x } // goto before declaration okay func _() { goto L L: x := 1 _ = x } // goto across declaration not okay func _() { goto L // ERROR "goto L jumps over declaration of x at LINE+1\|goto jumps over declaration" x := 1 // GCCGO_ERROR "defined here" _ = x L: } // goto across declaration in inner scope okay func _() { goto L { x := 1 _ = x } L: } // goto across declaration after inner scope not okay func _() { goto L // ERROR "goto L jumps over declaration of x at LINE+5\|goto jumps over declaration" { x := 1 _ = x } x := 1 // GCCGO_ERROR "defined here" _ = x L: } // goto across declaration in reverse okay func _() { L: x := 1 _ = x goto L } // error shows first offending variable func _() { goto L // ERROR "goto L jumps over declaration of y at LINE+3\|goto jumps over declaration" x := 1 // GCCGO_ERROR "defined here" _ = x y := 1 _ = y L: } // goto not okay even if code path is dead func _() { goto L // ERROR "goto L jumps over declaration of y at LINE+3\|goto jumps over declaration" x := 1 // GCCGO_ERROR "defined here" _ = x y := 1 _ = y return L: } // goto into outer block okay func _() { { goto L } L: } // goto backward into outer block okay func _() { L: { goto L } } // goto into inner block not okay func _() { goto L // ERROR "goto L jumps into block starting at LINE+1\|goto jumps into block" { // GCCGO_ERROR "block starts here" L: } } // goto backward into inner block still not okay func _() { { // GCCGO_ERROR "block starts here" L: } goto L // ERROR "goto L jumps into block starting at LINE-3\|goto jumps into block" } // error shows first (outermost) offending block func _() { goto L // ERROR "goto L jumps into block starting at LINE+3\|goto jumps into block" { { { // GCCGO_ERROR "block starts here" L: } } } } // error prefers block diagnostic over declaration diagnostic func _() { goto L // ERROR "goto L jumps into block starting at LINE+3\|goto jumps into block" x := 1 _ = x { // GCCGO_ERROR "block starts here" L: } } // many kinds of blocks, all invalid to jump into or among, // but valid to jump out of // if func _() { L: if true { goto L } } func _() { L: if true { goto L } else { } } func _() { L: if false { } else { goto L } } func _() { goto L // ERROR "goto L jumps into block starting at LINE+1\|goto jumps into block" if true { // GCCGO_ERROR "block starts here" L: } } func _() { goto L // ERROR "goto L jumps into block starting at LINE+1\|goto jumps into block" if true { // GCCGO_ERROR "block starts here" L: } else { } } func _() { goto L // ERROR "goto L jumps into block starting at LINE+2\|goto jumps into block" if true { } else { // GCCGO_ERROR "block starts here" L: } } func _() { if false { // GCCGO_ERROR "block starts here" L: } else { goto L // ERROR "goto L jumps into block starting at LINE-3\|goto jumps into block" } } func _() { if true { goto L // ERROR "goto L jumps into block starting at LINE+1\|goto jumps into block" } else { // GCCGO_ERROR "block starts here" L: } } func _() { if true { goto L // ERROR "goto L jumps into block starting at LINE+1\|goto jumps into block" } else if false { // GCCGO_ERROR "block starts here" L: } } func _() { if true { goto L // ERROR "goto L jumps into block starting at LINE+1\|goto jumps into block" } else if false { // GCCGO_ERROR "block starts here" L: } else { } } func _() { // This one is tricky. There is an implicit scope // starting at the second if statement, and it contains // the final else, so the outermost offending scope // really is LINE+1 (like in the previous test), // even though it looks like it might be LINE+3 instead. if true { goto L // ERROR "goto L jumps into block starting at LINE+2\|goto jumps into block" } else if false { } else { // GCCGO_ERROR "block starts here" L: } } /* Want to enable these tests but gofmt mangles them. Issue 1972. func _() { // This one is okay, because the else is in the // implicit whole-if block and has no inner block // (no { }) around it. if true { goto L } else L: } func _() { // Still not okay. if true { //// GCCGO_ERROR "block starts here" L: } else goto L //// ERROR "goto L jumps into block starting at LINE-3\|goto jumps into block" } */ // for func _() { for { goto L } L: } func _() { for { goto L L: } } func _() { for { // GCCGO_ERROR "block starts here" L: } goto L // ERROR "goto L jumps into block starting at LINE-3\|goto jumps into block" } func _() { for { // GCCGO_ERROR "block starts here" goto L L1: } L: goto L1 // ERROR "goto L1 jumps into block starting at LINE-5\|goto jumps into block" } func _() { for i < n { // GCCGO_ERROR "block starts here" L: } goto L // ERROR "goto L jumps into block starting at LINE-3\|goto jumps into block" } func _() { for i = 0; i < n; i++ { // GCCGO_ERROR "block starts here" L: } goto L // ERROR "goto L jumps into block starting at LINE-3\|goto jumps into block" } func _() { for i = range x { // GCCGO_ERROR "block starts here" L: } goto L // ERROR "goto L jumps into block starting at LINE-3\|goto jumps into block" } func _() { for i = range c { // GCCGO_ERROR "block starts here" L: } goto L // ERROR "goto L jumps into block starting at LINE-3\|goto jumps into block" } func _() { for i = range m { // GCCGO_ERROR "block starts here" L: } goto L // ERROR "goto L jumps into block starting at LINE-3\|goto jumps into block" } func _() { for i = range s { // GCCGO_ERROR "block starts here" L: } goto L // ERROR "goto L jumps into block starting at LINE-3\|goto jumps into block" } // switch func _() { L: switch i { case 0: goto L } } func _() { L: switch i { case 0: default: goto L } } func _() { switch i { case 0: default: L: goto L } } func _() { switch i { case 0: default: goto L L: } } func _() { switch i { case 0: goto L L: ; default: } } func _() { goto L // ERROR "goto L jumps into block starting at LINE+2\|goto jumps into block" switch i { case 0: L: // GCCGO_ERROR "block starts here" } } func _() { goto L // ERROR "goto L jumps into block starting at LINE+2\|goto jumps into block" switch i { case 0: L: // GCCGO_ERROR "block starts here" ; default: } } func _() { goto L // ERROR "goto L jumps into block starting at LINE+3\|goto jumps into block" switch i { case 0: default: L: // GCCGO_ERROR "block starts here" } } func _() { switch i { default: goto L // ERROR "goto L jumps into block starting at LINE+1\|goto jumps into block" case 0: L: // GCCGO_ERROR "block starts here" } } func _() { switch i { case 0: L: // GCCGO_ERROR "block starts here" ; default: goto L // ERROR "goto L jumps into block starting at LINE-4\|goto jumps into block" } } // select // different from switch. the statement has no implicit block around it. func _() { L: select { case <-c: goto L } } func _() { L: select { case c <- 1: default: goto L } } func _() { select { case <-c: default: L: goto L } } func _() { select { case c <- 1: default: goto L L: } } func _() { select { case <-c: goto L L: ; default: } } func _() { goto L // ERROR "goto L jumps into block starting at LINE+2\|goto jumps into block" select { case c <- 1: L: // GCCGO_ERROR "block starts here" } } func _() { goto L // ERROR "goto L jumps into block starting at LINE+2\|goto jumps into block" select { case c <- 1: L: // GCCGO_ERROR "block starts here" ; default: } } func _() { goto L // ERROR "goto L jumps into block starting at LINE+3\|goto jumps into block" select { case <-c: default: L: // GCCGO_ERROR "block starts here" } } func _() { select { default: goto L // ERROR "goto L jumps into block starting at LINE+1\|goto jumps into block" case <-c: L: // GCCGO_ERROR "block starts here" } } func _() { select { case <-c: L: // GCCGO_ERROR "block starts here" ; default: goto L // ERROR "goto L jumps into block starting at LINE-4\|goto jumps into block" } }	8.39 KB	2024-02-02 18:09
📄 heapsampling.go // run // Copyright 2009 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 heap sampling logic. package main import ( "fmt" "math" "runtime" ) var a16 [16]byte var a512 [512]byte var a256 [256]byte var a1k [1024]byte var a16k [16 1024]byte var a17k [17 1024]byte var a18k [18 1024]byte // This test checks that heap sampling produces reasonable results. // Note that heap sampling uses randomization, so the results vary for // run to run. To avoid flakes, this test performs multiple // experiments and only complains if all of them consistently fail. func main() { // Sample at 16K instead of default 512K to exercise sampling more heavily. runtime.MemProfileRate = 16 * 1024 if err := testInterleavedAllocations(); err != nil { panic(err.Error()) } if err := testSmallAllocations(); err != nil { panic(err.Error()) } } // Repeatedly exercise a set of allocations and check that the heap // profile collected by the runtime unsamples to a reasonable // value. Because sampling is based on randomization, there can be // significant variability on the unsampled data. To account for that, // the testcase allows for a 10% margin of error, but only fails if it // consistently fails across three experiments, avoiding flakes. func testInterleavedAllocations() error { const iters = 50000 // Sizes of the allocations performed by each experiment. frames := []string{"main.allocInterleaved1", "main.allocInterleaved2", "main.allocInterleaved3"} // Pass if at least one of three experiments has no errors. Use a separate // function for each experiment to identify each experiment in the profile. allocInterleaved1(iters) if checkAllocations(getMemProfileRecords(), frames[0:1], iters, allocInterleavedSizes) == nil { // Passed on first try, report no error. return nil } allocInterleaved2(iters) if checkAllocations(getMemProfileRecords(), frames[0:2], iters, allocInterleavedSizes) == nil { // Passed on second try, report no error. return nil } allocInterleaved3(iters) // If it fails a third time, we may be onto something. return checkAllocations(getMemProfileRecords(), frames[0:3], iters, allocInterleavedSizes) } var allocInterleavedSizes = []int64{17 * 1024, 1024, 18 * 1024, 512, 16 * 1024, 256} // allocInterleaved stress-tests the heap sampling logic by interleaving large and small allocations. func allocInterleaved(n int) { for i := 0; i < n; i++ { // Test verification depends on these lines being contiguous. a17k = new([17 * 1024]byte) a1k = new([1024]byte) a18k = new([18 * 1024]byte) a512 = new([512]byte) a16k = new([16 * 1024]byte) a256 = new([256]byte) // Test verification depends on these lines being contiguous. // Slow down the allocation rate to avoid #52433. runtime.Gosched() } } func allocInterleaved1(n int) { allocInterleaved(n) } func allocInterleaved2(n int) { allocInterleaved(n) } func allocInterleaved3(n int) { allocInterleaved(n) } // Repeatedly exercise a set of allocations and check that the heap // profile collected by the runtime unsamples to a reasonable // value. Because sampling is based on randomization, there can be // significant variability on the unsampled data. To account for that, // the testcase allows for a 10% margin of error, but only fails if it // consistently fails across three experiments, avoiding flakes. func testSmallAllocations() error { const iters = 50000 // Sizes of the allocations performed by each experiment. sizes := []int64{1024, 512, 256} frames := []string{"main.allocSmall1", "main.allocSmall2", "main.allocSmall3"} // Pass if at least one of three experiments has no errors. Use a separate // function for each experiment to identify each experiment in the profile. allocSmall1(iters) if checkAllocations(getMemProfileRecords(), frames[0:1], iters, sizes) == nil { // Passed on first try, report no error. return nil } allocSmall2(iters) if checkAllocations(getMemProfileRecords(), frames[0:2], iters, sizes) == nil { // Passed on second try, report no error. return nil } allocSmall3(iters) // If it fails a third time, we may be onto something. return checkAllocations(getMemProfileRecords(), frames[0:3], iters, sizes) } // allocSmall performs only small allocations for sanity testing. func allocSmall(n int) { for i := 0; i < n; i++ { // Test verification depends on these lines being contiguous. a1k = new([1024]byte) a512 = new([512]byte) a256 = new([256]byte) // Slow down the allocation rate to avoid #52433. runtime.Gosched() } } // Three separate instances of testing to avoid flakes. Will report an error // only if they all consistently report failures. func allocSmall1(n int) { allocSmall(n) } func allocSmall2(n int) { allocSmall(n) } func allocSmall3(n int) { allocSmall(n) } // checkAllocations validates that the profile records collected for // the named function are consistent with count contiguous allocations // of the specified sizes. // Check multiple functions and only report consistent failures across // multiple tests. // Look only at samples that include the named frames, and group the // allocations by their line number. All these allocations are done from // the same leaf function, so their line numbers are the same. func checkAllocations(records []runtime.MemProfileRecord, frames []string, count int64, size []int64) error { objectsPerLine := map[int][]int64{} bytesPerLine := map[int][]int64{} totalCount := []int64{} // Compute the line number of the first allocation. All the // allocations are from the same leaf, so pick the first one. var firstLine int for ln := range allocObjects(records, frames[0]) { if firstLine == 0 \|\| firstLine > ln { firstLine = ln } } for _, frame := range frames { var objectCount int64 a := allocObjects(records, frame) for s := range size { // Allocations of size size[s] should be on line firstLine + s. ln := firstLine + s objectsPerLine[ln] = append(objectsPerLine[ln], a[ln].objects) bytesPerLine[ln] = append(bytesPerLine[ln], a[ln].bytes) objectCount += a[ln].objects } totalCount = append(totalCount, objectCount) } for i, w := range size { ln := firstLine + i if err := checkValue(frames[0], ln, "objects", count, objectsPerLine[ln]); err != nil { return err } if err := checkValue(frames[0], ln, "bytes", countw, bytesPerLine[ln]); err != nil { return err } } return checkValue(frames[0], 0, "total", countint64(len(size)), totalCount) } // checkValue checks an unsampled value against its expected value. // Given that this is a sampled value, it will be unexact and will change // from run to run. Only report it as a failure if all the values land // consistently far from the expected value. func checkValue(fname string, ln int, testName string, want int64, got []int64) error { if got == nil { return fmt.Errorf("Unexpected empty result") } min, max := got[0], got[0] for _, g := range got[1:] { if g < min { min = g } if g > max { max = g } } margin := want / 10 // 10% margin. if min > want+margin \|\| max < want-margin { return fmt.Errorf("%s:%d want %s in [%d: %d], got %v", fname, ln, testName, want-margin, want+margin, got) } return nil } func getMemProfileRecords() []runtime.MemProfileRecord { // Force the runtime to update the object and byte counts. // This can take up to two GC cycles to get a complete // snapshot of the current point in time. runtime.GC() runtime.GC() // Find out how many records there are (MemProfile(nil, true)), // allocate that many records, and get the data. // There's a race—more records might be added between // the two calls—so allocate a few extra records for safety // and also try again if we're very unlucky. // The loop should only execute one iteration in the common case. var p []runtime.MemProfileRecord n, ok := runtime.MemProfile(nil, true) for { // Allocate room for a slightly bigger profile, // in case a few more entries have been added // since the call to MemProfile. p = make([]runtime.MemProfileRecord, n+50) n, ok = runtime.MemProfile(p, true) if ok { p = p[0:n] break } // Profile grew; try again. } return p } type allocStat struct { bytes, objects int64 } // allocObjects examines the profile records for samples including the // named function and returns the allocation stats aggregated by // source line number of the allocation (at the leaf frame). func allocObjects(records []runtime.MemProfileRecord, function string) map[int]allocStat { a := make(map[int]allocStat) for _, r := range records { var pcs []uintptr for _, s := range r.Stack0 { if s == 0 { break } pcs = append(pcs, s) } frames := runtime.CallersFrames(pcs) line := 0 for { frame, more := frames.Next() name := frame.Function if line == 0 { line = frame.Line } if name == function { allocStat := a[line] allocStat.bytes += r.AllocBytes allocStat.objects += r.AllocObjects a[line] = allocStat } if !more { break } } } for line, stats := range a { objects, bytes := scaleHeapSample(stats.objects, stats.bytes, int64(runtime.MemProfileRate)) a[line] = allocStat{bytes, objects} } return a } // scaleHeapSample unsamples heap allocations. // Taken from src/cmd/pprof/internal/profile/legacy_profile.go func scaleHeapSample(count, size, rate int64) (int64, int64) { if count == 0 \|\| size == 0 { return 0, 0 } if rate <= 1 { // if rate==1 all samples were collected so no adjustment is needed. // if rate<1 treat as unknown and skip scaling. return count, size } avgSize := float64(size) / float64(count) scale := 1 / (1 - math.Exp(-avgSize/float64(rate))) return int64(float64(count) * scale), int64(float64(size) * scale) }	9.67 KB	2024-02-02 18:09
📄 helloworld.go // run // Copyright 2009 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 that we can do page 1 of the C book. package main func main() { print("hello, world\n") }	269 B	2024-02-02 18:09
📄 helloworld.out hello, world	13 B	2024-02-02 18:09
📄 if.go // run // Copyright 2009 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 if statements in various forms. package main func assertequal(is, shouldbe int, msg string) { if is != shouldbe { print("assertion fail", msg, "\n") panic(1) } } func main() { i5 := 5 i7 := 7 var count int count = 0 if true { count = count + 1 } assertequal(count, 1, "if true") count = 0 if false { count = count + 1 } assertequal(count, 0, "if false") count = 0 if one := 1; true { count = count + one } assertequal(count, 1, "if true one") count = 0 if one := 1; false { count = count + 1 _ = one } assertequal(count, 0, "if false one") count = 0 if i5 < i7 { count = count + 1 } assertequal(count, 1, "if cond") count = 0 if true { count = count + 1 } else { count = count - 1 } assertequal(count, 1, "if else true") count = 0 if false { count = count + 1 } else { count = count - 1 } assertequal(count, -1, "if else false") count = 0 if t := 1; false { count = count + 1 _ = t t := 7 _ = t } else { count = count - t } assertequal(count, -1, "if else false var") count = 0 t := 1 if false { count = count + 1 t := 7 _ = t } else { count = count - t } _ = t assertequal(count, -1, "if else false var outside") }	1.36 KB	2024-02-02 18:09
📄 import.go // compile // Copyright 2009 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 that when import gives multiple names // to a single type, they still all refer to the same type. package main import _os_ "os" import "os" import . "os" func f(e os.File) func main() { var _e_ _os_.File var dot *File f(_e_) f(dot) }	425 B	2024-02-02 18:09
📄 import1.go // errorcheck // Copyright 2009 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. // Verify that import conflicts are detected by the compiler. // Does not compile. package main import "bufio" // ERROR "previous\|not used" import bufio "os" // ERROR "redeclared\|redefinition\|incompatible" "imported and not used\|imported as bufio and not used" import ( "fmt" // ERROR "previous\|not used" fmt "math" // ERROR "redeclared\|redefinition\|incompatible" "imported and not used: \x22math\x22 as fmt\|imported as fmt and not used" . "math" // GC_ERROR "imported and not used: \x22math\x22$\|imported and not used" )	703 B	2024-02-02 18:09
📁 import2.dir	-	2024-02-02 18:09
📄 import2.go // compiledir // Copyright 2010 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. // Tests that export data does not corrupt type syntax. package ignored	247 B	2024-02-02 18:09
📁 import4.dir	-	2024-02-02 18:09
📄 import4.go // errorcheckdir // Copyright 2009 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. // Verify that various kinds of "imported and not used" // errors are caught by the compiler. // Does not compile. package ignored	310 B	2024-02-02 18:09
📄 import5.go // errorcheck // Copyright 2009 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. // Verify that invalid imports are rejected by the compiler. // Does not compile. package main // Correct import paths. import _ "fmt" import _ `time` import _ "m\x61th" import _ "go/parser" // Correct import paths, but the packages don't exist. // Don't test. //import "a.b" //import "greek/αβ" // Import paths must be strings. import 42 // ERROR "import path must be a string" import 'a' // ERROR "import path must be a string" import 3.14 // ERROR "import path must be a string" import 0.25i // ERROR "import path must be a string"	722 B	2024-02-02 18:09
📄 import6.go // 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. // Verify that invalid imports are rejected by the compiler. // Does not compile. package main // Each of these pairs tests both `` vs "" strings // and also use of invalid characters spelled out as // escape sequences and written directly. // For example `"\x00"` tests import "\x00" // while "`\x00`" tests import `<actual-NUL-byte>`. import "" // ERROR "import path" import `` // ERROR "import path" import "\x00" // ERROR "import path" import `\x00` // ERROR "import path" import "\x7f" // ERROR "import path" import `\x7f` // ERROR "import path" import "a!" // ERROR "import path" import `a!` // ERROR "import path" import "a b" // ERROR "import path" import `a b` // ERROR "import path" import "a\\b" // ERROR "import path" import `a\\b` // ERROR "import path" import "\"`a`\"" // ERROR "import path" import `\"a\"` // ERROR "import path" import "\x80\x80" // ERROR "import path" import `\x80\x80` // ERROR "import path" import "\xFFFD" // ERROR "import path" import `\xFFFD` // ERROR "import path" // Invalid local imports. // types2 adds extra "not used" error. import "/foo" // ERROR "import path cannot be absolute path\|not used" import "c:/foo" // ERROR "import path contains invalid character\|invalid character"	1.44 KB	2024-02-02 18:09
📄 index.go // skip // Copyright 2010 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. // Generate test of index and slice bounds checks. // The actual tests are index0.go, index1.go, index2.go. package main import ( "bufio" "fmt" "os" "unsafe" ) const prolog = ` package main import ( "runtime" ) type quad struct { x, y, z, w int } const ( cj = 100011 ci int = 100012 ci8 int8 = 115 ci16 int16 = 10016 ci32 int32 = 100013 ci64 int64 = 100014 ci64big int64 = 1<<31 ci64bigger int64 = 1<<32 chuge = 1<<100 cfgood = 2.0 cfbad = 2.1 cnj = -2 cni int = -3 cni8 int8 = -6 cni16 int16 = -7 cni32 int32 = -4 cni64 int64 = -5 cni64big int64 = -1<<31 cni64bigger int64 = -1<<32 cnhuge = -1<<100 cnfgood = -2.0 cnfbad = -2.1 ) var j int = 100020 var i int = 100021 var i8 int8 = 126 var i16 int16 = 10025 var i32 int32 = 100022 var i64 int64 = 100023 var i64big int64 = 1<<31 var i64bigger int64 = 1<<32 var huge uint64 = 1<<64 - 1 var fgood float64 = 2.0 var fbad float64 = 2.1 var nj int = -10 var ni int = -11 var ni8 int8 = -14 var ni16 int16 = -15 var ni32 int32 = -12 var ni64 int64 = -13 var ni64big int64 = -1<<31 var ni64bigger int64 = -1<<32 var nhuge int64 = -1<<63 var nfgood float64 = -2.0 var nfbad float64 = -2.1 var si []int = make([]int, 10) var ai [10]int var pai [10]int = &ai var sq []quad = make([]quad, 10) var aq [10]quad var paq [10]quad = &aq var sib []int = make([]int, 100000) var aib [100000]int var paib [100000]int = &aib var sqb []quad = make([]quad, 100000) var aqb [100000]quad var paqb [100000]quad = &aqb type T struct { si []int ai [10]int pai [10]int sq []quad aq [10]quad paq [10]quad sib []int aib [100000]int paib [100000]int sqb []quad aqb [100000]quad paqb [100000]quad } var t = T{si, ai, pai, sq, aq, paq, sib, aib, paib, sqb, aqb, paqb} var pt = &T{si, ai, pai, sq, aq, paq, sib, aib, paib, sqb, aqb, paqb} // test that f panics func test(f func(), s string) { defer func() { if err := recover(); err == nil { _, file, line, _ := runtime.Caller(2) bug() print(file, ":", line, ": ", s, " did not panic\n") } else if !contains(err.(error).Error(), "out of range") { _, file, line, _ := runtime.Caller(2) bug() print(file, ":", line, ": ", s, " unexpected panic: ", err.(error).Error(), "\n") } }() f() } func contains(x, y string) bool { for i := 0; i+len(y) <= len(x); i++ { if x[i:i+len(y)] == y { return true } } return false } var X interface{} func use(y interface{}) { X = y } var didBug = false func bug() { if !didBug { didBug = true println("BUG") } } func main() { ` // pass variable set in index[012].go // 0 - dynamic checks // 1 - static checks of invalid constants (cannot assign to types) // 2 - static checks of array bounds func testExpr(b *bufio.Writer, expr string) { if pass == 0 { fmt.Fprintf(b, "\ttest(func(){use(%s)}, %q)\n", expr, expr) } else { fmt.Fprintf(b, "\tuse(%s) // ERROR \"index\|overflow\|truncated\|must be integer\"\n", expr) } } func main() { b := bufio.NewWriter(os.Stdout) if pass == 0 { fmt.Fprint(b, "// run\n\n") } else { fmt.Fprint(b, "// errorcheck\n\n") } fmt.Fprint(b, prolog) var choices = [][]string{ // Direct value, fetch from struct, fetch from struct pointer. // The last two cases get us to oindex_const_sudo in gsubr.c. []string{"", "t.", "pt."}, // Array, pointer to array, slice. []string{"a", "pa", "s"}, // Element is int, element is quad (struct). // This controls whether we end up in gsubr.c (i) or cgen.c (q). []string{"i", "q"}, // Small or big len. []string{"", "b"}, // Variable or constant. []string{"", "c"}, // Positive or negative. []string{"", "n"}, // Size of index. []string{"j", "i", "i8", "i16", "i32", "i64", "i64big", "i64bigger", "huge", "fgood", "fbad"}, } forall(choices, func(x []string) { p, a, e, big, c, n, i := x[0], x[1], x[2], x[3], x[4], x[5], x[6] // Pass: dynamic=0, static=1, 2. // Which cases should be caught statically? // Only constants, obviously. // Beyond that, must be one of these: // indexing into array or pointer to array // negative constant // large constant thisPass := 0 if c == "c" && (a == "a" \|\| a == "pa" \|\| n == "n" \|\| i == "i64big" \|\| i == "i64bigger" \|\| i == "huge" \|\| i == "fbad") { if i == "huge" { // Due to a detail of gc's internals, // the huge constant errors happen in an // earlier pass than the others and inhibits // the next pass from running. // So run it as a separate check. thisPass = 1 } else if a == "s" && n == "" && (i == "i64big" \|\| i == "i64bigger") && unsafe.Sizeof(int(0)) > 4 { // If int is 64 bits, these huge // numbers do fit in an int, so they // are not rejected at compile time. thisPass = 0 } else { thisPass = 2 } } pae := p + a + e + big cni := c + n + i // If we're using the big-len data, positive int8 and int16 cannot overflow. if big == "b" && n == "" && (i == "i8" \|\| i == "i16") { if pass == 0 { fmt.Fprintf(b, "\tuse(%s[%s])\n", pae, cni) fmt.Fprintf(b, "\tuse(%s[0:%s])\n", pae, cni) fmt.Fprintf(b, "\tuse(%s[1:%s])\n", pae, cni) fmt.Fprintf(b, "\tuse(%s[%s:])\n", pae, cni) fmt.Fprintf(b, "\tuse(%s[%s:%s])\n", pae, cni, cni) } return } // Float variables cannot be used as indices. if c == "" && (i == "fgood" \|\| i == "fbad") { return } // Integral float constant is ok. if c == "c" && n == "" && i == "fgood" { if pass == 0 { fmt.Fprintf(b, "\tuse(%s[%s])\n", pae, cni) fmt.Fprintf(b, "\tuse(%s[0:%s])\n", pae, cni) fmt.Fprintf(b, "\tuse(%s[1:%s])\n", pae, cni) fmt.Fprintf(b, "\tuse(%s[%s:])\n", pae, cni) fmt.Fprintf(b, "\tuse(%s[%s:%s])\n", pae, cni, cni) } return } // Only print the test case if it is appropriate for this pass. if thisPass == pass { // Index operation testExpr(b, pae+"["+cni+"]") // Slice operation. // Low index 0 is a special case in ggen.c // so test both 0 and 1. testExpr(b, pae+"[0:"+cni+"]") testExpr(b, pae+"[1:"+cni+"]") testExpr(b, pae+"["+cni+":]") testExpr(b, pae+"["+cni+":"+cni+"]") } }) fmt.Fprintln(b, "}") b.Flush() } func forall(choices [][]string, f func([]string)) { x := make([]string, len(choices)) var recurse func(d int) recurse = func(d int) { if d >= len(choices) { f(x) return } for _, x[d] = range choices[d] { recurse(d + 1) } } recurse(0) }	6.42 KB	2024-02-02 18:09
📄 index0.go // runoutput ./index.go // 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. // Generate test of index and slice bounds checks. // The output is compiled and run. package main const pass = 0	301 B	2024-02-02 18:09
📄 index1.go // errorcheckoutput ./index.go // Copyright 2010 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. // Generate test of index and slice bounds checks. // The output is error checked. package main const pass = 1	305 B	2024-02-02 18:09
📄 index2.go // errorcheckoutput ./index.go // Copyright 2010 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. // Generate test of index and slice bounds checks. // The output is error checked. package main const pass = 2	305 B	2024-02-02 18:09
📄 indirect.go // run // Copyright 2009 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 various safe uses of indirection. package main var m0 map[string]int var m1 map[string]int var m2 map[string]int = &m0 var m3 map[string]int = map[string]int{"a": 1} var m4 map[string]int = &m3 var s0 string var s1 string var s2 string = &s0 var s3 string = "a" var s4 string = &s3 var a0 [10]int var a1 [10]int var a2 [10]int = &a0 var b0 []int var b1 []int var b2 []int = &b0 var b3 []int = []int{1, 2, 3} var b4 *[]int = &b3 func crash() { // these uses of nil pointers // would crash but should type check println("crash", len(a1)+cap(a1)) } func nocrash() { // this is spaced funny so that // the compiler will print a different // line number for each len call if // it decides there are type errors. // it might also help in the traceback. x := len(m0) + len(m3) if x != 1 { println("wrong maplen") panic("fail") } x = len(s0) + len(s3) if x != 1 { println("wrong stringlen") panic("fail") } x = len(a0) + len(a2) if x != 20 { println("wrong arraylen") panic("fail") } x = len(b0) + len(b3) if x != 3 { println("wrong slicelen") panic("fail") } x = cap(b0) + cap(b3) if x != 3 { println("wrong slicecap") panic("fail") } } func main() { nocrash() }	1.39 KB	2024-02-02 18:09
📄 indirect1.go // errorcheck // Copyright 2009 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. // Verify that illegal uses of indirection are caught by the compiler. // Does not compile. package main var m0 map[string]int var m1 map[string]int var m2 map[string]int = &m0 var m3 map[string]int = map[string]int{"a": 1} var m4 map[string]int = &m3 var s0 string var s1 string var s2 string = &s0 var s3 string = "a" var s4 string = &s3 var a0 [10]int var a1 [10]int var a2 [10]int = &a0 var b0 []int var b1 []int var b2 []int = &b0 var b3 []int = []int{1, 2, 3} var b4 *[]int = &b3 func f() { // this is spaced funny so that // the compiler will print a different // line number for each len call when // it decides there are type errors. x := len(m0)+ len(m1)+ // ERROR "illegal\|invalid\|must be" len(m2)+ // ERROR "illegal\|invalid\|must be" len(m3)+ len(m4)+ // ERROR "illegal\|invalid\|must be" len(s0)+ len(s1)+ // ERROR "illegal\|invalid\|must be" len(s2)+ // ERROR "illegal\|invalid\|must be" len(s3)+ len(s4)+ // ERROR "illegal\|invalid\|must be" len(a0)+ len(a1)+ len(a2)+ cap(a0)+ cap(a1)+ cap(a2)+ len(b0)+ len(b1)+ // ERROR "illegal\|invalid\|must be" len(b2)+ // ERROR "illegal\|invalid\|must be" len(b3)+ len(b4)+ // ERROR "illegal\|invalid\|must be" cap(b0)+ cap(b1)+ // ERROR "illegal\|invalid\|must be" cap(b2)+ // ERROR "illegal\|invalid\|must be" cap(b3)+ cap(b4) // ERROR "illegal\|invalid\|must be" _ = x }	1.53 KB	2024-02-02 18:09
📄 init.go // errorcheck // 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. // Verify that erroneous use of init is detected. // Does not compile. package main func init() { } func main() { init() // ERROR "undefined.init" runtime.init() // ERROR "undefined.runtime\.init\|reference to undefined name\|undefined: runtime" var _ = init // ERROR "undefined.*init" }	479 B	2024-02-02 18:09
📄 init1.go // run // 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. // Test that goroutines and garbage collection run during init. package main import "runtime" var x []byte func init() { c := make(chan int) go send(c) <-c const N = 1000 const MB = 1 << 20 b := make([]byte, MB) for i := range b { b[i] = byte(i%10 + '0') } s := string(b) memstats := new(runtime.MemStats) runtime.ReadMemStats(memstats) sys, numGC := memstats.Sys, memstats.NumGC // Generate 1,000 MB of garbage, only retaining 1 MB total. for i := 0; i < N; i++ { x = []byte(s) } // Verify that the garbage collector ran by seeing if we // allocated fewer than NMB bytes from the system. runtime.ReadMemStats(memstats) sys1, numGC1 := memstats.Sys, memstats.NumGC if sys1-sys >= NMB \|\| numGC1 == numGC { println("allocated 1000 chunks of", MB, "and used ", sys1-sys, "memory") println("numGC went", numGC, "to", numGC1) panic("init1") } } func send(c chan int) { c <- 1 } func main() { }	1.08 KB	2024-02-02 18:09
📄 initcomma.go // run // Copyright 2009 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 trailing commas. DO NOT gofmt THIS FILE. package main var a = []int{1, 2, } var b = [5]int{1, 2, 3, } var c = []int{1, } var d = [...]int{1, 2, 3, } func main() { if len(a) != 2 { println("len a", len(a)) panic("fail") } if len(b) != 5 { println("len b", len(b)) panic("fail") } if len(c) != 1 { println("len d", len(c)) panic("fail") } if len(d) != 3 { println("len c", len(d)) panic("fail") } if a[0] != 1 { println("a[0]", a[0]) panic("fail") } if a[1] != 2 { println("a[1]", a[1]) panic("fail") } if b[0] != 1 { println("b[0]", b[0]) panic("fail") } if b[1] != 2 { println("b[1]", b[1]) panic("fail") } if b[2] != 3 { println("b[2]", b[2]) panic("fail") } if b[3] != 0 { println("b[3]", b[3]) panic("fail") } if b[4] != 0 { println("b[4]", b[4]) panic("fail") } if c[0] != 1 { println("c[0]", c[0]) panic("fail") } if d[0] != 1 { println("d[0]", d[0]) panic("fail") } if d[1] != 2 { println("d[1]", d[1]) panic("fail") } if d[2] != 3 { println("d[2]", d[2]) panic("fail") } }	1.22 KB	2024-02-02 18:09
📄 initexp.go // errorcheck -t 10 // Copyright 2021 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 p // The init cycle diagnosis used to take exponential time // to traverse the call graph paths. This test case takes // at least two minutes on a modern laptop with the bug // and runs in a fraction of a second without it. // 10 seconds (-t 10 above) should be plenty if the code is working. var x = f() + z() // ERROR "initialization cycle" func f() int { return a1() + a2() + a3() + a4() + a5() + a6() + a7() } func z() int { return x } func a1() int { return b1() + b2() + b3() + b4() + b5() + b6() + b7() } func a2() int { return b1() + b2() + b3() + b4() + b5() + b6() + b7() } func a3() int { return b1() + b2() + b3() + b4() + b5() + b6() + b7() } func a4() int { return b1() + b2() + b3() + b4() + b5() + b6() + b7() } func a5() int { return b1() + b2() + b3() + b4() + b5() + b6() + b7() } func a6() int { return b1() + b2() + b3() + b4() + b5() + b6() + b7() } func a7() int { return b1() + b2() + b3() + b4() + b5() + b6() + b7() } func a8() int { return b1() + b2() + b3() + b4() + b5() + b6() + b7() } func b1() int { return a1() + a2() + a3() + a4() + a5() + a6() + a7() } func b2() int { return a1() + a2() + a3() + a4() + a5() + a6() + a7() } func b3() int { return a1() + a2() + a3() + a4() + a5() + a6() + a7() } func b4() int { return a1() + a2() + a3() + a4() + a5() + a6() + a7() } func b5() int { return a1() + a2() + a3() + a4() + a5() + a6() + a7() } func b6() int { return a1() + a2() + a3() + a4() + a5() + a6() + a7() } func b7() int { return a1() + a2() + a3() + a4() + a5() + a6() + a7() } func b8() int { return a1() + a2() + a3() + a4() + a5() + a6() + a7() }	1.74 KB	2024-02-02 18:09
📄 initialize.go // run // Copyright 2009 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 initialization of package-level variables. package main import ( "fmt" "reflect" ) type S struct { A, B, C, X, Y, Z int } type T struct { S } var a1 = S{0, 0, 0, 1, 2, 3} var b1 = S{X: 1, Z: 3, Y: 2} var a2 = S{0, 0, 0, 0, 0, 0} var b2 = S{} var a3 = T{S{1, 2, 3, 0, 0, 0}} var b3 = T{S: S{A: 1, B: 2, C: 3}} var a4 = &[16]byte{0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0} var b4 = &[16]byte{4: 1, 1, 1, 1, 12: 1, 1} var a5 = &[16]byte{1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0} var b5 = &[16]byte{1, 4: 1, 1, 1, 1, 12: 1, 1} var a6 = &[16]byte{1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0} var b6 = &[...]byte{1, 4: 1, 1, 1, 1, 12: 1, 1, 0, 0} func f7(ch chan int) [2]chan int { return [2]chan int{ch, ch} } var a7 = f7(make(chan int)) func f8(m map[string]string) [2]map[string]string { return [2]map[string]string{m, m} } func m8(m [2]map[string]string) string { m[0]["def"] = "ghi" return m[1]["def"] } var a8 = f8(make(map[string]string)) var a9 = f8(map[string]string{"abc": "def"}) func f10(s S) [2]S { return [2]*S{s, s} } var a10 = f10(new(S)) var a11 = f10(&S{X: 1}) func f12(b []byte) [2][]byte { return [2][]byte{b, b} } var a12 = f12([]byte("hello")) var a13 = f12([]byte{1, 2, 3}) var a14 = f12(make([]byte, 1)) func f15(b []rune) [2][]rune { return [2][]rune{b, b} } var a15 = f15([]rune("hello")) var a16 = f15([]rune{1, 2, 3}) type Same struct { a, b interface{} } var same = []Same{ {a1, b1}, {a2, b2}, {a3, b3}, {a4, b4}, {a5, b5}, {a6, b6}, {a7[0] == a7[1], true}, {m8(a8) == "ghi", true}, {m8(a9) == "ghi", true}, {a10[0] == a10[1], true}, {a11[0] == a11[1], true}, {&a12[0][0] == &a12[1][0], true}, {&a13[0][0] == &a13[1][0], true}, {&a14[0][0] == &a14[1][0], true}, {&a15[0][0] == &a15[1][0], true}, {&a16[0][0] == &a16[1][0], true}, } func main() { ok := true for i, s := range same { if !reflect.DeepEqual(s.a, s.b) { ok = false fmt.Printf("#%d not same: %v and %v\n", i+1, s.a, s.b) } } if !ok { fmt.Println("BUG: test/initialize") } }	2.16 KB	2024-02-02 18:09
📄 initializerr.go // errorcheck // Copyright 2009 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. // Verify that erroneous initialization expressions are caught by the compiler // Does not compile. package main type S struct { A, B, C, X, Y, Z int } type T struct { S } var x = 1 var a1 = S{0, X: 1} // ERROR "mixture\|undefined" "too few values" var a2 = S{Y: 3, Z: 2, Y: 3} // ERROR "duplicate" var a3 = T{S{}, 2, 3, 4, 5, 6} // ERROR "convert\|too many" var a4 = [5]byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10} // ERROR "index\|too many" var a5 = []byte{x: 2} // ERROR "index" var a6 = []byte{1: 1, 2: 2, 1: 3} // ERROR "duplicate" var ok1 = S{} // should be ok var ok2 = T{S: ok1} // should be ok // These keys can be computed at compile time but they are // not constants as defined by the spec, so they do not trigger // compile-time errors about duplicate key values. // See issue 4555. type Key struct{ X, Y int } var _ = map[Key]string{ Key{1, 2}: "hello", Key{1, 2}: "world", }	1.15 KB	2024-02-02 18:09
📄 initloop.go // 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. // Verify that initialization loops are caught // and that the errors print correctly. package main var ( x int = a a int = b // ERROR "a refers to\n.b refers to\n.c refers to\n.*a\|initialization loop" b int = c c int = a )	407 B	2024-02-02 18:09
📄 inline.go // errorcheckwithauto -0 -m -d=inlfuncswithclosures=1 //go:build !goexperiment.newinliner // 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. // Test, using compiler diagnostic flags, that inlining is working. // Compiles but does not run. package foo import ( "errors" "runtime" "unsafe" ) func add2(p byte, n uintptr) byte { // ERROR "can inline add2" "leaking param: p to result" return (byte)(add1(unsafe.Pointer(p), n)) // ERROR "inlining call to add1" } func add1(p unsafe.Pointer, x uintptr) unsafe.Pointer { // ERROR "can inline add1" "leaking param: p to result" return unsafe.Pointer(uintptr(p) + x) } func f(x byte) byte { // ERROR "can inline f" "leaking param: x to result" return add2(x, 1) // ERROR "inlining call to add2" "inlining call to add1" } //go:noinline func g(x int) int { return x + 1 } func h(x int) int { // ERROR "can inline h" return x + 2 } func i(x int) int { // ERROR "can inline i" const y = 2 return x + y } func j(x int) int { // ERROR "can inline j" switch { case x > 0: return x + 2 default: return x + 1 } } func f2() int { // ERROR "can inline f2" tmp1 := h tmp2 := tmp1 return tmp2(0) // ERROR "inlining call to h" } var abc = errors.New("abc") // ERROR "inlining call to errors.New" var somethingWrong error // local closures can be inlined func l(x, y int) (int, int, error) { // ERROR "can inline l" e := func(err error) (int, int, error) { // ERROR "can inline l.func1" "func literal does not escape" "leaking param: err to result" return 0, 0, err } if x == y { e(somethingWrong) // ERROR "inlining call to l.func1" } else { f := e f(nil) // ERROR "inlining call to l.func1" } return y, x, nil } // any re-assignment prevents closure inlining func m() int { foo := func() int { return 1 } // ERROR "can inline m.func1" "func literal does not escape" x := foo() foo = func() int { return 2 } // ERROR "can inline m.func2" "func literal does not escape" return x + foo() } // address taking prevents closure inlining func n() int { foo := func() int { return 1 } // ERROR "can inline n.func1" "func literal does not escape" bar := &foo x := (bar)() + foo() return x } // make sure assignment inside closure is detected func o() int { foo := func() int { return 1 } // ERROR "can inline o.func1" "func literal does not escape" func(x int) { // ERROR "can inline o.func2" if x > 10 { foo = func() int { return 2 } // ERROR "can inline o.func2" } }(11) // ERROR "func literal does not escape" "inlining call to o.func2" return foo() } func p() int { // ERROR "can inline p" return func() int { return 42 }() // ERROR "can inline p.func1" "inlining call to p.func1" } func q(x int) int { // ERROR "can inline q" foo := func() int { return x * 2 } // ERROR "can inline q.func1" "func literal does not escape" return foo() // ERROR "inlining call to q.func1" } func r(z int) int { foo := func(x int) int { // ERROR "can inline r.func1" "func literal does not escape" return x + z } bar := func(x int) int { // ERROR "func literal does not escape" "can inline r.func2" return x + func(y int) int { // ERROR "can inline r.func2.1" "can inline r.r.func2.func3" return 2y + xz }(x) // ERROR "inlining call to r.func2.1" } return foo(42) + bar(42) // ERROR "inlining call to r.func1" "inlining call to r.func2" "inlining call to r.r.func2.func3" } func s0(x int) int { // ERROR "can inline s0" foo := func() { // ERROR "can inline s0.func1" "func literal does not escape" x = x + 1 } foo() // ERROR "inlining call to s0.func1" return x } func s1(x int) int { // ERROR "can inline s1" foo := func() int { // ERROR "can inline s1.func1" "func literal does not escape" return x } x = x + 1 return foo() // ERROR "inlining call to s1.func1" } func switchBreak(x, y int) int { // ERROR "can inline switchBreak" var n int switch x { case 0: n = 1 Done: switch y { case 0: n += 10 break Done } n = 2 } return n } func switchType(x interface{}) int { // ERROR "can inline switchType" "x does not escape" switch x.(type) { case int: return x.(int) default: return 0 } } // Test that switches on constant things, with constant cases, only cost anything for // the case that matches. See issue 50253. func switchConst1(p func(string)) { // ERROR "can inline switchConst" "p does not escape" const c = 1 switch c { case 0: p("zero") case 1: p("one") case 2: p("two") default: p("other") } } func switchConst2() string { // ERROR "can inline switchConst2" switch runtime.GOOS { case "linux": return "Leenooks" case "windows": return "Windoze" case "darwin": return "MackBone" case "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "30", "31", "32", "33", "34", "35", "36", "37", "38", "39", "40", "41", "42", "43", "44", "45", "46", "47", "48", "49", "50", "51", "52", "53", "54", "55", "56", "57", "58", "59", "60", "61", "62", "63", "64", "65", "66", "67", "68", "69", "70", "71", "72", "73", "74", "75", "76", "77", "78", "79", "80", "81", "82", "83", "84", "85", "86", "87", "88", "89", "90", "91", "92", "93", "94", "95", "96", "97", "98", "99", "100": return "Numbers" default: return "oh nose!" } } func switchConst3() string { // ERROR "can inline switchConst3" switch runtime.GOOS { case "Linux": panic("Linux") case "Windows": panic("Windows") case "Darwin": panic("Darwin") case "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "30", "31", "32", "33", "34", "35", "36", "37", "38", "39", "40", "41", "42", "43", "44", "45", "46", "47", "48", "49", "50", "51", "52", "53", "54", "55", "56", "57", "58", "59", "60", "61", "62", "63", "64", "65", "66", "67", "68", "69", "70", "71", "72", "73", "74", "75", "76", "77", "78", "79", "80", "81", "82", "83", "84", "85", "86", "87", "88", "89", "90", "91", "92", "93", "94", "95", "96", "97", "98", "99", "100": panic("Numbers") default: return "oh nose!" } } func switchConst4() { // ERROR "can inline switchConst4" const intSize = 32 << (^uint(0) >> 63) want := func() string { // ERROR "can inline switchConst4.func1" switch intSize { case 32: return "32" case 64: return "64" default: panic("unreachable") } }() // ERROR "inlining call to switchConst4.func1" _ = want } func inlineRangeIntoMe(data []int) { // ERROR "can inline inlineRangeIntoMe" "data does not escape" rangeFunc(data, 12) // ERROR "inlining call to rangeFunc" } func rangeFunc(xs []int, b int) int { // ERROR "can inline rangeFunc" "xs does not escape" for i, x := range xs { if x == b { return i } } return -1 } type T struct{} func (T) meth(int, int) {} // ERROR "can inline T.meth" func k() (T, int, int) { return T{}, 0, 0 } // ERROR "can inline k" func f3() { // ERROR "can inline f3" T.meth(k()) // ERROR "inlining call to k" "inlining call to T.meth" // ERRORAUTO "inlining call to T.meth" } func small1() { // ERROR "can inline small1" runtime.GC() } func small2() int { // ERROR "can inline small2" return runtime.GOMAXPROCS(0) } func small3(t T) { // ERROR "can inline small3" t.meth2(3, 5) } func small4(t T) { // not inlineable - has 2 calls. t.meth2(runtime.GOMAXPROCS(0), 5) } func (T) meth2(int, int) { // not inlineable - has 2 calls. runtime.GC() runtime.GC() } // Issue #29737 - make sure we can do inlining for a chain of recursive functions func ee() { // ERROR "can inline ee" ff(100) // ERROR "inlining call to ff" "inlining call to gg" "inlining call to hh" } func ff(x int) { // ERROR "can inline ff" if x < 0 { return } gg(x - 1) // ERROR "inlining call to gg" "inlining call to hh" } func gg(x int) { // ERROR "can inline gg" hh(x - 1) // ERROR "inlining call to hh" "inlining call to ff" } func hh(x int) { // ERROR "can inline hh" ff(x - 1) // ERROR "inlining call to ff" "inlining call to gg" } // Issue #14768 - make sure we can inline for loops. func for1(fn func() bool) { // ERROR "can inline for1" "fn does not escape" for { if fn() { break } else { continue } } } func for2(fn func() bool) { // ERROR "can inline for2" "fn does not escape" Loop: for { if fn() { break Loop } else { continue Loop } } } // Issue #18493 - make sure we can do inlining of functions with a method value type T1 struct{} func (a T1) meth(val int) int { // ERROR "can inline T1.meth" return val + 5 } func getMeth(t1 T1) func(int) int { // ERROR "can inline getMeth" return t1.meth // ERROR "t1.meth escapes to heap" // ERRORAUTO "inlining call to T1.meth" } func ii() { // ERROR "can inline ii" var t1 T1 f := getMeth(t1) // ERROR "inlining call to getMeth" "t1.meth does not escape" _ = f(3) } // Issue #42194 - make sure that functions evaluated in // go and defer statements can be inlined. func gd1(int) { defer gd1(gd2()) // ERROR "inlining call to gd2" defer gd3()() // ERROR "inlining call to gd3" go gd1(gd2()) // ERROR "inlining call to gd2" go gd3()() // ERROR "inlining call to gd3" } func gd2() int { // ERROR "can inline gd2" return 1 } func gd3() func() { // ERROR "can inline gd3" return ii } // Issue #42788 - ensure ODEREF OCONVNOP* OADDR is low cost. func EncodeQuad(d []uint32, x [6]float32) { // ERROR "can inline EncodeQuad" "d does not escape" _ = d[:6] d[0] = float32bits(x[0]) // ERROR "inlining call to float32bits" d[1] = float32bits(x[1]) // ERROR "inlining call to float32bits" d[2] = float32bits(x[2]) // ERROR "inlining call to float32bits" d[3] = float32bits(x[3]) // ERROR "inlining call to float32bits" d[4] = float32bits(x[4]) // ERROR "inlining call to float32bits" d[5] = float32bits(x[5]) // ERROR "inlining call to float32bits" } // float32bits is a copy of math.Float32bits to ensure that // these tests pass with `-gcflags=-l`. func float32bits(f float32) uint32 { // ERROR "can inline float32bits" return (uint32)(unsafe.Pointer(&f)) } // Ensure OCONVNOP is zero cost. func Conv(v uint64) uint64 { // ERROR "can inline Conv" return conv2(conv2(conv2(v))) // ERROR "inlining call to (conv1\|conv2)" } func conv2(v uint64) uint64 { // ERROR "can inline conv2" return conv1(conv1(conv1(conv1(v)))) // ERROR "inlining call to conv1" } func conv1(v uint64) uint64 { // ERROR "can inline conv1" return uint64(uint64(uint64(uint64(uint64(uint64(uint64(uint64(uint64(uint64(uint64(v))))))))))) } func select1(x, y chan bool) int { // ERROR "can inline select1" "x does not escape" "y does not escape" select { case <-x: return 1 case <-y: return 2 } } func select2(x, y chan bool) { // ERROR "can inline select2" "x does not escape" "y does not escape" loop: // test that labeled select can be inlined. select { case <-x: break loop case <-y: } } func inlineSelect2(x, y chan bool) { // ERROR "can inline inlineSelect2" ERROR "x does not escape" "y does not escape" loop: for i := 0; i < 5; i++ { if i == 3 { break loop } select2(x, y) // ERROR "inlining call to select2" } } // Issue #62211: inlining a function with unreachable "return" // statements could trip up phi insertion. func issue62211(x bool) { // ERROR "can inline issue62211" if issue62211F(x) { // ERROR "inlining call to issue62211F" } if issue62211G(x) { // ERROR "inlining call to issue62211G" } // Initial fix CL caused a "non-monotonic scope positions" failure // on code like this. if z := 0; false { panic(z) } } func issue62211F(x bool) bool { // ERROR "can inline issue62211F" if x \|\| true { return true } return true } func issue62211G(x bool) bool { // ERROR "can inline issue62211G" if x \|\| true { return true } else { return true } }	11.69 KB	2024-02-02 18:09
📄 inline_big.go // errorcheck -0 -m=2 // 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. // Test that we restrict inlining into very large functions. // See issue #26546. package foo func small(a []int) int { // ERROR "can inline small with cost .* as:." "a does not escape" // Cost 16 body (need cost < 20). // See cmd/compile/internal/gc/inl.go:inlineBigFunction return a[0] + a[1] + a[2] + a[3] } func medium(a []int) int { // ERROR "can inline medium with cost .* as:." "a does not escape" // Cost 32 body (need cost > 20 and cost < 80). // See cmd/compile/internal/gc/inl.go:inlineBigFunction return a[0] + a[1] + a[2] + a[3] + a[4] + a[5] + a[6] + a[7] } func f(a []int) int { // ERROR "cannot inline f:." "a does not escape" "function f considered 'big'" // Add lots of nodes to f's body. We need >5000. // See cmd/compile/internal/gc/inl.go:inlineBigFunction a[0] = 0 a[1] = 0 a[2] = 0 a[3] = 0 a[4] = 0 a[5] = 0 a[6] = 0 a[7] = 0 a[8] = 0 a[9] = 0 a[10] = 0 a[11] = 0 a[12] = 0 a[13] = 0 a[14] = 0 a[15] = 0 a[16] = 0 a[17] = 0 a[18] = 0 a[19] = 0 a[20] = 0 a[21] = 0 a[22] = 0 a[23] = 0 a[24] = 0 a[25] = 0 a[26] = 0 a[27] = 0 a[28] = 0 a[29] = 0 a[30] = 0 a[31] = 0 a[32] = 0 a[33] = 0 a[34] = 0 a[35] = 0 a[36] = 0 a[37] = 0 a[38] = 0 a[39] = 0 a[40] = 0 a[41] = 0 a[42] = 0 a[43] = 0 a[44] = 0 a[45] = 0 a[46] = 0 a[47] = 0 a[48] = 0 a[49] = 0 a[50] = 0 a[51] = 0 a[52] = 0 a[53] = 0 a[54] = 0 a[55] = 0 a[56] = 0 a[57] = 0 a[58] = 0 a[59] = 0 a[60] = 0 a[61] = 0 a[62] = 0 a[63] = 0 a[64] = 0 a[65] = 0 a[66] = 0 a[67] = 0 a[68] = 0 a[69] = 0 a[70] = 0 a[71] = 0 a[72] = 0 a[73] = 0 a[74] = 0 a[75] = 0 a[76] = 0 a[77] = 0 a[78] = 0 a[79] = 0 a[80] = 0 a[81] = 0 a[82] = 0 a[83] = 0 a[84] = 0 a[85] = 0 a[86] = 0 a[87] = 0 a[88] = 0 a[89] = 0 a[90] = 0 a[91] = 0 a[92] = 0 a[93] = 0 a[94] = 0 a[95] = 0 a[96] = 0 a[97] = 0 a[98] = 0 a[99] = 0 a[100] = 0 a[101] = 0 a[102] = 0 a[103] = 0 a[104] = 0 a[105] = 0 a[106] = 0 a[107] = 0 a[108] = 0 a[109] = 0 a[110] = 0 a[111] = 0 a[112] = 0 a[113] = 0 a[114] = 0 a[115] = 0 a[116] = 0 a[117] = 0 a[118] = 0 a[119] = 0 a[120] = 0 a[121] = 0 a[122] = 0 a[123] = 0 a[124] = 0 a[125] = 0 a[126] = 0 a[127] = 0 a[128] = 0 a[129] = 0 a[130] = 0 a[131] = 0 a[132] = 0 a[133] = 0 a[134] = 0 a[135] = 0 a[136] = 0 a[137] = 0 a[138] = 0 a[139] = 0 a[140] = 0 a[141] = 0 a[142] = 0 a[143] = 0 a[144] = 0 a[145] = 0 a[146] = 0 a[147] = 0 a[148] = 0 a[149] = 0 a[150] = 0 a[151] = 0 a[152] = 0 a[153] = 0 a[154] = 0 a[155] = 0 a[156] = 0 a[157] = 0 a[158] = 0 a[159] = 0 a[160] = 0 a[161] = 0 a[162] = 0 a[163] = 0 a[164] = 0 a[165] = 0 a[166] = 0 a[167] = 0 a[168] = 0 a[169] = 0 a[170] = 0 a[171] = 0 a[172] = 0 a[173] = 0 a[174] = 0 a[175] = 0 a[176] = 0 a[177] = 0 a[178] = 0 a[179] = 0 a[180] = 0 a[181] = 0 a[182] = 0 a[183] = 0 a[184] = 0 a[185] = 0 a[186] = 0 a[187] = 0 a[188] = 0 a[189] = 0 a[190] = 0 a[191] = 0 a[192] = 0 a[193] = 0 a[194] = 0 a[195] = 0 a[196] = 0 a[197] = 0 a[198] = 0 a[199] = 0 a[200] = 0 a[201] = 0 a[202] = 0 a[203] = 0 a[204] = 0 a[205] = 0 a[206] = 0 a[207] = 0 a[208] = 0 a[209] = 0 a[210] = 0 a[211] = 0 a[212] = 0 a[213] = 0 a[214] = 0 a[215] = 0 a[216] = 0 a[217] = 0 a[218] = 0 a[219] = 0 a[220] = 0 a[221] = 0 a[222] = 0 a[223] = 0 a[224] = 0 a[225] = 0 a[226] = 0 a[227] = 0 a[228] = 0 a[229] = 0 a[230] = 0 a[231] = 0 a[232] = 0 a[233] = 0 a[234] = 0 a[235] = 0 a[236] = 0 a[237] = 0 a[238] = 0 a[239] = 0 a[240] = 0 a[241] = 0 a[242] = 0 a[243] = 0 a[244] = 0 a[245] = 0 a[246] = 0 a[247] = 0 a[248] = 0 a[249] = 0 a[250] = 0 a[251] = 0 a[252] = 0 a[253] = 0 a[254] = 0 a[255] = 0 a[256] = 0 a[257] = 0 a[258] = 0 a[259] = 0 a[260] = 0 a[261] = 0 a[262] = 0 a[263] = 0 a[264] = 0 a[265] = 0 a[266] = 0 a[267] = 0 a[268] = 0 a[269] = 0 a[270] = 0 a[271] = 0 a[272] = 0 a[273] = 0 a[274] = 0 a[275] = 0 a[276] = 0 a[277] = 0 a[278] = 0 a[279] = 0 a[280] = 0 a[281] = 0 a[282] = 0 a[283] = 0 a[284] = 0 a[285] = 0 a[286] = 0 a[287] = 0 a[288] = 0 a[289] = 0 a[290] = 0 a[291] = 0 a[292] = 0 a[293] = 0 a[294] = 0 a[295] = 0 a[296] = 0 a[297] = 0 a[298] = 0 a[299] = 0 a[300] = 0 a[301] = 0 a[302] = 0 a[303] = 0 a[304] = 0 a[305] = 0 a[306] = 0 a[307] = 0 a[308] = 0 a[309] = 0 a[310] = 0 a[311] = 0 a[312] = 0 a[313] = 0 a[314] = 0 a[315] = 0 a[316] = 0 a[317] = 0 a[318] = 0 a[319] = 0 a[320] = 0 a[321] = 0 a[322] = 0 a[323] = 0 a[324] = 0 a[325] = 0 a[326] = 0 a[327] = 0 a[328] = 0 a[329] = 0 a[330] = 0 a[331] = 0 a[332] = 0 a[333] = 0 a[334] = 0 a[335] = 0 a[336] = 0 a[337] = 0 a[338] = 0 a[339] = 0 a[340] = 0 a[341] = 0 a[342] = 0 a[343] = 0 a[344] = 0 a[345] = 0 a[346] = 0 a[347] = 0 a[348] = 0 a[349] = 0 a[350] = 0 a[351] = 0 a[352] = 0 a[353] = 0 a[354] = 0 a[355] = 0 a[356] = 0 a[357] = 0 a[358] = 0 a[359] = 0 a[360] = 0 a[361] = 0 a[362] = 0 a[363] = 0 a[364] = 0 a[365] = 0 a[366] = 0 a[367] = 0 a[368] = 0 a[369] = 0 a[370] = 0 a[371] = 0 a[372] = 0 a[373] = 0 a[374] = 0 a[375] = 0 a[376] = 0 a[377] = 0 a[378] = 0 a[379] = 0 a[380] = 0 a[381] = 0 a[382] = 0 a[383] = 0 a[384] = 0 a[385] = 0 a[386] = 0 a[387] = 0 a[388] = 0 a[389] = 0 a[390] = 0 a[391] = 0 a[392] = 0 a[393] = 0 a[394] = 0 a[395] = 0 a[396] = 0 a[397] = 0 a[398] = 0 a[399] = 0 a[400] = 0 a[401] = 0 a[402] = 0 a[403] = 0 a[404] = 0 a[405] = 0 a[406] = 0 a[407] = 0 a[408] = 0 a[409] = 0 a[410] = 0 a[411] = 0 a[412] = 0 a[413] = 0 a[414] = 0 a[415] = 0 a[416] = 0 a[417] = 0 a[418] = 0 a[419] = 0 a[420] = 0 a[421] = 0 a[422] = 0 a[423] = 0 a[424] = 0 a[425] = 0 a[426] = 0 a[427] = 0 a[428] = 0 a[429] = 0 a[430] = 0 a[431] = 0 a[432] = 0 a[433] = 0 a[434] = 0 a[435] = 0 a[436] = 0 a[437] = 0 a[438] = 0 a[439] = 0 a[440] = 0 a[441] = 0 a[442] = 0 a[443] = 0 a[444] = 0 a[445] = 0 a[446] = 0 a[447] = 0 a[448] = 0 a[449] = 0 a[450] = 0 a[451] = 0 a[452] = 0 a[453] = 0 a[454] = 0 a[455] = 0 a[456] = 0 a[457] = 0 a[458] = 0 a[459] = 0 a[460] = 0 a[461] = 0 a[462] = 0 a[463] = 0 a[464] = 0 a[465] = 0 a[466] = 0 a[467] = 0 a[468] = 0 a[469] = 0 a[470] = 0 a[471] = 0 a[472] = 0 a[473] = 0 a[474] = 0 a[475] = 0 a[476] = 0 a[477] = 0 a[478] = 0 a[479] = 0 a[480] = 0 a[481] = 0 a[482] = 0 a[483] = 0 a[484] = 0 a[485] = 0 a[486] = 0 a[487] = 0 a[488] = 0 a[489] = 0 a[490] = 0 a[491] = 0 a[492] = 0 a[493] = 0 a[494] = 0 a[495] = 0 a[496] = 0 a[497] = 0 a[498] = 0 a[499] = 0 a[500] = 0 a[501] = 0 a[502] = 0 a[503] = 0 a[504] = 0 a[505] = 0 a[506] = 0 a[507] = 0 a[508] = 0 a[509] = 0 a[510] = 0 a[511] = 0 a[512] = 0 a[513] = 0 a[514] = 0 a[515] = 0 a[516] = 0 a[517] = 0 a[518] = 0 a[519] = 0 a[520] = 0 a[521] = 0 a[522] = 0 a[523] = 0 a[524] = 0 a[525] = 0 a[526] = 0 a[527] = 0 a[528] = 0 a[529] = 0 a[530] = 0 a[531] = 0 a[532] = 0 a[533] = 0 a[534] = 0 a[535] = 0 a[536] = 0 a[537] = 0 a[538] = 0 a[539] = 0 a[540] = 0 a[541] = 0 a[542] = 0 a[543] = 0 a[544] = 0 a[545] = 0 a[546] = 0 a[547] = 0 a[548] = 0 a[549] = 0 a[550] = 0 a[551] = 0 a[552] = 0 a[553] = 0 a[554] = 0 a[555] = 0 a[556] = 0 a[557] = 0 a[558] = 0 a[559] = 0 a[560] = 0 a[561] = 0 a[562] = 0 a[563] = 0 a[564] = 0 a[565] = 0 a[566] = 0 a[567] = 0 a[568] = 0 a[569] = 0 a[570] = 0 a[571] = 0 a[572] = 0 a[573] = 0 a[574] = 0 a[575] = 0 a[576] = 0 a[577] = 0 a[578] = 0 a[579] = 0 a[580] = 0 a[581] = 0 a[582] = 0 a[583] = 0 a[584] = 0 a[585] = 0 a[586] = 0 a[587] = 0 a[588] = 0 a[589] = 0 a[590] = 0 a[591] = 0 a[592] = 0 a[593] = 0 a[594] = 0 a[595] = 0 a[596] = 0 a[597] = 0 a[598] = 0 a[599] = 0 a[600] = 0 a[601] = 0 a[602] = 0 a[603] = 0 a[604] = 0 a[605] = 0 a[606] = 0 a[607] = 0 a[608] = 0 a[609] = 0 a[610] = 0 a[611] = 0 a[612] = 0 a[613] = 0 a[614] = 0 a[615] = 0 a[616] = 0 a[617] = 0 a[618] = 0 a[619] = 0 a[620] = 0 a[621] = 0 a[622] = 0 a[623] = 0 a[624] = 0 a[625] = 0 a[626] = 0 a[627] = 0 a[628] = 0 a[629] = 0 a[630] = 0 a[631] = 0 a[632] = 0 a[633] = 0 a[634] = 0 a[635] = 0 a[636] = 0 a[637] = 0 a[638] = 0 a[639] = 0 a[640] = 0 a[641] = 0 a[642] = 0 a[643] = 0 a[644] = 0 a[645] = 0 a[646] = 0 a[647] = 0 a[648] = 0 a[649] = 0 a[650] = 0 a[651] = 0 a[652] = 0 a[653] = 0 a[654] = 0 a[655] = 0 a[656] = 0 a[657] = 0 a[658] = 0 a[659] = 0 a[660] = 0 a[661] = 0 a[662] = 0 a[663] = 0 a[664] = 0 a[665] = 0 a[666] = 0 a[667] = 0 a[668] = 0 a[669] = 0 a[670] = 0 a[671] = 0 a[672] = 0 a[673] = 0 a[674] = 0 a[675] = 0 a[676] = 0 a[677] = 0 a[678] = 0 a[679] = 0 a[680] = 0 a[681] = 0 a[682] = 0 a[683] = 0 a[684] = 0 a[685] = 0 a[686] = 0 a[687] = 0 a[688] = 0 a[689] = 0 a[690] = 0 a[691] = 0 a[692] = 0 a[693] = 0 a[694] = 0 a[695] = 0 a[696] = 0 a[697] = 0 a[698] = 0 a[699] = 0 a[700] = 0 a[701] = 0 a[702] = 0 a[703] = 0 a[704] = 0 a[705] = 0 a[706] = 0 a[707] = 0 a[708] = 0 a[709] = 0 a[710] = 0 a[711] = 0 a[712] = 0 a[713] = 0 a[714] = 0 a[715] = 0 a[716] = 0 a[717] = 0 a[718] = 0 a[719] = 0 a[720] = 0 a[721] = 0 a[722] = 0 a[723] = 0 a[724] = 0 a[725] = 0 a[726] = 0 a[727] = 0 a[728] = 0 a[729] = 0 a[730] = 0 a[731] = 0 a[732] = 0 a[733] = 0 a[734] = 0 a[735] = 0 a[736] = 0 a[737] = 0 a[738] = 0 a[739] = 0 a[740] = 0 a[741] = 0 a[742] = 0 a[743] = 0 a[744] = 0 a[745] = 0 a[746] = 0 a[747] = 0 a[748] = 0 a[749] = 0 a[750] = 0 a[751] = 0 a[752] = 0 a[753] = 0 a[754] = 0 a[755] = 0 a[756] = 0 a[757] = 0 a[758] = 0 a[759] = 0 a[760] = 0 a[761] = 0 a[762] = 0 a[763] = 0 a[764] = 0 a[765] = 0 a[766] = 0 a[767] = 0 a[768] = 0 a[769] = 0 a[770] = 0 a[771] = 0 a[772] = 0 a[773] = 0 a[774] = 0 a[775] = 0 a[776] = 0 a[777] = 0 a[778] = 0 a[779] = 0 a[780] = 0 a[781] = 0 a[782] = 0 a[783] = 0 a[784] = 0 a[785] = 0 a[786] = 0 a[787] = 0 a[788] = 0 a[789] = 0 a[790] = 0 a[791] = 0 a[792] = 0 a[793] = 0 a[794] = 0 a[795] = 0 a[796] = 0 a[797] = 0 a[798] = 0 a[799] = 0 a[800] = 0 a[801] = 0 a[802] = 0 a[803] = 0 a[804] = 0 a[805] = 0 a[806] = 0 a[807] = 0 a[808] = 0 a[809] = 0 a[810] = 0 a[811] = 0 a[812] = 0 a[813] = 0 a[814] = 0 a[815] = 0 a[816] = 0 a[817] = 0 a[818] = 0 a[819] = 0 a[820] = 0 a[821] = 0 a[822] = 0 a[823] = 0 a[824] = 0 a[825] = 0 a[826] = 0 a[827] = 0 a[828] = 0 a[829] = 0 a[830] = 0 a[831] = 0 a[832] = 0 a[833] = 0 a[834] = 0 a[835] = 0 a[836] = 0 a[837] = 0 a[838] = 0 a[839] = 0 a[840] = 0 a[841] = 0 a[842] = 0 a[843] = 0 a[844] = 0 a[845] = 0 a[846] = 0 a[847] = 0 a[848] = 0 a[849] = 0 a[850] = 0 a[851] = 0 a[852] = 0 a[853] = 0 a[854] = 0 a[855] = 0 a[856] = 0 a[857] = 0 a[858] = 0 a[859] = 0 a[860] = 0 a[861] = 0 a[862] = 0 a[863] = 0 a[864] = 0 a[865] = 0 a[866] = 0 a[867] = 0 a[868] = 0 a[869] = 0 a[870] = 0 a[871] = 0 a[872] = 0 a[873] = 0 a[874] = 0 a[875] = 0 a[876] = 0 a[877] = 0 a[878] = 0 a[879] = 0 a[880] = 0 a[881] = 0 a[882] = 0 a[883] = 0 a[884] = 0 a[885] = 0 a[886] = 0 a[887] = 0 a[888] = 0 a[889] = 0 a[890] = 0 a[891] = 0 a[892] = 0 a[893] = 0 a[894] = 0 a[895] = 0 a[896] = 0 a[897] = 0 a[898] = 0 a[899] = 0 a[900] = 0 a[901] = 0 a[902] = 0 a[903] = 0 a[904] = 0 a[905] = 0 a[906] = 0 a[907] = 0 a[908] = 0 a[909] = 0 a[910] = 0 a[911] = 0 a[912] = 0 a[913] = 0 a[914] = 0 a[915] = 0 a[916] = 0 a[917] = 0 a[918] = 0 a[919] = 0 a[920] = 0 a[921] = 0 a[922] = 0 a[923] = 0 a[924] = 0 a[925] = 0 a[926] = 0 a[927] = 0 a[928] = 0 a[929] = 0 a[930] = 0 a[931] = 0 a[932] = 0 a[933] = 0 a[934] = 0 a[935] = 0 a[936] = 0 a[937] = 0 a[938] = 0 a[939] = 0 a[940] = 0 a[941] = 0 a[942] = 0 a[943] = 0 a[944] = 0 a[945] = 0 a[946] = 0 a[947] = 0 a[948] = 0 a[949] = 0 a[950] = 0 a[951] = 0 a[952] = 0 a[953] = 0 a[954] = 0 a[955] = 0 a[956] = 0 a[957] = 0 a[958] = 0 a[959] = 0 a[960] = 0 a[961] = 0 a[962] = 0 a[963] = 0 a[964] = 0 a[965] = 0 a[966] = 0 a[967] = 0 a[968] = 0 a[969] = 0 a[970] = 0 a[971] = 0 a[972] = 0 a[973] = 0 a[974] = 0 a[975] = 0 a[976] = 0 a[977] = 0 a[978] = 0 a[979] = 0 a[980] = 0 a[981] = 0 a[982] = 0 a[983] = 0 a[984] = 0 a[985] = 0 a[986] = 0 a[987] = 0 a[988] = 0 a[989] = 0 a[990] = 0 a[991] = 0 a[992] = 0 a[993] = 0 a[994] = 0 a[995] = 0 a[996] = 0 a[997] = 0 a[998] = 0 a[999] = 0 x := small(a) // ERROR "inlining call to small" y := medium(a) // The crux of this test: medium is not inlined. return x + y }	12.69 KB	2024-02-02 18:09
📄 inline_caller.go // run -gcflags -l=4 // 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. package main import ( "fmt" "runtime" ) type frame struct { pc uintptr file string line int ok bool } var ( skip int globalFrame frame ) func f() { g() // line 27 } func g() { h() // line 31 } func h() { x := &globalFrame x.pc, x.file, x.line, x.ok = runtime.Caller(skip) // line 36 } //go:noinline func testCaller(skp int) frame { skip = skp f() // line 42 frame := globalFrame if !frame.ok { panic(fmt.Sprintf("skip=%d runtime.Caller failed", skp)) } return frame } type wantFrame struct { funcName string line int } // -1 means don't care var expected = []wantFrame{ 0: {"main.h", 36}, 1: {"main.g", 31}, 2: {"main.f", 27}, 3: {"main.testCaller", 42}, 4: {"main.main", 68}, 5: {"runtime.main", -1}, 6: {"runtime.goexit", -1}, } func main() { for i := 0; i <= 6; i++ { frame := testCaller(i) // line 68 fn := runtime.FuncForPC(frame.pc) if expected[i].line >= 0 && frame.line != expected[i].line { panic(fmt.Sprintf("skip=%d expected line %d, got line %d", i, expected[i].line, frame.line)) } if fn.Name() != expected[i].funcName { panic(fmt.Sprintf("skip=%d expected function %s, got %s", i, expected[i].funcName, fn.Name())) } } }	1.36 KB	2024-02-02 18:09
📄 inline_callers.go // run -gcflags=-l=4 // 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. package main import ( "fmt" "runtime" ) var skip int var npcs int var pcs = make([]uintptr, 32) func f() { g() } func g() { h() } func h() { npcs = runtime.Callers(skip, pcs) } func testCallers(skp int) (frames []string) { skip = skp f() for i := 0; i < npcs; i++ { fn := runtime.FuncForPC(pcs[i] - 1) frames = append(frames, fn.Name()) if fn.Name() == "main.main" { break } } return } func testCallersFrames(skp int) (frames []string) { skip = skp f() callers := pcs[:npcs] ci := runtime.CallersFrames(callers) for { frame, more := ci.Next() frames = append(frames, frame.Function) if !more \|\| frame.Function == "main.main" { break } } return } var expectedFrames [][]string = [][]string{ 0: {"runtime.Callers", "main.h", "main.g", "main.f", "main.testCallers", "main.main"}, 1: {"main.h", "main.g", "main.f", "main.testCallers", "main.main"}, 2: {"main.g", "main.f", "main.testCallers", "main.main"}, 3: {"main.f", "main.testCallers", "main.main"}, 4: {"main.testCallers", "main.main"}, 5: {"main.main"}, } var allFrames = []string{"runtime.Callers", "main.h", "main.g", "main.f", "main.testCallersFrames", "main.main"} func same(xs, ys []string) bool { if len(xs) != len(ys) { return false } for i := range xs { if xs[i] != ys[i] { return false } } return true } func main() { for i := 0; i <= 5; i++ { frames := testCallers(i) expected := expectedFrames[i] if !same(frames, expected) { fmt.Printf("testCallers(%d):\n got %v\n want %v\n", i, frames, expected) } frames = testCallersFrames(i) expected = allFrames[i:] if !same(frames, expected) { fmt.Printf("testCallersFrames(%d):\n got %v\n want %v\n", i, frames, expected) } } }	1.87 KB	2024-02-02 18:09
📄 inline_endian.go // errorcheckwithauto -0 -m -d=inlfuncswithclosures=1 //go:build (386 \|\| amd64 \|\| arm64 \|\| ppc64le \|\| s390x) && !gcflags_noopt // Copyright 2021 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. // Similar to inline.go, but only for architectures that can merge loads. package foo import ( "encoding/binary" ) // Ensure that simple encoding/binary functions are cheap enough // that functions using them can also be inlined (issue 42958). func endian(b []byte) uint64 { // ERROR "can inline endian" "b does not escape" return binary.LittleEndian.Uint64(b) + binary.BigEndian.Uint64(b) // ERROR "inlining call to binary.littleEndian.Uint64" "inlining call to binary.bigEndian.Uint64" } func appendLittleEndian(b []byte) []byte { // ERROR "can inline appendLittleEndian" "leaking param: b to result ~r0 level=0" b = binary.LittleEndian.AppendUint64(b, 64) // ERROR "inlining call to binary.littleEndian.AppendUint64" b = binary.LittleEndian.AppendUint32(b, 32) // ERROR "inlining call to binary.littleEndian.AppendUint32" b = binary.LittleEndian.AppendUint16(b, 16) // ERROR "inlining call to binary.littleEndian.AppendUint16" return b } func appendBigEndian(b []byte) []byte { // ERROR "can inline appendBigEndian" "leaking param: b to result ~r0 level=0" b = binary.BigEndian.AppendUint64(b, 64) // ERROR "inlining call to binary.bigEndian.AppendUint64" b = binary.BigEndian.AppendUint32(b, 32) // ERROR "inlining call to binary.bigEndian.AppendUint32" b = binary.BigEndian.AppendUint16(b, 16) // ERROR "inlining call to binary.bigEndian.AppendUint16" return b }	1.63 KB	2024-02-02 18:09
📄 inline_literal.go // 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. package main import ( "log" "reflect" "runtime" ) func hello() string { return "Hello World" // line 16 } func foo() string { // line 19 x := hello() // line 20 y := hello() // line 21 return x + y // line 22 } func bar() string { x := hello() // line 26 return x } // funcPC returns the PC for the func value f. func funcPC(f interface{}) uintptr { return reflect.ValueOf(f).Pointer() } // Test for issue #15453. Previously, line 26 would appear in foo(). func main() { pc := funcPC(foo) f := runtime.FuncForPC(pc) for ; runtime.FuncForPC(pc) == f; pc++ { file, line := f.FileLine(pc) if line == 0 { continue } // Line 16 can appear inside foo() because PC-line table has // innermost line numbers after inlining. if line != 16 && !(line >= 19 && line <= 22) { log.Fatalf("unexpected line at PC=%d: %s:%d\n", pc, file, line) } } }	1.02 KB	2024-02-02 18:09
📄 inline_math_bits_rotate.go // errorcheck -0 -m //go:build amd64 // 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. // Test that inlining of math/bits.RotateLeft* treats those calls as intrinsics. package p import "math/bits" var ( x8 uint8 x16 uint16 x32 uint32 x64 uint64 x uint ) func f() { // ERROR "can inline f" x8 = bits.RotateLeft8(x8, 1) x16 = bits.RotateLeft16(x16, 1) x32 = bits.RotateLeft32(x32, 1) x64 = bits.RotateLeft64(x64, 1) x = bits.RotateLeft(x, 1) }	571 B	2024-02-02 18:09
📄 inline_sync.go // errorcheck -0 -m //go:build !nacl && !386 && !wasm && !arm && !gcflags_noopt // 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. // Test, using compiler diagnostic flags, that inlining of functions // imported from the sync package is working. // Compiles but does not run. // FIXME: This test is disabled on architectures where atomic operations // are function calls rather than intrinsics, since this prevents inlining // of the sync fast paths. This test should be re-enabled once the problem // is solved. package foo import ( "sync" ) var mutex sync.Mutex func small5() { // ERROR "can inline small5" // the Unlock fast path should be inlined mutex.Unlock() // ERROR "inlining call to sync\.$\Mutex$\.Unlock" } func small6() { // ERROR "can inline small6" // the Lock fast path should be inlined mutex.Lock() // ERROR "inlining call to sync\.$\Mutex$\.Lock" } var once sync.Once func small7() { // ERROR "can inline small7" // the Do fast path should be inlined once.Do(small5) // ERROR "inlining call to sync\.$\Once$\.Do" "inlining call to atomic\.$\Uint32$\.Load" } var rwmutex sync.RWMutex func small8() { // ERROR "can inline small8" // the RUnlock fast path should be inlined rwmutex.RUnlock() // ERROR "inlining call to sync\.$\RWMutex$\.RUnlock" "inlining call to atomic\.$\Int32$\.Add" } func small9() { // ERROR "can inline small9" // the RLock fast path should be inlined rwmutex.RLock() // ERROR "inlining call to sync\.$\RWMutex$\.RLock" "inlining call to atomic\.$\*Int32$\.Add" }	1.62 KB	2024-02-02 18:09
📄 inline_variadic.go // errorcheck -0 -m // 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. // Test inlining of variadic functions. // See issue #18116. package foo func head(xs ...string) string { // ERROR "can inline head" "leaking param: xs to result" return xs[0] } func f() string { // ERROR "can inline f" x := head("hello", "world") // ERROR "inlining call to head" "\.\.\. argument does not escape" return x }	513 B	2024-02-02 18:09
📄 int_lit.go // run // Copyright 2009 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 integer literal syntax. package main import "os" func main() { s := 0 + 123 + 0123 + 0000 + 0x0 + 0x123 + 0X0 + 0X123 if s != 788 { print("s is ", s, "; should be 788\n") os.Exit(1) } }	387 B	2024-02-02 18:09
📄 intcvt.go // run // Copyright 2009 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 implicit and explicit conversions of constants. package main const ( ci8 = -1 << 7 ci16 = -1<<15 + 100 ci32 = -1<<31 + 100000 ci64 = -1<<63 + 10000000001 cu8 = 1<<8 - 1 cu16 = 1<<16 - 1234 cu32 = 1<<32 - 1234567 cu64 = 1<<64 - 1234567890123 cf32 = 1e8 + 0.5 cf64 = -1e8 + 0.5 ) var ( i8 int8 = ci8 i16 int16 = ci16 i32 int32 = ci32 i64 int64 = ci64 u8 uint8 = cu8 u16 uint16 = cu16 u32 uint32 = cu32 u64 uint64 = cu64 // f32 float32 = 1e8 + 0.5 // f64 float64 = -1e8 + 0.5 ) func chki8(i, v int8) { if i != v { println(i, "!=", v) panic("fail") } } func chki16(i, v int16) { if i != v { println(i, "!=", v) panic("fail") } } func chki32(i, v int32) { if i != v { println(i, "!=", v) panic("fail") } } func chki64(i, v int64) { if i != v { println(i, "!=", v) panic("fail") } } func chku8(i, v uint8) { if i != v { println(i, "!=", v) panic("fail") } } func chku16(i, v uint16) { if i != v { println(i, "!=", v) panic("fail") } } func chku32(i, v uint32) { if i != v { println(i, "!=", v) panic("fail") } } func chku64(i, v uint64) { if i != v { println(i, "!=", v) panic("fail") } } //func chkf32(f, v float32) { if f != v { println(f, "!=", v); panic("fail") } } //func chkf64(f, v float64) { if f != v { println(f, "!=", v); panic("fail") } } func main() { chki8(int8(i8), ci8&0xff-1<<8) chki8(int8(i16), ci16&0xff) chki8(int8(i32), ci32&0xff-1<<8) chki8(int8(i64), ci64&0xff) chki8(int8(u8), cu8&0xff-1<<8) chki8(int8(u16), cu16&0xff) chki8(int8(u32), cu32&0xff) chki8(int8(u64), cu64&0xff) // chki8(int8(f32), 0) // chki8(int8(f64), 0) chki16(int16(i8), ci8&0xffff-1<<16) chki16(int16(i16), ci16&0xffff-1<<16) chki16(int16(i32), ci32&0xffff-1<<16) chki16(int16(i64), ci64&0xffff-1<<16) chki16(int16(u8), cu8&0xffff) chki16(int16(u16), cu16&0xffff-1<<16) chki16(int16(u32), cu32&0xffff) chki16(int16(u64), cu64&0xffff-1<<16) // chki16(int16(f32), 0) // chki16(int16(f64), 0) chki32(int32(i8), ci8&0xffffffff-1<<32) chki32(int32(i16), ci16&0xffffffff-1<<32) chki32(int32(i32), ci32&0xffffffff-1<<32) chki32(int32(i64), ci64&0xffffffff) chki32(int32(u8), cu8&0xffffffff) chki32(int32(u16), cu16&0xffffffff) chki32(int32(u32), cu32&0xffffffff-1<<32) chki32(int32(u64), cu64&0xffffffff-1<<32) // chki32(int32(f32), 0) // chki32(int32(f64), 0) chki64(int64(i8), ci8&0xffffffffffffffff-1<<64) chki64(int64(i16), ci16&0xffffffffffffffff-1<<64) chki64(int64(i32), ci32&0xffffffffffffffff-1<<64) chki64(int64(i64), ci64&0xffffffffffffffff-1<<64) chki64(int64(u8), cu8&0xffffffffffffffff) chki64(int64(u16), cu16&0xffffffffffffffff) chki64(int64(u32), cu32&0xffffffffffffffff) chki64(int64(u64), cu64&0xffffffffffffffff-1<<64) // chki64(int64(f32), 0) // chki64(int64(f64), 0) chku8(uint8(i8), ci8&0xff) chku8(uint8(i16), ci16&0xff) chku8(uint8(i32), ci32&0xff) chku8(uint8(i64), ci64&0xff) chku8(uint8(u8), cu8&0xff) chku8(uint8(u16), cu16&0xff) chku8(uint8(u32), cu32&0xff) chku8(uint8(u64), cu64&0xff) // chku8(uint8(f32), 0) // chku8(uint8(f64), 0) chku16(uint16(i8), ci8&0xffff) chku16(uint16(i16), ci16&0xffff) chku16(uint16(i32), ci32&0xffff) chku16(uint16(i64), ci64&0xffff) chku16(uint16(u8), cu8&0xffff) chku16(uint16(u16), cu16&0xffff) chku16(uint16(u32), cu32&0xffff) chku16(uint16(u64), cu64&0xffff) // chku16(uint16(f32), 0) // chku16(uint16(f64), 0) chku32(uint32(i8), ci8&0xffffffff) chku32(uint32(i16), ci16&0xffffffff) chku32(uint32(i32), ci32&0xffffffff) chku32(uint32(i64), ci64&0xffffffff) chku32(uint32(u8), cu8&0xffffffff) chku32(uint32(u16), cu16&0xffffffff) chku32(uint32(u32), cu32&0xffffffff) chku32(uint32(u64), cu64&0xffffffff) // chku32(uint32(f32), 0) // chku32(uint32(f64), 0) chku64(uint64(i8), ci8&0xffffffffffffffff) chku64(uint64(i16), ci16&0xffffffffffffffff) chku64(uint64(i32), ci32&0xffffffffffffffff) chku64(uint64(i64), ci64&0xffffffffffffffff) chku64(uint64(u8), cu8&0xffffffffffffffff) chku64(uint64(u16), cu16&0xffffffffffffffff) chku64(uint64(u32), cu32&0xffffffffffffffff) chku64(uint64(u64), cu64&0xffffffffffffffff) // chku64(uint64(f32), 0) // chku64(uint64(f64), 0) }	4.26 KB	2024-02-02 18:09
📁 interface	-	2024-02-02 18:09
📁 intrinsic.dir	-	2024-02-02 18:09
📄 intrinsic.go // errorcheckandrundir -0 -d=ssa/intrinsics/debug //go:build amd64 \|\| arm64 \|\| arm \|\| s390x // 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. package ignored	270 B	2024-02-02 18:09
📄 intrinsic_atomic.go // errorcheck -0 -d=ssa/intrinsics/debug //go:build amd64 \|\| arm64 \|\| loong64 \|\| mips \|\| mipsle \|\| mips64 \|\| mips64le \|\| ppc64 \|\| ppc64le \|\| riscv64 \|\| s390x // 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. package main import "sync/atomic" var x uint32 func atomics() { _ = atomic.LoadUint32(&x) // ERROR "intrinsic substitution for LoadUint32" atomic.StoreUint32(&x, 1) // ERROR "intrinsic substitution for StoreUint32" atomic.AddUint32(&x, 1) // ERROR "intrinsic substitution for AddUint32" atomic.SwapUint32(&x, 1) // ERROR "intrinsic substitution for SwapUint32" atomic.CompareAndSwapUint32(&x, 1, 2) // ERROR "intrinsic substitution for CompareAndSwapUint32" }	839 B	2024-02-02 18:09
📄 iota.go // run // Copyright 2009 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 iota. package main func assert(cond bool, msg string) { if !cond { print("assertion fail: ", msg, "\n") panic(1) } } const ( x int = iota y = iota z = 1 << iota f float32 = 2 * iota g float32 = 4.5 * float32(iota) ) const ( X = 0 Y Z ) const ( A = 1 << iota B C D E = iota * iota F G ) const ( a = 1 b = iota << a c = iota << b d ) const ( i = (a << iota) + (b * iota) j k l ) const ( m = iota == 0 n ) const ( p = float32(iota) q r ) const ( s = string(iota + 'a') t ) const ( abit, amask = 1 << iota, 1<<iota - 1 bbit, bmask = 1 << iota, 1<<iota - 1 cbit, cmask = 1 << iota, 1<<iota - 1 ) func main() { assert(x == 0, "x") assert(y == 1, "y") assert(z == 4, "z") assert(f == 6.0, "f") assert(g == 18.0, "g") assert(X == 0, "X") assert(Y == 0, "Y") assert(Z == 0, "Z") assert(A == 1, "A") assert(B == 2, "B") assert(C == 4, "C") assert(D == 8, "D") assert(E == 16, "E") assert(F == 25, "F") assert(a == 1, "a") assert(b == 2, "b") assert(c == 8, "c") assert(d == 12, "d") assert(i == 1, "i") assert(j == 4, "j") assert(k == 8, "k") assert(l == 14, "l") assert(m, "m") assert(!n, "n") assert(p == 0.0, "p") assert(q == 1.0, "q") assert(r == 2.0, "r") assert(s == "a", "s") assert(t == "b", "t") assert(abit == 1, "abit") assert(amask == 0, "amask") assert(bbit == 2, "bbit") assert(bmask == 1, "bmask") assert(cbit == 4, "cbit") assert(cmask == 3, "cmask") }	1.59 KB	2024-02-02 18:09
📁 ken	-	2024-02-02 18:09
📄 label.go // errorcheck // 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. // Verify that erroneous labels are caught by the compiler. // This set is caught by pass 1. // Does not compile. package main var x int func f() { L1: // ERROR "label .L1. defined and not used" for { } L2: // ERROR "label .L2. defined and not used" select {} L3: // ERROR "label .L3. defined and not used" switch { } L4: // ERROR "label .L4. defined and not used" if true { } L5: // ERROR "label .L5. defined and not used" f() L6: // GCCGO_ERROR "previous" f() L6: // ERROR "label .L6. already defined" f() if x == 20 { goto L6 } L7: for { break L7 } L8: for { if x == 21 { continue L8 } } L9: switch { case true: break L9 defalt: // ERROR "label .defalt. defined and not used" } L10: select { default: break L10 } goto L10 goto go2 // ERROR "label go2 not defined\|reference to undefined label .*go2" }	1.02 KB	2024-02-02 18:09
📄 label1.go // errorcheck // 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. // Verify that erroneous labels are caught by the compiler. // This set is caught by pass 2. That's why this file is label1.go. // Does not compile. package main var x int func f1() { switch x { case 1: continue // ERROR "continue is not in a loop$\|continue statement not within for" } select { default: continue // ERROR "continue is not in a loop$\|continue statement not within for" } } func f2() { L1: for { if x == 0 { break L1 } if x == 1 { continue L1 } goto L1 } L2: select { default: if x == 0 { break L2 } if x == 1 { continue L2 // ERROR "invalid continue label .L2\|continue is not in a loop$" } goto L2 } for { if x == 1 { continue L2 // ERROR "invalid continue label .L2" } } L3: switch { case x > 10: if x == 11 { break L3 } if x == 12 { continue L3 // ERROR "invalid continue label .L3\|continue is not in a loop$" } goto L3 } L4: if true { if x == 13 { break L4 // ERROR "invalid break label .L4" } if x == 14 { continue L4 // ERROR "invalid continue label .L4\|continue is not in a loop$" } if x == 15 { goto L4 } } L5: f2() if x == 16 { break L5 // ERROR "invalid break label .L5" } if x == 17 { continue L5 // ERROR "invalid continue label .L5\|continue is not in a loop$" } if x == 18 { goto L5 } for { if x == 19 { break L1 // ERROR "invalid break label .L1" } if x == 20 { continue L1 // ERROR "invalid continue label .L1" } if x == 21 { goto L1 } } continue // ERROR "continue is not in a loop$\|continue statement not within for" for { continue on // ERROR "continue label not defined: on\|invalid continue label .on" } break // ERROR "break is not in a loop, switch, or select\|break statement not within for or switch or select" for { break dance // ERROR "break label not defined: dance\|invalid break label .*dance" } for { switch x { case 1: continue } } }	2.08 KB	2024-02-02 18:09
📄 linkmain.go //go:build ignore // 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. // For linkmain_run.go. package notmain func main() { }	237 B	2024-02-02 18:09
📄 linkmain_run.go // run //go:build !nacl && !js && !wasip1 // 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. // Run the sinit test. package main import ( "fmt" "io/ioutil" "os" "os/exec" "path/filepath" "strings" ) var tmpDir string func cleanup() { os.RemoveAll(tmpDir) } func run(cmdline ...string) { args := strings.Fields(strings.Join(cmdline, " ")) cmd := exec.Command(args[0], args[1:]...) out, err := cmd.CombinedOutput() if err != nil { fmt.Printf("$ %s\n", cmdline) fmt.Println(string(out)) fmt.Println(err) cleanup() os.Exit(1) } } func runFail(cmdline ...string) { args := strings.Fields(strings.Join(cmdline, " ")) cmd := exec.Command(args[0], args[1:]...) out, err := cmd.CombinedOutput() if err == nil { fmt.Printf("$ %s\n", cmdline) fmt.Println(string(out)) fmt.Println("SHOULD HAVE FAILED!") cleanup() os.Exit(1) } } func main() { var err error tmpDir, err = ioutil.TempDir("", "") if err != nil { fmt.Println(err) os.Exit(1) } tmp := func(name string) string { return filepath.Join(tmpDir, name) } importcfg, err := exec.Command("go", "list", "-export", "-f", "{{if .Export}}packagefile {{.ImportPath}}={{.Export}}{{end}}", "std").Output() if err != nil { fmt.Println(err) os.Exit(1) } os.WriteFile(tmp("importcfg"), importcfg, 0644) // helloworld.go is package main run("go tool compile -p=main -importcfg", tmp("importcfg"), "-o", tmp("linkmain.o"), "helloworld.go") run("go tool compile -p=main -importcfg", tmp("importcfg"), " -pack -o", tmp("linkmain.a"), "helloworld.go") run("go tool link -importcfg", tmp("importcfg"), "-o", tmp("linkmain.exe"), tmp("linkmain.o")) run("go tool link -importcfg", tmp("importcfg"), "-o", tmp("linkmain.exe"), tmp("linkmain.a")) // linkmain.go is not run("go tool compile -importcfg", tmp("importcfg"), "-p=notmain -o", tmp("linkmain1.o"), "linkmain.go") run("go tool compile -importcfg", tmp("importcfg"), "-p=notmain -pack -o", tmp("linkmain1.a"), "linkmain.go") runFail("go tool link -importcfg", tmp("importcfg"), "-o", tmp("linkmain.exe"), tmp("linkmain1.o")) runFail("go tool link -importcfg", tmp("importcfg"), "-o", tmp("linkmain.exe"), tmp("linkmain1.a")) cleanup() }	2.28 KB	2024-02-02 18:09
📁 linkname.dir	-	2024-02-02 18:09
📄 linkname.go // errorcheckandrundir -0 -m -l=4 // Copyright 2010 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. // Tests that linknames are included in export data (issue 18167). package ignored /* Without CL 33911, this test would fail with the following error: main.main: relocation target linkname2.byteIndex not defined main.main: undefined: "linkname2.byteIndex" */	456 B	2024-02-02 18:09
📄 linkname3.go // errorcheck // 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. // Tests that errors are reported for misuse of linkname. package p import _ "unsafe" type t int var x, y int //go:linkname x ok // ERROR "//go:linkname must refer to declared function or variable" // ERROR "//go:linkname must refer to declared function or variable" // ERROR "duplicate //go:linkname for x" //line linkname3.go:18 //go:linkname nonexist nonexist //go:linkname t notvarfunc //go:linkname x duplicate	597 B	2024-02-02 18:09
📄 linkobj.go // run //go:build !nacl && !js && gc && !wasip1 // 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. // Test the compiler -linkobj flag. package main import ( "fmt" "io/ioutil" "log" "os" "os/exec" "strings" ) var pwd, tmpdir string func main() { dir, err := ioutil.TempDir("", "go-test-linkobj-") if err != nil { log.Fatal(err) } pwd, err = os.Getwd() if err != nil { log.Fatal(err) } if err := os.Chdir(dir); err != nil { os.RemoveAll(dir) log.Fatal(err) } tmpdir = dir writeFile("p1.go", ` package p1 func F() { println("hello from p1") } `) writeFile("p2.go", ` package p2 import "./p1" func F() { p1.F() println("hello from p2") } func main() {} `) writeFile("p3.go", ` package main import "./p2" func main() { p2.F() println("hello from main") } `) stdlibimportcfg, err := os.ReadFile(os.Getenv("STDLIB_IMPORTCFG")) if err != nil { fatalf("listing stdlib export files: %v", err) } // two rounds: once using normal objects, again using .a files (compile -pack). for round := 0; round < 2; round++ { pkg := "-pack=" + fmt.Sprint(round) // The compiler expects the files being read to have the right suffix. o := "o" if round == 1 { o = "a" } importcfg := string(stdlibimportcfg) + "\npackagefile p1=p1." + o + "\npackagefile p2=p2." + o os.WriteFile("importcfg", []byte(importcfg), 0644) // inlining is disabled to make sure that the link objects contain needed code. run("go", "tool", "compile", "-p=p1", pkg, "-D", ".", "-importcfg=importcfg", "-l", "-o", "p1."+o, "-linkobj", "p1.lo", "p1.go") run("go", "tool", "compile", "-p=p2", pkg, "-D", ".", "-importcfg=importcfg", "-l", "-o", "p2."+o, "-linkobj", "p2.lo", "p2.go") run("go", "tool", "compile", "-p=main", pkg, "-D", ".", "-importcfg=importcfg", "-l", "-o", "p3."+o, "-linkobj", "p3.lo", "p3.go") cp("p1."+o, "p1.oo") cp("p2."+o, "p2.oo") cp("p3."+o, "p3.oo") cp("p1.lo", "p1."+o) cp("p2.lo", "p2."+o) cp("p3.lo", "p3."+o) out := runFail("go", "tool", "link", "p2."+o) if !strings.Contains(out, "not package main") { fatalf("link p2.o failed but not for package main:\n%s", out) } run("go", "tool", "link", "-importcfg=importcfg", "-o", "a.out.exe", "p3."+o) out = run("./a.out.exe") if !strings.Contains(out, "hello from p1\nhello from p2\nhello from main\n") { fatalf("running main, incorrect output:\n%s", out) } // ensure that mistaken future round can't use these os.Remove("p1.o") os.Remove("a.out.exe") } cleanup() } func run(args ...string) string { out, err := exec.Command(args[0], args[1:]...).CombinedOutput() if err != nil { fatalf("run %v: %s\n%s", args, err, out) } return string(out) } func runFail(args ...string) string { out, err := exec.Command(args[0], args[1:]...).CombinedOutput() if err == nil { fatalf("runFail %v: unexpected success!\n%s", args, err, out) } return string(out) } func cp(src, dst string) { data, err := ioutil.ReadFile(src) if err != nil { fatalf("%v", err) } err = ioutil.WriteFile(dst, data, 0666) if err != nil { fatalf("%v", err) } } func writeFile(name, data string) { err := ioutil.WriteFile(name, []byte(data), 0666) if err != nil { fatalf("%v", err) } } func cleanup() { const debug = false if debug { println("TMPDIR:", tmpdir) return } os.Chdir(pwd) // get out of tmpdir before removing it os.RemoveAll(tmpdir) } func fatalf(format string, args ...interface{}) { cleanup() log.Fatalf(format, args...) }	3.55 KB	2024-02-02 18:09
📄 linkx.go // skip // 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. // Test the -X facility of the gc linker (6l etc.). // This test is run by linkx_run.go. package main import "fmt" var tbd string var overwrite string = "dibs" var tbdcopy = tbd var overwritecopy = overwrite var arraycopy = [2]string{tbd, overwrite} var b bool var x int func main() { fmt.Println(tbd) fmt.Println(tbdcopy) fmt.Println(arraycopy[0]) fmt.Println(overwrite) fmt.Println(overwritecopy) fmt.Println(arraycopy[1]) // Check non-string symbols are not overwritten. // This also make them used. if b \|\| x != 0 { panic("b or x overwritten") } }	741 B	2024-02-02 18:09
📄 linkx_run.go // run //go:build !nacl && !js && !wasip1 && gc // 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. // Run the linkx test. package main import ( "bytes" "fmt" "os" "os/exec" "strings" ) func main() { // test(" ") // old deprecated & removed syntax test("=") // new syntax } func test(sep string) { // Successful run cmd := exec.Command("go", "run", "-ldflags=-X main.tbd"+sep+"hello -X main.overwrite"+sep+"trumped -X main.nosuchsymbol"+sep+"neverseen", "linkx.go") var out, errbuf bytes.Buffer cmd.Stdout = &out cmd.Stderr = &errbuf err := cmd.Run() if err != nil { fmt.Println(errbuf.String()) fmt.Println(out.String()) fmt.Println(err) os.Exit(1) } want := "hello\nhello\nhello\ntrumped\ntrumped\ntrumped\n" got := out.String() if got != want { fmt.Printf("got %q want %q\n", got, want) os.Exit(1) } // Issue 8810 cmd = exec.Command("go", "run", "-ldflags=-X main.tbd", "linkx.go") _, err = cmd.CombinedOutput() if err == nil { fmt.Println("-X linker flag should not accept keys without values") os.Exit(1) } // Issue 9621 cmd = exec.Command("go", "run", "-ldflags=-X main.b=false -X main.x=42", "linkx.go") outx, err := cmd.CombinedOutput() if err == nil { fmt.Println("-X linker flag should not overwrite non-strings") os.Exit(1) } outstr := string(outx) if !strings.Contains(outstr, "main.b") { fmt.Printf("-X linker flag did not diagnose overwrite of main.b:\n%s\n", outstr) os.Exit(1) } if !strings.Contains(outstr, "main.x") { fmt.Printf("-X linker flag did not diagnose overwrite of main.x:\n%s\n", outstr) os.Exit(1) } }	1.67 KB	2024-02-02 18:09
📄 literal.go // run // Copyright 2009 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 literal syntax for basic types. package main var nbad int func assert(cond bool, msg string) { if !cond { if nbad == 0 { print("BUG") } nbad++ print(" ", msg) } } func equal(a, b float32) bool { return a == b } func main() { // bool var t bool = true var f bool = false assert(t == !f, "bool") // int8 var i00 int8 = 0 var i01 int8 = 1 var i02 int8 = -1 var i03 int8 = 127 var i04 int8 = -127 var i05 int8 = -128 var i06 int8 = +127 assert(i01 == i00+1, "i01") assert(i02 == -i01, "i02") assert(i03 == -i04, "i03") assert(-(i05+1) == i06, "i05") // int16 var i10 int16 = 0 var i11 int16 = 1 var i12 int16 = -1 var i13 int16 = 32767 var i14 int16 = -32767 var i15 int16 = -32768 var i16 int16 = +32767 assert(i11 == i10+1, "i11") assert(i12 == -i11, "i12") assert(i13 == -i14, "i13") assert(-(i15+1) == i16, "i15") // int32 var i20 int32 = 0 var i21 int32 = 1 var i22 int32 = -1 var i23 int32 = 2147483647 var i24 int32 = -2147483647 var i25 int32 = -2147483648 var i26 int32 = +2147483647 assert(i21 == i20+1, "i21") assert(i22 == -i21, "i22") assert(i23 == -i24, "i23") assert(-(i25+1) == i26, "i25") assert(i23 == (1<<31)-1, "i23 size") // int64 var i30 int64 = 0 var i31 int64 = 1 var i32 int64 = -1 var i33 int64 = 9223372036854775807 var i34 int64 = -9223372036854775807 var i35 int64 = -9223372036854775808 var i36 int64 = +9223372036854775807 assert(i31 == i30+1, "i31") assert(i32 == -i31, "i32") assert(i33 == -i34, "i33") assert(-(i35+1) == i36, "i35") assert(i33 == (1<<63)-1, "i33 size") // uint8 var u00 uint8 = 0 var u01 uint8 = 1 var u02 uint8 = 255 var u03 uint8 = +255 assert(u01 == u00+1, "u01") assert(u02 == u03, "u02") assert(u03 == (1<<8)-1, "u03 size") // uint16 var u10 uint16 = 0 var u11 uint16 = 1 var u12 uint16 = 65535 var u13 uint16 = +65535 assert(u11 == u10+1, "u11") assert(u12 == u13, "u12") // uint32 var u20 uint32 = 0 var u21 uint32 = 1 var u22 uint32 = 4294967295 var u23 uint32 = +4294967295 assert(u21 == u20+1, "u21") assert(u22 == u23, "u22") // uint64 var u30 uint64 = 0 var u31 uint64 = 1 var u32 uint64 = 18446744073709551615 var u33 uint64 = +18446744073709551615 _, _, _, _ = u30, u31, u32, u33 // float var f00 float32 = 3.14159 var f01 float32 = -3.14159 var f02 float32 = +3.14159 var f03 float32 = 0.0 var f04 float32 = .0 var f05 float32 = 0. var f06 float32 = -0.0 var f07 float32 = 1e10 var f08 float32 = -1e10 var f09 float32 = 1e-10 var f10 float32 = 1e+10 var f11 float32 = 1.e-10 var f12 float32 = 1.e+10 var f13 float32 = .1e-10 var f14 float32 = .1e+10 var f15 float32 = 1.1e-10 var f16 float32 = 1.1e+10 assert(f01 == -f00, "f01") assert(f02 == -f01, "f02") assert(f03 == f04, "f03") assert(f04 == f05, "f04") assert(f05 == f06, "f05") assert(f07 == -f08, "f07") assert(equal(f09, 1/f10), "f09") assert(f11 == f09, "f11") assert(f12 == f10, "f12") assert(equal(f13, f09/10.0), "f13") assert(equal(f14, f12/10.0), "f14") assert(equal(f15, f16/1e20), "f15") // character var c0 uint8 = 'a' var c1 uint8 = 'ä' var c2 uint8 = '\a' var c3 uint8 = '\b' var c4 uint8 = '\f' var c5 uint8 = '\n' var c6 uint8 = '\r' var c7 uint8 = '\t' var c8 uint8 = '\v' // var c9 uint8 = '本' // correctly caught as error var c9 uint16 = '本' assert(c0 == 0x61, "c0") assert(c1 == 0xe4, "c1") assert(c2 == 0x07, "c2") assert(c3 == 0x08, "c3") assert(c4 == 0x0c, "c4") assert(c5 == 0x0a, "c4") assert(c6 == 0x0d, "c6") assert(c7 == 0x09, "c7") assert(c8 == 0x0b, "c8") assert(c9 == 0x672c, "c9") var c00 uint8 = '\000' var c01 uint8 = '\007' var c02 uint8 = '\177' var c03 uint8 = '\377' assert(c00 == 0, "c00") assert(c01 == 7, "c01") assert(c02 == 127, "c02") assert(c03 == 255, "c03") var cx0 uint8 = '\x00' var cx1 uint8 = '\x0f' var cx2 uint8 = '\xff' assert(cx0 == 0, "cx0") assert(cx1 == 15, "cx1") assert(cx2 == 255, "cx2") var cu0 uint16 = '\u1234' var cu1 uint32 = '\U00101234' assert(cu0 == 0x1234, "cu0") assert(cu1 == 0x101234, "cu1") // string var s0 string = "" var s1 string = "hellô" assert(s1[0] == 'h', "s1-0") assert(s1[4] == 0xc3, "s1-4") assert(s1[5] == 0xb4, "s1-5") var s2 string = "\a\b\f\n\r\t\v" _, _ = s0, s2 var s00 string = "\000" var s01 string = "\007" var s02 string = "\377" assert(s00[0] == 0, "s00") assert(s01[0] == 7, "s01") assert(s02[0] == 255, "s02") var x00 string = "\x00" var x01 string = "\x0f" var x02 string = "\xff" assert(x00[0] == 0, "x00") assert(x01[0] == 15, "x01") assert(x02[0] == 255, "x02") // these are all the same string var sj0 string = "日本語" var sj1 string = "\u65e5\u672c\u8a9e" var sj2 string = "\U000065e5\U0000672c\U00008a9e" var sj3 string = "\xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e" assert(sj0 == sj1, "sj1") assert(sj0 == sj2, "sj2") assert(sj0 == sj3, "sj3") if nbad > 0 { panic("literal failed") } }	4.99 KB	2024-02-02 18:09
📄 literal2.go // 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. // Test Go2 literal syntax for basic types. // Avoid running gofmt on this file to preserve the // test cases with upper-case prefixes (0B, 0O, 0X). package main import "fmt" func assert(cond bool) { if !cond { panic("assertion failed") } } func equal(x, y interface{}) bool { if x != y { fmt.Printf("%g != %g\n", x, y) return false } return true } func main() { // 0-octals assert(0_1 == 01) assert(012 == 012) assert(0_1_2 == 012) assert(0_1_2i == complex(0, 12)) // decimal digits despite leading 0 for backward-compatibility assert(00089i == complex(0, 89)) // decimal digits despite leading 0 for backward-compatibility // decimals assert(1_000_000 == 1000000) assert(1_000i == complex(0, 1000)) // hexadecimals assert(0x_1 == 0x1) assert(0x1_2 == 0x12) assert(0x_cafe_f00d == 0xcafef00d) assert(0x_cafei == complex(0, 0xcafe)) // octals assert(0o_1 == 01) assert(0o12 == 012) assert(0o_1_2 == 012) assert(0o_1_2i == complex(0, 0o12)) // binaries assert(0b_1 == 1) assert(0b10 == 2) assert(0b_1_0 == 2) assert(0b_1_0i == complex(0, 2)) // decimal floats assert(0. == 0.0) assert(.0 == 0.0) assert(1_0. == 10.0) assert(.0_1 == 0.01) assert(1_0.0_1 == 10.01) assert(1_0.0_1i == complex(0, 10.01)) assert(0.e1_0 == 0.0e10) assert(.0e1_0 == 0.0e10) assert(1_0.e1_0 == 10.0e10) assert(.0_1e1_0 == 0.01e10) assert(1_0.0_1e1_0 == 10.01e10) assert(1_0.0_1e1_0i == complex(0, 10.01e10)) // hexadecimal floats assert(equal(0x1p-2, 0.25)) assert(equal(0x2.p10, 2048.0)) assert(equal(0x1.Fp+0, 1.9375)) assert(equal(0x.8p-0, 0.5)) assert(equal(0x1FFFp-16, 0.1249847412109375)) assert(equal(0x1.fffffffffffffp1023, 1.7976931348623157e308)) assert(equal(0x1.fffffffffffffp1023i, complex(0, 1.7976931348623157e308))) assert(equal(0x_1p-2, 0.25)) assert(equal(0x2.p1_0, 2048.0)) assert(equal(0x1_0.Fp+0, 16.9375)) assert(equal(0x_0.8p-0, 0.5)) assert(equal(0x_1FF_Fp-16, 0.1249847412109375)) assert(equal(0x1.f_ffff_ffff_ffffp1_023, 1.7976931348623157e308)) assert(equal(0x1.f_ffff_ffff_ffffp1_023i, complex(0, 1.7976931348623157e308))) }	2.22 KB	2024-02-02 18:09
📄 live.go // errorcheckwithauto -0 -l -live -wb=0 -d=ssa/insert_resched_checks/off //go:build !ppc64 && !ppc64le && !goexperiment.regabiargs // ppc64 needs a better tighten pass to make f18 pass // rescheduling checks need to be turned off because there are some live variables across the inserted check call // // For register ABI, liveness info changes slightly. See live_regabi.go. // 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. // liveness tests with inlining disabled. // see also live2.go. package main func printnl() //go:noescape func printpointer(*int) //go:noescape func printintpointer(int) //go:noescape func printstringpointer(string) //go:noescape func printstring(string) //go:noescape func printbytepointer(byte) func printint(int) func f1() { var x int // ERROR "stack object x \int$" printpointer(&x) // ERROR "live at call to printpointer: x$" printpointer(&x) } func f2(b bool) { if b { printint(0) // nothing live here return } var x int // ERROR "stack object x \int$" printpointer(&x) // ERROR "live at call to printpointer: x$" printpointer(&x) } func f3(b1, b2 bool) { // Here x and y are ambiguously live. In previous go versions they // were marked as live throughout the function to avoid being // poisoned in GODEBUG=gcdead=1 mode; this is now no longer the // case. printint(0) if b1 == false { printint(0) return } if b2 { var x int // ERROR "stack object x \int$" printpointer(&x) // ERROR "live at call to printpointer: x$" printpointer(&x) } else { var y int // ERROR "stack object y \int$" printpointer(&y) // ERROR "live at call to printpointer: y$" printpointer(&y) } printint(0) // nothing is live here } // The old algorithm treated x as live on all code that // could flow to a return statement, so it included the // function entry and code above the declaration of x // but would not include an indirect use of x in an infinite loop. // Check that these cases are handled correctly. func f4(b1, b2 bool) { // x not live here if b2 { printint(0) // x not live here return } var z *int x := new(int) // ERROR "stack object x \int$" x = 42 z = &x printint(z) // ERROR "live at call to printint: x$" if b2 { printint(1) // x not live here return } for { printint(z) // ERROR "live at call to printint: x$" } } func f5(b1 bool) { var z int if b1 { x := new(int) // ERROR "stack object x \int$" x = 42 z = &x } else { y := new(int) // ERROR "stack object y \int$" y = 54 z = &y } printint(z) // nothing live here } // confusion about the _ result used to cause spurious "live at entry to f6: _". func f6() (_, y string) { y = "hello" return } // confusion about addressed results used to cause "live at entry to f7: x". func f7() (x string) { // ERROR "stack object x string" _ = &x x = "hello" return } // ignoring block returns used to cause "live at entry to f8: x, y". func f8() (x, y string) { return g8() } func g8() (string, string) // ignoring block assignments used to cause "live at entry to f9: x" // issue 7205 var i9 interface{} func f9() bool { g8() x := i9 y := interface{}(g18()) // ERROR "live at call to convT: x.data$" "live at call to g18: x.data$" "stack object .autotmp_[0-9]+ \[2\]string$" i9 = y // make y escape so the line above has to call convT return x != y } // liveness formerly confused by UNDEF followed by RET, // leading to "live at entry to f10: ~r1" (unnamed result). func f10() string { panic(1) } // liveness formerly confused by select, thinking runtime.selectgo // can return to next instruction; it always jumps elsewhere. // note that you have to use at least two cases in the select // to get a true select; smaller selects compile to optimized helper functions. var c chan int var b bool // this used to have a spurious "live at entry to f11a: ~r0" func f11a() int { select { // ERROR "stack object .autotmp_[0-9]+ \[2\]runtime.scase$" case <-c: return nil case <-c: return nil } } func f11b() int { p := new(int) if b { // At this point p is dead: the code here cannot // get to the bottom of the function. // This used to have a spurious "live at call to printint: p". printint(1) // nothing live here! select { // ERROR "stack object .autotmp_[0-9]+ \[2\]runtime.scase$" case <-c: return nil case <-c: return nil } } println(p) return nil } var sink int func f11c() int { p := new(int) sink = p // prevent stack allocation, otherwise p is rematerializeable if b { // Unlike previous, the cases in this select fall through, // so we can get to the println, so p is not dead. printint(1) // ERROR "live at call to printint: p$" select { // ERROR "live at call to selectgo: p$" "stack object .autotmp_[0-9]+ \[2\]runtime.scase$" case <-c: case <-c: } } println(p) return nil } // similarly, select{} does not fall through. // this used to have a spurious "live at entry to f12: ~r0". func f12() int { if b { select {} } else { return nil } } // incorrectly placed VARDEF annotations can cause missing liveness annotations. // this used to be missing the fact that s is live during the call to g13 (because it is // needed for the call to h13). func f13() { s := g14() s = h13(s, g13(s)) // ERROR "live at call to g13: s.ptr$" } func g13(string) string func h13(string, string) string // more incorrectly placed VARDEF. func f14() { x := g14() // ERROR "stack object x string$" printstringpointer(&x) } func g14() string // Checking that various temporaries do not persist or cause // ambiguously live values that must be zeroed. // The exact temporary names are inconsequential but we are // trying to check that there is only one at any given site, // and also that none show up in "ambiguously live" messages. var m map[string]int var mi map[interface{}]int // str and iface are used to ensure that a temp is required for runtime calls below. func str() string func iface() interface{} func f16() { if b { delete(mi, iface()) // ERROR "stack object .autotmp_[0-9]+ interface \{\}$" } delete(mi, iface()) delete(mi, iface()) } var m2s map[string]byte var m2 map[[2]string]byte var x2 [2]string var bp byte func f17a(p byte) { // ERROR "live at entry to f17a: p$" if b { m2[x2] = p // ERROR "live at call to mapassign: p$" } m2[x2] = p // ERROR "live at call to mapassign: p$" m2[x2] = p // ERROR "live at call to mapassign: p$" } func f17b(p byte) { // ERROR "live at entry to f17b: p$" // key temporary if b { m2s[str()] = p // ERROR "live at call to mapassign_faststr: p$" "live at call to str: p$" } m2s[str()] = p // ERROR "live at call to mapassign_faststr: p$" "live at call to str: p$" m2s[str()] = p // ERROR "live at call to mapassign_faststr: p$" "live at call to str: p$" } func f17c() { // key and value temporaries if b { m2s[str()] = f17d() // ERROR "live at call to f17d: .autotmp_[0-9]+$" "live at call to mapassign_faststr: .autotmp_[0-9]+$" } m2s[str()] = f17d() // ERROR "live at call to f17d: .autotmp_[0-9]+$" "live at call to mapassign_faststr: .autotmp_[0-9]+$" m2s[str()] = f17d() // ERROR "live at call to f17d: .autotmp_[0-9]+$" "live at call to mapassign_faststr: .autotmp_[0-9]+$" } func f17d() byte func g18() [2]string func f18() { // key temporary for mapaccess. // temporary introduced by orderexpr. var z byte if b { z = m2[g18()] // ERROR "stack object .autotmp_[0-9]+ \[2\]string$" } z = m2[g18()] z = m2[g18()] printbytepointer(z) } var ch chan byte // byteptr is used to ensure that a temp is required for runtime calls below. func byteptr() byte func f19() { // dest temporary for channel receive. var z byte if b { z = <-ch // ERROR "stack object .autotmp_[0-9]+ \byte$" } z = <-ch z = <-ch // ERROR "live at call to chanrecv1: .autotmp_[0-9]+$" printbytepointer(z) } func f20() { // src temporary for channel send if b { ch <- byteptr() // ERROR "stack object .autotmp_[0-9]+ \byte$" } ch <- byteptr() ch <- byteptr() } func f21() { // key temporary for mapaccess using array literal key. var z byte if b { z = m2[[2]string{"x", "y"}] // ERROR "stack object .autotmp_[0-9]+ \[2\]string$" } z = m2[[2]string{"x", "y"}] z = m2[[2]string{"x", "y"}] printbytepointer(z) } func f23() { // key temporary for two-result map access using array literal key. var z byte var ok bool if b { z, ok = m2[[2]string{"x", "y"}] // ERROR "stack object .autotmp_[0-9]+ \[2\]string$" } z, ok = m2[[2]string{"x", "y"}] z, ok = m2[[2]string{"x", "y"}] printbytepointer(z) print(ok) } func f24() { // key temporary for map access using array literal key. // value temporary too. if b { m2[[2]string{"x", "y"}] = nil // ERROR "stack object .autotmp_[0-9]+ \[2\]string$" } m2[[2]string{"x", "y"}] = nil m2[[2]string{"x", "y"}] = nil } // Non-open-coded defers should not cause autotmps. (Open-coded defers do create extra autotmps). func f25(b bool) { for i := 0; i < 2; i++ { // Put in loop to make sure defer is not open-coded defer g25() } if b { return } var x string x = g14() printstring(x) return } func g25() // non-escaping ... slices passed to function call should die on return, // so that the temporaries do not stack and do not cause ambiguously // live variables. func f26(b bool) { if b { print26((int)(nil), (int)(nil), (int)(nil)) // ERROR "stack object .autotmp_[0-9]+ \[3\]interface \{\}$" } print26((int)(nil), (int)(nil), (int)(nil)) print26((int)(nil), (int)(nil), (int)(nil)) printnl() } //go:noescape func print26(...interface{}) // non-escaping closures passed to function call should die on return func f27(b bool) { x := 0 if b { call27(func() { x++ }) // ERROR "stack object .autotmp_[0-9]+ struct \{" } call27(func() { x++ }) call27(func() { x++ }) printnl() } // but defer does escape to later execution in the function func f27defer(b bool) { x := 0 if b { defer call27(func() { x++ }) // ERROR "stack object .autotmp_[0-9]+ struct \{" } defer call27(func() { x++ }) // ERROR "stack object .autotmp_[0-9]+ struct \{" printnl() // ERROR "live at call to printnl: .autotmp_[0-9]+ .autotmp_[0-9]+" return // ERROR "live at indirect call: .autotmp_[0-9]+" } // and newproc (go) escapes to the heap func f27go(b bool) { x := 0 if b { go call27(func() { x++ }) // ERROR "live at call to newobject: &x$" "live at call to newobject: &x .autotmp_[0-9]+$" "live at call to newproc: &x$" // allocate two closures, the func literal, and the wrapper for go } go call27(func() { x++ }) // ERROR "live at call to newobject: &x$" "live at call to newobject: .autotmp_[0-9]+$" // allocate two closures, the func literal, and the wrapper for go printnl() } //go:noescape func call27(func()) // concatstring slice should die on return var s1, s2, s3, s4, s5, s6, s7, s8, s9, s10 string func f28(b bool) { if b { printstring(s1 + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9 + s10) // ERROR "stack object .autotmp_[0-9]+ \[10\]string$" } printstring(s1 + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9 + s10) printstring(s1 + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9 + s10) } // map iterator should die on end of range loop func f29(b bool) { if b { for k := range m { // ERROR "live at call to mapiterinit: .autotmp_[0-9]+$" "live at call to mapiternext: .autotmp_[0-9]+$" "stack object .autotmp_[0-9]+ runtime.hiter$" printstring(k) // ERROR "live at call to printstring: .autotmp_[0-9]+$" } } for k := range m { // ERROR "live at call to mapiterinit: .autotmp_[0-9]+$" "live at call to mapiternext: .autotmp_[0-9]+$" printstring(k) // ERROR "live at call to printstring: .autotmp_[0-9]+$" } for k := range m { // ERROR "live at call to mapiterinit: .autotmp_[0-9]+$" "live at call to mapiternext: .autotmp_[0-9]+$" printstring(k) // ERROR "live at call to printstring: .autotmp_[0-9]+$" } } // copy of array of pointers should die at end of range loop var pstructarr [10]pstruct // Struct size chosen to make pointer to element in pstructarr // not computable by strength reduction. type pstruct struct { intp int _ [8]byte } func f30(b bool) { // live temp during printintpointer(p): // the internal iterator pointer if a pointer to pstruct in pstructarr // can not be easily computed by strength reduction. if b { for _, p := range pstructarr { // ERROR "stack object .autotmp_[0-9]+ \[10\]pstruct$" printintpointer(p.intp) // ERROR "live at call to printintpointer: .autotmp_[0-9]+$" } } for _, p := range pstructarr { printintpointer(p.intp) // ERROR "live at call to printintpointer: .autotmp_[0-9]+$" } for _, p := range pstructarr { printintpointer(p.intp) // ERROR "live at call to printintpointer: .autotmp_[0-9]+$" } } // conversion to interface should not leave temporary behind func f31(b1, b2, b3 bool) { if b1 { g31(g18()) // ERROR "stack object .autotmp_[0-9]+ \[2\]string$" } if b2 { h31(g18()) // ERROR "live at call to convT: .autotmp_[0-9]+$" "live at call to newobject: .autotmp_[0-9]+$" } if b3 { panic(g18()) } print(b3) } func g31(interface{}) func h31(...interface{}) // non-escaping partial functions passed to function call should die on return type T32 int func (t T32) Inc() { // ERROR "live at entry to $\T32$.Inc: t$" t++ } var t32 T32 func f32(b bool) { if b { call32(t32.Inc) // ERROR "stack object .autotmp_[0-9]+ struct \{" } call32(t32.Inc) call32(t32.Inc) } //go:noescape func call32(func()) // temporaries introduced during if conditions and && \|\| expressions // should die once the condition has been acted upon. var m33 map[interface{}]int func f33() { if m33[byteptr()] == 0 { // ERROR "stack object .autotmp_[0-9]+ interface \{\}$" printnl() return } else { printnl() } printnl() } func f34() { if m33[byteptr()] == 0 { // ERROR "stack object .autotmp_[0-9]+ interface \{\}$" printnl() return } printnl() } func f35() { if m33[byteptr()] == 0 && // ERROR "stack object .autotmp_[0-9]+ interface \{\}" m33[byteptr()] == 0 { // ERROR "stack object .autotmp_[0-9]+ interface \{\}" printnl() return } printnl() } func f36() { if m33[byteptr()] == 0 \|\| // ERROR "stack object .autotmp_[0-9]+ interface \{\}" m33[byteptr()] == 0 { // ERROR "stack object .autotmp_[0-9]+ interface \{\}" printnl() return } printnl() } func f37() { if (m33[byteptr()] == 0 \|\| // ERROR "stack object .autotmp_[0-9]+ interface \{\}" m33[byteptr()] == 0) && // ERROR "stack object .autotmp_[0-9]+ interface \{\}" m33[byteptr()] == 0 { printnl() return } printnl() } // select temps should disappear in the case bodies var c38 chan string func fc38() chan string func fi38(int) string func fb38() bool func f38(b bool) { // we don't care what temps are printed on the lines with output. // we care that the println lines have no live variables // and therefore no output. if b { select { // ERROR "live at call to selectgo:( .autotmp_[0-9]+)+$" "stack object .autotmp_[0-9]+ \[4\]runtime.scase$" case <-fc38(): printnl() case fc38() <- fi38(1): // ERROR "live at call to fc38:( .autotmp_[0-9]+)+$" "live at call to fi38:( .autotmp_[0-9]+)+$" "stack object .autotmp_[0-9]+ string$" printnl() case fi38(2) = <-fc38(): // ERROR "live at call to fc38:( .autotmp_[0-9]+)+$" "live at call to fi38:( .autotmp_[0-9]+)+$" "stack object .autotmp_[0-9]+ string$" printnl() case fi38(3), fb38() = <-fc38(): // ERROR "stack object .autotmp_[0-9]+ string$" "live at call to f[ibc]38:( .autotmp_[0-9]+)+$" printnl() } printnl() } printnl() } // issue 8097: mishandling of x = x during return. func f39() (x []int) { x = []int{1} printnl() // ERROR "live at call to printnl: .autotmp_[0-9]+$" return x } func f39a() (x []int) { x = []int{1} printnl() // ERROR "live at call to printnl: .autotmp_[0-9]+$" return } func f39b() (x [10]int) { x = [10]int{} x[0] = new(int) // ERROR "live at call to newobject: x$" printnl() // ERROR "live at call to printnl: x$" return x } func f39c() (x [10]int) { x = [10]int{} x[0] = new(int) // ERROR "live at call to newobject: x$" printnl() // ERROR "live at call to printnl: x$" return } // issue 8142: lost 'addrtaken' bit on inlined variables. // no inlining in this test, so just checking that non-inlined works. type T40 struct { m map[int]int } //go:noescape func useT40(T40) func newT40() T40 { ret := T40{} ret.m = make(map[int]int, 42) // ERROR "live at call to makemap: &ret$" return &ret } func bad40() { t := newT40() _ = t printnl() } func good40() { ret := T40{} // ERROR "stack object ret T40$" ret.m = make(map[int]int) // ERROR "live at call to rand32: .autotmp_[0-9]+$" "stack object .autotmp_[0-9]+ runtime.hmap$" t := &ret printnl() // ERROR "live at call to printnl: ret$" // Note: ret is live at the printnl because the compiler moves &ret // from before the printnl to after. useT40(t) } func ddd1(x, y int) { // ERROR "live at entry to ddd1: x y$" ddd2(x, y) // ERROR "stack object .autotmp_[0-9]+ \[2\]\int$" printnl() // Note: no .?autotmp live at printnl. See issue 16996. } func ddd2(a ...int) { // ERROR "live at entry to ddd2: a$" sink = a[0] } // issue 16016: autogenerated wrapper should have arguments live type T struct{} func (T) Foo(ptr int) {} type R struct{ T } // issue 18860: output arguments must be live all the time if there is a defer. // In particular, at printint r must be live. func f41(p, q int) (r int) { // ERROR "live at entry to f41: p q$" r = p defer func() { recover() }() printint(0) // ERROR "live at call to printint: .autotmp_[0-9]+ q r$" r = q return // ERROR "live at call to f41.func1: .autotmp_[0-9]+ r$" } func f42() { var p, q, r int f43([]int{&p, &q, &r}) // ERROR "stack object .autotmp_[0-9]+ \[3\]\int$" f43([]int{&p, &r, &q}) f43([]int{&q, &p, &r}) } //go:noescape func f43(a []int) // Assigning to a sub-element that makes up an entire local variable // should clobber that variable. func f44(f func() [2]int) interface{} { // ERROR "live at entry to f44: f" type T struct { s [1][2]*int } ret := T{} // ERROR "stack object ret T" ret.s[0] = f() return ret }	18.03 KB	2024-02-02 18:09
📄 live1.go // 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. // Test that code compiles without // "internal error: ... recorded as live on entry" errors // from the liveness code. // // This code contains methods or other construct that // trigger the generation of wrapper functions with no // clear line number (they end up using line 1), and those // would have annotations printed if we used -live=1, // like the live.go test does. // Instead, this test relies on the fact that the liveness // analysis turns any non-live parameter on entry into // a compile error. Compiling successfully means that bug // has been avoided. package main // The liveness analysis used to get confused by the tail return // instruction in the wrapper methods generated for T1.M and (T1).M, // causing a spurious "live at entry: ~r1" for the return result. type T struct { } func (t T) M() int type T1 struct { T } // Liveness analysis used to have the VARDEFs in the wrong place, // causing a temporary to appear live on entry. func f1(pkg, typ, meth string) { panic("value method " + pkg + "." + typ + "." + meth + " called using nil *" + typ + " pointer") } func f2() interface{} { return new(int) }	1.29 KB	2024-02-02 18:09
📄 live2.go // errorcheck -0 -live -wb=0 // 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. // liveness tests with inlining ENABLED // see also live.go. package main // issue 8142: lost 'addrtaken' bit on inlined variables. func printnl() //go:noescape func useT40(T40) type T40 struct { m map[int]int } func newT40() T40 { ret := T40{} ret.m = make(map[int]int, 42) // ERROR "live at call to makemap: &ret$" return &ret } func bad40() { t := newT40() // ERROR "stack object ret T40$" "stack object .autotmp_[0-9]+ runtime.hmap$" printnl() // ERROR "live at call to printnl: ret$" useT40(t) } func good40() { ret := T40{} // ERROR "stack object ret T40$" ret.m = make(map[int]int, 42) // ERROR "stack object .autotmp_[0-9]+ runtime.hmap$" t := &ret printnl() // ERROR "live at call to printnl: ret$" useT40(t) }	953 B	2024-02-02 18:09
📄 live_regabi.go // errorcheckwithauto -0 -l -live -wb=0 -d=ssa/insert_resched_checks/off //go:build (amd64 && goexperiment.regabiargs) \|\| (arm64 && goexperiment.regabiargs) // 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. // liveness tests with inlining disabled. // see also live2.go. package main import "runtime" func printnl() //go:noescape func printpointer(*int) //go:noescape func printintpointer(int) //go:noescape func printstringpointer(string) //go:noescape func printstring(string) //go:noescape func printbytepointer(byte) func printint(int) func f1() { var x int // ERROR "stack object x \int$" printpointer(&x) // ERROR "live at call to printpointer: x$" printpointer(&x) } func f2(b bool) { if b { printint(0) // nothing live here return } var x int // ERROR "stack object x \int$" printpointer(&x) // ERROR "live at call to printpointer: x$" printpointer(&x) } func f3(b1, b2 bool) { // Here x and y are ambiguously live. In previous go versions they // were marked as live throughout the function to avoid being // poisoned in GODEBUG=gcdead=1 mode; this is now no longer the // case. printint(0) if b1 == false { printint(0) return } if b2 { var x int // ERROR "stack object x \int$" printpointer(&x) // ERROR "live at call to printpointer: x$" printpointer(&x) } else { var y int // ERROR "stack object y \int$" printpointer(&y) // ERROR "live at call to printpointer: y$" printpointer(&y) } printint(0) // nothing is live here } // The old algorithm treated x as live on all code that // could flow to a return statement, so it included the // function entry and code above the declaration of x // but would not include an indirect use of x in an infinite loop. // Check that these cases are handled correctly. func f4(b1, b2 bool) { // x not live here if b2 { printint(0) // x not live here return } var z *int x := new(int) // ERROR "stack object x \int$" x = 42 z = &x printint(z) // ERROR "live at call to printint: x$" if b2 { printint(1) // x not live here return } for { printint(z) // ERROR "live at call to printint: x$" } } func f5(b1 bool) { var z int if b1 { x := new(int) // ERROR "stack object x \int$" x = 42 z = &x } else { y := new(int) // ERROR "stack object y \int$" y = 54 z = &y } printint(z) // nothing live here } // confusion about the _ result used to cause spurious "live at entry to f6: _". func f6() (_, y string) { y = "hello" return } // confusion about addressed results used to cause "live at entry to f7: x". func f7() (x string) { // ERROR "stack object x string" _ = &x x = "hello" return } // ignoring block returns used to cause "live at entry to f8: x, y". func f8() (x, y string) { return g8() } func g8() (string, string) // ignoring block assignments used to cause "live at entry to f9: x" // issue 7205 var i9 interface{} func f9() bool { g8() x := i9 y := interface{}(g18()) // ERROR "live at call to convT: x.data$" "live at call to g18: x.data$" "stack object .autotmp_[0-9]+ \[2\]string$" i9 = y // make y escape so the line above has to call convT return x != y } // liveness formerly confused by UNDEF followed by RET, // leading to "live at entry to f10: ~r1" (unnamed result). func f10() string { panic(1) } // liveness formerly confused by select, thinking runtime.selectgo // can return to next instruction; it always jumps elsewhere. // note that you have to use at least two cases in the select // to get a true select; smaller selects compile to optimized helper functions. var c chan int var b bool // this used to have a spurious "live at entry to f11a: ~r0" func f11a() int { select { // ERROR "stack object .autotmp_[0-9]+ \[2\]runtime.scase$" case <-c: return nil case <-c: return nil } } func f11b() int { p := new(int) if b { // At this point p is dead: the code here cannot // get to the bottom of the function. // This used to have a spurious "live at call to printint: p". printint(1) // nothing live here! select { // ERROR "stack object .autotmp_[0-9]+ \[2\]runtime.scase$" case <-c: return nil case <-c: return nil } } println(p) return nil } var sink int func f11c() int { p := new(int) sink = p // prevent stack allocation, otherwise p is rematerializeable if b { // Unlike previous, the cases in this select fall through, // so we can get to the println, so p is not dead. printint(1) // ERROR "live at call to printint: p$" select { // ERROR "live at call to selectgo: p$" "stack object .autotmp_[0-9]+ \[2\]runtime.scase$" case <-c: case <-c: } } println(p) return nil } // similarly, select{} does not fall through. // this used to have a spurious "live at entry to f12: ~r0". func f12() int { if b { select {} } else { return nil } } // incorrectly placed VARDEF annotations can cause missing liveness annotations. // this used to be missing the fact that s is live during the call to g13 (because it is // needed for the call to h13). func f13() { s := g14() s = h13(s, g13(s)) // ERROR "live at call to g13: s.ptr$" } func g13(string) string func h13(string, string) string // more incorrectly placed VARDEF. func f14() { x := g14() // ERROR "stack object x string$" printstringpointer(&x) } func g14() string // Checking that various temporaries do not persist or cause // ambiguously live values that must be zeroed. // The exact temporary names are inconsequential but we are // trying to check that there is only one at any given site, // and also that none show up in "ambiguously live" messages. var m map[string]int var mi map[interface{}]int // str and iface are used to ensure that a temp is required for runtime calls below. func str() string func iface() interface{} func f16() { if b { delete(mi, iface()) // ERROR "stack object .autotmp_[0-9]+ interface \{\}$" } delete(mi, iface()) delete(mi, iface()) } var m2s map[string]byte var m2 map[[2]string]byte var x2 [2]string var bp byte func f17a(p byte) { // ERROR "live at entry to f17a: p$" if b { m2[x2] = p // ERROR "live at call to mapassign: p$" } m2[x2] = p // ERROR "live at call to mapassign: p$" m2[x2] = p // ERROR "live at call to mapassign: p$" } func f17b(p byte) { // ERROR "live at entry to f17b: p$" // key temporary if b { m2s[str()] = p // ERROR "live at call to mapassign_faststr: p$" "live at call to str: p$" } m2s[str()] = p // ERROR "live at call to mapassign_faststr: p$" "live at call to str: p$" m2s[str()] = p // ERROR "live at call to mapassign_faststr: p$" "live at call to str: p$" } func f17c() { // key and value temporaries if b { m2s[str()] = f17d() // ERROR "live at call to f17d: .autotmp_[0-9]+$" "live at call to mapassign_faststr: .autotmp_[0-9]+$" } m2s[str()] = f17d() // ERROR "live at call to f17d: .autotmp_[0-9]+$" "live at call to mapassign_faststr: .autotmp_[0-9]+$" m2s[str()] = f17d() // ERROR "live at call to f17d: .autotmp_[0-9]+$" "live at call to mapassign_faststr: .autotmp_[0-9]+$" } func f17d() byte func g18() [2]string func f18() { // key temporary for mapaccess. // temporary introduced by orderexpr. var z byte if b { z = m2[g18()] // ERROR "stack object .autotmp_[0-9]+ \[2\]string$" } z = m2[g18()] z = m2[g18()] printbytepointer(z) } var ch chan byte // byteptr is used to ensure that a temp is required for runtime calls below. func byteptr() byte func f19() { // dest temporary for channel receive. var z byte if b { z = <-ch // ERROR "stack object .autotmp_[0-9]+ \byte$" } z = <-ch z = <-ch // ERROR "live at call to chanrecv1: .autotmp_[0-9]+$" printbytepointer(z) } func f20() { // src temporary for channel send if b { ch <- byteptr() // ERROR "stack object .autotmp_[0-9]+ \byte$" } ch <- byteptr() ch <- byteptr() } func f21() { // key temporary for mapaccess using array literal key. var z byte if b { z = m2[[2]string{"x", "y"}] // ERROR "stack object .autotmp_[0-9]+ \[2\]string$" } z = m2[[2]string{"x", "y"}] z = m2[[2]string{"x", "y"}] printbytepointer(z) } func f23() { // key temporary for two-result map access using array literal key. var z byte var ok bool if b { z, ok = m2[[2]string{"x", "y"}] // ERROR "stack object .autotmp_[0-9]+ \[2\]string$" } z, ok = m2[[2]string{"x", "y"}] z, ok = m2[[2]string{"x", "y"}] printbytepointer(z) print(ok) } func f24() { // key temporary for map access using array literal key. // value temporary too. if b { m2[[2]string{"x", "y"}] = nil // ERROR "stack object .autotmp_[0-9]+ \[2\]string$" } m2[[2]string{"x", "y"}] = nil m2[[2]string{"x", "y"}] = nil } // Non-open-coded defers should not cause autotmps. (Open-coded defers do create extra autotmps). func f25(b bool) { for i := 0; i < 2; i++ { // Put in loop to make sure defer is not open-coded defer g25() } if b { return } var x string x = g14() printstring(x) return } func g25() // non-escaping ... slices passed to function call should die on return, // so that the temporaries do not stack and do not cause ambiguously // live variables. func f26(b bool) { if b { print26((int)(nil), (int)(nil), (int)(nil)) // ERROR "stack object .autotmp_[0-9]+ \[3\]interface \{\}$" } print26((int)(nil), (int)(nil), (int)(nil)) print26((int)(nil), (int)(nil), (int)(nil)) printnl() } //go:noescape func print26(...interface{}) // non-escaping closures passed to function call should die on return func f27(b bool) { x := 0 if b { call27(func() { x++ }) // ERROR "stack object .autotmp_[0-9]+ struct \{" } call27(func() { x++ }) call27(func() { x++ }) printnl() } // but defer does escape to later execution in the function func f27defer(b bool) { x := 0 if b { defer call27(func() { x++ }) // ERROR "stack object .autotmp_[0-9]+ struct \{" } defer call27(func() { x++ }) // ERROR "stack object .autotmp_[0-9]+ struct \{" printnl() // ERROR "live at call to printnl: .autotmp_[0-9]+ .autotmp_[0-9]+" return // ERROR "live at indirect call: .autotmp_[0-9]+" } // and newproc (go) escapes to the heap func f27go(b bool) { x := 0 if b { go call27(func() { x++ }) // ERROR "live at call to newobject: &x$" "live at call to newobject: &x .autotmp_[0-9]+$" "live at call to newproc: &x$" // allocate two closures, the func literal, and the wrapper for go } go call27(func() { x++ }) // ERROR "live at call to newobject: &x$" "live at call to newobject: .autotmp_[0-9]+$" // allocate two closures, the func literal, and the wrapper for go printnl() } //go:noescape func call27(func()) // concatstring slice should die on return var s1, s2, s3, s4, s5, s6, s7, s8, s9, s10 string func f28(b bool) { if b { printstring(s1 + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9 + s10) // ERROR "stack object .autotmp_[0-9]+ \[10\]string$" } printstring(s1 + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9 + s10) printstring(s1 + s2 + s3 + s4 + s5 + s6 + s7 + s8 + s9 + s10) } // map iterator should die on end of range loop func f29(b bool) { if b { for k := range m { // ERROR "live at call to mapiterinit: .autotmp_[0-9]+$" "live at call to mapiternext: .autotmp_[0-9]+$" "stack object .autotmp_[0-9]+ runtime.hiter$" printstring(k) // ERROR "live at call to printstring: .autotmp_[0-9]+$" } } for k := range m { // ERROR "live at call to mapiterinit: .autotmp_[0-9]+$" "live at call to mapiternext: .autotmp_[0-9]+$" printstring(k) // ERROR "live at call to printstring: .autotmp_[0-9]+$" } for k := range m { // ERROR "live at call to mapiterinit: .autotmp_[0-9]+$" "live at call to mapiternext: .autotmp_[0-9]+$" printstring(k) // ERROR "live at call to printstring: .autotmp_[0-9]+$" } } // copy of array of pointers should die at end of range loop var pstructarr [10]pstruct // Struct size chosen to make pointer to element in pstructarr // not computable by strength reduction. type pstruct struct { intp int _ [8]byte } func f30(b bool) { // live temp during printintpointer(p): // the internal iterator pointer if a pointer to pstruct in pstructarr // can not be easily computed by strength reduction. if b { for _, p := range pstructarr { // ERROR "stack object .autotmp_[0-9]+ \[10\]pstruct$" printintpointer(p.intp) // ERROR "live at call to printintpointer: .autotmp_[0-9]+$" } } for _, p := range pstructarr { printintpointer(p.intp) // ERROR "live at call to printintpointer: .autotmp_[0-9]+$" } for _, p := range pstructarr { printintpointer(p.intp) // ERROR "live at call to printintpointer: .autotmp_[0-9]+$" } } // conversion to interface should not leave temporary behind func f31(b1, b2, b3 bool) { if b1 { g31(g18()) // ERROR "stack object .autotmp_[0-9]+ \[2\]string$" } if b2 { h31(g18()) // ERROR "live at call to convT: .autotmp_[0-9]+$" "live at call to newobject: .autotmp_[0-9]+$" } if b3 { panic(g18()) } print(b3) } func g31(interface{}) func h31(...interface{}) // non-escaping partial functions passed to function call should die on return type T32 int func (t T32) Inc() { // ERROR "live at entry to $\T32$.Inc: t$" t++ } var t32 T32 func f32(b bool) { if b { call32(t32.Inc) // ERROR "stack object .autotmp_[0-9]+ struct \{" } call32(t32.Inc) call32(t32.Inc) } //go:noescape func call32(func()) // temporaries introduced during if conditions and && \|\| expressions // should die once the condition has been acted upon. var m33 map[interface{}]int func f33() { if m33[byteptr()] == 0 { // ERROR "stack object .autotmp_[0-9]+ interface \{\}$" printnl() return } else { printnl() } printnl() } func f34() { if m33[byteptr()] == 0 { // ERROR "stack object .autotmp_[0-9]+ interface \{\}$" printnl() return } printnl() } func f35() { if m33[byteptr()] == 0 && // ERROR "stack object .autotmp_[0-9]+ interface \{\}" m33[byteptr()] == 0 { // ERROR "stack object .autotmp_[0-9]+ interface \{\}" printnl() return } printnl() } func f36() { if m33[byteptr()] == 0 \|\| // ERROR "stack object .autotmp_[0-9]+ interface \{\}" m33[byteptr()] == 0 { // ERROR "stack object .autotmp_[0-9]+ interface \{\}" printnl() return } printnl() } func f37() { if (m33[byteptr()] == 0 \|\| // ERROR "stack object .autotmp_[0-9]+ interface \{\}" m33[byteptr()] == 0) && // ERROR "stack object .autotmp_[0-9]+ interface \{\}" m33[byteptr()] == 0 { printnl() return } printnl() } // select temps should disappear in the case bodies var c38 chan string func fc38() chan string func fi38(int) string func fb38() bool func f38(b bool) { // we don't care what temps are printed on the lines with output. // we care that the println lines have no live variables // and therefore no output. if b { select { // ERROR "live at call to selectgo:( .autotmp_[0-9]+)+$" "stack object .autotmp_[0-9]+ \[4\]runtime.scase$" case <-fc38(): printnl() case fc38() <- fi38(1): // ERROR "live at call to fc38:( .autotmp_[0-9]+)+$" "live at call to fi38:( .autotmp_[0-9]+)+$" "stack object .autotmp_[0-9]+ string$" printnl() case fi38(2) = <-fc38(): // ERROR "live at call to fc38:( .autotmp_[0-9]+)+$" "live at call to fi38:( .autotmp_[0-9]+)+$" "stack object .autotmp_[0-9]+ string$" printnl() case fi38(3), fb38() = <-fc38(): // ERROR "stack object .autotmp_[0-9]+ string$" "live at call to f[ibc]38:( .autotmp_[0-9]+)+$" printnl() } printnl() } printnl() } // issue 8097: mishandling of x = x during return. func f39() (x []int) { x = []int{1} printnl() // ERROR "live at call to printnl: .autotmp_[0-9]+$" return x } func f39a() (x []int) { x = []int{1} printnl() // ERROR "live at call to printnl: .autotmp_[0-9]+$" return } func f39b() (x [10]int) { x = [10]int{} x[0] = new(int) // ERROR "live at call to newobject: x$" printnl() // ERROR "live at call to printnl: x$" return x } func f39c() (x [10]int) { x = [10]int{} x[0] = new(int) // ERROR "live at call to newobject: x$" printnl() // ERROR "live at call to printnl: x$" return } // issue 8142: lost 'addrtaken' bit on inlined variables. // no inlining in this test, so just checking that non-inlined works. type T40 struct { m map[int]int } //go:noescape func useT40(T40) func newT40() T40 { ret := T40{} ret.m = make(map[int]int, 42) // ERROR "live at call to makemap: &ret$" return &ret } func bad40() { t := newT40() _ = t printnl() } func good40() { ret := T40{} // ERROR "stack object ret T40$" ret.m = make(map[int]int) // ERROR "live at call to rand32: .autotmp_[0-9]+$" "stack object .autotmp_[0-9]+ runtime.hmap$" t := &ret printnl() // ERROR "live at call to printnl: ret$" // Note: ret is live at the printnl because the compiler moves &ret // from before the printnl to after. useT40(t) } func ddd1(x, y int) { // ERROR "live at entry to ddd1: x y$" ddd2(x, y) // ERROR "stack object .autotmp_[0-9]+ \[2\]\int$" printnl() // Note: no .?autotmp live at printnl. See issue 16996. } func ddd2(a ...int) { // ERROR "live at entry to ddd2: a$" sink = a[0] } // issue 16016: autogenerated wrapper should have arguments live type T struct{} func (T) Foo(ptr int) {} type R struct{ T } // issue 18860: output arguments must be live all the time if there is a defer. // In particular, at printint r must be live. func f41(p, q int) (r int) { // ERROR "live at entry to f41: p q$" r = p defer func() { recover() }() printint(0) // ERROR "live at call to printint: .autotmp_[0-9]+ q r$" r = q return // ERROR "live at call to f41.func1: .autotmp_[0-9]+ r$" } func f42() { var p, q, r int f43([]int{&p, &q, &r}) // ERROR "stack object .autotmp_[0-9]+ \[3\]\int$" f43([]int{&p, &r, &q}) f43([]int{&q, &p, &r}) } //go:noescape func f43(a []int) // Assigning to a sub-element that makes up an entire local variable // should clobber that variable. func f44(f func() [2]int) interface{} { // ERROR "live at entry to f44: f" type T struct { s [1][2]int } ret := T{} // ERROR "stack object ret T" ret.s[0] = f() return ret } func f45(a, b, c, d, e, f, g, h, i, j, k, l byte) { // ERROR "live at entry to f45: a b c d e f g h i j k l" f46(a, b, c, d, e, f, g, h, i, j, k, l) // ERROR "live at call to f46: a b c d e f g h i j k l" runtime.KeepAlive(a) runtime.KeepAlive(b) runtime.KeepAlive(c) runtime.KeepAlive(d) runtime.KeepAlive(e) runtime.KeepAlive(f) runtime.KeepAlive(g) runtime.KeepAlive(h) runtime.KeepAlive(i) runtime.KeepAlive(j) runtime.KeepAlive(k) runtime.KeepAlive(l) } //go:noinline func f46(a, b, c, d, e, f, g, h, i, j, k, l *byte) { }	18.36 KB	2024-02-02 18:09
📄 live_uintptrkeepalive.go // errorcheck -0 -m -live -std //go:build !windows && !js && !wasip1 // 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. // Test escape analysis and liveness inferred for uintptrkeepalive functions. // // This behavior is enabled automatically for function declarations with no // bodies (assembly, linkname), as well as explicitly on complete functions // with //go:uintptrkeepalive. // // This is most important for syscall.Syscall (and similar functions), so we // test it explicitly. package p import ( "syscall" "unsafe" ) func implicit(uintptr) // ERROR "assuming ~p0 is unsafe uintptr" //go:uintptrkeepalive //go:nosplit func explicit(uintptr) { } func autotmpImplicit() { // ERROR "can inline autotmpImplicit" var t int implicit(uintptr(unsafe.Pointer(&t))) // ERROR "live at call to implicit: .?autotmp" "stack object .autotmp_[0-9]+ unsafe.Pointer$" } func autotmpExplicit() { // ERROR "can inline autotmpExplicit" var t int explicit(uintptr(unsafe.Pointer(&t))) // ERROR "live at call to explicit: .?autotmp" "stack object .autotmp_[0-9]+ unsafe.Pointer$" } func autotmpSyscall() { // ERROR "can inline autotmpSyscall" var v int syscall.Syscall(0, 1, uintptr(unsafe.Pointer(&v)), 2) // ERROR "live at call to Syscall: .?autotmp" "stack object .autotmp_[0-9]+ unsafe.Pointer$" } func localImplicit() { // ERROR "can inline localImplicit" var t int p := unsafe.Pointer(&t) implicit(uintptr(p)) // ERROR "live at call to implicit: .?autotmp" "stack object .autotmp_[0-9]+ unsafe.Pointer$" } func localExplicit() { // ERROR "can inline localExplicit" var t int p := unsafe.Pointer(&t) explicit(uintptr(p)) // ERROR "live at call to explicit: .?autotmp" "stack object .autotmp_[0-9]+ unsafe.Pointer$" } func localSyscall() { // ERROR "can inline localSyscall" var v int p := unsafe.Pointer(&v) syscall.Syscall(0, 1, uintptr(p), 2) // ERROR "live at call to Syscall: .?autotmp" "stack object .autotmp_[0-9]+ unsafe.Pointer$" }	2.02 KB	2024-02-02 18:09
📄 loopbce.go // errorcheck -0 -d=ssa/prove/debug=1 //go:build amd64 package main import "math" func f0a(a []int) int { x := 0 for i := range a { // ERROR "Induction variable: limits \[0,\?\), increment 1$" x += a[i] // ERROR "($[0-9]+$ )?Proved IsInBounds$" } return x } func f0b(a []int) int { x := 0 for i := range a { // ERROR "Induction variable: limits \[0,\?\), increment 1$" b := a[i:] // ERROR "($[0-9]+$ )?Proved IsSliceInBounds$" x += b[0] } return x } func f0c(a []int) int { x := 0 for i := range a { // ERROR "Induction variable: limits \[0,\?\), increment 1$" b := a[:i+1] // ERROR "($[0-9]+$ )?Proved IsSliceInBounds$" x += b[0] } return x } func f1(a []int) int { x := 0 for _, i := range a { // ERROR "Induction variable: limits \[0,\?\), increment 1$" x += i } return x } func f2(a []int) int { x := 0 for i := 1; i < len(a); i++ { // ERROR "Induction variable: limits \[1,\?\), increment 1$" x += a[i] // ERROR "($[0-9]+$ )?Proved IsInBounds$" } return x } func f4(a [10]int) int { x := 0 for i := 0; i < len(a); i += 2 { // ERROR "Induction variable: limits \[0,8\], increment 2$" x += a[i] // ERROR "($[0-9]+$ )?Proved IsInBounds$" } return x } func f5(a [10]int) int { x := 0 for i := -10; i < len(a); i += 2 { // ERROR "Induction variable: limits \[-10,8\], increment 2$" x += a[i+10] } return x } func f5_int32(a [10]int) int { x := 0 for i := int32(-10); i < int32(len(a)); i += 2 { // ERROR "Induction variable: limits \[-10,8\], increment 2$" x += a[i+10] } return x } func f5_int16(a [10]int) int { x := 0 for i := int16(-10); i < int16(len(a)); i += 2 { // ERROR "Induction variable: limits \[-10,8\], increment 2$" x += a[i+10] } return x } func f5_int8(a [10]int) int { x := 0 for i := int8(-10); i < int8(len(a)); i += 2 { // ERROR "Induction variable: limits \[-10,8\], increment 2$" x += a[i+10] } return x } func f6(a []int) { for i := range a { // ERROR "Induction variable: limits \[0,\?\), increment 1$" b := a[0:i] // ERROR "($[0-9]+$ )?Proved IsSliceInBounds$" f6(b) } } func g0a(a string) int { x := 0 for i := 0; i < len(a); i++ { // ERROR "Induction variable: limits \[0,\?\), increment 1$" x += int(a[i]) // ERROR "($[0-9]+$ )?Proved IsInBounds$" } return x } func g0b(a string) int { x := 0 for i := 0; len(a) > i; i++ { // ERROR "Induction variable: limits \[0,\?\), increment 1$" x += int(a[i]) // ERROR "($[0-9]+$ )?Proved IsInBounds$" } return x } func g0c(a string) int { x := 0 for i := len(a); i > 0; i-- { // ERROR "Induction variable: limits $0,\?\], increment 1$" x += int(a[i-1]) // ERROR "(\([0-9]+$ )?Proved IsInBounds$" } return x } func g0d(a string) int { x := 0 for i := len(a); 0 < i; i-- { // ERROR "Induction variable: limits $0,\?\], increment 1$" x += int(a[i-1]) // ERROR "(\([0-9]+$ )?Proved IsInBounds$" } return x } func g0e(a string) int { x := 0 for i := len(a) - 1; i >= 0; i-- { // ERROR "Induction variable: limits \[0,\?\], increment 1$" x += int(a[i]) // ERROR "($[0-9]+$ )?Proved IsInBounds$" } return x } func g0f(a string) int { x := 0 for i := len(a) - 1; 0 <= i; i-- { // ERROR "Induction variable: limits \[0,\?\], increment 1$" x += int(a[i]) // ERROR "($[0-9]+$ )?Proved IsInBounds$" } return x } func g1() int { a := "evenlength" x := 0 for i := 0; i < len(a); i += 2 { // ERROR "Induction variable: limits \[0,8\], increment 2$" x += int(a[i]) // ERROR "($[0-9]+$ )?Proved IsInBounds$" } return x } func g2() int { a := "evenlength" x := 0 for i := 0; i < len(a); i += 2 { // ERROR "Induction variable: limits \[0,8\], increment 2$" j := i if a[i] == 'e' { // ERROR "($[0-9]+$ )?Proved IsInBounds$" j = j + 1 } x += int(a[j]) } return x } func g3a() { a := "this string has length 25" for i := 0; i < len(a); i += 5 { // ERROR "Induction variable: limits \[0,20\], increment 5$" useString(a[i:]) // ERROR "($[0-9]+$ )?Proved IsSliceInBounds$" useString(a[:i+3]) // ERROR "($[0-9]+$ )?Proved IsSliceInBounds$" useString(a[:i+5]) // ERROR "($[0-9]+$ )?Proved IsSliceInBounds$" useString(a[:i+6]) } } func g3b(a string) { for i := 0; i < len(a); i++ { // ERROR "Induction variable: limits \[0,\?\), increment 1$" useString(a[i+1:]) // ERROR "($[0-9]+$ )?Proved IsSliceInBounds$" } } func g3c(a string) { for i := 0; i < len(a); i++ { // ERROR "Induction variable: limits \[0,\?\), increment 1$" useString(a[:i+1]) // ERROR "($[0-9]+$ )?Proved IsSliceInBounds$" } } func h1(a []byte) { c := a[:128] for i := range c { // ERROR "Induction variable: limits \[0,128\), increment 1$" c[i] = byte(i) // ERROR "($[0-9]+$ )?Proved IsInBounds$" } } func h2(a []byte) { for i := range a[:128] { // ERROR "Induction variable: limits \[0,128\), increment 1$" a[i] = byte(i) } } func k0(a [100]int) [100]int { for i := 10; i < 90; i++ { // ERROR "Induction variable: limits \[10,90\), increment 1$" if a[0] == 0xdeadbeef { // This is a trick to prohibit sccp to optimize out the following out of bound check continue } a[i-11] = i a[i-10] = i // ERROR "($[0-9]+$ )?Proved IsInBounds$" a[i-5] = i // ERROR "($[0-9]+$ )?Proved IsInBounds$" a[i] = i // ERROR "($[0-9]+$ )?Proved IsInBounds$" a[i+5] = i // ERROR "($[0-9]+$ )?Proved IsInBounds$" a[i+10] = i // ERROR "($[0-9]+$ )?Proved IsInBounds$" a[i+11] = i } return a } func k1(a [100]int) [100]int { for i := 10; i < 90; i++ { // ERROR "Induction variable: limits \[10,90\), increment 1$" if a[0] == 0xdeadbeef { // This is a trick to prohibit sccp to optimize out the following out of bound check continue } useSlice(a[:i-11]) useSlice(a[:i-10]) // ERROR "($[0-9]+$ )?Proved IsSliceInBounds$" useSlice(a[:i-5]) // ERROR "($[0-9]+$ )?Proved IsSliceInBounds$" useSlice(a[:i]) // ERROR "($[0-9]+$ )?Proved IsSliceInBounds$" useSlice(a[:i+5]) // ERROR "($[0-9]+$ )?Proved IsSliceInBounds$" useSlice(a[:i+10]) // ERROR "($[0-9]+$ )?Proved IsSliceInBounds$" useSlice(a[:i+11]) // ERROR "($[0-9]+$ )?Proved IsSliceInBounds$" useSlice(a[:i+12]) } return a } func k2(a [100]int) [100]int { for i := 10; i < 90; i++ { // ERROR "Induction variable: limits \[10,90\), increment 1$" if a[0] == 0xdeadbeef { // This is a trick to prohibit sccp to optimize out the following out of bound check continue } useSlice(a[i-11:]) useSlice(a[i-10:]) // ERROR "($[0-9]+$ )?Proved IsSliceInBounds$" useSlice(a[i-5:]) // ERROR "($[0-9]+$ )?Proved IsSliceInBounds$" useSlice(a[i:]) // ERROR "($[0-9]+$ )?Proved IsSliceInBounds$" useSlice(a[i+5:]) // ERROR "($[0-9]+$ )?Proved IsSliceInBounds$" useSlice(a[i+10:]) // ERROR "($[0-9]+$ )?Proved IsSliceInBounds$" useSlice(a[i+11:]) // ERROR "($[0-9]+$ )?Proved IsSliceInBounds$" useSlice(a[i+12:]) } return a } func k3(a [100]int) [100]int { for i := -10; i < 90; i++ { // ERROR "Induction variable: limits \[-10,90\), increment 1$" if a[0] == 0xdeadbeef { // This is a trick to prohibit sccp to optimize out the following out of bound check continue } a[i+9] = i a[i+10] = i // ERROR "($[0-9]+$ )?Proved IsInBounds$" a[i+11] = i } return a } func k3neg(a [100]int) [100]int { for i := 89; i > -11; i-- { // ERROR "Induction variable: limits $-11,89\], increment 1$" if a[0] == 0xdeadbeef { // This is a trick to prohibit sccp to optimize out the following out of bound check continue } a[i+9] = i a[i+10] = i // ERROR "(\([0-9]+$ )?Proved IsInBounds$" a[i+11] = i } return a } func k3neg2(a [100]int) [100]int { for i := 89; i >= -10; i-- { // ERROR "Induction variable: limits \[-10,89\], increment 1$" if a[0] == 0xdeadbeef { // This is a trick to prohibit sccp to optimize out the following out of bound check continue } a[i+9] = i a[i+10] = i // ERROR "($[0-9]+$ )?Proved IsInBounds$" a[i+11] = i } return a } func k4(a [100]int) [100]int { min := (-1) << 63 for i := min; i < min+50; i++ { // ERROR "Induction variable: limits \[-9223372036854775808,-9223372036854775758\), increment 1$" a[i-min] = i // ERROR "($[0-9]+$ )?Proved IsInBounds$" } return a } func k5(a [100]int) [100]int { max := (1 << 63) - 1 for i := max - 50; i < max; i++ { // ERROR "Induction variable: limits \[9223372036854775757,9223372036854775807\), increment 1$" a[i-max+50] = i // ERROR "($[0-9]+$ )?Proved IsInBounds$" a[i-(max-70)] = i // ERROR "($[0-9]+$ )?Proved IsInBounds$" } return a } func d1(a [100]int) [100]int { for i := 0; i < 100; i++ { // ERROR "Induction variable: limits \[0,100\), increment 1$" for j := 0; j < i; j++ { // ERROR "Induction variable: limits \[0,\?\), increment 1$" a[j] = 0 // ERROR "Proved IsInBounds$" a[j+1] = 0 // FIXME: this boundcheck should be eliminated a[j+2] = 0 } } return a } func d2(a [100]int) [100]int { for i := 0; i < 100; i++ { // ERROR "Induction variable: limits \[0,100\), increment 1$" for j := 0; i > j; j++ { // ERROR "Induction variable: limits \[0,\?\), increment 1$" a[j] = 0 // ERROR "Proved IsInBounds$" a[j+1] = 0 // FIXME: this boundcheck should be eliminated a[j+2] = 0 } } return a } func d3(a [100]int) [100]int { for i := 0; i <= 99; i++ { // ERROR "Induction variable: limits \[0,99\], increment 1$" for j := 0; j <= i-1; j++ { a[j] = 0 a[j+1] = 0 // ERROR "Proved IsInBounds$" a[j+2] = 0 } } return a } func d4() { for i := int64(math.MaxInt64 - 9); i < math.MaxInt64-2; i += 4 { // ERROR "Induction variable: limits \[9223372036854775798,9223372036854775802\], increment 4$" useString("foo") } for i := int64(math.MaxInt64 - 8); i < math.MaxInt64-2; i += 4 { // ERROR "Induction variable: limits \[9223372036854775799,9223372036854775803\], increment 4$" useString("foo") } for i := int64(math.MaxInt64 - 7); i < math.MaxInt64-2; i += 4 { useString("foo") } for i := int64(math.MaxInt64 - 6); i < math.MaxInt64-2; i += 4 { // ERROR "Induction variable: limits \[9223372036854775801,9223372036854775801\], increment 4$" useString("foo") } for i := int64(math.MaxInt64 - 9); i <= math.MaxInt64-2; i += 4 { // ERROR "Induction variable: limits \[9223372036854775798,9223372036854775802\], increment 4$" useString("foo") } for i := int64(math.MaxInt64 - 8); i <= math.MaxInt64-2; i += 4 { // ERROR "Induction variable: limits \[9223372036854775799,9223372036854775803\], increment 4$" useString("foo") } for i := int64(math.MaxInt64 - 7); i <= math.MaxInt64-2; i += 4 { useString("foo") } for i := int64(math.MaxInt64 - 6); i <= math.MaxInt64-2; i += 4 { useString("foo") } } func d5() { for i := int64(math.MinInt64 + 9); i > math.MinInt64+2; i -= 4 { // ERROR "Induction variable: limits \[-9223372036854775803,-9223372036854775799\], increment 4" useString("foo") } for i := int64(math.MinInt64 + 8); i > math.MinInt64+2; i -= 4 { // ERROR "Induction variable: limits \[-9223372036854775804,-9223372036854775800\], increment 4" useString("foo") } for i := int64(math.MinInt64 + 7); i > math.MinInt64+2; i -= 4 { useString("foo") } for i := int64(math.MinInt64 + 6); i > math.MinInt64+2; i -= 4 { // ERROR "Induction variable: limits \[-9223372036854775802,-9223372036854775802\], increment 4" useString("foo") } for i := int64(math.MinInt64 + 9); i >= math.MinInt64+2; i -= 4 { // ERROR "Induction variable: limits \[-9223372036854775803,-9223372036854775799\], increment 4" useString("foo") } for i := int64(math.MinInt64 + 8); i >= math.MinInt64+2; i -= 4 { // ERROR "Induction variable: limits \[-9223372036854775804,-9223372036854775800\], increment 4" useString("foo") } for i := int64(math.MinInt64 + 7); i >= math.MinInt64+2; i -= 4 { useString("foo") } for i := int64(math.MinInt64 + 6); i >= math.MinInt64+2; i -= 4 { useString("foo") } } func bce1() { // tests overflow of max-min a := int64(9223372036854774057) b := int64(-1547) z := int64(1337) if a%z == b%z { panic("invalid test: modulos should differ") } for i := b; i < a; i += z { // ERROR "Induction variable: limits \[-1547,9223372036854772720\], increment 1337" useString("foobar") } } func nobce2(a string) { for i := int64(0); i < int64(len(a)); i++ { // ERROR "Induction variable: limits \[0,\?\), increment 1$" useString(a[i:]) // ERROR "($[0-9]+$ )?Proved IsSliceInBounds$" } for i := int64(0); i < int64(len(a))-31337; i++ { // ERROR "Induction variable: limits \[0,\?\), increment 1$" useString(a[i:]) // ERROR "($[0-9]+$ )?Proved IsSliceInBounds$" } for i := int64(0); i < int64(len(a))+int64(-1<<63); i++ { // ERROR "Induction variable: limits \[0,\?\), increment 1$" useString(a[i:]) // ERROR "($[0-9]+$ )?Proved IsSliceInBounds$" } j := int64(len(a)) - 123 for i := int64(0); i < j+123+int64(-1<<63); i++ { // ERROR "Induction variable: limits \[0,\?\), increment 1$" useString(a[i:]) // ERROR "($[0-9]+$ )?Proved IsSliceInBounds$" } for i := int64(0); i < j+122+int64(-1<<63); i++ { // ERROR "Induction variable: limits \[0,\?\), increment 1$" // len(a)-123+122+MinInt overflows when len(a) == 0, so a bound check is needed here useString(a[i:]) } } func nobce3(a [100]int64) [100]int64 { min := int64((-1) << 63) max := int64((1 << 63) - 1) for i := min; i < max; i++ { // ERROR "Induction variable: limits \[-9223372036854775808,9223372036854775807\), increment 1$" } return a } func issue26116a(a []int) { // There is no induction variable here. The comparison is in the wrong direction. for i := 3; i > 6; i++ { a[i] = 0 } for i := 7; i < 3; i-- { a[i] = 1 } } func stride1(x [7]int) int { s := 0 for i := 0; i <= 8; i += 3 { // ERROR "Induction variable: limits \[0,6\], increment 3" s += x[i] // ERROR "Proved IsInBounds" } return s } func stride2(x [7]int) int { s := 0 for i := 0; i < 9; i += 3 { // ERROR "Induction variable: limits \[0,6\], increment 3" s += x[i] // ERROR "Proved IsInBounds" } return s } //go:noinline func useString(a string) { } //go:noinline func useSlice(a []int) { } func main() { }	13.81 KB	2024-02-02 18:09
📄 mainsig.go // errorcheck // 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 func main(int) {} // ERROR "func main must have no arguments and no return values" func main() int { return 1 } // ERROR "func main must have no arguments and no return values" "main redeclared in this block" func init(int) {} // ERROR "func init must have no arguments and no return values" func init() int { return 1 } // ERROR "func init must have no arguments and no return values"	598 B	2024-02-02 18:09
📄 makechan.go // 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. // Ensure that typed non-integer, negative and to large // values are not accepted as size argument in make for // channels. package main type T chan byte var sink T func main() { sink = make(T, -1) // ERROR "negative buffer argument in make.\|must not be negative" sink = make(T, uint64(1<<63)) // ERROR "buffer argument too large in make.\|overflows int" sink = make(T, 0.5) // ERROR "constant 0.5 truncated to integer\|truncated to int" sink = make(T, 1.0) sink = make(T, float32(1.0)) // ERROR "non-integer buffer argument in make.\|must be integer" sink = make(T, float64(1.0)) // ERROR "non-integer buffer argument in make.\|must be integer" sink = make(T, 1+0i) sink = make(T, complex64(1+0i)) // ERROR "non-integer buffer argument in make.\|must be integer" sink = make(T, complex128(1+0i)) // ERROR "non-integer buffer argument in make.\|must be integer" }	1.04 KB	2024-02-02 18:09
📄 makemap.go // 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. // Ensure that typed non-integer, negative and too large // values are not accepted as size argument in make for // maps. package main type T map[int]int var sink T func main() { sink = make(T, -1) // ERROR "negative size argument in make.\|must not be negative" sink = make(T, uint64(1<<63)) // ERROR "size argument too large in make.\|overflows int" // Test that errors are emitted at call sites, not const declarations const x = -1 sink = make(T, x) // ERROR "negative size argument in make.\|must not be negative" const y = uint64(1 << 63) sink = make(T, y) // ERROR "size argument too large in make.\|overflows int" sink = make(T, 0.5) // ERROR "constant 0.5 truncated to integer\|truncated to int" sink = make(T, 1.0) sink = make(T, float32(1.0)) // ERROR "non-integer size argument in make.\|must be integer" sink = make(T, float64(1.0)) // ERROR "non-integer size argument in make.\|must be integer" sink = make(T, 1+0i) sink = make(T, complex64(1+0i)) // ERROR "non-integer size argument in make.\|must be integer" sink = make(T, complex128(1+0i)) // ERROR "non-integer size argument in make.\|must be integer" }	1.3 KB	2024-02-02 18:09
📄 makenew.go // 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. // Verify that make and new arguments requirements are enforced by the // compiler. package main func main() { _ = make() // ERROR "missing argument\|not enough arguments" _ = make(int) // ERROR "cannot make type\|cannot make int" _ = make([]int) // ERROR "missing len argument\|expects 2 or 3 arguments" _ = new() // ERROR "missing argument\|not enough arguments" _ = new(int, 2) // ERROR "too many arguments" }	605 B	2024-02-02 18:09
📄 makeslice.go // run // 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. package main import ( "strings" "unsafe" ) func main() { n := -1 testInts(uint64(n)) testBytes(uint64(n)) var t byte if unsafe.Sizeof(t) == 8 { // Test mem > maxAlloc testInts(1 << 59) // Test elem.sizecap overflow testInts(1<<63 - 1) testInts(1<<64 - 1) testBytes(1<<64 - 1) } else { testInts(1<<31 - 1) // Test elem.size*cap overflow testInts(1<<32 - 1) testBytes(1<<32 - 1) } } func shouldPanic(str string, f func()) { defer func() { err := recover() if err == nil { panic("did not panic") } s := err.(error).Error() if !strings.Contains(s, str) { panic("got panic " + s + ", want " + str) } }() f() } func testInts(n uint64) { testMakeInts(n) testMakeCopyInts(n) testMakeInAppendInts(n) } func testBytes(n uint64) { testMakeBytes(n) testMakeCopyBytes(n) testMakeInAppendBytes(n) } // Test make panics for given length or capacity n. func testMakeInts(n uint64) { type T []int shouldPanic("len out of range", func() { _ = make(T, int(n)) }) shouldPanic("cap out of range", func() { _ = make(T, 0, int(n)) }) shouldPanic("len out of range", func() { _ = make(T, uint(n)) }) shouldPanic("cap out of range", func() { _ = make(T, 0, uint(n)) }) shouldPanic("len out of range", func() { _ = make(T, int64(n)) }) shouldPanic("cap out of range", func() { _ = make(T, 0, int64(n)) }) shouldPanic("len out of range", func() { _ = make(T, uint64(n)) }) shouldPanic("cap out of range", func() { _ = make(T, 0, uint64(n)) }) } func testMakeBytes(n uint64) { type T []byte shouldPanic("len out of range", func() { _ = make(T, int(n)) }) shouldPanic("cap out of range", func() { _ = make(T, 0, int(n)) }) shouldPanic("len out of range", func() { _ = make(T, uint(n)) }) shouldPanic("cap out of range", func() { _ = make(T, 0, uint(n)) }) shouldPanic("len out of range", func() { _ = make(T, int64(n)) }) shouldPanic("cap out of range", func() { _ = make(T, 0, int64(n)) }) shouldPanic("len out of range", func() { _ = make(T, uint64(n)) }) shouldPanic("cap out of range", func() { _ = make(T, 0, uint64(n)) }) } // Test make+copy panics since the gc compiler optimizes these // to runtime.makeslicecopy calls. func testMakeCopyInts(n uint64) { type T []int var c = make(T, 8) shouldPanic("len out of range", func() { x := make(T, int(n)); copy(x, c) }) shouldPanic("cap out of range", func() { x := make(T, 0, int(n)); copy(x, c) }) shouldPanic("len out of range", func() { x := make(T, uint(n)); copy(x, c) }) shouldPanic("cap out of range", func() { x := make(T, 0, uint(n)); copy(x, c) }) shouldPanic("len out of range", func() { x := make(T, int64(n)); copy(x, c) }) shouldPanic("cap out of range", func() { x := make(T, 0, int64(n)); copy(x, c) }) shouldPanic("len out of range", func() { x := make(T, uint64(n)); copy(x, c) }) shouldPanic("cap out of range", func() { x := make(T, 0, uint64(n)); copy(x, c) }) } func testMakeCopyBytes(n uint64) { type T []byte var c = make(T, 8) shouldPanic("len out of range", func() { x := make(T, int(n)); copy(x, c) }) shouldPanic("cap out of range", func() { x := make(T, 0, int(n)); copy(x, c) }) shouldPanic("len out of range", func() { x := make(T, uint(n)); copy(x, c) }) shouldPanic("cap out of range", func() { x := make(T, 0, uint(n)); copy(x, c) }) shouldPanic("len out of range", func() { x := make(T, int64(n)); copy(x, c) }) shouldPanic("cap out of range", func() { x := make(T, 0, int64(n)); copy(x, c) }) shouldPanic("len out of range", func() { x := make(T, uint64(n)); copy(x, c) }) shouldPanic("cap out of range", func() { x := make(T, 0, uint64(n)); copy(x, c) }) } // Test make in append panics for int slices since the gc compiler optimizes makes in appends. func testMakeInAppendInts(n uint64) { type T []int for _, length := range []int{0, 1} { t := make(T, length) shouldPanic("len out of range", func() { _ = append(t, make(T, int(n))...) }) shouldPanic("cap out of range", func() { _ = append(t, make(T, 0, int(n))...) }) shouldPanic("len out of range", func() { _ = append(t, make(T, int64(n))...) }) shouldPanic("cap out of range", func() { _ = append(t, make(T, 0, int64(n))...) }) shouldPanic("len out of range", func() { _ = append(t, make(T, uint64(n))...) }) shouldPanic("cap out of range", func() { _ = append(t, make(T, 0, uint64(n))...) }) shouldPanic("len out of range", func() { _ = append(t, make(T, int(n))...) }) shouldPanic("cap out of range", func() { _ = append(t, make(T, 0, int(n))...) }) shouldPanic("len out of range", func() { _ = append(t, make(T, uint(n))...) }) shouldPanic("cap out of range", func() { _ = append(t, make(T, 0, uint(n))...) }) } } func testMakeInAppendBytes(n uint64) { type T []byte for _, length := range []int{0, 1} { t := make(T, length) shouldPanic("len out of range", func() { _ = append(t, make(T, int(n))...) }) shouldPanic("cap out of range", func() { _ = append(t, make(T, 0, int(n))...) }) shouldPanic("len out of range", func() { _ = append(t, make(T, uint(n))...) }) shouldPanic("cap out of range", func() { _ = append(t, make(T, 0, uint(n))...) }) shouldPanic("len out of range", func() { _ = append(t, make(T, int64(n))...) }) shouldPanic("cap out of range", func() { _ = append(t, make(T, 0, int64(n))...) }) shouldPanic("len out of range", func() { _ = append(t, make(T, uint64(n))...) }) shouldPanic("cap out of range", func() { _ = append(t, make(T, 0, uint64(n))...) }) } }	5.49 KB	2024-02-02 18:09
📄 mallocfin.go // run // Copyright 2009 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 basic operation of finalizers. package main import ( "runtime" "time" ) const N = 250 type A struct { b B n int } type B struct { n int } var i int var nfinal int var final [N]int // the unused return is to test finalizers with return values func finalA(a A) (unused [N]int) { if final[a.n] != 0 { println("finalA", a.n, final[a.n]) panic("fail") } final[a.n] = 1 return } func finalB(b B) { if final[b.n] != 1 { println("finalB", b.n, final[b.n]) panic("fail") } final[b.n] = 2 nfinal++ } func nofinalB(b B) { panic("nofinalB run") } func main() { runtime.GOMAXPROCS(4) for i = 0; i < N; i++ { b := &B{i} a := &A{b, i} c := new(B) runtime.SetFinalizer(c, nofinalB) runtime.SetFinalizer(b, finalB) runtime.SetFinalizer(a, finalA) runtime.SetFinalizer(c, nil) } for i := 0; i < N; i++ { runtime.GC() runtime.Gosched() time.Sleep(1e6) if nfinal >= N8/10 { break } } if nfinal < N8/10 { println("not enough finalizing:", nfinal, "/", N) panic("fail") } }	1.18 KB	2024-02-02 18:09
📄 map.go // run // Copyright 2009 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 maps, almost exhaustively. // Complexity (linearity) test is in maplinear.go. package main import ( "fmt" "math" "strconv" ) const count = 100 func P(a []string) string { s := "{" for i := 0; i < len(a); i++ { if i > 0 { s += "," } s += `"` + a[i] + `"` } s += "}" return s } func main() { testbasic() testfloat() testnan() } func testbasic() { // Test a map literal. mlit := map[string]int{"0": 0, "1": 1, "2": 2, "3": 3, "4": 4} for i := 0; i < len(mlit); i++ { s := string([]byte{byte(i) + '0'}) if mlit[s] != i { panic(fmt.Sprintf("mlit[%s] = %d\n", s, mlit[s])) } } mib := make(map[int]bool) mii := make(map[int]int) mfi := make(map[float32]int) mif := make(map[int]float32) msi := make(map[string]int) mis := make(map[int]string) mss := make(map[string]string) mspa := make(map[string][]string) // BUG need an interface map both ways too type T struct { i int64 // can't use string here; struct values are only compared at the top level f float32 } mipT := make(map[int]T) mpTi := make(map[T]int) mit := make(map[int]T) // mti := make(map[T] int) type M map[int]int mipM := make(map[int]M) var apT [2 * count]T for i := 0; i < count; i++ { s := strconv.Itoa(i) s10 := strconv.Itoa(i 10) f := float32(i) t := T{int64(i), f} apT[i] = new(T) apT[i].i = int64(i) apT[i].f = f apT[2i] = new(T) // need twice as many entries as we use, for the nonexistence check apT[2i].i = int64(i) apT[2i].f = f m := M{i: i + 1} mib[i] = (i != 0) mii[i] = 10 i mfi[float32(i)] = 10 * i mif[i] = 10.0 * f mis[i] = s msi[s] = i mss[s] = s10 mss[s] = s10 as := make([]string, 2) as[0] = s10 as[1] = s10 mspa[s] = as mipT[i] = apT[i] mpTi[apT[i]] = i mipM[i] = m mit[i] = t // mti[t] = i } // test len if len(mib) != count { panic(fmt.Sprintf("len(mib) = %d\n", len(mib))) } if len(mii) != count { panic(fmt.Sprintf("len(mii) = %d\n", len(mii))) } if len(mfi) != count { panic(fmt.Sprintf("len(mfi) = %d\n", len(mfi))) } if len(mif) != count { panic(fmt.Sprintf("len(mif) = %d\n", len(mif))) } if len(msi) != count { panic(fmt.Sprintf("len(msi) = %d\n", len(msi))) } if len(mis) != count { panic(fmt.Sprintf("len(mis) = %d\n", len(mis))) } if len(mss) != count { panic(fmt.Sprintf("len(mss) = %d\n", len(mss))) } if len(mspa) != count { panic(fmt.Sprintf("len(mspa) = %d\n", len(mspa))) } if len(mipT) != count { panic(fmt.Sprintf("len(mipT) = %d\n", len(mipT))) } if len(mpTi) != count { panic(fmt.Sprintf("len(mpTi) = %d\n", len(mpTi))) } // if len(mti) != count { // panic(fmt.Sprintf("len(mti) = %d\n", len(mti))) // } if len(mipM) != count { panic(fmt.Sprintf("len(mipM) = %d\n", len(mipM))) } // if len(mti) != count { // panic(fmt.Sprintf("len(mti) = %d\n", len(mti))) // } if len(mit) != count { panic(fmt.Sprintf("len(mit) = %d\n", len(mit))) } // test construction directly for i := 0; i < count; i++ { s := strconv.Itoa(i) s10 := strconv.Itoa(i * 10) f := float32(i) // BUG m := M(i, i+1) if mib[i] != (i != 0) { panic(fmt.Sprintf("mib[%d] = %t\n", i, mib[i])) } if mii[i] != 10i { panic(fmt.Sprintf("mii[%d] = %d\n", i, mii[i])) } if mfi[f] != 10i { panic(fmt.Sprintf("mfi[%d] = %d\n", i, mfi[f])) } if mif[i] != 10.0f { panic(fmt.Sprintf("mif[%d] = %g\n", i, mif[i])) } if mis[i] != s { panic(fmt.Sprintf("mis[%d] = %s\n", i, mis[i])) } if msi[s] != i { panic(fmt.Sprintf("msi[%s] = %d\n", s, msi[s])) } if mss[s] != s10 { panic(fmt.Sprintf("mss[%s] = %g\n", s, mss[s])) } for j := 0; j < len(mspa[s]); j++ { if mspa[s][j] != s10 { panic(fmt.Sprintf("mspa[%s][%d] = %s\n", s, j, mspa[s][j])) } } if mipT[i].i != int64(i) \|\| mipT[i].f != f { panic(fmt.Sprintf("mipT[%d] = %v\n", i, mipT[i])) } if mpTi[apT[i]] != i { panic(fmt.Sprintf("mpTi[apT[%d]] = %d\n", i, mpTi[apT[i]])) } // if(mti[t] != i) { // panic(fmt.Sprintf("mti[%s] = %s\n", s, mti[t])) // } if mipM[i][i] != i+1 { panic(fmt.Sprintf("mipM[%d][%d] = %d\n", i, i, mipM[i][i])) } // if(mti[t] != i) { // panic(fmt.Sprintf("mti[%v] = %d\n", t, mti[t])) // } if mit[i].i != int64(i) \|\| mit[i].f != f { panic(fmt.Sprintf("mit[%d] = {%d %g}\n", i, mit[i].i, mit[i].f)) } } // test existence with tuple check // failed lookups yield a false value for the boolean. for i := 0; i < count; i++ { s := strconv.Itoa(i) f := float32(i) { _, b := mib[i] if !b { panic(fmt.Sprintf("tuple existence decl: mib[%d]\n", i)) } _, b = mib[i] if !b { panic(fmt.Sprintf("tuple existence assign: mib[%d]\n", i)) } } { _, b := mii[i] if !b { panic(fmt.Sprintf("tuple existence decl: mii[%d]\n", i)) } _, b = mii[i] if !b { panic(fmt.Sprintf("tuple existence assign: mii[%d]\n", i)) } } { _, b := mfi[f] if !b { panic(fmt.Sprintf("tuple existence decl: mfi[%d]\n", i)) } _, b = mfi[f] if !b { panic(fmt.Sprintf("tuple existence assign: mfi[%d]\n", i)) } } { _, b := mif[i] if !b { panic(fmt.Sprintf("tuple existence decl: mif[%d]\n", i)) } _, b = mif[i] if !b { panic(fmt.Sprintf("tuple existence assign: mif[%d]\n", i)) } } { _, b := mis[i] if !b { panic(fmt.Sprintf("tuple existence decl: mis[%d]\n", i)) } _, b = mis[i] if !b { panic(fmt.Sprintf("tuple existence assign: mis[%d]\n", i)) } } { _, b := msi[s] if !b { panic(fmt.Sprintf("tuple existence decl: msi[%d]\n", i)) } _, b = msi[s] if !b { panic(fmt.Sprintf("tuple existence assign: msi[%d]\n", i)) } } { _, b := mss[s] if !b { panic(fmt.Sprintf("tuple existence decl: mss[%d]\n", i)) } _, b = mss[s] if !b { panic(fmt.Sprintf("tuple existence assign: mss[%d]\n", i)) } } { _, b := mspa[s] if !b { panic(fmt.Sprintf("tuple existence decl: mspa[%d]\n", i)) } _, b = mspa[s] if !b { panic(fmt.Sprintf("tuple existence assign: mspa[%d]\n", i)) } } { _, b := mipT[i] if !b { panic(fmt.Sprintf("tuple existence decl: mipT[%d]\n", i)) } _, b = mipT[i] if !b { panic(fmt.Sprintf("tuple existence assign: mipT[%d]\n", i)) } } { _, b := mpTi[apT[i]] if !b { panic(fmt.Sprintf("tuple existence decl: mpTi[apT[%d]]\n", i)) } _, b = mpTi[apT[i]] if !b { panic(fmt.Sprintf("tuple existence assign: mpTi[apT[%d]]\n", i)) } } { _, b := mipM[i] if !b { panic(fmt.Sprintf("tuple existence decl: mipM[%d]\n", i)) } _, b = mipM[i] if !b { panic(fmt.Sprintf("tuple existence assign: mipM[%d]\n", i)) } } { _, b := mit[i] if !b { panic(fmt.Sprintf("tuple existence decl: mit[%d]\n", i)) } _, b = mit[i] if !b { panic(fmt.Sprintf("tuple existence assign: mit[%d]\n", i)) } } // { // _, b := mti[t] // if !b { // panic(fmt.Sprintf("tuple existence decl: mti[%d]\n", i)) // } // _, b = mti[t] // if !b { // panic(fmt.Sprintf("tuple existence assign: mti[%d]\n", i)) // } // } } // test nonexistence with tuple check // failed lookups yield a false value for the boolean. for i := count; i < 2count; i++ { s := strconv.Itoa(i) f := float32(i) { _, b := mib[i] if b { panic(fmt.Sprintf("tuple nonexistence decl: mib[%d]", i)) } _, b = mib[i] if b { panic(fmt.Sprintf("tuple nonexistence assign: mib[%d]", i)) } } { _, b := mii[i] if b { panic(fmt.Sprintf("tuple nonexistence decl: mii[%d]", i)) } _, b = mii[i] if b { panic(fmt.Sprintf("tuple nonexistence assign: mii[%d]", i)) } } { _, b := mfi[f] if b { panic(fmt.Sprintf("tuple nonexistence decl: mfi[%d]", i)) } _, b = mfi[f] if b { panic(fmt.Sprintf("tuple nonexistence assign: mfi[%d]", i)) } } { _, b := mif[i] if b { panic(fmt.Sprintf("tuple nonexistence decl: mif[%d]", i)) } _, b = mif[i] if b { panic(fmt.Sprintf("tuple nonexistence assign: mif[%d]", i)) } } { _, b := mis[i] if b { panic(fmt.Sprintf("tuple nonexistence decl: mis[%d]", i)) } _, b = mis[i] if b { panic(fmt.Sprintf("tuple nonexistence assign: mis[%d]", i)) } } { _, b := msi[s] if b { panic(fmt.Sprintf("tuple nonexistence decl: msi[%d]", i)) } _, b = msi[s] if b { panic(fmt.Sprintf("tuple nonexistence assign: msi[%d]", i)) } } { _, b := mss[s] if b { panic(fmt.Sprintf("tuple nonexistence decl: mss[%d]", i)) } _, b = mss[s] if b { panic(fmt.Sprintf("tuple nonexistence assign: mss[%d]", i)) } } { _, b := mspa[s] if b { panic(fmt.Sprintf("tuple nonexistence decl: mspa[%d]", i)) } _, b = mspa[s] if b { panic(fmt.Sprintf("tuple nonexistence assign: mspa[%d]", i)) } } { _, b := mipT[i] if b { panic(fmt.Sprintf("tuple nonexistence decl: mipT[%d]", i)) } _, b = mipT[i] if b { panic(fmt.Sprintf("tuple nonexistence assign: mipT[%d]", i)) } } { _, b := mpTi[apT[i]] if b { panic(fmt.Sprintf("tuple nonexistence decl: mpTi[apt[%d]]", i)) } _, b = mpTi[apT[i]] if b { panic(fmt.Sprintf("tuple nonexistence assign: mpTi[apT[%d]]", i)) } } { _, b := mipM[i] if b { panic(fmt.Sprintf("tuple nonexistence decl: mipM[%d]", i)) } _, b = mipM[i] if b { panic(fmt.Sprintf("tuple nonexistence assign: mipM[%d]", i)) } } // { // _, b := mti[t] // if b { // panic(fmt.Sprintf("tuple nonexistence decl: mti[%d]", i)) // } // _, b = mti[t] // if b { // panic(fmt.Sprintf("tuple nonexistence assign: mti[%d]", i)) // } // } { _, b := mit[i] if b { panic(fmt.Sprintf("tuple nonexistence decl: mit[%d]", i)) } _, b = mit[i] if b { panic(fmt.Sprintf("tuple nonexistence assign: mit[%d]", i)) } } } // tests for structured map element updates for i := 0; i < count; i++ { s := strconv.Itoa(i) mspa[s][i%2] = "deleted" if mspa[s][i%2] != "deleted" { panic(fmt.Sprintf("update mspa[%s][%d] = %s\n", s, i%2, mspa[s][i%2])) } mipT[i].i += 1 if mipT[i].i != int64(i)+1 { panic(fmt.Sprintf("update mipT[%d].i = %d\n", i, mipT[i].i)) } mipT[i].f = float32(i + 1) if mipT[i].f != float32(i+1) { panic(fmt.Sprintf("update mipT[%d].f = %g\n", i, mipT[i].f)) } mipM[i][i]++ if mipM[i][i] != (i+1)+1 { panic(fmt.Sprintf("update mipM[%d][%d] = %d\n", i, i, mipM[i][i])) } } // test range on nil map var mnil map[string]int for _, _ = range mnil { panic("range mnil") } } func testfloat() { // Test floating point numbers in maps. // Two map keys refer to the same entry if the keys are ==. // The special cases, then, are that +0 == -0 and that NaN != NaN. { var ( pz = float32(0) nz = math.Float32frombits(1 << 31) nana = float32(math.NaN()) nanb = math.Float32frombits(math.Float32bits(nana) ^ 2) ) m := map[float32]string{ pz: "+0", nana: "NaN", nanb: "NaN", } if m[pz] != "+0" { panic(fmt.Sprintln("float32 map cannot read back m[+0]:", m[pz])) } if m[nz] != "+0" { fmt.Sprintln("float32 map does not treat", pz, "and", nz, "as equal for read") panic(fmt.Sprintln("float32 map does not treat -0 and +0 as equal for read")) } m[nz] = "-0" if m[pz] != "-0" { panic(fmt.Sprintln("float32 map does not treat -0 and +0 as equal for write")) } if _, ok := m[nana]; ok { panic(fmt.Sprintln("float32 map allows NaN lookup (a)")) } if _, ok := m[nanb]; ok { panic(fmt.Sprintln("float32 map allows NaN lookup (b)")) } if len(m) != 3 { panic(fmt.Sprintln("float32 map should have 3 entries:", m)) } m[nana] = "NaN" m[nanb] = "NaN" if len(m) != 5 { panic(fmt.Sprintln("float32 map should have 5 entries:", m)) } } { var ( pz = float64(0) nz = math.Float64frombits(1 << 63) nana = float64(math.NaN()) nanb = math.Float64frombits(math.Float64bits(nana) ^ 2) ) m := map[float64]string{ pz: "+0", nana: "NaN", nanb: "NaN", } if m[nz] != "+0" { panic(fmt.Sprintln("float64 map does not treat -0 and +0 as equal for read")) } m[nz] = "-0" if m[pz] != "-0" { panic(fmt.Sprintln("float64 map does not treat -0 and +0 as equal for write")) } if _, ok := m[nana]; ok { panic(fmt.Sprintln("float64 map allows NaN lookup (a)")) } if _, ok := m[nanb]; ok { panic(fmt.Sprintln("float64 map allows NaN lookup (b)")) } if len(m) != 3 { panic(fmt.Sprintln("float64 map should have 3 entries:", m)) } m[nana] = "NaN" m[nanb] = "NaN" if len(m) != 5 { panic(fmt.Sprintln("float64 map should have 5 entries:", m)) } } { var ( pz = complex64(0) nz = complex(0, math.Float32frombits(1<<31)) nana = complex(5, float32(math.NaN())) nanb = complex(5, math.Float32frombits(math.Float32bits(float32(math.NaN()))^2)) ) m := map[complex64]string{ pz: "+0", nana: "NaN", nanb: "NaN", } if m[nz] != "+0" { panic(fmt.Sprintln("complex64 map does not treat -0 and +0 as equal for read")) } m[nz] = "-0" if m[pz] != "-0" { panic(fmt.Sprintln("complex64 map does not treat -0 and +0 as equal for write")) } if _, ok := m[nana]; ok { panic(fmt.Sprintln("complex64 map allows NaN lookup (a)")) } if _, ok := m[nanb]; ok { panic(fmt.Sprintln("complex64 map allows NaN lookup (b)")) } if len(m) != 3 { panic(fmt.Sprintln("complex64 map should have 3 entries:", m)) } m[nana] = "NaN" m[nanb] = "NaN" if len(m) != 5 { panic(fmt.Sprintln("complex64 map should have 5 entries:", m)) } } { var ( pz = complex128(0) nz = complex(0, math.Float64frombits(1<<63)) nana = complex(5, float64(math.NaN())) nanb = complex(5, math.Float64frombits(math.Float64bits(float64(math.NaN()))^2)) ) m := map[complex128]string{ pz: "+0", nana: "NaN", nanb: "NaN", } if m[nz] != "+0" { panic(fmt.Sprintln("complex128 map does not treat -0 and +0 as equal for read")) } m[nz] = "-0" if m[pz] != "-0" { panic(fmt.Sprintln("complex128 map does not treat -0 and +0 as equal for write")) } if _, ok := m[nana]; ok { panic(fmt.Sprintln("complex128 map allows NaN lookup (a)")) } if _, ok := m[nanb]; ok { panic(fmt.Sprintln("complex128 map allows NaN lookup (b)")) } if len(m) != 3 { panic(fmt.Sprintln("complex128 map should have 3 entries:", m)) } m[nana] = "NaN" m[nanb] = "NaN" if len(m) != 5 { panic(fmt.Sprintln("complex128 map should have 5 entries:", m)) } } } func testnan() { n := 500 m := map[float64]int{} nan := math.NaN() for i := 0; i < n; i++ { m[nan] = 1 } if len(m) != n { panic("wrong size map after nan insertion") } iters := 0 for k, v := range m { iters++ if !math.IsNaN(k) { panic("not NaN") } if v != 1 { panic("wrong value") } } if iters != n { panic("wrong number of nan range iters") } }	14.91 KB	2024-02-02 18:09
📄 map1.go // errorcheck // 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. // Test map declarations of many types, including erroneous ones. // Does not compile. package main type v bool var ( // valid _ map[int8]v _ map[uint8]v _ map[int16]v _ map[uint16]v _ map[int32]v _ map[uint32]v _ map[int64]v _ map[uint64]v _ map[int]v _ map[uint]v _ map[uintptr]v _ map[float32]v _ map[float64]v _ map[complex64]v _ map[complex128]v _ map[bool]v _ map[string]v _ map[chan int]v _ map[int]v _ map[struct{}]v _ map[[10]int]v // invalid _ map[[]int]v // ERROR "invalid map key" _ map[func()]v // ERROR "invalid map key" _ map[map[int]int]v // ERROR "invalid map key" _ map[T1]v // ERROR "invalid map key" _ map[T2]v // ERROR "invalid map key" _ map[T3]v // ERROR "invalid map key" _ map[T4]v // ERROR "invalid map key" _ map[T5]v _ map[T6]v _ map[T7]v _ map[T8]v ) type T1 []int type T2 struct { F T1 } type T3 []T4 type T4 struct { F T3 } type T5 int type T6 struct { F T5 } type T7 T4 type T8 struct { F T7 } func main() { m := make(map[int]int) delete() // ERROR "missing arguments\|not enough arguments" delete(m) // ERROR "missing second $key$ argument\|not enough arguments" delete(m, 2, 3) // ERROR "too many arguments" delete(1, m) // ERROR "first argument to delete must be map\|argument 1 must be a map\|is not a map" }	1.47 KB	2024-02-02 18:09
📄 mapclear.go // 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. // Ensure that range loops over maps with delete statements // have the requisite side-effects. package main import ( "fmt" "os" ) func checkcleared() { m := make(map[byte]int) m[1] = 1 m[2] = 2 for k := range m { delete(m, k) } l := len(m) if want := 0; l != want { fmt.Printf("len after map clear = %d want %d\n", l, want) os.Exit(1) } m[0] = 0 // To have non empty map and avoid internal map code fast paths. n := 0 for range m { n++ } if want := 1; n != want { fmt.Printf("number of keys found = %d want %d\n", n, want) os.Exit(1) } } func checkloopvars() { k := 0 m := make(map[int]int) m[42] = 0 for k = range m { delete(m, k) } if want := 42; k != want { fmt.Printf("var after range with side-effect = %d want %d\n", k, want) os.Exit(1) } } func checksideeffects() { var x int f := func() int { x++ return 0 } m := make(map[int]int) m[0] = 0 m[1] = 1 for k := range m { delete(m, k+f()) } if want := 2; x != want { fmt.Printf("var after range with side-effect = %d want %d\n", x, want) os.Exit(1) } var n int m = make(map[int]int) m[0] = 0 m[1] = 1 for k := range m { delete(m, k) n++ } if want := 2; n != want { fmt.Printf("counter for range with side-effect = %d want %d\n", n, want) os.Exit(1) } } func main() { checkcleared() checkloopvars() checksideeffects() }	1.49 KB	2024-02-02 18:09
📄 maplinear.go // run //go:build darwin \|\| linux // 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. // Test that maps don't go quadratic for NaNs and other values. package main import ( "fmt" "math" "time" ) // checkLinear asserts that the running time of f(n) is in O(n). // tries is the initial number of iterations. func checkLinear(typ string, tries int, f func(n int)) { // Depending on the machine and OS, this test might be too fast // to measure with accurate enough granularity. On failure, // make it run longer, hoping that the timing granularity // is eventually sufficient. timeF := func(n int) time.Duration { t1 := time.Now() f(n) return time.Since(t1) } t0 := time.Now() n := tries fails := 0 for { t1 := timeF(n) t2 := timeF(2 * n) // should be 2x (linear); allow up to 3x if t2 < 3t1 { if false { fmt.Println(typ, "\t", time.Since(t0)) } return } // If n ops run in under a second and the ratio // doesn't work out, make n bigger, trying to reduce // the effect that a constant amount of overhead has // on the computed ratio. if t1 < 1time.Second { n = 2 continue } // Once the test runs long enough for n ops, // try to get the right ratio at least once. // If five in a row all fail, give up. if fails++; fails >= 5 { panic(fmt.Sprintf("%s: too slow: %d inserts: %v; %d inserts: %v\n", typ, n, t1, 2n, t2)) } } } type I interface { f() } type C int func (C) f() {} func main() { // NaNs. ~31ms on a 1.6GHz Zeon. checkLinear("NaN", 30000, func(n int) { m := map[float64]int{} nan := math.NaN() for i := 0; i < n; i++ { m[nan] = 1 } if len(m) != n { panic("wrong size map after nan insertion") } }) // ~6ms on a 1.6GHz Zeon. checkLinear("eface", 10000, func(n int) { m := map[interface{}]int{} for i := 0; i < n; i++ { m[i] = 1 } }) // ~7ms on a 1.6GHz Zeon. // Regression test for CL 119360043. checkLinear("iface", 10000, func(n int) { m := map[I]int{} for i := 0; i < n; i++ { m[C(i)] = 1 } }) // ~6ms on a 1.6GHz Zeon. checkLinear("int", 10000, func(n int) { m := map[int]int{} for i := 0; i < n; i++ { m[i] = 1 } }) // ~18ms on a 1.6GHz Zeon. checkLinear("string", 10000, func(n int) { m := map[string]int{} for i := 0; i < n; i++ { m[fmt.Sprint(i)] = 1 } }) // ~6ms on a 1.6GHz Zeon. checkLinear("float32", 10000, func(n int) { m := map[float32]int{} for i := 0; i < n; i++ { m[float32(i)] = 1 } }) // ~6ms on a 1.6GHz Zeon. checkLinear("float64", 10000, func(n int) { m := map[float64]int{} for i := 0; i < n; i++ { m[float64(i)] = 1 } }) // ~22ms on a 1.6GHz Zeon. checkLinear("complex64", 10000, func(n int) { m := map[complex64]int{} for i := 0; i < n; i++ { m[complex(float32(i), float32(i))] = 1 } }) // ~32ms on a 1.6GHz Zeon. checkLinear("complex128", 10000, func(n int) { m := map[complex128]int{} for i := 0; i < n; i++ { m[complex(float64(i), float64(i))] = 1 } }) // ~70ms on a 1.6GHz Zeon. // The iterate/delete idiom currently takes expected // O(n lg n) time. Fortunately, the checkLinear test // leaves enough wiggle room to include n lg n time // (it actually tests for O(n^log_2(3)). // To prevent false positives, average away variation // by doing multiple rounds within a single run. checkLinear("iterdelete", 2500, func(n int) { for round := 0; round < 4; round++ { m := map[int]int{} for i := 0; i < n; i++ { m[i] = i } for i := 0; i < n; i++ { for k := range m { delete(m, k) break } } } }) }	3.62 KB	2024-02-02 18:09
📄 maymorestack.go // run -gcflags=-d=maymorestack=main.mayMoreStack // Copyright 2021 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 the maymorestack testing hook by injecting a hook that counts // how many times it is called and checking that count. package main import "runtime" var count uint32 //go:nosplit func mayMoreStack() { count++ } func main() { const wantCount = 128 anotherFunc(wantCount - 1) // -1 because the call to main already counted if count == 0 { panic("mayMoreStack not called") } else if count != wantCount { println(count, "!=", wantCount) panic("wrong number of calls to mayMoreStack") } } //go:noinline func anotherFunc(n int) { // Trigger a stack growth on at least some calls to // anotherFunc to test that mayMoreStack is called outside the // morestack loop. It's also important that it is called // before (not after) morestack, but that's hard to test. var x [1 << 10]byte if n > 1 { anotherFunc(n - 1) } runtime.KeepAlive(x) }	1.05 KB	2024-02-02 18:09
📄 mergemul.go // runoutput // 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. package main import "fmt" // Check that expressions like (cn + d(n+k)) get correctly merged by // the compiler into (c+d)n + dk (with c+d and dk computed at // compile time). // // The merging is performed by a combination of the multiplication // merge rules // (cn + dn) -> (c+d)n // and the distributive multiplication rules // c * (d+x) -> cd + cx // Generate a MergeTest that looks like this: // // a8, b8 = m1n8 + m2(n8+k), (m1+m2)n8 + m2k // if a8 != b8 { // // print error msg and panic // } func makeMergeAddTest(m1, m2, k int, size string) string { model := " a" + size + ", b" + size model += fmt.Sprintf(" = %%dn%s + %%d(n%s+%%d), (%%d+%%d)n%s + (%%d%%d)", size, size, size) test := fmt.Sprintf(model, m1, m2, k, m1, m2, m2, k) test += fmt.Sprintf(` if a%s != b%s { fmt.Printf("MergeAddTest(%d, %d, %d, %s) failed\n") fmt.Printf("%%d != %%d\n", a%s, b%s) panic("FAIL") } `, size, size, m1, m2, k, size, size, size) return test + "\n" } // Check that expressions like (cn - d(n+k)) get correctly merged by // the compiler into (c-d)n - dk (with c-d and dk computed at // compile time). // // The merging is performed by a combination of the multiplication // merge rules // (cn - dn) -> (c-d)n // and the distributive multiplication rules // c * (d-x) -> cd - cx // Generate a MergeTest that looks like this: // // a8, b8 = m1n8 - m2(n8+k), (m1-m2)n8 - m2k // if a8 != b8 { // // print error msg and panic // } func makeMergeSubTest(m1, m2, k int, size string) string { model := " a" + size + ", b" + size model += fmt.Sprintf(" = %%dn%s - %%d(n%s+%%d), (%%d-%%d)n%s - (%%d%%d)", size, size, size) test := fmt.Sprintf(model, m1, m2, k, m1, m2, m2, k) test += fmt.Sprintf(` if a%s != b%s { fmt.Printf("MergeSubTest(%d, %d, %d, %s) failed\n") fmt.Printf("%%d != %%d\n", a%s, b%s) panic("FAIL") } `, size, size, m1, m2, k, size, size, size) return test + "\n" } func makeAllSizes(m1, m2, k int) string { var tests string tests += makeMergeAddTest(m1, m2, k, "8") tests += makeMergeAddTest(m1, m2, k, "16") tests += makeMergeAddTest(m1, m2, k, "32") tests += makeMergeAddTest(m1, m2, k, "64") tests += makeMergeSubTest(m1, m2, k, "8") tests += makeMergeSubTest(m1, m2, k, "16") tests += makeMergeSubTest(m1, m2, k, "32") tests += makeMergeSubTest(m1, m2, k, "64") tests += "\n" return tests } func main() { fmt.Println(`package main import "fmt" var n8 int8 = 42 var n16 int16 = 42 var n32 int32 = 42 var n64 int64 = 42 func main() { var a8, b8 int8 var a16, b16 int16 var a32, b32 int32 var a64, b64 int64 `) fmt.Println(makeAllSizes(03, 05, 0)) // 3n + 5n fmt.Println(makeAllSizes(17, 33, 0)) fmt.Println(makeAllSizes(80, 45, 0)) fmt.Println(makeAllSizes(32, 64, 0)) fmt.Println(makeAllSizes(7, 11, +1)) // 7n + 11(n+1) fmt.Println(makeAllSizes(9, 13, +2)) fmt.Println(makeAllSizes(11, 16, -1)) fmt.Println(makeAllSizes(17, 9, -2)) fmt.Println("}") }	3.16 KB	2024-02-02 18:09
📄 method.go // run // Copyright 2009 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 simple methods of various types, with pointer and // value receivers. package main type S string type S1 string type I int type I1 int type T struct { x int } type T1 T func (s S) val() int { return 1 } func (s S1) val() int { return 2 } func (i I) val() int { return 3 } func (i I1) val() int { return 4 } func (t T) val() int { return 7 } func (t T1) val() int { return 8 } type Val interface { val() int } func val(v Val) int { return v.val() } func main() { var s S var ps S1 var i I var pi I1 var pt T1 var t T var v Val if s.val() != 1 { println("s.val:", s.val()) panic("fail") } if S.val(s) != 1 { println("S.val(s):", S.val(s)) panic("fail") } if (S).val(&s) != 1 { println("(S).val(s):", (S).val(&s)) panic("fail") } if ps.val() != 2 { println("ps.val:", ps.val()) panic("fail") } if (S1).val(ps) != 2 { println("(S1).val(ps):", (S1).val(ps)) panic("fail") } if i.val() != 3 { println("i.val:", i.val()) panic("fail") } if I.val(i) != 3 { println("I.val(i):", I.val(i)) panic("fail") } if (I).val(&i) != 3 { println("(I).val(&i):", (I).val(&i)) panic("fail") } if pi.val() != 4 { println("pi.val:", pi.val()) panic("fail") } if (I1).val(pi) != 4 { println("(I1).val(pi):", (I1).val(pi)) panic("fail") } if t.val() != 7 { println("t.val:", t.val()) panic("fail") } if pt.val() != 8 { println("pt.val:", pt.val()) panic("fail") } if (T1).val(pt) != 8 { println("(T1).val(pt):", (T1).val(pt)) panic("fail") } if val(s) != 1 { println("val(s):", val(s)) panic("fail") } if val(ps) != 2 { println("val(ps):", val(ps)) panic("fail") } if val(i) != 3 { println("val(i):", val(i)) panic("fail") } if val(pi) != 4 { println("val(pi):", val(pi)) panic("fail") } if val(t) != 7 { println("val(t):", val(t)) panic("fail") } if val(pt) != 8 { println("val(pt):", val(pt)) panic("fail") } if Val.val(i) != 3 { println("Val.val(i):", Val.val(i)) panic("fail") } v = i if Val.val(v) != 3 { println("Val.val(v):", Val.val(v)) panic("fail") } var zs struct{ S } var zps struct{ S1 } var zi struct{ I } var zpi struct{ I1 } var zpt struct{ T1 } var zt struct{ T } var zv struct{ Val } if zs.val() != 1 { println("zs.val:", zs.val()) panic("fail") } if zps.val() != 2 { println("zps.val:", zps.val()) panic("fail") } if zi.val() != 3 { println("zi.val:", zi.val()) panic("fail") } if zpi.val() != 4 { println("zpi.val:", zpi.val()) panic("fail") } if zt.val() != 7 { println("zt.val:", zt.val()) panic("fail") } if zpt.val() != 8 { println("zpt.val:", zpt.val()) panic("fail") } if val(zs) != 1 { println("val(zs):", val(zs)) panic("fail") } if val(zps) != 2 { println("val(zps):", val(zps)) panic("fail") } if val(zi) != 3 { println("val(zi):", val(zi)) panic("fail") } if val(zpi) != 4 { println("val(zpi):", val(zpi)) panic("fail") } if val(zt) != 7 { println("val(zt):", val(zt)) panic("fail") } if val(zpt) != 8 { println("val(zpt):", val(zpt)) panic("fail") } zv.Val = zi if zv.val() != 3 { println("zv.val():", zv.val()) panic("fail") } if (&zs).val() != 1 { println("(&zs).val:", (&zs).val()) panic("fail") } if (&zps).val() != 2 { println("(&zps).val:", (&zps).val()) panic("fail") } if (&zi).val() != 3 { println("(&zi).val:", (&zi).val()) panic("fail") } if (&zpi).val() != 4 { println("(&zpi).val:", (&zpi).val()) panic("fail") } if (&zt).val() != 7 { println("(&zt).val:", (&zt).val()) panic("fail") } if (&zpt).val() != 8 { println("(&zpt).val:", (&zpt).val()) panic("fail") } if val(&zs) != 1 { println("val(&zs):", val(&zs)) panic("fail") } if val(&zps) != 2 { println("val(&zps):", val(&zps)) panic("fail") } if val(&zi) != 3 { println("val(&zi):", val(&zi)) panic("fail") } if val(&zpi) != 4 { println("val(&zpi):", val(&zpi)) panic("fail") } if val(&zt) != 7 { println("val(&zt):", val(&zt)) panic("fail") } if val(&zpt) != 8 { println("val(&zpt):", val(&zpt)) panic("fail") } zv.Val = &zi if zv.val() != 3 { println("zv.val():", zv.val()) panic("fail") } promotion() } type A struct{ B } type B struct { C D } type C int func (C) f() {} // value receiver, direct field of A func (C) g() {} // pointer receiver type D int func (D) h() {} // value receiver, indirect field of A func (*D) i() {} // pointer receiver func expectPanic() { if r := recover(); r == nil { panic("expected nil dereference") } } func promotion() { var a A // Addressable value receiver. a.f() a.g() func() { defer expectPanic() a.h() // dynamic error: nil dereference in a.B.D->f() }() a.i() // Non-addressable value receiver. A(a).f() // A(a).g() // static error: cannot call pointer method on A literal.B.C func() { defer expectPanic() A(a).h() // dynamic error: nil dereference in A().B.D->f() }() A(a).i() // Pointer receiver. (&a).f() (&a).g() func() { defer expectPanic() (&a).h() // dynamic error: nil deref: nil dereference in (&a).B.D->f() }() (&a).i() c := new(C) c.f() // makes a copy c.g() }	5.24 KB	2024-02-02 18:09
📄 method1.go // errorcheck // Copyright 2009 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. // Verify that method redeclarations are caught by the compiler. // Does not compile. package main type T struct{} func (t T) M(int, string) // GCCGO_ERROR "previous" func (t T) M(int, float64) {} // ERROR "already declared\|redefinition" func (t T) H() // GCCGO_ERROR "previous" func (t *T) H() {} // ERROR "already declared\|redefinition" func f(int, string) // GCCGO_ERROR "previous" func f(int, float64) {} // ERROR "redeclared\|redefinition" func g(a int, b string) // GCCGO_ERROR "previous" func g(a int, c string) // ERROR "redeclared\|redefinition"	739 B	2024-02-02 18:09
📄 method2.go // errorcheck // Copyright 2009 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. // Verify that pointers and interface types cannot be method receivers. // Does not compile. package main type T struct { a int } type P T type P1 T func (p P) val() int { return 1 } // ERROR "receiver.* pointer\|invalid pointer or interface receiver\|invalid receiver" func (p P1) val() int { return 1 } // ERROR "receiver. pointer\|invalid pointer or interface receiver\|invalid receiver" type I interface{} type I1 interface{} func (p I) val() int { return 1 } // ERROR "receiver.interface\|invalid pointer or interface receiver" func (p I1) val() int { return 1 } // ERROR "receiver.interface\|invalid pointer or interface receiver" type Val interface { val() int } var _ = (Val).val // ERROR "method\|type \Val is pointer to interface, not interface" var v Val var pv = &v var _ = pv.val() // ERROR "undefined\|pointer to interface" var _ = pv.val // ERROR "undefined\|pointer to interface" func (t T) g() int { return t.a } var _ = (T).g() // ERROR "needs pointer receiver\|undefined\|method requires pointer\|cannot call pointer method"	1.21 KB	2024-02-02 18:09
📄 method3.go // run // Copyright 2009 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 methods on slices. package main type T []int func (t T) Len() int { return len(t) } type I interface { Len() int } func main() { var t T = T{0, 1, 2, 3, 4} var i I i = t if i.Len() != 5 { println("i.Len", i.Len()) panic("fail") } if T.Len(t) != 5 { println("T.Len", T.Len(t)) panic("fail") } if (T).Len(&t) != 5 { println("(T).Len", (*T).Len(&t)) panic("fail") } }	570 B	2024-02-02 18:09
📁 method4.dir	-	2024-02-02 18:09
📄 method4.go // rundir // 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. // Test method expressions with arguments. package ignored	230 B	2024-02-02 18:09
📄 method5.go // run // 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. package main // Concrete types implementing M method. // Smaller than a word, word-sized, larger than a word. // Value and pointer receivers. type Tinter interface { M(int, byte) (byte, int) } type Tsmallv byte func (v Tsmallv) M(x int, b byte) (byte, int) { return b, x+int(v) } type Tsmallp byte func (p Tsmallp) M(x int, b byte) (byte, int) { return b, x+int(p) } type Twordv uintptr func (v Twordv) M(x int, b byte) (byte, int) { return b, x+int(v) } type Twordp uintptr func (p Twordp) M(x int, b byte) (byte, int) { return b, x+int(p) } type Tbigv [2]uintptr func (v Tbigv) M(x int, b byte) (byte, int) { return b, x+int(v[0])+int(v[1]) } type Tbigp [2]uintptr func (p Tbigp) M(x int, b byte) (byte, int) { return b, x+int(p[0])+int(p[1]) } // Again, with an unexported method. type tsmallv byte func (v tsmallv) m(x int, b byte) (byte, int) { return b, x+int(v) } type tsmallp byte func (p tsmallp) m(x int, b byte) (byte, int) { return b, x+int(p) } type twordv uintptr func (v twordv) m(x int, b byte) (byte, int) { return b, x+int(v) } type twordp uintptr func (p twordp) m(x int, b byte) (byte, int) { return b, x+int(p) } type tbigv [2]uintptr func (v tbigv) m(x int, b byte) (byte, int) { return b, x+int(v[0])+int(v[1]) } type tbigp [2]uintptr func (p tbigp) m(x int, b byte) (byte, int) { return b, x+int(p[0])+int(p[1]) } type tinter interface { m(int, byte) (byte, int) } // Embedding via pointer. type T1 struct { T2 } type T2 struct { T3 } type T3 struct { T4 } type T4 struct { } func (t4 T4) M(x int, b byte) (byte, int) { return b, x+40 } var failed = false func CheckI(name string, i Tinter, inc int) { b, x := i.M(1000, 99) if b != 99 \|\| x != 1000+inc { failed = true print(name, ".M(1000, 99) = ", b, ", ", x, " want 99, ", 1000+inc, "\n") } CheckF("(i="+name+")", i.M, inc) } func CheckF(name string, f func(int, byte) (byte, int), inc int) { b, x := f(1000, 99) if b != 99 \|\| x != 1000+inc { failed = true print(name, "(1000, 99) = ", b, ", ", x, " want 99, ", 1000+inc, "\n") } } func checkI(name string, i tinter, inc int) { b, x := i.m(1000, 99) if b != 99 \|\| x != 1000+inc { failed = true print(name, ".m(1000, 99) = ", b, ", ", x, " want 99, ", 1000+inc, "\n") } checkF("(i="+name+")", i.m, inc) } func checkF(name string, f func(int, byte) (byte, int), inc int) { b, x := f(1000, 99) if b != 99 \|\| x != 1000+inc { failed = true print(name, "(1000, 99) = ", b, ", ", x, " want 99, ", 1000+inc, "\n") } } func shouldPanic(f func()) { defer func() { if recover() == nil { panic("not panicking") } }() f() } func shouldNotPanic(f func()) { f() } func main() { sv := Tsmallv(1) CheckI("sv", sv, 1) CheckF("sv.M", sv.M, 1) CheckF("(&sv).M", (&sv).M, 1) psv := &sv CheckI("psv", psv, 1) CheckF("psv.M", psv.M, 1) CheckF("(psv).M", (psv).M, 1) sp := Tsmallp(2) CheckI("&sp", &sp, 2) CheckF("sp.M", sp.M, 2) CheckF("(&sp).M", (&sp).M, 2) psp := &sp CheckI("psp", psp, 2) CheckF("psp.M", psp.M, 2) CheckF("(psp).M", (psp).M, 2) wv := Twordv(3) CheckI("wv", wv, 3) CheckF("wv.M", wv.M, 3) CheckF("(&wv).M", (&wv).M, 3) pwv := &wv CheckI("pwv", pwv, 3) CheckF("pwv.M", pwv.M, 3) CheckF("(pwv).M", (pwv).M, 3) wp := Twordp(4) CheckI("&wp", &wp, 4) CheckF("wp.M", wp.M, 4) CheckF("(&wp).M", (&wp).M, 4) pwp := &wp CheckI("pwp", pwp, 4) CheckF("pwp.M", pwp.M, 4) CheckF("(pwp).M", (pwp).M, 4) bv := Tbigv([2]uintptr{5, 6}) pbv := &bv CheckI("bv", bv, 11) CheckF("bv.M", bv.M, 11) CheckF("(&bv).M", (&bv).M, 11) CheckI("pbv", pbv, 11) CheckF("pbv.M", pbv.M, 11) CheckF("(pbv).M", (pbv).M, 11) bp := Tbigp([2]uintptr{7,8}) CheckI("&bp", &bp, 15) CheckF("bp.M", bp.M, 15) CheckF("(&bp).M", (&bp).M, 15) pbp := &bp CheckI("pbp", pbp, 15) CheckF("pbp.M", pbp.M, 15) CheckF("(pbp).M", (pbp).M, 15) _sv := tsmallv(1) checkI("_sv", _sv, 1) checkF("_sv.m", _sv.m, 1) checkF("(&_sv).m", (&_sv).m, 1) _psv := &_sv checkI("_psv", _psv, 1) checkF("_psv.m", _psv.m, 1) checkF("(_psv).m", (_psv).m, 1) _sp := tsmallp(2) checkI("&_sp", &_sp, 2) checkF("_sp.m", _sp.m, 2) checkF("(&_sp).m", (&_sp).m, 2) _psp := &_sp checkI("_psp", _psp, 2) checkF("_psp.m", _psp.m, 2) checkF("(_psp).m", (_psp).m, 2) _wv := twordv(3) checkI("_wv", _wv, 3) checkF("_wv.m", _wv.m, 3) checkF("(&_wv).m", (&_wv).m, 3) _pwv := &_wv checkI("_pwv", _pwv, 3) checkF("_pwv.m", _pwv.m, 3) checkF("(_pwv).m", (_pwv).m, 3) _wp := twordp(4) checkI("&_wp", &_wp, 4) checkF("_wp.m", _wp.m, 4) checkF("(&_wp).m", (&_wp).m, 4) _pwp := &_wp checkI("_pwp", _pwp, 4) checkF("_pwp.m", _pwp.m, 4) checkF("(_pwp).m", (_pwp).m, 4) _bv := tbigv([2]uintptr{5, 6}) _pbv := &_bv checkI("_bv", _bv, 11) checkF("_bv.m", _bv.m, 11) checkF("(&_bv).m", (&_bv).m, 11) checkI("_pbv", _pbv, 11) checkF("_pbv.m", _pbv.m, 11) checkF("(_pbv).m", (_pbv).m, 11) _bp := tbigp([2]uintptr{7,8}) checkI("&_bp", &_bp, 15) checkF("_bp.m", _bp.m, 15) checkF("(&_bp).m", (&_bp).m, 15) _pbp := &_bp checkI("_pbp", _pbp, 15) checkF("_pbp.m", _pbp.m, 15) checkF("(_pbp).m", (_pbp).m, 15) t4 := T4{} t3 := T3{&t4} t2 := T2{&t3} t1 := T1{t2} CheckI("t4", t4, 40) CheckI("&t4", &t4, 40) CheckI("t3", t3, 40) CheckI("&t3", &t3, 40) CheckI("t2", t2, 40) CheckI("&t2", &t2, 40) CheckI("t1", t1, 40) CheckI("&t1", &t1, 40) // x.M panics if x is an interface type and is nil, // or if x.M expands to (x).M where x is nil, // or if x.M expands to x.y.z.w.M where something // along the evaluation of x.y.z.w is nil. var f func(int, byte) (byte, int) shouldPanic(func() { psv = nil; f = psv.M }) shouldPanic(func() { pwv = nil; f = pwv.M }) shouldPanic(func() { pbv = nil; f = pbv.M }) shouldPanic(func() { var i Tinter; f = i.M }) shouldPanic(func() { _psv = nil; f = _psv.m }) shouldPanic(func() { _pwv = nil; f = _pwv.m }) shouldPanic(func() { _pbv = nil; f = _pbv.m }) shouldPanic(func() { var _i tinter; f = _i.m }) shouldPanic(func() { var t1 T1; f = t1.M }) shouldPanic(func() { var t2 T2; f = t2.M }) shouldPanic(func() { var t3 T3; f = t3.M }) shouldPanic(func() { var t3 T3; f = t3.M }) if f != nil { panic("something set f") } // x.M does not panic if x is a nil pointer and // M is a method with a pointer receiver. shouldNotPanic(func() { psp = nil; f = psp.M }) shouldNotPanic(func() { pwp = nil; f = pwp.M }) shouldNotPanic(func() { pbp = nil; f = pbp.M }) shouldNotPanic(func() { _psp = nil; f = _psp.m }) shouldNotPanic(func() { _pwp = nil; f = _pwp.m }) shouldNotPanic(func() { _pbp = nil; f = _pbp.m }) shouldNotPanic(func() { var t4 T4; f = t4.M }) if f == nil { panic("nothing set f") } }	6.73 KB	2024-02-02 18:09
📄 method6.go // 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. // Verify that pointer method calls are caught during typechecking. // Reproducer extracted and adapted from method.go package foo type A struct { B } type B int func (B) g() {} var _ = func() { var a A A(a).g() // ERROR "cannot call pointer method .on\|cannot take the address of" }	467 B	2024-02-02 18:09
📄 method7.go // 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 forms of method expressions T.m where T is // a literal type. package main var got, want string type I interface { m() } type S struct { } func (S) m() { got += " m()" } func (S) m1(s string) { got += " m1(" + s + ")" } type T int func (T) m2() { got += " m2()" } type Outer struct{ Inner } type Inner struct{ s string } func (i Inner) M() string { return i.s } func main() { // method expressions with named receiver types I.m(S{}) want += " m()" S.m1(S{}, "a") want += " m1(a)" // method expressions with literal receiver types f := interface{ m1(string) }.m1 f(S{}, "b") want += " m1(b)" interface{ m1(string) }.m1(S{}, "c") want += " m1(c)" x := S{} interface{ m1(string) }.m1(x, "d") want += " m1(d)" g := struct{ T }.m2 g(struct{ T }{}) want += " m2()" if got != want { panic("got" + got + ", want" + want) } h := (Outer).M got := h(&Outer{&Inner{"hello"}}) want := "hello" if got != want { panic("got " + got + ", want " + want) } }	1.15 KB	2024-02-02 18:09
📄 named.go // run // Copyright 2009 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 that basic operations on named types are valid // and preserve the type. package main type Array [10]byte type Bool bool type Chan chan int type Float float32 type Int int type Map map[int]byte type Slice []byte type String string // Calling these functions checks at compile time that the argument // can be converted implicitly to (used as) the given type. func asArray(Array) {} func asBool(Bool) {} func asChan(Chan) {} func asFloat(Float) {} func asInt(Int) {} func asMap(Map) {} func asSlice(Slice) {} func asString(String) {} func (Map) M() {} // These functions check at run time that the default type // (in the absence of any implicit conversion hints) // is the given type. func isArray(x interface{}) { _ = x.(Array) } func isBool(x interface{}) { _ = x.(Bool) } func isChan(x interface{}) { _ = x.(Chan) } func isFloat(x interface{}) { _ = x.(Float) } func isInt(x interface{}) { _ = x.(Int) } func isMap(x interface{}) { _ = x.(Map) } func isSlice(x interface{}) { _ = x.(Slice) } func isString(x interface{}) { _ = x.(String) } func main() { var ( a Array b Bool = true c Chan = make(Chan) f Float = 1 i Int = 1 m Map = make(Map) slice Slice = make(Slice, 10) str String = "hello" ) asArray(a) isArray(a) asArray(&a) isArray(&a) asArray(Array{}) isArray(Array{}) asBool(b) isBool(b) asBool(!b) isBool(!b) asBool(true) asBool(&b) isBool(&b) asBool(Bool(true)) isBool(Bool(true)) asChan(c) isChan(c) asChan(make(Chan)) isChan(make(Chan)) asChan(&c) isChan(&c) asChan(Chan(nil)) isChan(Chan(nil)) asFloat(f) isFloat(f) asFloat(-f) isFloat(-f) asFloat(+f) isFloat(+f) asFloat(f + 1) isFloat(f + 1) asFloat(1 + f) isFloat(1 + f) asFloat(f + f) isFloat(f + f) f++ f += 2 asFloat(f - 1) isFloat(f - 1) asFloat(1 - f) isFloat(1 - f) asFloat(f - f) isFloat(f - f) f-- f -= 2 asFloat(f * 2.5) isFloat(f * 2.5) asFloat(2.5 * f) isFloat(2.5 * f) asFloat(f * f) isFloat(f * f) f = 4 asFloat(f / 2.5) isFloat(f / 2.5) asFloat(2.5 / f) isFloat(2.5 / f) asFloat(f / f) isFloat(f / f) f /= 4 asFloat(f) isFloat(f) f = 5 asFloat(&f) isFloat(&f) asFloat(234) asFloat(Float(234)) isFloat(Float(234)) asFloat(1.2) asFloat(Float(i)) isFloat(Float(i)) asInt(i) isInt(i) asInt(-i) isInt(-i) asInt(^i) isInt(^i) asInt(+i) isInt(+i) asInt(i + 1) isInt(i + 1) asInt(1 + i) isInt(1 + i) asInt(i + i) isInt(i + i) i++ i += 1 asInt(i - 1) isInt(i - 1) asInt(1 - i) isInt(1 - i) asInt(i - i) isInt(i - i) i-- i -= 1 asInt(i 2) isInt(i * 2) asInt(2 * i) isInt(2 * i) asInt(i * i) isInt(i * i) i = 2 asInt(i / 5) isInt(i / 5) asInt(5 / i) isInt(5 / i) asInt(i / i) isInt(i / i) i /= 2 asInt(i % 5) isInt(i % 5) asInt(5 % i) isInt(5 % i) asInt(i % i) isInt(i % i) i %= 2 asInt(i & 5) isInt(i & 5) asInt(5 & i) isInt(5 & i) asInt(i & i) isInt(i & i) i &= 2 asInt(i &^ 5) isInt(i &^ 5) asInt(5 &^ i) isInt(5 &^ i) asInt(i &^ i) isInt(i &^ i) i &^= 2 asInt(i \| 5) isInt(i \| 5) asInt(5 \| i) isInt(5 \| i) asInt(i \| i) isInt(i \| i) i \|= 2 asInt(i ^ 5) isInt(i ^ 5) asInt(5 ^ i) isInt(5 ^ i) asInt(i ^ i) isInt(i ^ i) i ^= 2 asInt(i << 4) isInt(i << 4) i <<= 2 asInt(i >> 4) isInt(i >> 4) i >>= 2 asInt(i) isInt(i) asInt(0) asInt(Int(0)) isInt(Int(0)) i = 10 asInt(&i) isInt(&i) asInt(23) asInt(Int(f)) isInt(Int(f)) asMap(m) isMap(m) asMap(nil) m = nil asMap(make(Map)) isMap(make(Map)) asMap(&m) isMap(&m) asMap(Map(nil)) isMap(Map(nil)) asMap(Map{}) isMap(Map{}) asSlice(slice) isSlice(slice) asSlice(make(Slice, 5)) isSlice(make(Slice, 5)) asSlice([]byte{1, 2, 3}) asSlice([]byte{1, 2, 3}[0:2]) asSlice(slice[0:4]) isSlice(slice[0:4]) asSlice(slice[3:8]) isSlice(slice[3:8]) asSlice(nil) asSlice(Slice(nil)) isSlice(Slice(nil)) slice = nil asSlice(Slice{1, 2, 3}) isSlice(Slice{1, 2, 3}) asSlice(Slice{}) isSlice(Slice{}) asSlice(&slice) isSlice(&slice) asString(str) isString(str) asString(str + "a") isString(str + "a") asString("a" + str) isString("a" + str) asString(str + str) isString(str + str) str += "a" str += str asString(String('a')) isString(String('a')) asString(String([]byte(slice))) isString(String([]byte(slice))) asString(String([]byte(nil))) isString(String([]byte(nil))) asString("hello") asString(String("hello")) isString(String("hello")) str = "hello" isString(str) asString(&str) isString(*&str) }	4.61 KB	2024-02-02 18:09
📄 named1.go // errorcheck // Copyright 2009 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 that basic operations on named types are valid // and preserve the type. // Does not compile. package main type Bool bool type Map map[int]int func (Map) M() {} type Slice []byte var slice Slice func asBool(Bool) {} func asString(String) {} type String string func main() { var ( b Bool = true i, j int c = make(chan int) m = make(Map) ) asBool(b) asBool(!b) asBool(true) asBool(&b) asBool(Bool(true)) asBool(1 != 2) // ok now asBool(i < j) // ok now _, b = m[2] // ok now var inter interface{} _, b = inter.(Map) // ok now _ = b var minter interface { M() } _, b = minter.(Map) // ok now _ = b _, bb := <-c asBool(bb) // ERROR "cannot use.type bool.*as type Bool\|cannot use bb" _, b = <-c // ok now _ = b asString(String(slice)) // ok }	984 B	2024-02-02 18:09
📄 newinline.go // errorcheckwithauto -0 -m -d=inlfuncswithclosures=1 //go:build goexperiment.newinliner // Copyright 2023 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, using compiler diagnostic flags, that inlining is working. // Compiles but does not run. package foo import ( "errors" "runtime" "unsafe" ) func add2(p byte, n uintptr) byte { // ERROR "can inline add2" "leaking param: p to result" return (byte)(add1(unsafe.Pointer(p), n)) // ERROR "inlining call to add1" } func add1(p unsafe.Pointer, x uintptr) unsafe.Pointer { // ERROR "can inline add1" "leaking param: p to result" return unsafe.Pointer(uintptr(p) + x) } func f(x byte) byte { // ERROR "can inline f" "leaking param: x to result" return add2(x, 1) // ERROR "inlining call to add2" "inlining call to add1" } //go:noinline func g(x int) int { return x + 1 } func h(x int) int { // ERROR "can inline h" return x + 2 } func i(x int) int { // ERROR "can inline i" const y = 2 return x + y } func j(x int) int { // ERROR "can inline j" switch { case x > 0: return x + 2 default: return x + 1 } } func f2() int { // ERROR "can inline f2" tmp1 := h tmp2 := tmp1 return tmp2(0) // ERROR "inlining call to h" } var abc = errors.New("abc") // ERROR "inlining call to errors.New" var somethingWrong error // local closures can be inlined func l(x, y int) (int, int, error) { // ERROR "can inline l" e := func(err error) (int, int, error) { // ERROR "can inline l.func1" "func literal does not escape" "leaking param: err to result" return 0, 0, err } if x == y { e(somethingWrong) // ERROR "inlining call to l.func1" } else { f := e f(nil) // ERROR "inlining call to l.func1" } return y, x, nil } // any re-assignment prevents closure inlining func m() int { foo := func() int { return 1 } // ERROR "can inline m.func1" "func literal does not escape" x := foo() foo = func() int { return 2 } // ERROR "can inline m.func2" "func literal does not escape" return x + foo() } // address taking prevents closure inlining func n() int { // ERROR "can inline n" foo := func() int { return 1 } // ERROR "can inline n.func1" "func literal does not escape" bar := &foo x := (bar)() + foo() return x } // make sure assignment inside closure is detected func o() int { // ERROR "can inline o" foo := func() int { return 1 } // ERROR "can inline o.func1" "func literal does not escape" func(x int) { // ERROR "can inline o.func2" if x > 10 { foo = func() int { return 2 } // ERROR "can inline o.func2" } }(11) // ERROR "func literal does not escape" "inlining call to o.func2" return foo() } func p() int { // ERROR "can inline p" return func() int { return 42 }() // ERROR "can inline p.func1" "inlining call to p.func1" } func q(x int) int { // ERROR "can inline q" foo := func() int { return x * 2 } // ERROR "can inline q.func1" "func literal does not escape" return foo() // ERROR "inlining call to q.func1" } func r(z int) int { // ERROR "can inline r" foo := func(x int) int { // ERROR "can inline r.func1" "func literal does not escape" return x + z } bar := func(x int) int { // ERROR "func literal does not escape" "can inline r.func2" return x + func(y int) int { // ERROR "can inline r.func2.1" "can inline r.r.func2.func3" return 2y + xz }(x) // ERROR "inlining call to r.func2.1" } return foo(42) + bar(42) // ERROR "inlining call to r.func1" "inlining call to r.func2" "inlining call to r.r.func2.func3" } func s0(x int) int { // ERROR "can inline s0" foo := func() { // ERROR "can inline s0.func1" "func literal does not escape" x = x + 1 } foo() // ERROR "inlining call to s0.func1" return x } func s1(x int) int { // ERROR "can inline s1" foo := func() int { // ERROR "can inline s1.func1" "func literal does not escape" return x } x = x + 1 return foo() // ERROR "inlining call to s1.func1" } func switchBreak(x, y int) int { // ERROR "can inline switchBreak" var n int switch x { case 0: n = 1 Done: switch y { case 0: n += 10 break Done } n = 2 } return n } func switchType(x interface{}) int { // ERROR "can inline switchType" "x does not escape" switch x.(type) { case int: return x.(int) default: return 0 } } // Test that switches on constant things, with constant cases, only cost anything for // the case that matches. See issue 50253. func switchConst1(p func(string)) { // ERROR "can inline switchConst" "p does not escape" const c = 1 switch c { case 0: p("zero") case 1: p("one") case 2: p("two") default: p("other") } } func switchConst2() string { // ERROR "can inline switchConst2" switch runtime.GOOS { case "linux": return "Leenooks" case "windows": return "Windoze" case "darwin": return "MackBone" case "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "30", "31", "32", "33", "34", "35", "36", "37", "38", "39", "40", "41", "42", "43", "44", "45", "46", "47", "48", "49", "50", "51", "52", "53", "54", "55", "56", "57", "58", "59", "60", "61", "62", "63", "64", "65", "66", "67", "68", "69", "70", "71", "72", "73", "74", "75", "76", "77", "78", "79", "80", "81", "82", "83", "84", "85", "86", "87", "88", "89", "90", "91", "92", "93", "94", "95", "96", "97", "98", "99", "100": return "Numbers" default: return "oh nose!" } } func switchConst3() string { // ERROR "can inline switchConst3" switch runtime.GOOS { case "Linux": panic("Linux") case "Windows": panic("Windows") case "Darwin": panic("Darwin") case "1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "30", "31", "32", "33", "34", "35", "36", "37", "38", "39", "40", "41", "42", "43", "44", "45", "46", "47", "48", "49", "50", "51", "52", "53", "54", "55", "56", "57", "58", "59", "60", "61", "62", "63", "64", "65", "66", "67", "68", "69", "70", "71", "72", "73", "74", "75", "76", "77", "78", "79", "80", "81", "82", "83", "84", "85", "86", "87", "88", "89", "90", "91", "92", "93", "94", "95", "96", "97", "98", "99", "100": panic("Numbers") default: return "oh nose!" } } func switchConst4() { // ERROR "can inline switchConst4" const intSize = 32 << (^uint(0) >> 63) want := func() string { // ERROR "can inline switchConst4.func1" switch intSize { case 32: return "32" case 64: return "64" default: panic("unreachable") } }() // ERROR "inlining call to switchConst4.func1" _ = want } func inlineRangeIntoMe(data []int) { // ERROR "can inline inlineRangeIntoMe" "data does not escape" rangeFunc(data, 12) // ERROR "inlining call to rangeFunc" } func rangeFunc(xs []int, b int) int { // ERROR "can inline rangeFunc" "xs does not escape" for i, x := range xs { if x == b { return i } } return -1 } type T struct{} func (T) meth(int, int) {} // ERROR "can inline T.meth" func k() (T, int, int) { return T{}, 0, 0 } // ERROR "can inline k" func f3() { // ERROR "can inline f3" T.meth(k()) // ERROR "inlining call to k" "inlining call to T.meth" // ERRORAUTO "inlining call to T.meth" } func small1() { // ERROR "can inline small1" runtime.GC() } func small2() int { // ERROR "can inline small2" return runtime.GOMAXPROCS(0) } func small3(t T) { // ERROR "can inline small3" t.meth2(3, 5) } func small4(t T) { // ERROR "can inline small4" t.meth2(runtime.GOMAXPROCS(0), 5) } func (T) meth2(int, int) { // ERROR "can inline T.meth2" runtime.GC() runtime.GC() } // Issue #29737 - make sure we can do inlining for a chain of recursive functions func ee() { // ERROR "can inline ee" ff(100) // ERROR "inlining call to ff" "inlining call to gg" "inlining call to hh" } func ff(x int) { // ERROR "can inline ff" if x < 0 { return } gg(x - 1) // ERROR "inlining call to gg" "inlining call to hh" } func gg(x int) { // ERROR "can inline gg" hh(x - 1) // ERROR "inlining call to hh" "inlining call to ff" } func hh(x int) { // ERROR "can inline hh" ff(x - 1) // ERROR "inlining call to ff" "inlining call to gg" } // Issue #14768 - make sure we can inline for loops. func for1(fn func() bool) { // ERROR "can inline for1" "fn does not escape" for { if fn() { break } else { continue } } } func for2(fn func() bool) { // ERROR "can inline for2" "fn does not escape" Loop: for { if fn() { break Loop } else { continue Loop } } } // Issue #18493 - make sure we can do inlining of functions with a method value type T1 struct{} func (a T1) meth(val int) int { // ERROR "can inline T1.meth" return val + 5 } func getMeth(t1 T1) func(int) int { // ERROR "can inline getMeth" return t1.meth // ERROR "t1.meth escapes to heap" // ERRORAUTO "inlining call to T1.meth" } func ii() { // ERROR "can inline ii" var t1 T1 f := getMeth(t1) // ERROR "inlining call to getMeth" "t1.meth does not escape" _ = f(3) } // Issue #42194 - make sure that functions evaluated in // go and defer statements can be inlined. func gd1(int) { defer gd1(gd2()) // ERROR "inlining call to gd2" "can inline gd1.deferwrap1" defer gd3()() // ERROR "inlining call to gd3" go gd1(gd2()) // ERROR "inlining call to gd2" "can inline gd1.gowrap2" go gd3()() // ERROR "inlining call to gd3" } func gd2() int { // ERROR "can inline gd2" return 1 } func gd3() func() { // ERROR "can inline gd3" return ii } // Issue #42788 - ensure ODEREF OCONVNOP* OADDR is low cost. func EncodeQuad(d []uint32, x [6]float32) { // ERROR "can inline EncodeQuad" "d does not escape" _ = d[:6] d[0] = float32bits(x[0]) // ERROR "inlining call to float32bits" d[1] = float32bits(x[1]) // ERROR "inlining call to float32bits" d[2] = float32bits(x[2]) // ERROR "inlining call to float32bits" d[3] = float32bits(x[3]) // ERROR "inlining call to float32bits" d[4] = float32bits(x[4]) // ERROR "inlining call to float32bits" d[5] = float32bits(x[5]) // ERROR "inlining call to float32bits" } // float32bits is a copy of math.Float32bits to ensure that // these tests pass with `-gcflags=-l`. func float32bits(f float32) uint32 { // ERROR "can inline float32bits" return (uint32)(unsafe.Pointer(&f)) } // Ensure OCONVNOP is zero cost. func Conv(v uint64) uint64 { // ERROR "can inline Conv" return conv2(conv2(conv2(v))) // ERROR "inlining call to (conv1\|conv2)" } func conv2(v uint64) uint64 { // ERROR "can inline conv2" return conv1(conv1(conv1(conv1(v)))) // ERROR "inlining call to conv1" } func conv1(v uint64) uint64 { // ERROR "can inline conv1" return uint64(uint64(uint64(uint64(uint64(uint64(uint64(uint64(uint64(uint64(uint64(v))))))))))) } func select1(x, y chan bool) int { // ERROR "can inline select1" "x does not escape" "y does not escape" select { case <-x: return 1 case <-y: return 2 } } func select2(x, y chan bool) { // ERROR "can inline select2" "x does not escape" "y does not escape" loop: // test that labeled select can be inlined. select { case <-x: break loop case <-y: } } func inlineSelect2(x, y chan bool) { // ERROR "can inline inlineSelect2" ERROR "x does not escape" "y does not escape" loop: for i := 0; i < 5; i++ { if i == 3 { break loop } select2(x, y) // ERROR "inlining call to select2" } }	11.16 KB	2024-02-02 18:09
📄 nil.go // run // Copyright 2009 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 nil. package main import ( "fmt" "time" ) type T struct { i int } type IN interface{} func main() { var i int var f float32 var s string var m map[float32]int var c chan int var t T var in IN var ta []IN i = nil f = nil s = nil m = nil c = nil t = nil i = nil ta = make([]IN, 1) ta[0] = nil _, _, _, _, _, _, _, _ = i, f, s, m, c, t, in, ta arraytest() chantest() maptest() slicetest() } func shouldPanic(f func()) { defer func() { if recover() == nil { panic("not panicking") } }() f() } func shouldBlock(f func()) { go func() { f() panic("did not block") }() time.Sleep(1e7) } // nil array pointer func arraytest() { var p [10]int // Looping over indices is fine. s := 0 for i := range p { s += i } if s != 45 { panic(s) } s = 0 for i := 0; i < len(p); i++ { s += i } if s != 45 { panic(s) } // Looping over values is not. shouldPanic(func() { for i, v := range p { s += i + v } }) shouldPanic(func() { for i := 0; i < len(p); i++ { s += p[i] } }) } // nil channel // select tests already handle select on nil channel func chantest() { var ch chan int // nil channel is never ready shouldBlock(func() { ch <- 1 }) shouldBlock(func() { <-ch }) shouldBlock(func() { x, ok := <-ch println(x, ok) // unreachable }) if len(ch) != 0 { panic(len(ch)) } if cap(ch) != 0 { panic(cap(ch)) } } // nil map func maptest() { var m map[int]int // nil map appears empty if len(m) != 0 { panic(len(m)) } if m[1] != 0 { panic(m[1]) } if x, ok := m[1]; x != 0 \|\| ok { panic(fmt.Sprint(x, ok)) } for k, v := range m { panic(k) panic(v) } // can delete (non-existent) entries delete(m, 2) // but cannot be written to shouldPanic(func() { m[2] = 3 }) } // nil slice func slicetest() { var x []int // nil slice is just a 0-element slice. if len(x) != 0 { panic(len(x)) } if cap(x) != 0 { panic(cap(x)) } // no 0-element slices can be read from or written to var s int shouldPanic(func() { s += x[1] }) shouldPanic(func() { x[2] = s }) }	2.23 KB	2024-02-02 18:09
📄 nilcheck.go // errorcheck -0 -N -d=nil // 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. // Test that nil checks are inserted. // Optimization is disabled, so redundant checks are not removed. package p type Struct struct { X int Y float64 } type BigStruct struct { X int Y float64 A [1 << 20]int Z string } type Empty struct { } type Empty1 struct { Empty } var ( intp int arrayp [10]int array0p [0]int bigarrayp [1 << 26]int structp Struct bigstructp BigStruct emptyp Empty empty1p Empty1 ) func f1() { _ = intp // ERROR "nil check" _ = arrayp // ERROR "nil check" _ = array0p // ERROR "nil check" _ = array0p // ERROR "nil check" _ = intp // ERROR "nil check" _ = arrayp // ERROR "nil check" _ = structp // ERROR "nil check" _ = emptyp // ERROR "nil check" _ = arrayp // ERROR "nil check" } func f2() { var ( intp int arrayp [10]int array0p [0]int bigarrayp [1 << 20]int structp Struct bigstructp BigStruct emptyp Empty empty1p Empty1 ) _ = intp // ERROR "nil check" _ = arrayp // ERROR "nil check" _ = array0p // ERROR "nil check" _ = array0p // ERROR "nil check" _ = intp // ERROR "nil check" _ = arrayp // ERROR "nil check" _ = structp // ERROR "nil check" _ = emptyp // ERROR "nil check" _ = arrayp // ERROR "nil check" _ = bigarrayp // ERROR "nil check" _ = bigstructp // ERROR "nil check" _ = empty1p // ERROR "nil check" } func fx10k() [10000]int var b bool func f3(x [10000]int) { // Using a huge type and huge offsets so the compiler // does not expect the memory hardware to fault. _ = x[9999] // ERROR "nil check" for { if x[9999] != 0 { // ERROR "nil check" break } } x = fx10k() _ = x[9999] // ERROR "nil check" if b { _ = x[9999] // ERROR "nil check" } else { _ = x[9999] // ERROR "nil check" } _ = x[9999] // ERROR "nil check" x = fx10k() if b { _ = x[9999] // ERROR "nil check" } else { _ = x[9999] // ERROR "nil check" } _ = x[9999] // ERROR "nil check" fx10k() // This one is a bit redundant, if we figured out that // x wasn't going to change across the function call. // But it's a little complex to do and in practice doesn't // matter enough. _ = x[9999] // ERROR "nil check" } func f3a() { x := fx10k() y := fx10k() z := fx10k() _ = &x[9] // ERROR "nil check" y = z _ = &x[9] // ERROR "nil check" x = y _ = &x[9] // ERROR "nil check" } func f3b() { x := fx10k() y := fx10k() _ = &x[9] // ERROR "nil check" y = x _ = &x[9] // ERROR "nil check" x = y _ = &x[9] // ERROR "nil check" } func fx10() [10]int func f4(x *[10]int) { // Most of these have no checks because a real memory reference follows, // and the offset is small enough that if x is nil, the address will still be // in the first unmapped page of memory. _ = x[9] // ERROR "nil check" for { if x[9] != 0 { // ERROR "nil check" break } } x = fx10() _ = x[9] // ERROR "nil check" if b { _ = x[9] // ERROR "nil check" } else { _ = x[9] // ERROR "nil check" } _ = x[9] // ERROR "nil check" x = fx10() if b { _ = x[9] // ERROR "nil check" } else { _ = &x[9] // ERROR "nil check" } _ = x[9] // ERROR "nil check" fx10() _ = x[9] // ERROR "nil check" x = fx10() y := fx10() _ = &x[9] // ERROR "nil check" y = x _ = &x[9] // ERROR "nil check" x = y _ = &x[9] // ERROR "nil check" } func f5(m map[string]struct{}) bool { // Existence-only map lookups should not generate a nil check tmp1, tmp2 := m[""] // ERROR "removed nil check" _, ok := tmp1, tmp2 return ok }	3.67 KB	2024-02-02 18:09
📄 nilptr.go // run // 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. // Test that the implementation catches nil ptr indirection // in a large address space. // Address space starts at 1<<32 on AIX and on darwin/arm64 and on windows/arm64, so dummy is too far. //go:build !aix && (!darwin \|\| !arm64) && (!windows \|\| !arm64) package main import "unsafe" // Having a big address space means that indexing // at a 256 MB offset from a nil pointer might not // cause a memory access fault. This test checks // that Go is doing the correct explicit checks to catch // these nil pointer accesses, not just relying on the hardware. var dummy [256 << 20]byte // give us a big address space func main() { // the test only tests what we intend to test // if dummy starts in the first 256 MB of memory. // otherwise there might not be anything mapped // at the address that might be accidentally // dereferenced below. if uintptr(unsafe.Pointer(&dummy)) > 256<<20 { panic("dummy too far out") } shouldPanic(p1) shouldPanic(p2) shouldPanic(p3) shouldPanic(p4) shouldPanic(p5) shouldPanic(p6) shouldPanic(p7) shouldPanic(p8) shouldPanic(p9) shouldPanic(p10) shouldPanic(p11) shouldPanic(p12) shouldPanic(p13) shouldPanic(p14) shouldPanic(p15) shouldPanic(p16) } func shouldPanic(f func()) { defer func() { if recover() == nil { panic("memory reference did not panic") } }() f() } func p1() { // Array index. var p [1 << 30]byte = nil println(p[256<<20]) // very likely to be inside dummy, but should panic } var xb byte func p2() { var p [1 << 30]byte = nil xb = 123 // Array index. println(p[uintptr(unsafe.Pointer(&xb))]) // should panic } func p3() { // Array to slice. var p [1 << 30]byte = nil var x []byte = p[0:] // should panic _ = x } var q [1 << 30]byte func p4() { // Array to slice. var x []byte var y = &x y = q[0:] // should crash (uses arraytoslice runtime routine) } func fb([]byte) { panic("unreachable") } func p5() { // Array to slice. var p [1 << 30]byte = nil fb(p[0:]) // should crash } func p6() { // Array to slice. var p [1 << 30]byte = nil var _ []byte = p[10 : len(p)-10] // should crash } type T struct { x [256 << 20]byte i int } func f() T { return nil } var y T var x = &y func p7() { // Struct field access with large offset. println(f().i) // should crash } func p8() { // Struct field access with large offset. println((x).i) // should crash } func p9() { // Struct field access with large offset. var t T println(&t.i) // should crash } func p10() { // Struct field access with large offset. var t T println(t.i) // should crash } type T1 struct { T } type T2 struct { T1 } func p11() { t := &T2{} p := &t.i println(p) } // ADDR(DOT(IND(p))) needs a check also func p12() { var p T = nil println((&((p).i))) } // Tests suggested in golang.org/issue/6080. func p13() { var x [10]int y := x[:] _ = y } func p14() { println(([1]int)(nil)[:]) } func p15() { for i := range ([1]int)(nil)[:] { _ = i } } func p16() { for i, v := range (*[1]int)(nil)[:] { _ = i + v } }	3.15 KB	2024-02-02 18:09
📄 nilptr2.go // run // 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. package main func main() { ok := true for _, tt := range tests { func() { defer func() { if err := recover(); err == nil { println(tt.name, "did not panic") ok = false } }() tt.fn() }() } if !ok { println("BUG") } } var intp int var slicep []byte var a10p [10]int var a10Mp [1<<20]int var structp Struct var bigstructp BigStruct var i int var m M var m1 M1 var m2 M2 var V interface{} func use(x interface{}) { V = x } var tests = []struct{ name string fn func() }{ // Edit .+1,/^}/s/^[^ ].+/ {"&", func() { println(&) }},\n {"\&&", func() { println(\&&) }},/g {"intp", func() { println(intp) }}, {"&intp", func() { println(&intp) }}, {"slicep", func() { println(slicep) }}, {"&slicep", func() { println(&slicep) }}, {"(slicep)[0]", func() { println((slicep)[0]) }}, {"&(slicep)[0]", func() { println(&(slicep)[0]) }}, {"(slicep)[i]", func() { println((slicep)[i]) }}, {"&(slicep)[i]", func() { println(&(slicep)[i]) }}, {"a10p", func() { use(a10p) }}, {"&a10p", func() { println(&a10p) }}, {"a10p[0]", func() { println(a10p[0]) }}, {"&a10p[0]", func() { println(&a10p[0]) }}, {"a10p[i]", func() { println(a10p[i]) }}, {"&a10p[i]", func() { println(&a10p[i]) }}, {"structp", func() { use(structp) }}, {"&structp", func() { println(&structp) }}, {"structp.i", func() { println(structp.i) }}, {"&structp.i", func() { println(&structp.i) }}, {"structp.j", func() { println(structp.j) }}, {"&structp.j", func() { println(&structp.j) }}, {"structp.k", func() { println(structp.k) }}, {"&structp.k", func() { println(&structp.k) }}, {"structp.x[0]", func() { println(structp.x[0]) }}, {"&structp.x[0]", func() { println(&structp.x[0]) }}, {"structp.x[i]", func() { println(structp.x[i]) }}, {"&structp.x[i]", func() { println(&structp.x[i]) }}, {"structp.x[9]", func() { println(structp.x[9]) }}, {"&structp.x[9]", func() { println(&structp.x[9]) }}, {"structp.l", func() { println(structp.l) }}, {"&structp.l", func() { println(&structp.l) }}, {"bigstructp", func() { use(bigstructp) }}, {"&bigstructp", func() { println(&bigstructp) }}, {"bigstructp.i", func() { println(bigstructp.i) }}, {"&bigstructp.i", func() { println(&bigstructp.i) }}, {"bigstructp.j", func() { println(bigstructp.j) }}, {"&bigstructp.j", func() { println(&bigstructp.j) }}, {"bigstructp.k", func() { println(bigstructp.k) }}, {"&bigstructp.k", func() { println(&bigstructp.k) }}, {"bigstructp.x[0]", func() { println(bigstructp.x[0]) }}, {"&bigstructp.x[0]", func() { println(&bigstructp.x[0]) }}, {"bigstructp.x[i]", func() { println(bigstructp.x[i]) }}, {"&bigstructp.x[i]", func() { println(&bigstructp.x[i]) }}, {"bigstructp.x[9]", func() { println(bigstructp.x[9]) }}, {"&bigstructp.x[9]", func() { println(&bigstructp.x[9]) }}, {"bigstructp.x[100<<20]", func() { println(bigstructp.x[100<<20]) }}, {"&bigstructp.x[100<<20]", func() { println(&bigstructp.x[100<<20]) }}, {"bigstructp.l", func() { println(bigstructp.l) }}, {"&bigstructp.l", func() { println(&bigstructp.l) }}, {"m1.F()", func() { println(m1.F()) }}, {"m1.M.F()", func() { println(m1.M.F()) }}, {"m2.F()", func() { println(m2.F()) }}, {"m2.M.F()", func() { println(m2.M.F()) }}, } type Struct struct { i int j float64 k string x [10]int l []byte } type BigStruct struct { i int j float64 k string x [128<<20]byte l []byte } type M struct { } func (m M) F() int {return 0} type M1 struct { M } type M2 struct { x int M }	3.6 KB	2024-02-02 18:09
📄 nilptr3.go // errorcheck -0 -d=nil //go:build !wasm && !aix // 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. // Test that nil checks are removed. // Optimization is enabled. package p type Struct struct { X int Y float64 } type BigStruct struct { X int Y float64 A [1 << 20]int Z string } type Empty struct { } type Empty1 struct { Empty } var ( intp int arrayp [10]int array0p [0]int bigarrayp [1 << 26]int structp Struct bigstructp BigStruct emptyp Empty empty1p Empty1 ) func f1() { _ = intp // ERROR "generated nil check" // This one should be removed but the block copy needs // to be turned into its own pseudo-op in order to see // the indirect. _ = arrayp // ERROR "generated nil check" // 0-byte indirect doesn't suffice. // we don't registerize globals, so there are no removed.* nil checks. _ = array0p // ERROR "generated nil check" _ = array0p // ERROR "removed nil check" _ = intp // ERROR "removed nil check" _ = arrayp // ERROR "removed nil check" _ = structp // ERROR "generated nil check" _ = emptyp // ERROR "generated nil check" _ = arrayp // ERROR "removed nil check" } func f2() { var ( intp int arrayp [10]int array0p [0]int bigarrayp [1 << 20]int structp Struct bigstructp BigStruct emptyp Empty empty1p Empty1 ) _ = intp // ERROR "generated nil check" _ = arrayp // ERROR "generated nil check" _ = array0p // ERROR "generated nil check" _ = array0p // ERROR "removed. nil check" _ = intp // ERROR "removed. nil check" _ = arrayp // ERROR "removed. nil check" _ = structp // ERROR "generated nil check" _ = emptyp // ERROR "generated nil check" _ = arrayp // ERROR "removed. nil check" _ = bigarrayp // ERROR "generated nil check" ARM removed nil check before indirect!! _ = bigstructp // ERROR "generated nil check" _ = empty1p // ERROR "generated nil check" } func fx10k() [10000]int var b bool func f3(x [10000]int) { // Using a huge type and huge offsets so the compiler // does not expect the memory hardware to fault. _ = x[9999] // ERROR "generated nil check" for { if x[9999] != 0 { // ERROR "removed nil check" break } } x = fx10k() _ = x[9999] // ERROR "generated nil check" if b { _ = x[9999] // ERROR "removed. nil check" } else { _ = x[9999] // ERROR "removed.* nil check" } _ = x[9999] // ERROR "removed nil check" x = fx10k() if b { _ = x[9999] // ERROR "generated nil check" } else { _ = x[9999] // ERROR "generated nil check" } _ = x[9999] // ERROR "generated nil check" fx10k() // This one is a bit redundant, if we figured out that // x wasn't going to change across the function call. // But it's a little complex to do and in practice doesn't // matter enough. _ = x[9999] // ERROR "removed nil check" } func f3a() { x := fx10k() y := fx10k() z := fx10k() _ = &x[9] // ERROR "generated nil check" y = z _ = &x[9] // ERROR "removed.* nil check" x = y _ = &x[9] // ERROR "generated nil check" } func f3b() { x := fx10k() y := fx10k() _ = &x[9] // ERROR "generated nil check" y = x _ = &x[9] // ERROR "removed.* nil check" x = y _ = &x[9] // ERROR "removed.* nil check" } func fx10() [10]int func f4(x [10]int) { // Most of these have no checks because a real memory reference follows, // and the offset is small enough that if x is nil, the address will still be // in the first unmapped page of memory. _ = x[9] // ERROR "generated nil check" // bug: would like to remove this check (but nilcheck and load are in different blocks) for { if x[9] != 0 { // ERROR "removed nil check" break } } x = fx10() _ = x[9] // ERROR "generated nil check" // bug would like to remove before indirect if b { _ = x[9] // ERROR "removed nil check" } else { _ = x[9] // ERROR "removed nil check" } _ = x[9] // ERROR "removed nil check" x = fx10() if b { _ = x[9] // ERROR "generated nil check" // bug would like to remove before indirect } else { _ = &x[9] // ERROR "generated nil check" } _ = x[9] // ERROR "generated nil check" // bug would like to remove before indirect fx10() _ = x[9] // ERROR "removed nil check" x = fx10() y := fx10() _ = &x[9] // ERROR "generated nil check" y = x _ = &x[9] // ERROR "removed[a-z ]* nil check" x = y _ = &x[9] // ERROR "removed[a-z ]* nil check" } func m1(m map[int][80]byte) byte { v := m[3] // ERROR "removed nil check" return v[5] } func m2(m map[int][800]byte) byte { v := m[3] // ERROR "removed nil check" return v[5] } func m3(m map[int][80]byte) (byte, bool) { v, ok := m[3] // ERROR "removed nil check" return v[5], ok } func m4(m map[int][800]byte) (byte, bool) { v, ok := m[3] // ERROR "removed nil check" return v[5], ok } func p1() byte { p := new([100]byte) return p[5] // ERROR "removed nil check" } type SS struct { x byte } type TT struct { SS } func f(t TT) byte { // See issue 17242. s := &t.SS // ERROR "generated nil check" return &s.x // ERROR "removed nil check" } // make sure not to do nil check for newobject func f7() (Struct, float64) { t := new(Struct) p := &t.Y // ERROR "removed nil check" return t, p // ERROR "removed nil check" } func f9() []int { x := new([1]int) x[0] = 1 // ERROR "removed nil check" y := x[:] // ERROR "removed nil check" return y } // See issue 42673. func f10(p *int) int { return // ERROR "removed nil check" /* / p // ERROR "removed nil check" } func f11(x []byte) { p := ([0]byte)(x) _ = p // ERROR "generated nil check" q := ([4]byte)(x) _ = q // ERROR "removed nil check" }	5.65 KB	2024-02-02 18:09
📄 nilptr4.go // build // 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 that the compiler does not crash during compilation. package main import "unsafe" // Issue 7413 func f1() { type t struct { i int } var v *t _ = int(uintptr(unsafe.Pointer(&v.i))) _ = int32(uintptr(unsafe.Pointer(&v.i))) } func main() {}	428 B	2024-02-02 18:09
📄 nilptr5.go // errorcheck -0 -d=nil //go:build !wasm && !aix // 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. // Test that nil checks are removed. // Optimization is enabled. package p func f5(p float32, q float64, r float32, s float64) float64 { x := float64(p) // ERROR "removed nil check" y := q // ERROR "removed nil check" r = 7 // ERROR "removed nil check" s = 9 // ERROR "removed nil check" return x + y } type T struct{ b [29]byte } func f6(p, q T) { x := p // ERROR "removed nil check" q = x // ERROR "removed nil check" } // make sure to remove nil check for memory move (issue #18003) func f8(t struct{ b [8]int }) struct{ b [8]int } { return *t // ERROR "removed nil check" }	844 B	2024-02-02 18:09
📄 nilptr5_aix.go // errorcheck -0 -d=nil //go:build aix // 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. // Test that nil checks are removed. // Optimization is enabled. package p func f5(p float32, q float64, r float32, s float64) float64 { x := float64(p) // ERROR "generated nil check" y := q // ERROR "generated nil check" r = 7 // ERROR "removed nil check" s = 9 // ERROR "removed nil check" return x + y } type T [29]byte func f6(p, q T) { x := p // ERROR "generated nil check" q = x // ERROR "removed nil check" } // make sure to remove nil check for memory move (issue #18003) func f8(t [8]int) [8]int { return *t // ERROR "generated nil check" }	806 B	2024-02-02 18:09
📄 nilptr5_wasm.go // errorcheck -0 -d=nil //go:build wasm // 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. // Test that nil checks are removed. // Optimization is enabled. package p func f5(p float32, q float64, r float32, s float64) float64 { x := float64(p) // ERROR "generated nil check" y := q // ERROR "generated nil check" r = 7 // ERROR "generated nil check" s = 9 // ERROR "generated nil check" return x + y } type T [29]byte func f6(p, q T) { x := p // ERROR "generated nil check" q = x // ERROR "generated nil check" } // make sure to remove nil check for memory move (issue #18003) func f8(t [8]int) [8]int { return *t // ERROR "generated nil check" }	813 B	2024-02-02 18:09
📄 nilptr_aix.go // 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. // Test that the implementation catches nil ptr indirection // in a large address space. //go:build aix package main import "unsafe" // Having a big address space means that indexing // at a 1G + 256 MB offset from a nil pointer might not // cause a memory access fault. This test checks // that Go is doing the correct explicit checks to catch // these nil pointer accesses, not just relying on the hardware. // The reason of the 1G offset is because AIX addresses start after 1G. var dummy [256 << 20]byte // give us a big address space func main() { // the test only tests what we intend to test // if dummy starts in the first 256 MB of memory. // otherwise there might not be anything mapped // at the address that might be accidentally // dereferenced below. if uintptr(unsafe.Pointer(&dummy)) < 1<<32 { panic("dummy not far enough") } shouldPanic(p1) shouldPanic(p2) shouldPanic(p3) shouldPanic(p4) shouldPanic(p5) shouldPanic(p6) shouldPanic(p7) shouldPanic(p8) shouldPanic(p9) shouldPanic(p10) shouldPanic(p11) shouldPanic(p12) shouldPanic(p13) shouldPanic(p14) shouldPanic(p15) shouldPanic(p16) } func shouldPanic(f func()) { defer func() { if recover() == nil { panic("memory reference did not panic") } }() f() } func p1() { // Array index. var p [1 << 33]byte = nil println(p[1<<32+256<<20]) // very likely to be inside dummy, but should panic } var xb byte func p2() { var p [1 << 33]byte = nil xb = 123 // Array index. println(p[uintptr(unsafe.Pointer(&xb))]) // should panic } func p3() { // Array to slice. var p [1 << 33]byte = nil var x []byte = p[0:] // should panic _ = x } var q [1 << 33]byte func p4() { // Array to slice. var x []byte var y = &x y = q[0:] // should crash (uses arraytoslice runtime routine) } func fb([]byte) { panic("unreachable") } func p5() { // Array to slice. var p [1 << 33]byte = nil fb(p[0:]) // should crash } func p6() { // Array to slice. var p [1 << 33]byte = nil var _ []byte = p[10 : len(p)-10] // should crash } type T struct { x [1<<32 + 256<<20]byte i int } func f() T { return nil } var y T var x = &y func p7() { // Struct field access with large offset. println(f().i) // should crash } func p8() { // Struct field access with large offset. println((x).i) // should crash } func p9() { // Struct field access with large offset. var t T println(&t.i) // should crash } func p10() { // Struct field access with large offset. var t T println(t.i) // should crash } type T1 struct { T } type T2 struct { T1 } func p11() { t := &T2{} p := &t.i println(p) } // ADDR(DOT(IND(p))) needs a check also func p12() { var p T = nil println((&((p).i))) } // Tests suggested in golang.org/issue/6080. func p13() { var x [10]int y := x[:] _ = y } func p14() { println(([1]int)(nil)[:]) } func p15() { for i := range ([1]int)(nil)[:] { _ = i } } func p16() { for i, v := range (*[1]int)(nil)[:] { _ = i + v } }	3.09 KB	2024-02-02 18:09
📄 noinit.go // run //go:build !gcflags_noopt // Copyright 2010 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 that many initializations can be done at link time and // generate no executable init functions. // Also test that trivial func init are optimized away. package main import ( "errors" "unsafe" ) // All these initializations should be done at link time. type S struct{ a, b, c int } type SS struct{ aa, bb, cc S } type SA struct{ a, b, c [3]int } type SC struct{ a, b, c []int } var ( zero = 2 one = 1 pi = 3.14 slice = []byte{1, 2, 3} sliceInt = []int{1, 2, 3} hello = "hello, world" bytes = []byte("hello, world") four, five = 4, 5 x, y = 0.1, "hello" nilslice []byte = nil nilmap map[string]int = nil nilfunc func() = nil nilchan chan int = nil nilptr byte = nil ) var a = [3]int{1001, 1002, 1003} var s = S{1101, 1102, 1103} var c = []int{1201, 1202, 1203} var aa = [3][3]int{[3]int{2001, 2002, 2003}, [3]int{2004, 2005, 2006}, [3]int{2007, 2008, 2009}} var as = [3]S{S{2101, 2102, 2103}, S{2104, 2105, 2106}, S{2107, 2108, 2109}} var sa = SA{[3]int{3001, 3002, 3003}, [3]int{3004, 3005, 3006}, [3]int{3007, 3008, 3009}} var ss = SS{S{3101, 3102, 3103}, S{3104, 3105, 3106}, S{3107, 3108, 3109}} var ca = [][3]int{[3]int{4001, 4002, 4003}, [3]int{4004, 4005, 4006}, [3]int{4007, 4008, 4009}} var cs = []S{S{4101, 4102, 4103}, S{4104, 4105, 4106}, S{4107, 4108, 4109}} var answers = [...]int{ // s 1101, 1102, 1103, // ss 3101, 3102, 3103, 3104, 3105, 3106, 3107, 3108, 3109, // [0] 1001, 1201, 1301, 2101, 2102, 2103, 4101, 4102, 4103, 5101, 5102, 5103, 3001, 3004, 3007, 3201, 3204, 3207, 3301, 3304, 3307, // [0][j] 2001, 2201, 2301, 4001, 4201, 4301, 5001, 5201, 5301, 2002, 2202, 2302, 4002, 4202, 4302, 5002, 5202, 5302, 2003, 2203, 2303, 4003, 4203, 4303, 5003, 5203, 5303, // [1] 1002, 1202, 1302, 2104, 2105, 2106, 4104, 4105, 4106, 5104, 5105, 5106, 3002, 3005, 3008, 3202, 3205, 3208, 3302, 3305, 3308, // [1][j] 2004, 2204, 2304, 4004, 4204, 4304, 5004, 5204, 5304, 2005, 2205, 2305, 4005, 4205, 4305, 5005, 5205, 5305, 2006, 2206, 2306, 4006, 4206, 4306, 5006, 5206, 5306, // [2] 1003, 1203, 1303, 2107, 2108, 2109, 4107, 4108, 4109, 5107, 5108, 5109, 3003, 3006, 3009, 3203, 3206, 3209, 3303, 3306, 3309, // [2][j] 2007, 2207, 2307, 4007, 4207, 4307, 5007, 5207, 5307, 2008, 2208, 2308, 4008, 4208, 4308, 5008, 5208, 5308, 2009, 2209, 2309, 4009, 4209, 4309, 5009, 5209, 5309, } var ( copy_zero = zero copy_one = one copy_pi = pi copy_slice = slice copy_sliceInt = sliceInt // copy_hello = hello // static init of copied strings defeats link -X; see #34675 // Could be handled without an initialization function, but // requires special handling for "a = []byte("..."); b = a" // which is not a likely case. // copy_bytes = bytes // https://codereview.appspot.com/171840043 is one approach to // make this special case work. copy_four, copy_five = four, five copy_x = x // copy_y = y // static init of copied strings defeats link -X; see #34675 copy_nilslice = nilslice copy_nilmap = nilmap copy_nilfunc = nilfunc copy_nilchan = nilchan copy_nilptr = nilptr ) var copy_a = a var copy_s = s var copy_c = c var copy_aa = aa var copy_as = as var copy_sa = sa var copy_ss = ss var copy_ca = ca var copy_cs = cs var copy_answers = answers var bx bool var b0 = false var b1 = true var fx float32 var f0 = float32(0) var f1 = float32(1) var gx float64 var g0 = float64(0) var g1 = float64(1) var ix int var i0 = 0 var i1 = 1 var jx uint var j0 = uint(0) var j1 = uint(1) var cx complex64 var c0 = complex64(0) var c1 = complex64(1) var dx complex128 var d0 = complex128(0) var d1 = complex128(1) var sx []int var s0 = []int{0, 0, 0} var s1 = []int{1, 2, 3} func fi() int { return 1 } var ax [10]int var a0 = [10]int{0, 0, 0} var a1 = [10]int{1, 2, 3, 4} type T struct{ X, Y int } var tx T var t0 = T{} var t0a = T{0, 0} var t0b = T{X: 0} var t1 = T{X: 1, Y: 2} var t1a = T{3, 4} var psx []int var ps0 = &[]int{0, 0, 0} var ps1 = &[]int{1, 2, 3} var pax [10]int var pa0 = &[10]int{0, 0, 0} var pa1 = &[10]int{1, 2, 3} var ptx T var pt0 = &T{} var pt0a = &T{0, 0} var pt0b = &T{X: 0} var pt1 = &T{X: 1, Y: 2} var pt1a = &T{3, 4} // The checks similar to // var copy_bx = bx // are commented out. The compiler no longer statically initializes them. // See issue 7665 and https://codereview.appspot.com/93200044. // If https://codereview.appspot.com/169040043 is submitted, and this // test is changed to pass -complete to the compiler, then we can // uncomment the copy lines again. // var copy_bx = bx var copy_b0 = b0 var copy_b1 = b1 // var copy_fx = fx var copy_f0 = f0 var copy_f1 = f1 // var copy_gx = gx var copy_g0 = g0 var copy_g1 = g1 // var copy_ix = ix var copy_i0 = i0 var copy_i1 = i1 // var copy_jx = jx var copy_j0 = j0 var copy_j1 = j1 // var copy_cx = cx var copy_c0 = c0 var copy_c1 = c1 // var copy_dx = dx var copy_d0 = d0 var copy_d1 = d1 // var copy_sx = sx var copy_s0 = s0 var copy_s1 = s1 // var copy_ax = ax var copy_a0 = a0 var copy_a1 = a1 // var copy_tx = tx var copy_t0 = t0 var copy_t0a = t0a var copy_t0b = t0b var copy_t1 = t1 var copy_t1a = t1a // var copy_psx = psx var copy_ps0 = ps0 var copy_ps1 = ps1 // var copy_pax = pax var copy_pa0 = pa0 var copy_pa1 = pa1 // var copy_ptx = ptx var copy_pt0 = pt0 var copy_pt0a = pt0a var copy_pt0b = pt0b var copy_pt1 = pt1 var copy_pt1a = pt1a var _ interface{} = 1 type T1 int func (t T1) M() {} type Mer interface { M() } var _ Mer = (T1)(nil) var Byte byte var PtrByte unsafe.Pointer = unsafe.Pointer(&Byte) var LitSXInit = &S{1, 2, 3} var LitSAnyXInit any = &S{4, 5, 6} func FS(x, y, z int) S { return &S{x, y, z} } func FSA(x, y, z int) any { return &S{x, y, z} } func F3(x int) S { return &S{x, x, x} } var LitSCallXInit = FS(7, 8, 9) var LitSAnyCallXInit any = FSA(10, 11, 12) var LitSRepeat = F3(1 + 2) func F0() *S { return &S{1, 2, 3} } var LitSNoArgs = F0() var myError = errors.New("mine") func gopherize(s string) string { return "gopher gopher gopher " + s } var animals = gopherize("badger") // These init funcs should optimize away. func init() { } func init() { if false { } } func init() { for false { } } // Actual test: check for init funcs in runtime data structures. type initTask struct { state uint32 nfns uint32 } //go:linkname main_inittask main..inittask var main_inittask initTask func main() { if nfns := main_inittask.nfns; nfns != 0 { println(nfns) panic("unexpected init funcs") } }	6.79 KB	2024-02-02 18:09
📄 nosplit.go // run //go:build !nacl && !js && !aix && !wasip1 && !gcflags_noopt && gc // 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. package main import ( "bytes" "fmt" "io/ioutil" "log" "os" "os/exec" "path/filepath" "regexp" "runtime" "strconv" "strings" ) const debug = false var tests = ` # These are test cases for the linker analysis that detects chains of # nosplit functions that would cause a stack overflow. # # Lines beginning with # are comments. # # Each test case describes a sequence of functions, one per line. # Each function definition is the function name, then the frame size, # then optionally the keyword 'nosplit', then the body of the function. # The body is assembly code, with some shorthands. # The shorthand 'call x' stands for CALL x(SB). # The shorthand 'callind' stands for 'CALL R0', where R0 is a register. # Each test case must define a function named start, and it must be first. # That is, a line beginning "start " indicates the start of a new test case. # Within a stanza, ; can be used instead of \n to separate lines. # # After the function definition, the test case ends with an optional # REJECT line, specifying the architectures on which the case should # be rejected. "REJECT" without any architectures means reject on all architectures. # The linker should accept the test case on systems not explicitly rejected. # # 64-bit systems do not attempt to execute test cases with frame sizes # that are only 32-bit aligned. # Ordinary function should work start 0 # Large frame marked nosplit is always wrong. # Frame is so large it overflows cmd/link's int16. start 100000 nosplit REJECT # Calling a large frame is okay. start 0 call big big 10000 # But not if the frame is nosplit. start 0 call big big 10000 nosplit REJECT # Recursion is okay. start 0 call start # Recursive nosplit runs out of space. start 0 nosplit call start REJECT # Non-trivial recursion runs out of space. start 0 call f1 f1 0 nosplit call f2 f2 0 nosplit call f1 REJECT # Same but cycle starts below nosplit entry. start 0 call f1 f1 0 nosplit call f2 f2 0 nosplit call f3 f3 0 nosplit call f2 REJECT # Chains of ordinary functions okay. start 0 call f1 f1 80 call f2 f2 80 # Chains of nosplit must fit in the stack limit, 128 bytes. start 0 call f1 f1 80 nosplit call f2 f2 80 nosplit REJECT # Larger chains. start 0 call f1 f1 16 call f2 f2 16 call f3 f3 16 call f4 f4 16 call f5 f5 16 call f6 f6 16 call f7 f7 16 call f8 f8 16 call end end 1000 start 0 call f1 f1 16 nosplit call f2 f2 16 nosplit call f3 f3 16 nosplit call f4 f4 16 nosplit call f5 f5 16 nosplit call f6 f6 16 nosplit call f7 f7 16 nosplit call f8 f8 16 nosplit call end end 1000 REJECT # Two paths both go over the stack limit. start 0 call f1 f1 80 nosplit call f2 call f3 f2 40 nosplit call f4 f3 96 nosplit f4 40 nosplit REJECT # Test cases near the 128-byte limit. # Ordinary stack split frame is always okay. start 112 start 116 start 120 start 124 start 128 start 132 start 136 # A nosplit leaf can use the whole 128-CallSize bytes available on entry. # (CallSize is 32 on ppc64, 8 on amd64 for frame pointer.) start 96 nosplit start 100 nosplit; REJECT ppc64 ppc64le start 104 nosplit; REJECT ppc64 ppc64le arm64 start 108 nosplit; REJECT ppc64 ppc64le start 112 nosplit; REJECT ppc64 ppc64le arm64 start 116 nosplit; REJECT ppc64 ppc64le start 120 nosplit; REJECT ppc64 ppc64le amd64 arm64 start 124 nosplit; REJECT ppc64 ppc64le amd64 start 128 nosplit; REJECT start 132 nosplit; REJECT start 136 nosplit; REJECT # Calling a nosplit function from a nosplit function requires # having room for the saved caller PC and the called frame. # Because ARM doesn't save LR in the leaf, it gets an extra 4 bytes. # Because arm64 doesn't save LR in the leaf, it gets an extra 8 bytes. # ppc64 doesn't save LR in the leaf, but CallSize is 32, so it gets 24 bytes. # Because AMD64 uses frame pointer, it has 8 fewer bytes. start 96 nosplit call f; f 0 nosplit start 100 nosplit call f; f 0 nosplit; REJECT ppc64 ppc64le start 104 nosplit call f; f 0 nosplit; REJECT ppc64 ppc64le arm64 start 108 nosplit call f; f 0 nosplit; REJECT ppc64 ppc64le start 112 nosplit call f; f 0 nosplit; REJECT ppc64 ppc64le amd64 arm64 start 116 nosplit call f; f 0 nosplit; REJECT ppc64 ppc64le amd64 start 120 nosplit call f; f 0 nosplit; REJECT ppc64 ppc64le amd64 arm64 start 124 nosplit call f; f 0 nosplit; REJECT ppc64 ppc64le amd64 386 start 128 nosplit call f; f 0 nosplit; REJECT start 132 nosplit call f; f 0 nosplit; REJECT start 136 nosplit call f; f 0 nosplit; REJECT # Calling a splitting function from a nosplit function requires # having room for the saved caller PC of the call but also the # saved caller PC for the call to morestack. # Architectures differ in the same way as before. start 96 nosplit call f; f 0 call f start 100 nosplit call f; f 0 call f; REJECT ppc64 ppc64le start 104 nosplit call f; f 0 call f; REJECT ppc64 ppc64le amd64 arm64 start 108 nosplit call f; f 0 call f; REJECT ppc64 ppc64le amd64 start 112 nosplit call f; f 0 call f; REJECT ppc64 ppc64le amd64 arm64 start 116 nosplit call f; f 0 call f; REJECT ppc64 ppc64le amd64 start 120 nosplit call f; f 0 call f; REJECT ppc64 ppc64le amd64 386 arm64 start 124 nosplit call f; f 0 call f; REJECT ppc64 ppc64le amd64 386 start 128 nosplit call f; f 0 call f; REJECT start 132 nosplit call f; f 0 call f; REJECT start 136 nosplit call f; f 0 call f; REJECT # Indirect calls are assumed to be splitting functions. start 96 nosplit callind start 100 nosplit callind; REJECT ppc64 ppc64le start 104 nosplit callind; REJECT ppc64 ppc64le amd64 arm64 start 108 nosplit callind; REJECT ppc64 ppc64le amd64 start 112 nosplit callind; REJECT ppc64 ppc64le amd64 arm64 start 116 nosplit callind; REJECT ppc64 ppc64le amd64 start 120 nosplit callind; REJECT ppc64 ppc64le amd64 386 arm64 start 124 nosplit callind; REJECT ppc64 ppc64le amd64 386 start 128 nosplit callind; REJECT start 132 nosplit callind; REJECT start 136 nosplit callind; REJECT # Issue 7623 start 0 call f; f 112 start 0 call f; f 116 start 0 call f; f 120 start 0 call f; f 124 start 0 call f; f 128 start 0 call f; f 132 start 0 call f; f 136 ` var ( commentRE = regexp.MustCompile(`(?m)^#.`) rejectRE = regexp.MustCompile(`(?s)\A(.+?)((\n\|; )REJECT(.))?\z`) lineRE = regexp.MustCompile(`(\w+) (\d+)( nosplit)?(.)`) callRE = regexp.MustCompile(`\bcall (\w+)\b`) callindRE = regexp.MustCompile(`\bcallind\b`) ) func main() { goarch := os.Getenv("GOARCH") if goarch == "" { goarch = runtime.GOARCH } dir, err := ioutil.TempDir("", "go-test-nosplit") if err != nil { bug() fmt.Printf("creating temp dir: %v\n", err) return } defer os.RemoveAll(dir) os.Setenv("GOPATH", filepath.Join(dir, "_gopath")) if err := ioutil.WriteFile(filepath.Join(dir, "go.mod"), []byte("module go-test-nosplit\n"), 0666); err != nil { log.Panic(err) } tests = strings.Replace(tests, "\t", " ", -1) tests = commentRE.ReplaceAllString(tests, "") nok := 0 nfail := 0 TestCases: for len(tests) > 0 { var stanza string i := strings.Index(tests, "\nstart ") if i < 0 { stanza, tests = tests, "" } else { stanza, tests = tests[:i], tests[i+1:] } m := rejectRE.FindStringSubmatch(stanza) if m == nil { bug() fmt.Printf("invalid stanza:\n\t%s\n", indent(stanza)) continue } lines := strings.TrimSpace(m[1]) reject := false if m[2] != "" { if strings.TrimSpace(m[4]) == "" { reject = true } else { for _, rej := range strings.Fields(m[4]) { if rej == goarch { reject = true } } } } if lines == "" && !reject { continue } var gobuf bytes.Buffer fmt.Fprintf(&gobuf, "package main\n") var buf bytes.Buffer ptrSize := 4 switch goarch { case "mips", "mipsle": fmt.Fprintf(&buf, "#define REGISTER (R0)\n") case "mips64", "mips64le": ptrSize = 8 fmt.Fprintf(&buf, "#define REGISTER (R0)\n") case "loong64": ptrSize = 8 fmt.Fprintf(&buf, "#define REGISTER (R0)\n") case "ppc64", "ppc64le": ptrSize = 8 fmt.Fprintf(&buf, "#define REGISTER (CTR)\n") case "arm": fmt.Fprintf(&buf, "#define REGISTER (R0)\n") case "arm64": ptrSize = 8 fmt.Fprintf(&buf, "#define REGISTER (R0)\n") case "amd64": ptrSize = 8 fmt.Fprintf(&buf, "#define REGISTER AX\n") case "riscv64": ptrSize = 8 fmt.Fprintf(&buf, "#define REGISTER A0\n") case "s390x": ptrSize = 8 fmt.Fprintf(&buf, "#define REGISTER R10\n") default: fmt.Fprintf(&buf, "#define REGISTER AX\n") } // Since all of the functions we're generating are // ABI0, first enter ABI0 via a splittable function // and then go to the chain we're testing. This way we // don't have to account for ABI wrappers in the chain. fmt.Fprintf(&gobuf, "func main0()\n") fmt.Fprintf(&gobuf, "func main() { main0() }\n") fmt.Fprintf(&buf, "TEXT ·main0(SB),0,$0-0\n\tCALL ·start(SB)\n") adjusted := false for _, line := range strings.Split(lines, "\n") { line = strings.TrimSpace(line) if line == "" { continue } for _, subline := range strings.Split(line, ";") { subline = strings.TrimSpace(subline) if subline == "" { continue } m := lineRE.FindStringSubmatch(subline) if m == nil { bug() fmt.Printf("invalid function line: %s\n", subline) continue TestCases } name := m[1] size, _ := strconv.Atoi(m[2]) if size%ptrSize == 4 { continue TestCases } nosplit := m[3] body := m[4] // The limit was originally 128 but is now 800. // Instead of rewriting the test cases above, adjust // the first nosplit frame to use up the extra bytes. // This isn't exactly right because we could have // nosplit -> split -> nosplit, but it's good enough. if !adjusted && nosplit != "" { const stackNosplitBase = 800 // internal/abi.StackNosplitBase adjusted = true size += stackNosplitBase - 128 } if nosplit != "" { nosplit = ",7" } else { nosplit = ",0" } body = callRE.ReplaceAllString(body, "CALL ·$1(SB);") body = callindRE.ReplaceAllString(body, "CALL REGISTER;") fmt.Fprintf(&gobuf, "func %s()\n", name) fmt.Fprintf(&buf, "TEXT ·%s(SB)%s,$%d-0\n\t%s\n\tRET\n\n", name, nosplit, size, body) } } if debug { fmt.Printf("===\n%s\n", strings.TrimSpace(stanza)) fmt.Printf("-- main.go --\n%s", gobuf.String()) fmt.Printf("-- asm.s --\n%s", buf.String()) } if err := ioutil.WriteFile(filepath.Join(dir, "asm.s"), buf.Bytes(), 0666); err != nil { log.Fatal(err) } if err := ioutil.WriteFile(filepath.Join(dir, "main.go"), gobuf.Bytes(), 0666); err != nil { log.Fatal(err) } cmd := exec.Command("go", "build") cmd.Dir = dir output, err := cmd.CombinedOutput() if err == nil { nok++ if reject { bug() fmt.Printf("accepted incorrectly:\n\t%s\n", indent(strings.TrimSpace(stanza))) } } else { nfail++ if !reject { bug() fmt.Printf("rejected incorrectly:\n\t%s\n", indent(strings.TrimSpace(stanza))) fmt.Printf("\n\tlinker output:\n\t%s\n", indent(string(output))) } } } if !bugged && (nok == 0 \|\| nfail == 0) { bug() fmt.Printf("not enough test cases run\n") } } func indent(s string) string { return strings.Replace(s, "\n", "\n\t", -1) } var bugged = false func bug() { if !bugged { bugged = true fmt.Printf("BUG\n") } }	11.28 KB	2024-02-02 18:09
📄 nowritebarrier.go // errorcheck -+ -p=runtime // 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. // Test go:nowritebarrier and related directives. // This must appear to be in package runtime so the compiler // recognizes "systemstack". package runtime type t struct { f t } var x t var y t //go:nowritebarrier func a1() { x.f = y // ERROR "write barrier prohibited" a2() // no error } //go:noinline func a2() { x.f = y } //go:nowritebarrierrec func b1() { b2() } //go:noinline func b2() { x.f = y // ERROR "write barrier prohibited by caller" } // Test recursive cycles through nowritebarrierrec and yeswritebarrierrec. //go:nowritebarrierrec func c1() { c2() } //go:yeswritebarrierrec func c2() { c3() } func c3() { x.f = y c4() } //go:nowritebarrierrec func c4() { c2() } //go:nowritebarrierrec func d1() { d2() } func d2() { d3() } //go:noinline func d3() { x.f = y // ERROR "write barrier prohibited by caller" d4() } //go:yeswritebarrierrec func d4() { d2() } //go:noinline func systemstack(func()) {} //go:nowritebarrierrec func e1() { systemstack(e2) systemstack(func() { x.f = y // ERROR "write barrier prohibited by caller" }) } func e2() { x.f = y // ERROR "write barrier prohibited by caller" }	1.31 KB	2024-02-02 18:09
📄 nul1.go // errorcheckoutput // Copyright 2009 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 source files and strings containing NUL and invalid UTF-8. package main import ( "fmt" "os" ) func main() { var s = "\xc2\xff" var t = "\xd0\xfe" var u = "\xab\x00\xfc" if len(s) != 2 \|\| s[0] != 0xc2 \|\| s[1] != 0xff \|\| len(t) != 2 \|\| t[0] != 0xd0 \|\| t[1] != 0xfe \|\| len(u) != 3 \|\| u[0] != 0xab \|\| u[1] != 0x00 \|\| u[2] != 0xfc { println("BUG: non-UTF-8 string mangled") os.Exit(2) } fmt.Print(` package main var x = "in string ` + "\x00" + `" // ERROR "NUL" var y = ` + "`in raw string \x00 foo`" + ` // ERROR "NUL" // in comment ` + "\x00" + ` // ERROR "NUL" /* in other comment ` + "\x00" + ` / // ERROR "NUL" / in source code / ` + "\x00" + `// ERROR "NUL" var xx = "in string ` + "\xc2\xff" + `" // ERROR "UTF-8" var yy = ` + "`in raw string \xff foo`" + ` // ERROR "UTF-8" // in comment ` + "\xe2\x80\x01" + ` // ERROR "UTF-8" / in other comment ` + "\xe0\x00\x00" + ` / // ERROR "UTF-8\|NUL" / in variable name / var z` + "\xc1\x81" + ` int // ERROR "UTF-8" / in source code */ ` + "var \xc2A int" + `// ERROR "UTF-8" `) }	1.23 KB	2024-02-02 18:09
📄 opt_branchlikely.go // errorcheck -0 -d=ssa/likelyadjust/debug=1,ssa/insert_resched_checks/off // rescheduling check insertion is turned off because the inserted conditional branches perturb the errorcheck //go:build amd64 // 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. // Test that branches have some prediction properties. package foo func f(x, y, z int) int { a := 0 for i := 0; i < x; i++ { // ERROR "Branch prediction rule stay in loop" for j := 0; j < y; j++ { // ERROR "Branch prediction rule stay in loop" a += j } for k := 0; k < z; k++ { // ERROR "Branch prediction rule stay in loop" a -= x + y + z } } return a } func g(x, y, z int) int { a := 0 if y == 0 { // ERROR "Branch prediction rule default < call" y = g(y, z, x) } else { y++ } if y == x { // ERROR "Branch prediction rule default < call" y = g(y, z, x) } else { } if y == 2 { // ERROR "Branch prediction rule default < call" z++ } else { y = g(z, x, y) } if y+z == 3 { // ERROR "Branch prediction rule call < exit" println("ha ha") } else { panic("help help help") } if x != 0 { // ERROR "Branch prediction rule default < ret" for i := 0; i < x; i++ { // ERROR "Branch prediction rule stay in loop" if x == 4 { // ERROR "Branch prediction rule stay in loop" return a } for j := 0; j < y; j++ { // ERROR "Branch prediction rule stay in loop" for k := 0; k < z; k++ { // ERROR "Branch prediction rule stay in loop" a -= j * i } a += j } } } return a } func h(x, y, z int) int { a := 0 for i := 0; i < x; i++ { // ERROR "Branch prediction rule stay in loop" for j := 0; j < y; j++ { // ERROR "Branch prediction rule stay in loop" a += j if i == j { // ERROR "Branch prediction rule stay in loop" break } a = j } for k := 0; k < z; k++ { // ERROR "Branch prediction rule stay in loop" a -= k if i == k { continue } a = k } } if a > 0 { // ERROR "Branch prediction rule default < call" a = g(x, y, z) } else { a = -a } return a }	2.08 KB	2024-02-02 18:09
📄 parentype.go // compile // Copyright 2009 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 that types can be parenthesized. package main func f(interface{}) func g() {} func main() { f(map[string]string{"a":"b","c":"d"}) f([...]int{1,2,3}) f(map[string]func(){"a":g,"c":g}) f(make(chan(<-chan int))) f(make(chan<-(chan int))) }	424 B	2024-02-02 18:09
📄 peano.go // run // Copyright 2009 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 that heavy recursion works. Simple torture test for // segmented stacks: do math in unary by recursion. package main import "runtime" type Number Number // ------------------------------------- // Peano primitives func zero() Number { return nil } func is_zero(x Number) bool { return x == nil } func add1(x Number) Number { e := new(Number) e = x return e } func sub1(x Number) Number { return x } func add(x, y Number) Number { if is_zero(y) { return x } return add(add1(x), sub1(y)) } func mul(x, y Number) Number { if is_zero(x) \|\| is_zero(y) { return zero() } return add(mul(x, sub1(y)), x) } func fact(n Number) Number { if is_zero(n) { return add1(zero()) } return mul(fact(sub1(n)), n) } // ------------------------------------- // Helpers to generate/count Peano integers func gen(n int) Number { if n > 0 { return add1(gen(n - 1)) } return zero() } func count(x Number) int { if is_zero(x) { return 0 } return count(sub1(x)) + 1 } func check(x Number, expected int) { var c = count(x) if c != expected { print("error: found ", c, "; expected ", expected, "\n") panic("fail") } } // ------------------------------------- // Test basic functionality func init() { check(zero(), 0) check(add1(zero()), 1) check(gen(10), 10) check(add(gen(3), zero()), 3) check(add(zero(), gen(4)), 4) check(add(gen(3), gen(4)), 7) check(mul(zero(), zero()), 0) check(mul(gen(3), zero()), 0) check(mul(zero(), gen(4)), 0) check(mul(gen(3), add1(zero())), 3) check(mul(add1(zero()), gen(4)), 4) check(mul(gen(3), gen(4)), 12) check(fact(zero()), 1) check(fact(add1(zero())), 1) check(fact(gen(5)), 120) } // ------------------------------------- // Factorial var results = [...]int{ 1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800, 39916800, 479001600, } func main() { max := 9 if runtime.GOARCH == "wasm" { max = 7 // stack size is limited } for i := 0; i <= max; i++ { if f := count(fact(gen(i))); f != results[i] { println("FAIL:", i, "!:", f, "!=", results[i]) panic(0) } } }	2.22 KB	2024-02-02 18:09
📄 phiopt.go // errorcheck -0 -d=ssa/phiopt/debug=3 //go:build amd64 \|\| s390x \|\| arm64 // 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. package main //go:noinline func f0(a bool) bool { x := false if a { x = true } else { x = false } return x // ERROR "converted OpPhi to Copy$" } //go:noinline func f1(a bool) bool { x := false if a { x = false } else { x = true } return x // ERROR "converted OpPhi to Not$" } //go:noinline func f2(a, b int) bool { x := true if a == b { x = false } return x // ERROR "converted OpPhi to Not$" } //go:noinline func f3(a, b int) bool { x := false if a == b { x = true } return x // ERROR "converted OpPhi to Copy$" } //go:noinline func f4(a, b bool) bool { return a \|\| b // ERROR "converted OpPhi to OrB$" } //go:noinline func f5or(a int, b bool) bool { var x bool if a == 0 { x = true } else { x = b } return x // ERROR "converted OpPhi to OrB$" } //go:noinline func f5and(a int, b bool) bool { var x bool if a == 0 { x = b } else { x = false } return x // ERROR "converted OpPhi to AndB$" } //go:noinline func f6or(a int, b bool) bool { x := b if a == 0 { // f6or has side effects so the OpPhi should not be converted. x = f6or(a, b) } return x } //go:noinline func f6and(a int, b bool) bool { x := b if a == 0 { // f6and has side effects so the OpPhi should not be converted. x = f6and(a, b) } return x } //go:noinline func f7or(a bool, b bool) bool { return a \|\| b // ERROR "converted OpPhi to OrB$" } //go:noinline func f7and(a bool, b bool) bool { return a && b // ERROR "converted OpPhi to AndB$" } //go:noinline func f8(s string) (string, bool) { neg := false if s[0] == '-' { // ERROR "converted OpPhi to Copy$" neg = true s = s[1:] } return s, neg } var d int //go:noinline func f9(a, b int) bool { c := false if a < 0 { // ERROR "converted OpPhi to Copy$" if b < 0 { d = d + 1 } c = true } return c } func main() { }	2.03 KB	2024-02-02 18:09
📄 print.go // 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 internal print routines that are generated // by the print builtin. This test is not exhaustive, // we're just checking that the formatting is correct. package main func main() { println((interface{})(nil)) // printeface println((interface { // printiface f() })(nil)) println((map[int]int)(nil)) // printpointer println(([]int)(nil)) // printslice println(int64(-7)) // printint println(uint64(7)) // printuint println(uint32(7)) // printuint println(uint16(7)) // printuint println(uint8(7)) // printuint println(uint(7)) // printuint println(uintptr(7)) // printuint println(8.0) // printfloat println(complex(9.0, 10.0)) // printcomplex println(true) // printbool println(false) // printbool println("hello") // printstring println("one", "two") // printsp // test goprintf defer println((interface{})(nil)) defer println((interface { f() })(nil)) defer println((map[int]int)(nil)) defer println(([]int)(nil)) defer println(int64(-11)) defer println(uint64(12)) defer println(uint32(12)) defer println(uint16(12)) defer println(uint8(12)) defer println(uint(12)) defer println(uintptr(12)) defer println(13.0) defer println(complex(14.0, 15.0)) defer println(true) defer println(false) defer println("hello") defer println("one", "two") }	1.56 KB	2024-02-02 18:09
📄 print.out (0x0,0x0) (0x0,0x0) 0x0 [0/0]0x0 -7 7 7 7 7 7 7 +8.000000e+000 (+9.000000e+000+1.000000e+001i) true false hello one two one two hello false true (+1.400000e+001+1.500000e+001i) +1.300000e+001 12 12 12 12 12 12 -11 [0/0]0x0 0x0 (0x0,0x0) (0x0,0x0)	247 B	2024-02-02 18:09
📄 printbig.go // run // Copyright 2009 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 that big numbers work as constants and print can print them. package main func main() { print(-(1<<63), "\n") print((1<<63)-1, "\n") }	315 B	2024-02-02 18:09
📄 printbig.out -9223372036854775808 9223372036854775807	41 B	2024-02-02 18:09
📄 prove.go // errorcheck -0 -d=ssa/prove/debug=1 //go:build amd64 // 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. package main import "math" func f0(a []int) int { a[0] = 1 a[0] = 1 // ERROR "Proved IsInBounds$" a[6] = 1 a[6] = 1 // ERROR "Proved IsInBounds$" a[5] = 1 // ERROR "Proved IsInBounds$" a[5] = 1 // ERROR "Proved IsInBounds$" return 13 } func f1(a []int) int { if len(a) <= 5 { return 18 } a[0] = 1 // ERROR "Proved IsInBounds$" a[0] = 1 // ERROR "Proved IsInBounds$" a[6] = 1 a[6] = 1 // ERROR "Proved IsInBounds$" a[5] = 1 // ERROR "Proved IsInBounds$" a[5] = 1 // ERROR "Proved IsInBounds$" return 26 } func f1b(a []int, i int, j uint) int { if i >= 0 && i < len(a) { return a[i] // ERROR "Proved IsInBounds$" } if i >= 10 && i < len(a) { return a[i] // ERROR "Proved IsInBounds$" } if i >= 10 && i < len(a) { return a[i] // ERROR "Proved IsInBounds$" } if i >= 10 && i < len(a) { return a[i-10] // ERROR "Proved IsInBounds$" } if j < uint(len(a)) { return a[j] // ERROR "Proved IsInBounds$" } return 0 } func f1c(a []int, i int64) int { c := uint64(math.MaxInt64 + 10) // overflows int d := int64(c) if i >= d && i < int64(len(a)) { // d overflows, should not be handled. return a[i] } return 0 } func f2(a []int) int { for i := range a { // ERROR "Induction variable: limits \[0,\?\), increment 1$" a[i+1] = i a[i+1] = i // ERROR "Proved IsInBounds$" } return 34 } func f3(a []uint) int { for i := uint(0); i < uint(len(a)); i++ { a[i] = i // ERROR "Proved IsInBounds$" } return 41 } func f4a(a, b, c int) int { if a < b { if a == b { // ERROR "Disproved Eq64$" return 47 } if a > b { // ERROR "Disproved Less64$" return 50 } if a < b { // ERROR "Proved Less64$" return 53 } // We can't get to this point and prove knows that, so // there's no message for the next (obvious) branch. if a != a { return 56 } return 61 } return 63 } func f4b(a, b, c int) int { if a <= b { if a >= b { if a == b { // ERROR "Proved Eq64$" return 70 } return 75 } return 77 } return 79 } func f4c(a, b, c int) int { if a <= b { if a >= b { if a != b { // ERROR "Disproved Neq64$" return 73 } return 75 } return 77 } return 79 } func f4d(a, b, c int) int { if a < b { if a < c { if a < b { // ERROR "Proved Less64$" if a < c { // ERROR "Proved Less64$" return 87 } return 89 } return 91 } return 93 } return 95 } func f4e(a, b, c int) int { if a < b { if b > a { // ERROR "Proved Less64$" return 101 } return 103 } return 105 } func f4f(a, b, c int) int { if a <= b { if b > a { if b == a { // ERROR "Disproved Eq64$" return 112 } return 114 } if b >= a { // ERROR "Proved Leq64$" if b == a { // ERROR "Proved Eq64$" return 118 } return 120 } return 122 } return 124 } func f5(a, b uint) int { if a == b { if a <= b { // ERROR "Proved Leq64U$" return 130 } return 132 } return 134 } // These comparisons are compile time constants. func f6a(a uint8) int { if a < a { // ERROR "Disproved Less8U$" return 140 } return 151 } func f6b(a uint8) int { if a < a { // ERROR "Disproved Less8U$" return 140 } return 151 } func f6x(a uint8) int { if a > a { // ERROR "Disproved Less8U$" return 143 } return 151 } func f6d(a uint8) int { if a <= a { // ERROR "Proved Leq8U$" return 146 } return 151 } func f6e(a uint8) int { if a >= a { // ERROR "Proved Leq8U$" return 149 } return 151 } func f7(a []int, b int) int { if b < len(a) { a[b] = 3 if b < len(a) { // ERROR "Proved Less64$" a[b] = 5 // ERROR "Proved IsInBounds$" } } return 161 } func f8(a, b uint) int { if a == b { return 166 } if a > b { return 169 } if a < b { // ERROR "Proved Less64U$" return 172 } return 174 } func f9(a, b bool) int { if a { return 1 } if a \|\| b { // ERROR "Disproved Arg$" return 2 } return 3 } func f10(a string) int { n := len(a) // We optimize comparisons with small constant strings (see cmd/compile/internal/gc/walk.go), // so this string literal must be long. if a[:n>>1] == "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" { return 0 } return 1 } func f11a(a []int, i int) { useInt(a[i]) useInt(a[i]) // ERROR "Proved IsInBounds$" } func f11b(a []int, i int) { useSlice(a[i:]) useSlice(a[i:]) // ERROR "Proved IsSliceInBounds$" } func f11c(a []int, i int) { useSlice(a[:i]) useSlice(a[:i]) // ERROR "Proved IsSliceInBounds$" } func f11d(a []int, i int) { useInt(a[2i+7]) useInt(a[2i+7]) // ERROR "Proved IsInBounds$" } func f12(a []int, b int) { useSlice(a[:b]) } func f13a(a, b, c int, x bool) int { if a > 12 { if x { if a < 12 { // ERROR "Disproved Less64$" return 1 } } if x { if a <= 12 { // ERROR "Disproved Leq64$" return 2 } } if x { if a == 12 { // ERROR "Disproved Eq64$" return 3 } } if x { if a >= 12 { // ERROR "Proved Leq64$" return 4 } } if x { if a > 12 { // ERROR "Proved Less64$" return 5 } } return 6 } return 0 } func f13b(a int, x bool) int { if a == -9 { if x { if a < -9 { // ERROR "Disproved Less64$" return 7 } } if x { if a <= -9 { // ERROR "Proved Leq64$" return 8 } } if x { if a == -9 { // ERROR "Proved Eq64$" return 9 } } if x { if a >= -9 { // ERROR "Proved Leq64$" return 10 } } if x { if a > -9 { // ERROR "Disproved Less64$" return 11 } } return 12 } return 0 } func f13c(a int, x bool) int { if a < 90 { if x { if a < 90 { // ERROR "Proved Less64$" return 13 } } if x { if a <= 90 { // ERROR "Proved Leq64$" return 14 } } if x { if a == 90 { // ERROR "Disproved Eq64$" return 15 } } if x { if a >= 90 { // ERROR "Disproved Leq64$" return 16 } } if x { if a > 90 { // ERROR "Disproved Less64$" return 17 } } return 18 } return 0 } func f13d(a int) int { if a < 5 { if a < 9 { // ERROR "Proved Less64$" return 1 } } return 0 } func f13e(a int) int { if a > 9 { if a > 5 { // ERROR "Proved Less64$" return 1 } } return 0 } func f13f(a int64) int64 { if a > math.MaxInt64 { if a == 0 { // ERROR "Disproved Eq64$" return 1 } } return 0 } func f13g(a int) int { if a < 3 { return 5 } if a > 3 { return 6 } if a == 3 { // ERROR "Proved Eq64$" return 7 } return 8 } func f13h(a int) int { if a < 3 { if a > 1 { if a == 2 { // ERROR "Proved Eq64$" return 5 } } } return 0 } func f13i(a uint) int { if a == 0 { return 1 } if a > 0 { // ERROR "Proved Less64U$" return 2 } return 3 } func f14(p, q int, a []int) { // This crazy ordering usually gives i1 the lowest value ID, // j the middle value ID, and i2 the highest value ID. // That used to confuse CSE because it ordered the args // of the two + ops below differently. // That in turn foiled bounds check elimination. i1 := p j := q i2 := p useInt(a[i1+j]) useInt(a[i2+j]) // ERROR "Proved IsInBounds$" } func f15(s []int, x int) { useSlice(s[x:]) useSlice(s[:x]) // ERROR "Proved IsSliceInBounds$" } func f16(s []int) []int { if len(s) >= 10 { return s[:10] // ERROR "Proved IsSliceInBounds$" } return nil } func f17(b []int) { for i := 0; i < len(b); i++ { // ERROR "Induction variable: limits \[0,\?\), increment 1$" // This tests for i <= cap, which we can only prove // using the derived relation between len and cap. // This depends on finding the contradiction, since we // don't query this condition directly. useSlice(b[:i]) // ERROR "Proved IsSliceInBounds$" } } func f18(b []int, x int, y uint) { _ = b[x] _ = b[y] if x > len(b) { // ERROR "Disproved Less64$" return } if y > uint(len(b)) { // ERROR "Disproved Less64U$" return } if int(y) > len(b) { // ERROR "Disproved Less64$" return } } func f19() (e int64, err error) { // Issue 29502: slice[:0] is incorrectly disproved. var stack []int64 stack = append(stack, 123) if len(stack) > 1 { panic("too many elements") } last := len(stack) - 1 e = stack[last] // Buggy compiler prints "Disproved Leq64" for the next line. stack = stack[:last] return e, nil } func sm1(b []int, x int) { // Test constant argument to slicemask. useSlice(b[2:8]) // ERROR "Proved slicemask not needed$" // Test non-constant argument with known limits. if cap(b) > 10 { useSlice(b[2:]) } } func lim1(x, y, z int) { // Test relations between signed and unsigned limits. if x > 5 { if uint(x) > 5 { // ERROR "Proved Less64U$" return } } if y >= 0 && y < 4 { if uint(y) > 4 { // ERROR "Disproved Less64U$" return } if uint(y) < 5 { // ERROR "Proved Less64U$" return } } if z < 4 { if uint(z) > 4 { // Not provable without disjunctions. return } } } // fence1–4 correspond to the four fence-post implications. func fence1(b []int, x, y int) { // Test proofs that rely on fence-post implications. if x+1 > y { if x < y { // ERROR "Disproved Less64$" return } } if len(b) < cap(b) { // This eliminates the growslice path. b = append(b, 1) // ERROR "Disproved Less64U$" } } func fence2(x, y int) { if x-1 < y { if x > y { // ERROR "Disproved Less64$" return } } } func fence3(b, c []int, x, y int64) { if x-1 >= y { if x <= y { // Can't prove because x may have wrapped. return } } if x != math.MinInt64 && x-1 >= y { if x <= y { // ERROR "Disproved Leq64$" return } } c[len(c)-1] = 0 // Can't prove because len(c) might be 0 if n := len(b); n > 0 { b[n-1] = 0 // ERROR "Proved IsInBounds$" } } func fence4(x, y int64) { if x >= y+1 { if x <= y { return } } if y != math.MaxInt64 && x >= y+1 { if x <= y { // ERROR "Disproved Leq64$" return } } } // Check transitive relations func trans1(x, y int64) { if x > 5 { if y > x { if y > 2 { // ERROR "Proved Less64$" return } } else if y == x { if y > 5 { // ERROR "Proved Less64$" return } } } if x >= 10 { if y > x { if y > 10 { // ERROR "Proved Less64$" return } } } } func trans2(a, b []int, i int) { if len(a) != len(b) { return } _ = a[i] _ = b[i] // ERROR "Proved IsInBounds$" } func trans3(a, b []int, i int) { if len(a) > len(b) { return } _ = a[i] _ = b[i] // ERROR "Proved IsInBounds$" } func trans4(b []byte, x int) { // Issue #42603: slice len/cap transitive relations. switch x { case 0: if len(b) < 20 { return } _ = b[:2] // ERROR "Proved IsSliceInBounds$" case 1: if len(b) < 40 { return } _ = b[:2] // ERROR "Proved IsSliceInBounds$" } } // Derived from nat.cmp func natcmp(x, y []uint) (r int) { m := len(x) n := len(y) if m != n \|\| m == 0 { return } i := m - 1 for i > 0 && // ERROR "Induction variable: limits $0,\?\], increment 1$" x[i] == // ERROR "Proved IsInBounds$" y[i] { // ERROR "Proved IsInBounds$" i-- } switch { case x[i] < // todo, cannot prove this because it's dominated by i<=0 \|\| x[i]==y[i] y[i]: // ERROR "Proved IsInBounds$" r = -1 case x[i] > // ERROR "Proved IsInBounds$" y[i]: // ERROR "Proved IsInBounds$" r = 1 } return } func suffix(s, suffix string) bool { // todo, we're still not able to drop the bound check here in the general case return len(s) >= len(suffix) && s[len(s)-len(suffix):] == suffix } func constsuffix(s string) bool { return suffix(s, "abc") // ERROR "Proved IsSliceInBounds$" } // oforuntil tests the pattern created by OFORUNTIL blocks. These are // handled by addLocalInductiveFacts rather than findIndVar. func oforuntil(b []int) { i := 0 if len(b) > i { top: println(b[i]) // ERROR "Induction variable: limits \[0,\?$, increment 1$" "Proved IsInBounds$" i++ if i < len(b) { goto top } } } func atexit(foobar []func()) { for i := len(foobar) - 1; i >= 0; i-- { // ERROR "Induction variable: limits \[0,\?\], increment 1" f := foobar[i] foobar = foobar[:i] // ERROR "IsSliceInBounds" f() } } func make1(n int) []int { s := make([]int, n) for i := 0; i < n; i++ { // ERROR "Induction variable: limits \[0,\?\), increment 1" s[i] = 1 // ERROR "Proved IsInBounds$" } return s } func make2(n int) []int { s := make([]int, n) for i := range s { // ERROR "Induction variable: limits \[0,\?\), increment 1" s[i] = 1 // ERROR "Proved IsInBounds$" } return s } // The range tests below test the index variable of range loops. // range1 compiles to the "efficiently indexable" form of a range loop. func range1(b []int) { for i, v := range b { // ERROR "Induction variable: limits \[0,\?\), increment 1$" b[i] = v + 1 // ERROR "Proved IsInBounds$" if i < len(b) { // ERROR "Proved Less64$" println("x") } if i >= 0 { // ERROR "Proved Leq64$" println("x") } } } // range2 elements are larger, so they use the general form of a range loop. func range2(b [][32]int) { for i, v := range b { // ERROR "Induction variable: limits \[0,\?\), increment 1$" b[i][0] = v[0] + 1 // ERROR "Proved IsInBounds$" if i < len(b) { // ERROR "Proved Less64$" println("x") } if i >= 0 { // ERROR "Proved Leq64$" println("x") } } } // signhint1-2 test whether the hint (int >= 0) is propagated into the loop. func signHint1(i int, data []byte) { if i >= 0 { for i < len(data) { // ERROR "Induction variable: limits \[\?,\?\), increment 1$" _ = data[i] // ERROR "Proved IsInBounds$" i++ } } } func signHint2(b []byte, n int) { if n < 0 { panic("") } _ = b[25] for i := n; i <= 25; i++ { // ERROR "Induction variable: limits \[\?,25\], increment 1$" b[i] = 123 // ERROR "Proved IsInBounds$" } } // indexGT0 tests whether prove learns int index >= 0 from bounds check. func indexGT0(b []byte, n int) { _ = b[n] _ = b[25] for i := n; i <= 25; i++ { // ERROR "Induction variable: limits \[\?,25\], increment 1$" b[i] = 123 // ERROR "Proved IsInBounds$" } } // Induction variable in unrolled loop. func unrollUpExcl(a []int) int { var i, x int for i = 0; i < len(a)-1; i += 2 { // ERROR "Induction variable: limits \[0,\?\), increment 2$" x += a[i] // ERROR "Proved IsInBounds$" x += a[i+1] } if i == len(a)-1 { x += a[i] } return x } // Induction variable in unrolled loop. func unrollUpIncl(a []int) int { var i, x int for i = 0; i <= len(a)-2; i += 2 { // ERROR "Induction variable: limits \[0,\?\], increment 2$" x += a[i] // ERROR "Proved IsInBounds$" x += a[i+1] } if i == len(a)-1 { x += a[i] } return x } // Induction variable in unrolled loop. func unrollDownExcl0(a []int) int { var i, x int for i = len(a) - 1; i > 0; i -= 2 { // ERROR "Induction variable: limits \(0,\?\], increment 2$" x += a[i] // ERROR "Proved IsInBounds$" x += a[i-1] // ERROR "Proved IsInBounds$" } if i == 0 { x += a[i] } return x } // Induction variable in unrolled loop. func unrollDownExcl1(a []int) int { var i, x int for i = len(a) - 1; i >= 1; i -= 2 { // ERROR "Induction variable: limits \(0,\?\], increment 2$" x += a[i] // ERROR "Proved IsInBounds$" x += a[i-1] // ERROR "Proved IsInBounds$" } if i == 0 { x += a[i] } return x } // Induction variable in unrolled loop. func unrollDownInclStep(a []int) int { var i, x int for i = len(a); i >= 2; i -= 2 { // ERROR "Induction variable: limits \[2,\?\], increment 2$" x += a[i-1] // ERROR "Proved IsInBounds$" x += a[i-2] // ERROR "Proved IsInBounds$" } if i == 1 { x += a[i-1] } return x } // Not an induction variable (step too large) func unrollExclStepTooLarge(a []int) int { var i, x int for i = 0; i < len(a)-1; i += 3 { x += a[i] x += a[i+1] } if i == len(a)-1 { x += a[i] } return x } // Not an induction variable (step too large) func unrollInclStepTooLarge(a []int) int { var i, x int for i = 0; i <= len(a)-2; i += 3 { x += a[i] x += a[i+1] } if i == len(a)-1 { x += a[i] } return x } // Not an induction variable (min too small, iterating down) func unrollDecMin(a []int) int { var i, x int for i = len(a); i >= math.MinInt64; i -= 2 { x += a[i-1] x += a[i-2] } if i == 1 { // ERROR "Disproved Eq64$" x += a[i-1] } return x } // Not an induction variable (min too small, iterating up -- perhaps could allow, but why bother?) func unrollIncMin(a []int) int { var i, x int for i = len(a); i >= math.MinInt64; i += 2 { x += a[i-1] x += a[i-2] } if i == 1 { // ERROR "Disproved Eq64$" x += a[i-1] } return x } // The 4 xxxxExtNto64 functions below test whether prove is looking // through value-preserving sign/zero extensions of index values (issue #26292). // Look through all extensions func signExtNto64(x []int, j8 int8, j16 int16, j32 int32) int { if len(x) < 22 { return 0 } if j8 >= 0 && j8 < 22 { return x[j8] // ERROR "Proved IsInBounds$" } if j16 >= 0 && j16 < 22 { return x[j16] // ERROR "Proved IsInBounds$" } if j32 >= 0 && j32 < 22 { return x[j32] // ERROR "Proved IsInBounds$" } return 0 } func zeroExtNto64(x []int, j8 uint8, j16 uint16, j32 uint32) int { if len(x) < 22 { return 0 } if j8 >= 0 && j8 < 22 { return x[j8] // ERROR "Proved IsInBounds$" } if j16 >= 0 && j16 < 22 { return x[j16] // ERROR "Proved IsInBounds$" } if j32 >= 0 && j32 < 22 { return x[j32] // ERROR "Proved IsInBounds$" } return 0 } // Process fence-post implications through 32to64 extensions (issue #29964) func signExt32to64Fence(x []int, j int32) int { if x[j] != 0 { return 1 } if j > 0 && x[j-1] != 0 { // ERROR "Proved IsInBounds$" return 1 } return 0 } func zeroExt32to64Fence(x []int, j uint32) int { if x[j] != 0 { return 1 } if j > 0 && x[j-1] != 0 { // ERROR "Proved IsInBounds$" return 1 } return 0 } // Ensure that bounds checks with negative indexes are not incorrectly removed. func negIndex() { n := make([]int, 1) for i := -1; i <= 0; i++ { // ERROR "Induction variable: limits \[-1,0\], increment 1$" n[i] = 1 } } func negIndex2(n int) { a := make([]int, 5) b := make([]int, 5) c := make([]int, 5) for i := -1; i <= 0; i-- { b[i] = i n++ if n > 10 { break } } useSlice(a) useSlice(c) } // Check that prove is zeroing these right shifts of positive ints by bit-width - 1. // e.g (Rsh64x64 <t> n (Const64 <typ.UInt64> [63])) && ft.isNonNegative(n) -> 0 func sh64(n int64) int64 { if n < 0 { return n } return n >> 63 // ERROR "Proved Rsh64x64 shifts to zero" } func sh32(n int32) int32 { if n < 0 { return n } return n >> 31 // ERROR "Proved Rsh32x64 shifts to zero" } func sh32x64(n int32) int32 { if n < 0 { return n } return n >> uint64(31) // ERROR "Proved Rsh32x64 shifts to zero" } func sh16(n int16) int16 { if n < 0 { return n } return n >> 15 // ERROR "Proved Rsh16x64 shifts to zero" } func sh64noopt(n int64) int64 { return n >> 63 // not optimized; n could be negative } // These cases are division of a positive signed integer by a power of 2. // The opt pass doesnt have sufficient information to see that n is positive. // So, instead, opt rewrites the division with a less-than-optimal replacement. // Prove, which can see that n is nonnegative, cannot see the division because // opt, an earlier pass, has already replaced it. // The fix for this issue allows prove to zero a right shift that was added as // part of the less-than-optimal reqwrite. That change by prove then allows // lateopt to clean up all the unnecessary parts of the original division // replacement. See issue #36159. func divShiftClean(n int) int { if n < 0 { return n } return n / int(8) // ERROR "Proved Rsh64x64 shifts to zero" } func divShiftClean64(n int64) int64 { if n < 0 { return n } return n / int64(16) // ERROR "Proved Rsh64x64 shifts to zero" } func divShiftClean32(n int32) int32 { if n < 0 { return n } return n / int32(16) // ERROR "Proved Rsh32x64 shifts to zero" } // Bounds check elimination func sliceBCE1(p []string, h uint) string { if len(p) == 0 { return "" } i := h & uint(len(p)-1) return p[i] // ERROR "Proved IsInBounds$" } func sliceBCE2(p []string, h int) string { if len(p) == 0 { return "" } i := h & (len(p) - 1) return p[i] // ERROR "Proved IsInBounds$" } func and(p []byte) ([]byte, []byte) { // issue #52563 const blocksize = 16 fullBlocks := len(p) &^ (blocksize - 1) blk := p[:fullBlocks] // ERROR "Proved IsSliceInBounds$" rem := p[fullBlocks:] // ERROR "Proved IsSliceInBounds$" return blk, rem } func rshu(x, y uint) int { z := x >> y if z <= x { // ERROR "Proved Leq64U$" return 1 } return 0 } func divu(x, y uint) int { z := x / y if z <= x { // ERROR "Proved Leq64U$" return 1 } return 0 } func modu1(x, y uint) int { z := x % y if z < y { // ERROR "Proved Less64U$" return 1 } return 0 } func modu2(x, y uint) int { z := x % y if z <= x { // ERROR "Proved Leq64U$" return 1 } return 0 } func issue57077(s []int) (left, right []int) { middle := len(s) / 2 left = s[:middle] // ERROR "Proved IsSliceInBounds$" right = s[middle:] // ERROR "Proved IsSliceInBounds$" return } func issue51622(b []byte) int { if len(b) >= 3 && b[len(b)-3] == '#' { // ERROR "Proved IsInBounds$" return len(b) } return 0 } func issue45928(x int) { combinedFrac := x / (x \| (1 << 31)) // ERROR "Proved Neq64$" useInt(combinedFrac) } //go:noinline func useInt(a int) { } //go:noinline func useSlice(a []int) { } func main() { }	21.08 KB	2024-02-02 18:09
📄 prove_constant_folding.go // errorcheck -0 -d=ssa/prove/debug=2 //go:build amd64 // Copyright 2022 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 func f0i(x int) int { if x == 20 { return x // ERROR "Proved.+is constant 20$" } if (x + 20) == 20 { return x + 5 // ERROR "Proved.+is constant 0$" } return x / 2 } func f0u(x uint) uint { if x == 20 { return x // ERROR "Proved.+is constant 20$" } if (x + 20) == 20 { return x + 5 // ERROR "Proved.+is constant 0$" } return x / 2 }	604 B	2024-02-02 18:09
📄 prove_invert_loop_with_unused_iterators.go // errorcheck -0 -d=ssa/prove/debug=1 //go:build amd64 package main func invert(b func(), n int) { for i := 0; i < n; i++ { // ERROR "(Inverted loop iteration\|Induction variable: limits \[0,\?\), increment 1)" b() } }	225 B	2024-02-02 18:09
📄 range.go // run // Copyright 2009 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 the 'for range' construct. package main // test range over channels func gen(c chan int, lo, hi int) { for i := lo; i <= hi; i++ { c <- i } close(c) } func seq(lo, hi int) chan int { c := make(chan int) go gen(c, lo, hi) return c } const alphabet = "abcdefghijklmnopqrstuvwxyz" func testblankvars() { n := 0 for range alphabet { n++ } if n != 26 { println("for range: wrong count", n, "want 26") panic("fail") } n = 0 for _ = range alphabet { n++ } if n != 26 { println("for _ = range: wrong count", n, "want 26") panic("fail") } n = 0 for _, _ = range alphabet { n++ } if n != 26 { println("for _, _ = range: wrong count", n, "want 26") panic("fail") } s := 0 for i, _ := range alphabet { s += i } if s != 325 { println("for i, _ := range: wrong sum", s, "want 325") panic("fail") } r := rune(0) for _, v := range alphabet { r += v } if r != 2847 { println("for _, v := range: wrong sum", r, "want 2847") panic("fail") } } func testchan() { s := "" for i := range seq('a', 'z') { s += string(i) } if s != alphabet { println("Wanted lowercase alphabet; got", s) panic("fail") } n := 0 for range seq('a', 'z') { n++ } if n != 26 { println("testchan wrong count", n, "want 26") panic("fail") } } // test that range over slice only evaluates // the expression after "range" once. var nmake = 0 func makeslice() []int { nmake++ return []int{1, 2, 3, 4, 5} } func testslice() { s := 0 nmake = 0 for _, v := range makeslice() { s += v } if nmake != 1 { println("range called makeslice", nmake, "times") panic("fail") } if s != 15 { println("wrong sum ranging over makeslice", s) panic("fail") } x := []int{10, 20} y := []int{99} i := 1 for i, x[i] = range y { break } if i != 0 \|\| x[0] != 10 \|\| x[1] != 99 { println("wrong parallel assignment", i, x[0], x[1]) panic("fail") } } func testslice1() { s := 0 nmake = 0 for i := range makeslice() { s += i } if nmake != 1 { println("range called makeslice", nmake, "times") panic("fail") } if s != 10 { println("wrong sum ranging over makeslice", s) panic("fail") } } func testslice2() { n := 0 nmake = 0 for range makeslice() { n++ } if nmake != 1 { println("range called makeslice", nmake, "times") panic("fail") } if n != 5 { println("wrong count ranging over makeslice", n) panic("fail") } } // test that range over []byte(string) only evaluates // the expression after "range" once. func makenumstring() string { nmake++ return "\x01\x02\x03\x04\x05" } func testslice3() { s := byte(0) nmake = 0 for _, v := range []byte(makenumstring()) { s += v } if nmake != 1 { println("range called makenumstring", nmake, "times") panic("fail") } if s != 15 { println("wrong sum ranging over []byte(makenumstring)", s) panic("fail") } } // test that range over array only evaluates // the expression after "range" once. func makearray() [5]int { nmake++ return [5]int{1, 2, 3, 4, 5} } func testarray() { s := 0 nmake = 0 for _, v := range makearray() { s += v } if nmake != 1 { println("range called makearray", nmake, "times") panic("fail") } if s != 15 { println("wrong sum ranging over makearray", s) panic("fail") } } func testarray1() { s := 0 nmake = 0 for i := range makearray() { s += i } if nmake != 1 { println("range called makearray", nmake, "times") panic("fail") } if s != 10 { println("wrong sum ranging over makearray", s) panic("fail") } } func testarray2() { n := 0 nmake = 0 for range makearray() { n++ } if nmake != 1 { println("range called makearray", nmake, "times") panic("fail") } if n != 5 { println("wrong count ranging over makearray", n) panic("fail") } } func makearrayptr() [5]int { nmake++ return &[5]int{1, 2, 3, 4, 5} } func testarrayptr() { nmake = 0 x := len(makearrayptr()) if x != 5 \|\| nmake != 1 { println("len called makearrayptr", nmake, "times and got len", x) panic("fail") } nmake = 0 x = cap(makearrayptr()) if x != 5 \|\| nmake != 1 { println("cap called makearrayptr", nmake, "times and got len", x) panic("fail") } s := 0 nmake = 0 for _, v := range makearrayptr() { s += v } if nmake != 1 { println("range called makearrayptr", nmake, "times") panic("fail") } if s != 15 { println("wrong sum ranging over makearrayptr", s) panic("fail") } } func testarrayptr1() { s := 0 nmake = 0 for i := range makearrayptr() { s += i } if nmake != 1 { println("range called makearrayptr", nmake, "times") panic("fail") } if s != 10 { println("wrong sum ranging over makearrayptr", s) panic("fail") } } func testarrayptr2() { n := 0 nmake = 0 for range makearrayptr() { n++ } if nmake != 1 { println("range called makearrayptr", nmake, "times") panic("fail") } if n != 5 { println("wrong count ranging over makearrayptr", n) panic("fail") } } // test that range over string only evaluates // the expression after "range" once. func makestring() string { nmake++ return "abcd☺" } func teststring() { var s rune nmake = 0 for _, v := range makestring() { s += v } if nmake != 1 { println("range called makestring", nmake, "times") panic("fail") } if s != 'a'+'b'+'c'+'d'+'☺' { println("wrong sum ranging over makestring", s) panic("fail") } x := []rune{'a', 'b'} i := 1 for i, x[i] = range "c" { break } if i != 0 \|\| x[0] != 'a' \|\| x[1] != 'c' { println("wrong parallel assignment", i, x[0], x[1]) panic("fail") } y := []int{1, 2, 3} r := rune(1) for y[r], r = range "\x02" { break } if r != 2 \|\| y[0] != 1 \|\| y[1] != 0 \|\| y[2] != 3 { println("wrong parallel assignment", r, y[0], y[1], y[2]) panic("fail") } } func teststring1() { s := 0 nmake = 0 for i := range makestring() { s += i } if nmake != 1 { println("range called makestring", nmake, "times") panic("fail") } if s != 10 { println("wrong sum ranging over makestring", s) panic("fail") } } func teststring2() { n := 0 nmake = 0 for range makestring() { n++ } if nmake != 1 { println("range called makestring", nmake, "times") panic("fail") } if n != 5 { println("wrong count ranging over makestring", n) panic("fail") } } // test that range over map only evaluates // the expression after "range" once. func makemap() map[int]int { nmake++ return map[int]int{0: 'a', 1: 'b', 2: 'c', 3: 'd', 4: '☺'} } func testmap() { s := 0 nmake = 0 for _, v := range makemap() { s += v } if nmake != 1 { println("range called makemap", nmake, "times") panic("fail") } if s != 'a'+'b'+'c'+'d'+'☺' { println("wrong sum ranging over makemap", s) panic("fail") } } func testmap1() { s := 0 nmake = 0 for i := range makemap() { s += i } if nmake != 1 { println("range called makemap", nmake, "times") panic("fail") } if s != 10 { println("wrong sum ranging over makemap", s) panic("fail") } } func testmap2() { n := 0 nmake = 0 for range makemap() { n++ } if nmake != 1 { println("range called makemap", nmake, "times") panic("fail") } if n != 5 { println("wrong count ranging over makemap", n) panic("fail") } } // test that range evaluates the index and value expressions // exactly once per iteration. var ncalls = 0 func getvar(p int) int { ncalls++ return p } func testcalls() { var i, v int si := 0 sv := 0 for getvar(&i), getvar(&v) = range [2]int{1, 2} { si += i sv += v } if ncalls != 4 { println("wrong number of calls:", ncalls, "!= 4") panic("fail") } if si != 1 \|\| sv != 3 { println("wrong sum in testcalls", si, sv) panic("fail") } ncalls = 0 for getvar(&i), *getvar(&v) = range [0]int{} { println("loop ran on empty array") panic("fail") } if ncalls != 0 { println("wrong number of calls:", ncalls, "!= 0") panic("fail") } } func main() { testblankvars() testchan() testarray() testarray1() testarray2() testarrayptr() testarrayptr1() testarrayptr2() testslice() testslice1() testslice2() testslice3() teststring() teststring1() teststring2() testmap() testmap1() testmap2() testcalls() }	8.14 KB	2024-02-02 18:09
📄 range2.go // errorcheck -goexperiment rangefunc // Copyright 2023 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. // See ../internal/types/testdata/spec/range.go for most tests. // The ones in this file cannot be expressed in that framework // due to conflicts between that framework's error location pickiness // and gofmt's comment location pickiness. package p type T struct{} func (T) PM() {} func (T) M() {} func test() { for range T.M { // ERROR "cannot range over T.M $value of type func\(T$\): func must be func$yield func\(...$ bool\): argument is not func" } for range (T).PM { // ERROR "cannot range over $\T$.PM $value of type func\(\T$\): func must be func$yield func\(...$ bool\): argument is not func" } }	830 B	2024-02-02 18:09
📄 range3.go // run // Copyright 2023 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 the 'for range' construct ranging over integers. package main func testint1() { bad := false j := 0 for i := range int(4) { if i != j { println("range var", i, "want", j) bad = true } j++ } if j != 4 { println("wrong count ranging over 4:", j) bad = true } if bad { panic("testint1") } } func testint2() { bad := false j := 0 for i := range 4 { if i != j { println("range var", i, "want", j) bad = true } j++ } if j != 4 { println("wrong count ranging over 4:", j) bad = true } if bad { panic("testint2") } } func testint3() { bad := false type MyInt int j := MyInt(0) for i := range MyInt(4) { if i != j { println("range var", i, "want", j) bad = true } j++ } if j != 4 { println("wrong count ranging over 4:", j) bad = true } if bad { panic("testint3") } } // Issue #63378. func testint4() { for i := range -1 { _ = i panic("must not be executed") } } // Issue #64471. func testint5() { for i := range 'a' { var _ *rune = &i // ensure i has type rune } } func main() { testint1() testint2() testint3() testint4() testint5() }	1.27 KB	2024-02-02 18:09
📄 range4.go // run -goexperiment rangefunc // Copyright 2023 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 the 'for range' construct ranging over functions. package main var gj int func yield4x(yield func() bool) { _ = yield() && yield() && yield() && yield() } func yield4(yield func(int) bool) { _ = yield(1) && yield(2) && yield(3) && yield(4) } func yield3(yield func(int) bool) { _ = yield(1) && yield(2) && yield(3) } func yield2(yield func(int) bool) { _ = yield(1) && yield(2) } func testfunc0() { j := 0 for range yield4x { j++ } if j != 4 { println("wrong count ranging over yield4x:", j) panic("testfunc0") } j = 0 for _ = range yield4 { j++ } if j != 4 { println("wrong count ranging over yield4:", j) panic("testfunc0") } } func testfunc1() { bad := false j := 1 for i := range yield4 { if i != j { println("range var", i, "want", j) bad = true } j++ } if j != 5 { println("wrong count ranging over f:", j) bad = true } if bad { panic("testfunc1") } } func testfunc2() { bad := false j := 1 var i int for i = range yield4 { if i != j { println("range var", i, "want", j) bad = true } j++ } if j != 5 { println("wrong count ranging over f:", j) bad = true } if i != 4 { println("wrong final i ranging over f:", i) bad = true } if bad { panic("testfunc2") } } func testfunc3() { bad := false j := 1 var i int for i = range yield4 { if i != j { println("range var", i, "want", j) bad = true } j++ if i == 2 { break } continue } if j != 3 { println("wrong count ranging over f:", j) bad = true } if i != 2 { println("wrong final i ranging over f:", i) bad = true } if bad { panic("testfunc3") } } func testfunc4() { bad := false j := 1 var i int func() { for i = range yield4 { if i != j { println("range var", i, "want", j) bad = true } j++ if i == 2 { return } } }() if j != 3 { println("wrong count ranging over f:", j) bad = true } if i != 2 { println("wrong final i ranging over f:", i) bad = true } if bad { panic("testfunc3") } } func func5() (int, int) { for i := range yield4 { return 10, i } panic("still here") } func testfunc5() { x, y := func5() if x != 10 \|\| y != 1 { println("wrong results", x, y, "want", 10, 1) panic("testfunc5") } } func func6() (z, w int) { for i := range yield4 { z = 10 w = i return } panic("still here") } func testfunc6() { x, y := func6() if x != 10 \|\| y != 1 { println("wrong results", x, y, "want", 10, 1) panic("testfunc6") } } var saved []int func save(x int) { saved = append(saved, x) } func printslice(s []int) { print("[") for i, x := range s { if i > 0 { print(", ") } print(x) } print("]") } func eqslice(s, t []int) bool { if len(s) != len(t) { return false } for i, x := range s { if x != t[i] { return false } } return true } func func7() { defer save(-1) for i := range yield4 { defer save(i) } defer save(5) } func checkslice(name string, saved, want []int) { if !eqslice(saved, want) { print("wrong results ") printslice(saved) print(" want ") printslice(want) print("\n") panic(name) } } func testfunc7() { saved = nil func7() want := []int{5, 4, 3, 2, 1, -1} checkslice("testfunc7", saved, want) } func func8() { defer save(-1) for i := range yield2 { for j := range yield3 { defer save(i10 + j) } defer save(i) } defer save(-2) for i := range yield4 { defer save(i) } defer save(-3) } func testfunc8() { saved = nil func8() want := []int{-3, 4, 3, 2, 1, -2, 2, 23, 22, 21, 1, 13, 12, 11, -1} checkslice("testfunc8", saved, want) } func func9() { n := 0 for _ = range yield2 { for _ = range yield3 { n++ defer save(n) } } } func testfunc9() { saved = nil func9() want := []int{6, 5, 4, 3, 2, 1} checkslice("testfunc9", saved, want) } // test that range evaluates the index and value expressions // exactly once per iteration. var ncalls = 0 func getvar(p int) int { ncalls++ return p } func iter2(list ...int) func(func(int, int) bool) { return func(yield func(int, int) bool) { for i, x := range list { if !yield(i, x) { return } } } } func testcalls() { var i, v int ncalls = 0 si := 0 sv := 0 for getvar(&i), *getvar(&v) = range iter2(1, 2) { si += i sv += v } if ncalls != 4 { println("wrong number of calls:", ncalls, "!= 4") panic("fail") } if si != 1 \|\| sv != 3 { println("wrong sum in testcalls", si, sv) panic("fail") } } type iter3YieldFunc func(int, int) bool func iter3(list ...int) func(iter3YieldFunc) { return func(yield iter3YieldFunc) { for k, v := range list { if !yield(k, v) { return } } } } func testcalls1() { ncalls := 0 for k, v := range iter3(1, 2, 3) { _, _ = k, v ncalls++ } if ncalls != 3 { println("wrong number of calls:", ncalls, "!= 3") panic("fail") } } func main() { testfunc0() testfunc1() testfunc2() testfunc3() testfunc4() testfunc5() testfunc6() testfunc7() testfunc8() testfunc9() testcalls() testcalls1() }	5.11 KB	2024-02-02 18:09
📄 rangegen.go // runoutput -goexperiment rangefunc // Copyright 2023 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. // Torture test for range-over-func. // // cmd/internal/testdir runs this like // // go run rangegen.go >x.go // go run x.go // // but a longer version can be run using // // go run rangegen.go long // // In that second form, rangegen takes care of compiling // and running the code it generates, in batches. // That form takes 10-20 minutes to run. package main import ( "bytes" "fmt" "log" "math/bits" "os" "os/exec" "strings" ) const verbose = false func main() { long := len(os.Args) > 1 && os.Args[1] == "long" log.SetFlags(0) log.SetPrefix("rangegen: ") if !long && bits.UintSize == 32 { // Skip this test on 32-bit platforms, where it seems to // cause timeouts and build problems. skip() return } b := new(bytes.Buffer) tests := "" flush := func(force bool) { if !long \|\| (strings.Count(tests, "\n") < 1000 && !force) { return } p(b, mainCode, tests) err := os.WriteFile("tmp.go", b.Bytes(), 0666) if err != nil { log.Fatal(err) } out, err := exec.Command("go", "run", "tmp.go").CombinedOutput() if err != nil { log.Fatalf("go run tmp.go: %v\n%s", err, out) } print(".") if force { print("\nPASS\n") } b.Reset() tests = "" p(b, "package main\n\n") p(b, "const verbose = %v\n\n", verbose) } p(b, "package main\n\n") p(b, "const verbose = %v\n\n", verbose) max := 2 if !long { max = 5 } for i := 1; i <= max; i++ { maxDouble := -1 if long { maxDouble = i } for double := -1; double <= maxDouble; double++ { code := gen(new(bytes.Buffer), "", "", "", i, double, func(c int) bool { return true }) for j := 0; j < code; j++ { hi := j + 1 if long { hi = code } for k := j; k < hi && k < code; k++ { s := fmt.Sprintf("%d_%d_%d_%d", i, double+1, j, k) code0 := gen(b, "testFunc"+s, "", "yield2", i, double, func(c int) bool { return c == j \|\| c == k }) code1 := gen(b, "testSlice"+s, "_, ", "slice2", i, double, func(c int) bool { return c == j \|\| c == k }) if code0 != code1 { panic("bad generator") } tests += "test" + s + "()\n" p(b, testCode, "test"+s, []int{j, k}, "testFunc"+s, "testSlice"+s) flush(false) } } } } for i := 1; i <= max; i++ { maxDouble := -1 if long { maxDouble = i } for double := -1; double <= maxDouble; double++ { s := fmt.Sprintf("%d_%d", i, double+1) code := gen(b, "testFunc"+s, "", "yield2", i, double, func(c int) bool { return true }) code1 := gen(b, "testSlice"+s, "_, ", "slice2", i, double, func(c int) bool { return true }) if code != code1 { panic("bad generator") } tests += "test" + s + "()\n" var all []int for j := 0; j < code; j++ { all = append(all, j) } p(b, testCode, "test"+s, all, "testFunc"+s, "testSlice"+s) flush(false) } } if long { flush(true) os.Remove("tmp.go") return } p(b, mainCode, tests) os.Stdout.Write(b.Bytes()) } func p(b bytes.Buffer, format string, args ...any) { fmt.Fprintf(b, format, args...) } func gen(b bytes.Buffer, name, prefix, rangeExpr string, depth, double int, allowed func(int) bool) int { p(b, "func %s(o output, code int) int {\n", name) p(b, " dfr := 0; _ = dfr\n") code := genLoop(b, 0, prefix, rangeExpr, depth, double, 0, "", allowed) p(b, " return 0\n") p(b, "}\n\n") return code } func genLoop(b bytes.Buffer, d int, prefix, rangeExpr string, depth, double, code int, labelSuffix string, allowed func(int) bool) int { limit := 1 if d == double { limit = 2 } for rep := 0; rep < limit; rep++ { if rep == 1 { labelSuffix = "R" } s := fmt.Sprintf("%d%s", d, labelSuffix) p(b, " o.log(`top%s`)\n", s) p(b, " l%sa := 0\n", s) p(b, "goto L%sa; L%sa: o.log(`L%sa`)\n", s, s, s) p(b, " if l%sa++; l%sa >= 2 { o.log(`loop L%sa`); return -1 }\n", s, s, s) p(b, " l%sfor := 0\n", s) p(b, "goto L%sfor; L%sfor: for f := 0; f < 1; f++ { o.log(`L%sfor`)\n", s, s, s) p(b, " if l%sfor++; l%sfor >= 2 { o.log(`loop L%sfor`); return -1 }\n", s, s, s) p(b, " l%ssw := 0\n", s) p(b, "goto L%ssw; L%ssw: switch { default: o.log(`L%ssw`)\n", s, s, s) p(b, " if l%ssw++; l%ssw >= 2 { o.log(`loop L%ssw`); return -1 }\n", s, s, s) p(b, " l%ssel := 0\n", s) p(b, "goto L%ssel; L%ssel: select { default: o.log(`L%ssel`)\n", s, s, s) p(b, " if l%ssel++; l%ssel >= 2 { o.log(`loop L%ssel`); return -1 }\n", s, s, s) p(b, " l%s := 0\n", s) p(b, "goto L%s; L%s: for %s i%s := range %s {\n", s, s, prefix, s, rangeExpr) p(b, " o.log1(`L%s top`, i%s)\n", s, s) p(b, " if l%s++; l%s >= 4 { o.log(`loop L%s`); return -1 }\n", s, s, s) printTests := func() { if code++; allowed(code) { p(b, " if code == %v { break }\n", code) } if code++; allowed(code) { p(b, " if code == %v { continue }\n", code) } if code++; allowed(code) { p(b, " switch { case code == %v: continue }\n", code) } if code++; allowed(code) { p(b, " if code == %v { return %[1]v }\n", code) } if code++; allowed(code) { p(b, " if code == %v { select { default: break } }\n", code) } if code++; allowed(code) { p(b, " if code == %v { switch { default: break } }\n", code) } if code++; allowed(code) { p(b, " if code == %v { dfr++; defer o.log1(`defer %d`, dfr) }\n", code, code) } for i := d; i > 0; i-- { suffix := labelSuffix if i < double { suffix = "" } if code++; allowed(code) { p(b, " if code == %v { break L%d%s }\n", code, i, suffix) } if code++; allowed(code) { p(b, " if code == %v { select { default: break L%d%s } }\n", code, i, suffix) } if code++; allowed(code) { p(b, " if code == %v { break L%d%s }\n", code, i, suffix) } if code++; allowed(code) { p(b, " if code == %v { break L%d%ssw }\n", code, i, suffix) } if code++; allowed(code) { p(b, " if code == %v { break L%d%ssel }\n", code, i, suffix) } if code++; allowed(code) { p(b, " if code == %v { break L%d%sfor }\n", code, i, suffix) } if code++; allowed(code) { p(b, " if code == %v { continue L%d%sfor }\n", code, i, suffix) } if code++; allowed(code) { p(b, " if code == %v { goto L%d%sa }\n", code, i, suffix) } if code++; allowed(code) { p(b, " if code == %v { goto L%d%s }\n", code, i, suffix) } if code++; allowed(code) { p(b, " if code == %v { goto L%d%sb }\n", code, i, suffix) } } } printTests() if d < depth { if rep == 1 { double = d // signal to children to use the rep=1 labels } code = genLoop(b, d+1, prefix, rangeExpr, depth, double, code, labelSuffix, allowed) printTests() } p(b, " o.log(`L%s bot`)\n", s) p(b, " }\n") p(b, " o.log(`L%ssel bot`)\n", s) p(b, " }\n") p(b, " o.log(`L%ssw bot`)\n", s) p(b, " }\n") p(b, " o.log(`L%sfor bot`)\n", s) p(b, " }\n") p(b, " o.log(`done%s`)\n", s) p(b, "goto L%sb; L%sb: o.log(`L%sb`)\n", s, s, s) } return code } var testCode = ` func %s() { all := %#v for i := 0; i < len(all); i++ { c := all[i] outFunc := run(%s, c) outSlice := run(%s, c) if !outFunc.eq(outSlice) { println("mismatch", "%[3]s", "%[4]s", c) println() println("func:") outFunc.print() println() println("slice:") outSlice.print() panic("mismatch") } } if verbose { println("did", "%[3]s", "%[4]s", len(all)) } } ` var mainCode = ` func main() { if verbose { println("main") } %s } func yield2(yield func(int)bool) { _ = yield(1) && yield(2) } var slice2 = []int{1,2} type output struct { ret int trace []any } func (o output) log(x any) { o.trace = append(o.trace, x) } func (o output) log1(x, y any) { o.trace = append(o.trace, x, y) } func (o output) eq(p output) bool{ if o.ret != p.ret \|\| len(o.trace) != len(p.trace) { return false } for i ,x := range o.trace { if x != p.trace[i] { return false } } return true } func (o output) print() { println("ret", o.ret, "trace-len", len(o.trace)) for i := 0; i < len(o.trace); i++ { print("#", i, " ") switch x := o.trace[i].(type) { case int: print(x) case string: print(x) default: print(x) } print("\n") } } func run(f func(output, int)int, i int) *output { o := &output{} o.ret = f(o, i) return o } ` func skip() { const code = ` package main func main() { } ` fmt.Printf("%s\n", code) }	8.35 KB	2024-02-02 18:09
📄 recover.go // run // Copyright 2010 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 of basic recover functionality. package main import ( "os" "reflect" "runtime" ) func main() { // go.tools/ssa/interp still has: // - some lesser bugs in recover() // - incomplete support for reflection interp := os.Getenv("GOSSAINTERP") != "" test1() test1WithClosures() test2() test3() if !interp { test4() } test5() test6() test6WithClosures() test7() test8() test9() if !interp { test9reflect1() test9reflect2() } test10() if !interp { test10reflect1() test10reflect2() } test11() if !interp { test11reflect1() test11reflect2() } test111() test12() if !interp { test12reflect1() test12reflect2() } test13() if !interp { test13reflect1() test13reflect2() } test14() if !interp { test14reflect1() test14reflect2() test15() test16() } } func die() { runtime.Breakpoint() // can't depend on panic } func mustRecoverBody(v1, v2, v3, x interface{}) { v := v1 if v != nil { println("spurious recover", v) die() } v = v2 if v == nil { println("missing recover", x.(int)) die() // panic is useless here } if v != x { println("wrong value", v, x) die() } // the value should be gone now regardless v = v3 if v != nil { println("recover didn't recover") die() } } func doubleRecover() interface{} { return recover() } func mustRecover(x interface{}) { mustRecoverBody(doubleRecover(), recover(), recover(), x) } func mustNotRecover() { v := recover() if v != nil { println("spurious recover", v) die() } } func withoutRecover() { mustNotRecover() // because it's a sub-call } func withoutRecoverRecursive(n int) { if n == 0 { withoutRecoverRecursive(1) } else { v := recover() if v != nil { println("spurious recover (recursive)", v) die() } } } func test1() { defer mustNotRecover() // because mustRecover will squelch it defer mustRecover(1) // because of panic below defer withoutRecover() // should be no-op, leaving for mustRecover to find defer withoutRecoverRecursive(0) // ditto panic(1) } // Repeat test1 with closures instead of standard function. // Interesting because recover bases its decision // on the frame pointer of its caller, and a closure's // frame pointer is in the middle of its actual arguments // (after the hidden ones for the closed-over variables). func test1WithClosures() { defer func() { v := recover() if v != nil { println("spurious recover in closure") die() } }() defer func(x interface{}) { mustNotRecover() v := recover() if v == nil { println("missing recover", x.(int)) die() } if v != x { println("wrong value", v, x) die() } }(1) defer func() { mustNotRecover() }() panic(1) } func test2() { // Recover only sees the panic argument // if it is called from a deferred call. // It does not see the panic when called from a call within a deferred call (too late) // nor does it see the panic when it is the deferred call (too early). defer mustRecover(2) defer recover() // should be no-op panic(2) } func test3() { defer mustNotRecover() defer func() { recover() // should squelch }() panic(3) } func test4() { // Equivalent to test3 but using defer to make the call. defer mustNotRecover() defer func() { defer recover() // should squelch }() panic(4) } // Check that closures can set output arguments. // Run g(). If it panics, return x; else return deflt. func try(g func(), deflt interface{}) (x interface{}) { defer func() { if v := recover(); v != nil { x = v } }() defer g() return deflt } // Check that closures can set output arguments. // Run g(). If it panics, return x; else return deflt. func try1(g func(), deflt interface{}) (x interface{}) { defer func() { if v := recover(); v != nil { x = v } }() defer g() x = deflt return } func test5() { v := try(func() { panic(5) }, 55).(int) if v != 5 { println("wrong value", v, 5) die() } s := try(func() {}, "hi").(string) if s != "hi" { println("wrong value", s, "hi") die() } v = try1(func() { panic(5) }, 55).(int) if v != 5 { println("try1 wrong value", v, 5) die() } s = try1(func() {}, "hi").(string) if s != "hi" { println("try1 wrong value", s, "hi") die() } } // When a deferred big call starts, it must first // create yet another stack segment to hold the // giant frame for x. Make sure that doesn't // confuse recover. func big(mustRecover bool) { var x [100000]int x[0] = 1 x[99999] = 1 _ = x v := recover() if mustRecover { if v == nil { println("missing big recover") die() } } else { if v != nil { println("spurious big recover") die() } } } func test6() { defer big(false) defer big(true) panic(6) } func test6WithClosures() { defer func() { var x [100000]int x[0] = 1 x[99999] = 1 _ = x if recover() != nil { println("spurious big closure recover") die() } }() defer func() { var x [100000]int x[0] = 1 x[99999] = 1 _ = x if recover() == nil { println("missing big closure recover") die() } }() panic("6WithClosures") } func test7() { ok := false func() { // should panic, then call mustRecover 7, which stops the panic. // then should keep processing ordinary defers earlier than that one // before returning. // this test checks that the defer func on the next line actually runs. defer func() { ok = true }() defer mustRecover(7) panic(7) }() if !ok { println("did not run ok func") die() } } func varargs(s int, a ...int) { s = 0 for _, v := range a { s += v } if recover() != nil { s += 100 } } func test8a() (r int) { defer varargs(&r, 1, 2, 3) panic(0) } func test8b() (r int) { defer varargs(&r, 4, 5, 6) return } func test8() { if test8a() != 106 \|\| test8b() != 15 { println("wrong value") die() } } type I interface { M() } // pointer receiver, so no wrapper in i.M() type T1 struct{} func (T1) M() { mustRecoverBody(doubleRecover(), recover(), recover(), 9) } func test9() { var i I = &T1{} defer i.M() panic(9) } func test9reflect1() { f := reflect.ValueOf(&T1{}).Method(0).Interface().(func()) defer f() panic(9) } func test9reflect2() { f := reflect.TypeOf(&T1{}).Method(0).Func.Interface().(func(T1)) defer f(&T1{}) panic(9) } // word-sized value receiver, so no wrapper in i.M() type T2 uintptr func (T2) M() { mustRecoverBody(doubleRecover(), recover(), recover(), 10) } func test10() { var i I = T2(0) defer i.M() panic(10) } func test10reflect1() { f := reflect.ValueOf(T2(0)).Method(0).Interface().(func()) defer f() panic(10) } func test10reflect2() { f := reflect.TypeOf(T2(0)).Method(0).Func.Interface().(func(T2)) defer f(T2(0)) panic(10) } // tiny receiver, so basic wrapper in i.M() type T3 struct{} func (T3) M() { mustRecoverBody(doubleRecover(), recover(), recover(), 11) } func test11() { var i I = T3{} defer i.M() panic(11) } func test11reflect1() { f := reflect.ValueOf(T3{}).Method(0).Interface().(func()) defer f() panic(11) } func test11reflect2() { f := reflect.TypeOf(T3{}).Method(0).Func.Interface().(func(T3)) defer f(T3{}) panic(11) } // tiny receiver, so basic wrapper in i.M() type T3deeper struct{} func (T3deeper) M() { badstate() // difference from T3 mustRecoverBody(doubleRecover(), recover(), recover(), 111) } func test111() { var i I = T3deeper{} defer i.M() panic(111) } type Tiny struct{} func (Tiny) M() { panic(112) } // i.M is a wrapper, and i.M panics. // // This is a torture test for an old implementation of recover that // tried to deal with wrapper functions by doing some argument // positioning math on both entry and exit. Doing anything on exit // is a problem because sometimes functions exit via panic instead // of an ordinary return, so panic would have to know to do the // same math when unwinding the stack. It gets complicated fast. // This particular test never worked with the old scheme, because // panic never did the right unwinding math. // // The new scheme adjusts Panic.argp on entry to a wrapper. // It has no exit work, so if a wrapper is interrupted by a panic, // there's no cleanup that panic itself must do. // This test just works now. func badstate() { defer func() { recover() }() var i I = Tiny{} i.M() } // large receiver, so basic wrapper in i.M() type T4 [2]string func (T4) M() { mustRecoverBody(doubleRecover(), recover(), recover(), 12) } func test12() { var i I = T4{} defer i.M() panic(12) } func test12reflect1() { f := reflect.ValueOf(T4{}).Method(0).Interface().(func()) defer f() panic(12) } func test12reflect2() { f := reflect.TypeOf(T4{}).Method(0).Func.Interface().(func(T4)) defer f(T4{}) panic(12) } // enormous receiver, so wrapper splits stack to call M type T5 [8192]byte func (T5) M() { mustRecoverBody(doubleRecover(), recover(), recover(), 13) } func test13() { var i I = T5{} defer i.M() panic(13) } func test13reflect1() { f := reflect.ValueOf(T5{}).Method(0).Interface().(func()) defer f() panic(13) } func test13reflect2() { f := reflect.TypeOf(T5{}).Method(0).Func.Interface().(func(T5)) defer f(T5{}) panic(13) } // enormous receiver + enormous method frame, so wrapper splits stack to call M, // and then M splits stack to allocate its frame. // recover must look back two frames to find the panic. type T6 [8192]byte var global byte func (T6) M() { var x [8192]byte x[0] = 1 x[1] = 2 for i := range x { global += x[i] } mustRecoverBody(doubleRecover(), recover(), recover(), 14) } func test14() { var i I = T6{} defer i.M() panic(14) } func test14reflect1() { f := reflect.ValueOf(T6{}).Method(0).Interface().(func()) defer f() panic(14) } func test14reflect2() { f := reflect.TypeOf(T6{}).Method(0).Func.Interface().(func(T6)) defer f(T6{}) panic(14) } // function created by reflect.MakeFunc func reflectFunc(args []reflect.Value) (results []reflect.Value) { mustRecoverBody(doubleRecover(), recover(), recover(), 15) return nil } func test15() { f := reflect.MakeFunc(reflect.TypeOf((func())(nil)), reflectFunc).Interface().(func()) defer f() panic(15) } func reflectFunc2(args []reflect.Value) (results []reflect.Value) { // This will call reflectFunc3 args[0].Interface().(func())() return nil } func reflectFunc3(args []reflect.Value) (results []reflect.Value) { if v := recover(); v != nil { println("spurious recover", v) die() } return nil } func test16() { defer mustRecover(16) f2 := reflect.MakeFunc(reflect.TypeOf((func(func()))(nil)), reflectFunc2).Interface().(func(func())) f3 := reflect.MakeFunc(reflect.TypeOf((func())(nil)), reflectFunc3).Interface().(func()) defer f2(f3) panic(16) }	10.64 KB	2024-02-02 18:09
📄 recover1.go // run // Copyright 2010 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 of recover during recursive panics. // Here be dragons. package main import "runtime" func main() { test1() test2() test3() test4() test5() test6() test7() } func die() { runtime.Breakpoint() // can't depend on panic } func mustRecover(x interface{}) { mustNotRecover() // because it's not a defer call v := recover() if v == nil { println("missing recover") die() // panic is useless here } if v != x { println("wrong value", v, x) die() } // the value should be gone now regardless v = recover() if v != nil { println("recover didn't recover") die() } } func mustNotRecover() { v := recover() if v != nil { println("spurious recover") die() } } func withoutRecover() { mustNotRecover() // because it's a sub-call } func test1() { // Easy nested recursive panic. defer mustRecover(1) defer func() { defer mustRecover(2) panic(2) }() panic(1) } func test2() { // Sequential panic. defer mustNotRecover() defer func() { v := recover() if v == nil \|\| v.(int) != 2 { println("wrong value", v, 2) die() } defer mustRecover(3) panic(3) }() panic(2) } func test3() { // Sequential panic - like test2 but less picky. defer mustNotRecover() defer func() { recover() defer mustRecover(3) panic(3) }() panic(2) } func test4() { // Single panic. defer mustNotRecover() defer func() { recover() }() panic(4) } func test5() { // Single panic but recover called via defer defer mustNotRecover() defer func() { defer recover() }() panic(5) } func test6() { // Sequential panic. // Like test3, but changed recover to defer (same change as test4 → test5). defer mustNotRecover() defer func() { defer recover() // like a normal call from this func; runs because mustRecover stops the panic defer mustRecover(3) panic(3) }() panic(2) } func test7() { // Like test6, but swapped defer order. // The recover in "defer recover()" is now a no-op, // because it runs called from panic, not from the func, // and therefore cannot see the panic of 2. // (Alternately, it cannot see the panic of 2 because // there is an active panic of 3. And it cannot see the // panic of 3 because it is at the wrong level (too high on the stack).) defer mustRecover(2) defer func() { defer mustRecover(3) defer recover() // now a no-op, unlike in test6. panic(3) }() panic(2) }	2.5 KB	2024-02-02 18:09
📄 recover2.go // run // Copyright 2010 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 of recover for run-time errors. // TODO(rsc): // null pointer accesses package main import "strings" var x = make([]byte, 10) func main() { test1() test2() test3() test4() test5() test6() test7() } func mustRecover(s string) { v := recover() if v == nil { panic("expected panic") } if e := v.(error).Error(); strings.Index(e, s) < 0 { panic("want: " + s + "; have: " + e) } } func test1() { defer mustRecover("index") println(x[123]) } func test2() { defer mustRecover("slice") println(x[5:15]) } func test3() { defer mustRecover("slice") var lo = 11 var hi = 9 println(x[lo:hi]) } func test4() { defer mustRecover("interface") var x interface{} = 1 println(x.(float32)) } type T struct { a, b int c []int } func test5() { defer mustRecover("uncomparable") var x T var z interface{} = x println(z != z) } func test6() { defer mustRecover("unhashable type main.T") var x T var z interface{} = x m := make(map[interface{}]int) m[z] = 1 } func test7() { defer mustRecover("divide by zero") var x, y int println(x / y) }	1.22 KB	2024-02-02 18:09
📄 recover3.go // run // Copyright 2010 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 recovering from runtime errors. package main import ( "runtime" "strings" ) var didbug bool func bug() { if didbug { return } println("BUG") didbug = true } func check(name string, f func(), err string) { defer func() { v := recover() if v == nil { bug() println(name, "did not panic") return } runt, ok := v.(runtime.Error) if !ok { bug() println(name, "panicked but not with runtime.Error") return } s := runt.Error() if strings.Index(s, err) < 0 { bug() println(name, "panicked with", s, "not", err) return } }() f() } func main() { var x int var x64 int64 var p [10]int var q [10000]int var i int check("int-div-zero", func() { println(1 / x) }, "integer divide by zero") check("int64-div-zero", func() { println(1 / x64) }, "integer divide by zero") check("nil-deref", func() { println(p[0]) }, "nil pointer dereference") check("nil-deref-1", func() { println(p[1]) }, "nil pointer dereference") check("nil-deref-big", func() { println(q[5000]) }, "nil pointer dereference") i = 99999 var sl []int p1 := new([10]int) check("array-bounds", func() { println(p1[i]) }, "index out of range") check("slice-bounds", func() { println(sl[i]) }, "index out of range") var inter interface{} inter = 1 check("type-concrete", func() { println(inter.(string)) }, "int, not string") check("type-interface", func() { println(inter.(m)) }, "missing method m") if didbug { panic("recover3") } } type m interface { m() }	1.64 KB	2024-02-02 18:09
📄 recover4.go // run //go:build linux \|\| darwin // 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. // Test that if a slice access causes a fault, a deferred func // sees the most recent value of the variables it accesses. // This is true today; the role of the test is to ensure it stays true. // // In the test, memcopy is the function that will fault, during dst[i] = src[i]. // The deferred func recovers from the error and returns, making memcopy // return the current value of n. If n is not being flushed to memory // after each modification, the result will be a stale value of n. // // The test is set up by mmapping a 64 kB block of memory and then // unmapping a 16 kB hole in the middle of it. Running memcopy // on the resulting slice will fault when it reaches the hole. package main import ( "log" "runtime/debug" "syscall" ) func memcopy(dst, src []byte) (n int, err error) { defer func() { if r, ok := recover().(error); ok { err = r } }() for i := 0; i < len(dst) && i < len(src); i++ { dst[i] = src[i] n++ } return } func main() { // Turn the eventual fault into a panic, not a program crash, // so that memcopy can recover. debug.SetPanicOnFault(true) size := syscall.Getpagesize() // Map 16 pages of data with a 4-page hole in the middle. data, err := syscall.Mmap(-1, 0, 16size, syscall.PROT_READ\|syscall.PROT_WRITE, syscall.MAP_ANON\|syscall.MAP_PRIVATE) if err != nil { log.Fatalf("mmap: %v", err) } // Create a hole in the mapping that's PROT_NONE. // Note that we can't use munmap here because the Go runtime // could create a mapping that ends up in this hole otherwise, // invalidating the test. hole := data[len(data)/2 : 3(len(data)/4)] if err := syscall.Mprotect(hole, syscall.PROT_NONE); err != nil { log.Fatalf("mprotect: %v", err) } // Check that memcopy returns the actual amount copied // before the fault. const offset = 5 n, err := memcopy(data[offset:], make([]byte, len(data))) if err == nil { log.Fatal("no error from memcopy across memory hole") } if expect := len(data)/2 - offset; n != expect { log.Fatalf("memcopy returned %d, want %d", n, expect) } }	2.2 KB	2024-02-02 18:09
📄 recover5.go // 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. // Verify that recover arguments requirements are enforced by the // compiler. package main func main() { _ = recover() // OK _ = recover(1) // ERROR "too many arguments" _ = recover(1, 2) // ERROR "too many arguments" }	408 B	2024-02-02 18:09
📄 reflectmethod1.go // 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. // The linker can prune methods that are not directly called or // assigned to interfaces, but only if reflect.Type.Method is // never used. Test it here. package main import "reflect" var called = false type M int func (m M) UniqueMethodName() { called = true } var v M func main() { reflect.TypeOf(v).Method(0).Func.Interface().(func(M))(v) if !called { panic("UniqueMethodName not called") } }	578 B	2024-02-02 18:09
📄 reflectmethod2.go // 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. // The linker can prune methods that are not directly called or // assigned to interfaces, but only if reflect.Type.MethodByName is // never used. Test it here. package main import reflect1 "reflect" var called = false type M int func (m M) UniqueMethodName() { called = true } var v M type MyType interface { MethodByName(string) (reflect1.Method, bool) } func main() { var t MyType = reflect1.TypeOf(v) m, _ := t.MethodByName("UniqueMethodName") m.Func.Interface().(func(M))(v) if !called { panic("UniqueMethodName not called") } }	719 B	2024-02-02 18:09
📄 reflectmethod3.go // 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. // The linker can prune methods that are not directly called or // assigned to interfaces, but only if reflect.Type.Method is // never used. Test it here. package main import "reflect" var called = false type M int func (m M) UniqueMethodName() { called = true } var v M type MyType interface { Method(int) reflect.Method } func main() { var t MyType = reflect.TypeOf(v) t.Method(0).Func.Interface().(func(M))(v) if !called { panic("UniqueMethodName not called") } }	651 B	2024-02-02 18:09
📄 reflectmethod4.go // 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. // The linker can prune methods that are not directly called or // assigned to interfaces, but only if reflect.Value.Method is // never used. Test it here. package main import "reflect" var called = false type M int func (m M) UniqueMethodName() { called = true } var v M func main() { reflect.ValueOf(v).Method(0).Interface().(func())() if !called { panic("UniqueMethodName not called") } }	573 B	2024-02-02 18:09
📄 reflectmethod5.go // run // 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. // Issue 38515: failed to mark the method wrapper // reflect.Type.Method itself as REFLECTMETHOD. package main import "reflect" var called bool type foo struct{} func (foo) X() { called = true } var h = reflect.Type.Method func main() { v := reflect.ValueOf(foo{}) m := h(v.Type(), 0) f := m.Func.Interface().(func(foo)) f(foo{}) if !called { panic("FAIL") } }	544 B	2024-02-02 18:09
📄 reflectmethod6.go // run // 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. // Similar to reflectmethod5.go, but for reflect.Type.MethodByName. package main import "reflect" var called bool type foo struct{} func (foo) X() { called = true } var h = reflect.Type.MethodByName func main() { v := reflect.ValueOf(foo{}) m, ok := h(v.Type(), "X") if !ok { panic("FAIL") } f := m.Func.Interface().(func(foo)) f(foo{}) if !called { panic("FAIL") } }	555 B	2024-02-02 18:09
📄 reflectmethod7.go // run // Copyright 2021 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. // See issue 44207. package main import "reflect" type S int func (s S) M() {} func main() { t := reflect.TypeOf(S(0)) fn, ok := reflect.PointerTo(t).MethodByName("M") if !ok { panic("FAIL") } fn.Func.Call([]reflect.Value{reflect.New(t)}) }	421 B	2024-02-02 18:09
📄 reflectmethod8.go // compile // Copyright 2021 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. // Make sure that the compiler can analyze non-reflect // Type.{Method,MethodByName} calls. package p type I interface { MethodByName(string) Method(int) } type M struct{} func (M) MethodByName(string) {} func (M) Method(int) {} func f() { var m M I.MethodByName(m, "") I.Method(m, 42) }	479 B	2024-02-02 18:09
📄 rename.go // run // Copyright 2009 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 that predeclared names can be redeclared by the user. package main import ( "fmt" "runtime" ) func main() { n := append + bool + byte + complex + complex64 + complex128 + cap + close + delete + error + false + float32 + float64 + imag + int + int8 + int16 + int32 + int64 + len + make + new + nil + panic + print + println + real + recover + rune + string + true + uint + uint8 + uint16 + uint32 + uint64 + uintptr + iota if n != NUM(NUM-1)/2 { fmt.Println("BUG: wrong n", n, NUM(NUM-1)/2) runtime.Breakpoint() // panic is inaccessible } } const ( // cannot use iota here, because iota = 38 below append = 1 bool = 2 byte = 3 complex = 4 complex64 = 5 complex128 = 6 cap = 7 close = 8 delete = 9 error = 10 false = 11 float32 = 12 float64 = 13 imag = 14 int = 15 int8 = 16 int16 = 17 int32 = 18 int64 = 19 len = 20 make = 21 new = 22 nil = 23 panic = 24 print = 25 println = 26 real = 27 recover = 28 rune = 29 string = 30 true = 31 uint = 32 uint8 = 33 uint16 = 34 uint32 = 35 uint64 = 36 uintptr = 37 iota = 38 NUM = 39 )	1.52 KB	2024-02-02 18:09
📄 rename1.go // errorcheck // Copyright 2009 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. // Verify that renamed identifiers no longer have their old meaning. // Does not compile. package main func main() { var n byte // ERROR "not a type\|expected type" var y = float32(0) // ERROR "cannot call\|expected function" const ( a = 1 + iota // ERROR "invalid operation\|incompatible types\|cannot convert" ) _, _ = n, y } const ( append = 1 bool = 2 byte = 3 complex = 4 complex64 = 5 complex128 = 6 cap = 7 close = 8 delete = 9 error = 10 false = 11 float32 = 12 float64 = 13 imag = 14 int = 15 int8 = 16 int16 = 17 int32 = 18 int64 = 19 len = 20 make = 21 new = 22 nil = 23 panic = 24 print = 25 println = 26 real = 27 recover = 28 rune = 29 string = 30 true = 31 uint = 32 uint8 = 33 uint16 = 34 uint32 = 35 uint64 = 36 uintptr = 37 iota = "38" )	1.14 KB	2024-02-02 18:09
📄 reorder.go // run // 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. // Test reordering of assignments. package main import "fmt" func main() { p1() p2() p3() p4() p5() p6() p7() p8() p9() p10() p11() } var gx []int func f(i int) int { return gx[i] } func check(x []int, x0, x1, x2 int) { if x[0] != x0 \|\| x[1] != x1 \|\| x[2] != x2 { fmt.Printf("%v, want %d,%d,%d\n", x, x0, x1, x2) panic("failed") } } func check3(x, y, z, xx, yy, zz int) { if x != xx \|\| y != yy \|\| z != zz { fmt.Printf("%d,%d,%d, want %d,%d,%d\n", x, y, z, xx, yy, zz) panic("failed") } } func p1() { x := []int{1, 2, 3} i := 0 i, x[i] = 1, 100 _ = i check(x, 100, 2, 3) } func p2() { x := []int{1, 2, 3} i := 0 x[i], i = 100, 1 _ = i check(x, 100, 2, 3) } func p3() { x := []int{1, 2, 3} y := x gx = x x[1], y[0] = f(0), f(1) check(x, 2, 1, 3) } func p4() { x := []int{1, 2, 3} y := x gx = x x[1], y[0] = gx[0], gx[1] check(x, 2, 1, 3) } func p5() { x := []int{1, 2, 3} y := x p := &x[0] q := &x[1] p, q = x[1], y[0] check(x, 2, 1, 3) } func p6() { x := 1 y := 2 z := 3 px := &x py := &y px, py = y, x check3(x, y, z, 2, 1, 3) } func f1(x, y, z int) (xx, yy, zz int) { return x, y, z } func f2() (x, y, z int) { return f1(2, 1, 3) } func p7() { x, y, z := f2() check3(x, y, z, 2, 1, 3) } func p8() { m := make(map[int]int) m[0] = len(m) if m[0] != 0 { panic(m[0]) } } // Issue #13433: Left-to-right assignment of OAS2XXX nodes. func p9() { var x bool // OAS2FUNC x, x = fn() checkOAS2XXX(x, "x, x = fn()") // OAS2RECV var c = make(chan bool, 10) c <- false x, x = <-c checkOAS2XXX(x, "x, x <-c") // OAS2MAPR var m = map[int]bool{0: false} x, x = m[0] checkOAS2XXX(x, "x, x = m[0]") // OAS2DOTTYPE var i interface{} = false x, x = i.(bool) checkOAS2XXX(x, "x, x = i.(bool)") } //go:noinline func fn() (bool, bool) { return false, true } // checks the order of OAS2XXX. func checkOAS2XXX(x bool, s string) { if !x { fmt.Printf("%s; got=(false); want=(true)\n", s) panic("failed") } } //go:noinline func fp() (int, int) { return nil, 42 } func p10() { p := new(int) p, p = fp() } func p11() { var i interface{} p := new(bool) p, p = i.(bool) }	2.28 KB	2024-02-02 18:09
📄 reorder2.go // run // Copyright 2010 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 reorderings; derived from fixedbugs/bug294.go. package main var log string type TT int func (t TT) a(s string) TT { log += "a(" + s + ")" return t } func (TT) b(s string) string { log += "b(" + s + ")" return s } type F func(s string) F func a(s string) F { log += "a(" + s + ")" return F(a) } func b(s string) string { log += "b(" + s + ")" return s } type I interface { a(s string) I b(s string) string } type T1 int func (t T1) a(s string) I { log += "a(" + s + ")" return t } func (T1) b(s string) string { log += "b(" + s + ")" return s } // f(g(), h()) where g is not inlinable but h is will have the same problem. // As will x := g() + h() (same conditions). // And g() <- h(). func f(x, y string) { log += "f(" + x + ", " + y + ")" } //go:noinline func ff(x, y string) { log += "ff(" + x + ", " + y + ")" } func h(x string) string { log += "h(" + x + ")" return x } //go:noinline func g(x string) string { log += "g(" + x + ")" return x } func main() { err := 0 var t TT if a("1")("2")("3"); log != "a(1)a(2)a(3)" { println("expecting a(1)a(2)a(3) , got ", log) err++ } log = "" if t.a("1").a(t.b("2")); log != "a(1)b(2)a(2)" { println("expecting a(1)b(2)a(2), got ", log) err++ } log = "" if a("3")(b("4"))(b("5")); log != "a(3)b(4)a(4)b(5)a(5)" { println("expecting a(3)b(4)a(4)b(5)a(5), got ", log) err++ } log = "" var i I = T1(0) if i.a("6").a(i.b("7")).a(i.b("8")).a(i.b("9")); log != "a(6)b(7)a(7)b(8)a(8)b(9)a(9)" { println("expecting a(6)ba(7)ba(8)ba(9), got", log) err++ } log = "" if s := t.a("1").b("3"); log != "a(1)b(3)" \|\| s != "3" { println("expecting a(1)b(3) and 3, got ", log, " and ", s) err++ } log = "" if s := t.a("1").a(t.b("2")).b("3") + t.a("4").b("5"); log != "a(1)b(2)a(2)b(3)a(4)b(5)" \|\| s != "35" { println("expecting a(1)b(2)a(2)b(3)a(4)b(5) and 35, got ", log, " and ", s) err++ } log = "" if s := t.a("4").b("5") + t.a("1").a(t.b("2")).b("3"); log != "a(4)b(5)a(1)b(2)a(2)b(3)" \|\| s != "53" { println("expecting a(4)b(5)a(1)b(2)a(2)b(3) and 35, got ", log, " and ", s) err++ } log = "" if ff(g("1"), g("2")); log != "g(1)g(2)ff(1, 2)" { println("expecting g(1)g(2)ff..., got ", log) err++ } log = "" if ff(g("1"), h("2")); log != "g(1)h(2)ff(1, 2)" { println("expecting g(1)h(2)ff..., got ", log) err++ } log = "" if ff(h("1"), g("2")); log != "h(1)g(2)ff(1, 2)" { println("expecting h(1)g(2)ff..., got ", log) err++ } log = "" if ff(h("1"), h("2")); log != "h(1)h(2)ff(1, 2)" { println("expecting h(1)h(2)ff..., got ", log) err++ } log = "" if s := g("1") + g("2"); log != "g(1)g(2)" \|\| s != "12" { println("expecting g1g2 and 12, got ", log, " and ", s) err++ } log = "" if s := g("1") + h("2"); log != "g(1)h(2)" \|\| s != "12" { println("expecting g1h2 and 12, got ", log, " and ", s) err++ } log = "" if s := h("1") + g("2"); log != "h(1)g(2)" \|\| s != "12" { println("expecting h1g2 and 12, got ", log, " and ", s) err++ } log = "" if s := h("1") + h("2"); log != "h(1)h(2)" \|\| s != "12" { println("expecting h1h2 and 12, got ", log, " and ", s) err++ } log = "" x := 0 switch x { case 0: if a("1")("2")("3"); log != "a(1)a(2)a(3)" { println("in switch, expecting a(1)a(2)a(3) , got ", log) err++ } log = "" if t.a("1").a(t.b("2")); log != "a(1)b(2)a(2)" { println("in switch, expecting a(1)b(2)a(2), got ", log) err++ } log = "" if a("3")(b("4"))(b("5")); log != "a(3)b(4)a(4)b(5)a(5)" { println("in switch, expecting a(3)b(4)a(4)b(5)a(5), got ", log) err++ } log = "" var i I = T1(0) if i.a("6").a(i.b("7")).a(i.b("8")).a(i.b("9")); log != "a(6)b(7)a(7)b(8)a(8)b(9)a(9)" { println("in switch, expecting a(6)ba(7)ba(8)ba(9), got", log) err++ } log = "" } c := make(chan int, 1) c <- 1 select { case c <- 0: case c <- 1: case <-c: if a("1")("2")("3"); log != "a(1)a(2)a(3)" { println("in select1, expecting a(1)a(2)a(3) , got ", log) err++ } log = "" if t.a("1").a(t.b("2")); log != "a(1)b(2)a(2)" { println("in select1, expecting a(1)b(2)a(2), got ", log) err++ } log = "" if a("3")(b("4"))(b("5")); log != "a(3)b(4)a(4)b(5)a(5)" { println("in select1, expecting a(3)b(4)a(4)b(5)a(5), got ", log) err++ } log = "" var i I = T1(0) if i.a("6").a(i.b("7")).a(i.b("8")).a(i.b("9")); log != "a(6)b(7)a(7)b(8)a(8)b(9)a(9)" { println("in select1, expecting a(6)ba(7)ba(8)ba(9), got", log) err++ } log = "" } c <- 1 select { case <-c: if a("1")("2")("3"); log != "a(1)a(2)a(3)" { println("in select2, expecting a(1)a(2)a(3) , got ", log) err++ } log = "" if t.a("1").a(t.b("2")); log != "a(1)b(2)a(2)" { println("in select2, expecting a(1)b(2)a(2), got ", log) err++ } log = "" if a("3")(b("4"))(b("5")); log != "a(3)b(4)a(4)b(5)a(5)" { println("in select2, expecting a(3)b(4)a(4)b(5)a(5), got ", log) err++ } log = "" var i I = T1(0) if i.a("6").a(i.b("7")).a(i.b("8")).a(i.b("9")); log != "a(6)b(7)a(7)b(8)a(8)b(9)a(9)" { println("in select2, expecting a(6)ba(7)ba(8)ba(9), got", log) err++ } log = "" } c <- 1 select { default: case c <- 1: case <-c: if a("1")("2")("3"); log != "a(1)a(2)a(3)" { println("in select3, expecting a(1)a(2)a(3) , got ", log) err++ } log = "" if t.a("1").a(t.b("2")); log != "a(1)b(2)a(2)" { println("in select3, expecting a(1)b(2)a(2), got ", log) err++ } log = "" if a("3")(b("4"))(b("5")); log != "a(3)b(4)a(4)b(5)a(5)" { println("in select3, expecting a(3)b(4)a(4)b(5)a(5), got ", log) err++ } log = "" var i I = T1(0) if i.a("6").a(i.b("7")).a(i.b("8")).a(i.b("9")); log != "a(6)b(7)a(7)b(8)a(8)b(9)a(9)" { println("in select3, expecting a(6)ba(7)ba(8)ba(9), got", log) err++ } log = "" } c <- 1 select { default: case <-c: if a("1")("2")("3"); log != "a(1)a(2)a(3)" { println("in select4, expecting a(1)a(2)a(3) , got ", log) err++ } log = "" if t.a("1").a(t.b("2")); log != "a(1)b(2)a(2)" { println("in select4, expecting a(1)b(2)a(2), got ", log) err++ } log = "" if a("3")(b("4"))(b("5")); log != "a(3)b(4)a(4)b(5)a(5)" { println("in select4, expecting a(3)b(4)a(4)b(5)a(5), got ", log) err++ } log = "" var i I = T1(0) if i.a("6").a(i.b("7")).a(i.b("8")).a(i.b("9")); log != "a(6)b(7)a(7)b(8)a(8)b(9)a(9)" { println("in select4, expecting a(6)ba(7)ba(8)ba(9), got", log) err++ } log = "" } select { case <-c: case <-c: default: if a("1")("2")("3"); log != "a(1)a(2)a(3)" { println("in select5, expecting a(1)a(2)a(3) , got ", log) err++ } log = "" if t.a("1").a(t.b("2")); log != "a(1)b(2)a(2)" { println("in select5, expecting a(1)b(2)a(2), got ", log) err++ } log = "" if a("3")(b("4"))(b("5")); log != "a(3)b(4)a(4)b(5)a(5)" { println("in select5, expecting a(3)b(4)a(4)b(5)a(5), got ", log) err++ } log = "" var i I = T1(0) if i.a("6").a(i.b("7")).a(i.b("8")).a(i.b("9")); log != "a(6)b(7)a(7)b(8)a(8)b(9)a(9)" { println("in select5, expecting a(6)ba(7)ba(8)ba(9), got", log) err++ } log = "" } if err > 0 { panic("fail") } }	7.22 KB	2024-02-02 18:09
📁 retjmp.dir	-	2024-02-02 18:09
📄 retjmp.go // buildrundir // 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. // Test that return jump works correctly in assembly code. package ignored	252 B	2024-02-02 18:09
📄 return.go // errorcheck // 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. // Test compiler diagnosis of function missing return statements. // See issue 65 and golang.org/s/go11return. package p type T int var x interface{} var c chan int func external() int // ok func _() int { } // ERROR "missing return" func _() int { print(1) } // ERROR "missing return" // return is okay func _() int { print(1) return 2 } // goto is okay func _() int { L: print(1) goto L } // panic is okay func _() int { print(1) panic(2) } // but only builtin panic func _() int { var panic = func(int) {} print(1) panic(2) } // ERROR "missing return" // block ending in terminating statement is okay func _() int { { print(1) return 2 } } // block ending in terminating statement is okay func _() int { L: { print(1) goto L } } // block ending in terminating statement is okay func _() int { print(1) { panic(2) } } // adding more code - even though it is dead - now requires a return func _() int { print(1) return 2 print(3) } // ERROR "missing return" func _() int { L: print(1) goto L print(3) } // ERROR "missing return" func _() int { print(1) panic(2) print(3) } // ERROR "missing return" func _() int { { print(1) return 2 print(3) } } // ERROR "missing return" func _() int { L: { print(1) goto L print(3) } } // ERROR "missing return" func _() int { print(1) { panic(2) print(3) } } // ERROR "missing return" func _() int { { print(1) return 2 } print(3) } // ERROR "missing return" func _() int { L: { print(1) goto L } print(3) } // ERROR "missing return" func _() int { print(1) { panic(2) } print(3) } // ERROR "missing return" // even an empty dead block triggers the message, because it // becomes the final statement. func _() int { print(1) return 2 {} } // ERROR "missing return" func _() int { L: print(1) goto L {} } // ERROR "missing return" func _() int { print(1) panic(2) {} } // ERROR "missing return" func _() int { { print(1) return 2 {} } } // ERROR "missing return" func _() int { L: { print(1) goto L {} } } // ERROR "missing return" func _() int { print(1) { panic(2) {} } } // ERROR "missing return" func _() int { { print(1) return 2 } {} } // ERROR "missing return" func _() int { L: { print(1) goto L } {} } // ERROR "missing return" func _() int { print(1) { panic(2) } {} } // ERROR "missing return" // if-else chain with final else and all terminating is okay func _() int { print(1) if x == nil { panic(2) } else { panic(3) } } func _() int { L: print(1) if x == nil { panic(2) } else { goto L } } func _() int { L: print(1) if x == nil { panic(2) } else if x == 1 { return 0 } else if x != 2 { panic(3) } else { goto L } } // if-else chain missing final else is not okay, even if the // conditions cover every possible case. func _() int { print(1) if x == nil { panic(2) } else if x != nil { panic(3) } } // ERROR "missing return" func _() int { print(1) if x == nil { panic(2) } } // ERROR "missing return" func _() int { print(1) if x == nil { panic(2) } else if x == 1 { return 0 } else if x != 1 { panic(3) } } // ERROR "missing return" // for { loops that never break are okay. func _() int { print(1) for {} } func _() int { for { for { break } } } func _() int { for { L: for { break L } } } // for { loops that break are not okay. func _() int { print(1) for { break } } // ERROR "missing return" func _() int { for { for { } break } } // ERROR "missing return" func _() int { L: for { for { break L } } } // ERROR "missing return" // if there's a condition - even "true" - the loops are no longer syntactically terminating func _() int { print(1) for x == nil {} } // ERROR "missing return" func _() int { for x == nil { for { break } } } // ERROR "missing return" func _() int { for x == nil { L: for { break L } } } // ERROR "missing return" func _() int { print(1) for true {} } // ERROR "missing return" func _() int { for true { for { break } } } // ERROR "missing return" func _() int { for true { L: for { break L } } } // ERROR "missing return" // select in which all cases terminate and none break are okay. func _() int { print(1) select{} } func _() int { print(1) select { case <-c: print(2) panic("abc") } } func _() int { print(1) select { case <-c: print(2) for{} } } func _() int { L: print(1) select { case <-c: print(2) panic("abc") case c <- 1: print(2) goto L } } func _() int { print(1) select { case <-c: print(2) panic("abc") default: select{} } } // if any cases don't terminate, the select isn't okay anymore func _() int { print(1) select { case <-c: print(2) } } // ERROR "missing return" func _() int { L: print(1) select { case <-c: print(2) panic("abc") goto L case c <- 1: print(2) } } // ERROR "missing return" func _() int { print(1) select { case <-c: print(2) panic("abc") default: print(2) } } // ERROR "missing return" // if any breaks refer to the select, the select isn't okay anymore, even if they're dead func _() int { print(1) select{ default: break } } // ERROR "missing return" func _() int { print(1) select { case <-c: print(2) panic("abc") break } } // ERROR "missing return" func _() int { print(1) L: select { case <-c: print(2) for{ break L } } } // ERROR "missing return" func _() int { print(1) L: select { case <-c: print(2) panic("abc") case c <- 1: print(2) break L } } // ERROR "missing return" func _() int { print(1) select { case <-c: print(1) panic("abc") default: select{} break } } // ERROR "missing return" // switch with default in which all cases terminate is okay func _() int { print(1) switch x { case 1: print(2) panic(3) default: return 4 } } func _() int { print(1) switch x { default: return 4 case 1: print(2) panic(3) } } func _() int { print(1) switch x { case 1: print(2) fallthrough default: return 4 } } // if no default or some case doesn't terminate, switch is no longer okay func _() int { print(1) switch { } } // ERROR "missing return" func _() int { print(1) switch x { case 1: print(2) panic(3) case 2: return 4 } } // ERROR "missing return" func _() int { print(1) switch x { case 2: return 4 case 1: print(2) panic(3) } } // ERROR "missing return" func _() int { print(1) switch x { case 1: print(2) fallthrough case 2: return 4 } } // ERROR "missing return" func _() int { print(1) switch x { case 1: print(2) panic(3) } } // ERROR "missing return" // if any breaks refer to the switch, switch is no longer okay func _() int { print(1) L: switch x { case 1: print(2) panic(3) break L default: return 4 } } // ERROR "missing return" func _() int { print(1) switch x { default: return 4 break case 1: print(2) panic(3) } } // ERROR "missing return" func _() int { print(1) L: switch x { case 1: print(2) for { break L } default: return 4 } } // ERROR "missing return" // type switch with default in which all cases terminate is okay func _() int { print(1) switch x.(type) { case int: print(2) panic(3) default: return 4 } } func _() int { print(1) switch x.(type) { default: return 4 case int: print(2) panic(3) } } // if no default or some case doesn't terminate, switch is no longer okay func _() int { print(1) switch { } } // ERROR "missing return" func _() int { print(1) switch x.(type) { case int: print(2) panic(3) case float64: return 4 } } // ERROR "missing return" func _() int { print(1) switch x.(type) { case float64: return 4 case int: print(2) panic(3) } } // ERROR "missing return" func _() int { print(1) switch x.(type) { case int: print(2) panic(3) } } // ERROR "missing return" // if any breaks refer to the switch, switch is no longer okay func _() int { print(1) L: switch x.(type) { case int: print(2) panic(3) break L default: return 4 } } // ERROR "missing return" func _() int { print(1) switch x.(type) { default: return 4 break case int: print(2) panic(3) } } // ERROR "missing return" func _() int { print(1) L: switch x.(type) { case int: print(2) for { break L } default: return 4 } } // ERROR "missing return" // again, but without the leading print(1). // testing that everything works when the terminating statement is first. func _() int { } // ERROR "missing return" // return is okay func _() int { return 2 } // goto is okay func _() int { L: goto L } // panic is okay func _() int { panic(2) } // but only builtin panic func _() int { var panic = func(int) {} panic(2) } // ERROR "missing return" // block ending in terminating statement is okay func _() int { { return 2 } } // block ending in terminating statement is okay func _() int { L: { goto L } } // block ending in terminating statement is okay func _() int { { panic(2) } } // adding more code - even though it is dead - now requires a return func _() int { return 2 print(3) } // ERROR "missing return" func _() int { L: goto L print(3) } // ERROR "missing return" func _() int { panic(2) print(3) } // ERROR "missing return" func _() int { { return 2 print(3) } } // ERROR "missing return" func _() int { L: { goto L print(3) } } // ERROR "missing return" func _() int { { panic(2) print(3) } } // ERROR "missing return" func _() int { { return 2 } print(3) } // ERROR "missing return" func _() int { L: { goto L } print(3) } // ERROR "missing return" func _() int { { panic(2) } print(3) } // ERROR "missing return" // even an empty dead block triggers the message, because it // becomes the final statement. func _() int { return 2 {} } // ERROR "missing return" func _() int { L: goto L {} } // ERROR "missing return" func _() int { panic(2) {} } // ERROR "missing return" func _() int { { return 2 {} } } // ERROR "missing return" func _() int { L: { goto L {} } } // ERROR "missing return" func _() int { { panic(2) {} } } // ERROR "missing return" func _() int { { return 2 } {} } // ERROR "missing return" func _() int { L: { goto L } {} } // ERROR "missing return" func _() int { { panic(2) } {} } // ERROR "missing return" // if-else chain with final else and all terminating is okay func _() int { if x == nil { panic(2) } else { panic(3) } } func _() int { L: if x == nil { panic(2) } else { goto L } } func _() int { L: if x == nil { panic(2) } else if x == 1 { return 0 } else if x != 2 { panic(3) } else { goto L } } // if-else chain missing final else is not okay, even if the // conditions cover every possible case. func _() int { if x == nil { panic(2) } else if x != nil { panic(3) } } // ERROR "missing return" func _() int { if x == nil { panic(2) } } // ERROR "missing return" func _() int { if x == nil { panic(2) } else if x == 1 { return 0 } else if x != 1 { panic(3) } } // ERROR "missing return" // for { loops that never break are okay. func _() int { for {} } func _() int { for { for { break } } } func _() int { for { L: for { break L } } } // for { loops that break are not okay. func _() int { for { break } } // ERROR "missing return" func _() int { for { for { } break } } // ERROR "missing return" func _() int { L: for { for { break L } } } // ERROR "missing return" // if there's a condition - even "true" - the loops are no longer syntactically terminating func _() int { for x == nil {} } // ERROR "missing return" func _() int { for x == nil { for { break } } } // ERROR "missing return" func _() int { for x == nil { L: for { break L } } } // ERROR "missing return" func _() int { for true {} } // ERROR "missing return" func _() int { for true { for { break } } } // ERROR "missing return" func _() int { for true { L: for { break L } } } // ERROR "missing return" // select in which all cases terminate and none break are okay. func _() int { select{} } func _() int { select { case <-c: print(2) panic("abc") } } func _() int { select { case <-c: print(2) for{} } } func _() int { L: select { case <-c: print(2) panic("abc") case c <- 1: print(2) goto L } } func _() int { select { case <-c: print(2) panic("abc") default: select{} } } // if any cases don't terminate, the select isn't okay anymore func _() int { select { case <-c: print(2) } } // ERROR "missing return" func _() int { L: select { case <-c: print(2) panic("abc") goto L case c <- 1: print(2) } } // ERROR "missing return" func _() int { select { case <-c: print(2) panic("abc") default: print(2) } } // ERROR "missing return" // if any breaks refer to the select, the select isn't okay anymore, even if they're dead func _() int { select{ default: break } } // ERROR "missing return" func _() int { select { case <-c: print(2) panic("abc") break } } // ERROR "missing return" func _() int { L: select { case <-c: print(2) for{ break L } } } // ERROR "missing return" func _() int { L: select { case <-c: print(2) panic("abc") case c <- 1: print(2) break L } } // ERROR "missing return" func _() int { select { case <-c: panic("abc") default: select{} break } } // ERROR "missing return" // switch with default in which all cases terminate is okay func _() int { switch x { case 1: print(2) panic(3) default: return 4 } } func _() int { switch x { default: return 4 case 1: print(2) panic(3) } } func _() int { switch x { case 1: print(2) fallthrough default: return 4 } } // if no default or some case doesn't terminate, switch is no longer okay func _() int { switch { } } // ERROR "missing return" func _() int { switch x { case 1: print(2) panic(3) case 2: return 4 } } // ERROR "missing return" func _() int { switch x { case 2: return 4 case 1: print(2) panic(3) } } // ERROR "missing return" func _() int { switch x { case 1: print(2) fallthrough case 2: return 4 } } // ERROR "missing return" func _() int { switch x { case 1: print(2) panic(3) } } // ERROR "missing return" // if any breaks refer to the switch, switch is no longer okay func _() int { L: switch x { case 1: print(2) panic(3) break L default: return 4 } } // ERROR "missing return" func _() int { switch x { default: return 4 break case 1: print(2) panic(3) } } // ERROR "missing return" func _() int { L: switch x { case 1: print(2) for { break L } default: return 4 } } // ERROR "missing return" // type switch with default in which all cases terminate is okay func _() int { switch x.(type) { case int: print(2) panic(3) default: return 4 } } func _() int { switch x.(type) { default: return 4 case int: print(2) panic(3) } } // if no default or some case doesn't terminate, switch is no longer okay func _() int { switch { } } // ERROR "missing return" func _() int { switch x.(type) { case int: print(2) panic(3) case float64: return 4 } } // ERROR "missing return" func _() int { switch x.(type) { case float64: return 4 case int: print(2) panic(3) } } // ERROR "missing return" func _() int { switch x.(type) { case int: print(2) panic(3) } } // ERROR "missing return" // if any breaks refer to the switch, switch is no longer okay func _() int { L: switch x.(type) { case int: print(2) panic(3) break L default: return 4 } } // ERROR "missing return" func _() int { switch x.(type) { default: return 4 break case int: print(2) panic(3) } } // ERROR "missing return" func _() int { L: switch x.(type) { case int: print(2) for { break L } default: return 4 } } // ERROR "missing return" func _() int { switch x.(type) { default: return 4 case int, float64: print(2) panic(3) } } // again, with func literals var _ = func() int { } // ERROR "missing return" var _ = func() int { print(1) } // ERROR "missing return" // return is okay var _ = func() int { print(1) return 2 } // goto is okay var _ = func() int { L: print(1) goto L } // panic is okay var _ = func() int { print(1) panic(2) } // but only builtin panic var _ = func() int { var panic = func(int) {} print(1) panic(2) } // ERROR "missing return" // block ending in terminating statement is okay var _ = func() int { { print(1) return 2 } } // block ending in terminating statement is okay var _ = func() int { L: { print(1) goto L } } // block ending in terminating statement is okay var _ = func() int { print(1) { panic(2) } } // adding more code - even though it is dead - now requires a return var _ = func() int { print(1) return 2 print(3) } // ERROR "missing return" var _ = func() int { L: print(1) goto L print(3) } // ERROR "missing return" var _ = func() int { print(1) panic(2) print(3) } // ERROR "missing return" var _ = func() int { { print(1) return 2 print(3) } } // ERROR "missing return" var _ = func() int { L: { print(1) goto L print(3) } } // ERROR "missing return" var _ = func() int { print(1) { panic(2) print(3) } } // ERROR "missing return" var _ = func() int { { print(1) return 2 } print(3) } // ERROR "missing return" var _ = func() int { L: { print(1) goto L } print(3) } // ERROR "missing return" var _ = func() int { print(1) { panic(2) } print(3) } // ERROR "missing return" // even an empty dead block triggers the message, because it // becomes the final statement. var _ = func() int { print(1) return 2 {} } // ERROR "missing return" var _ = func() int { L: print(1) goto L {} } // ERROR "missing return" var _ = func() int { print(1) panic(2) {} } // ERROR "missing return" var _ = func() int { { print(1) return 2 {} } } // ERROR "missing return" var _ = func() int { L: { print(1) goto L {} } } // ERROR "missing return" var _ = func() int { print(1) { panic(2) {} } } // ERROR "missing return" var _ = func() int { { print(1) return 2 } {} } // ERROR "missing return" var _ = func() int { L: { print(1) goto L } {} } // ERROR "missing return" var _ = func() int { print(1) { panic(2) } {} } // ERROR "missing return" // if-else chain with final else and all terminating is okay var _ = func() int { print(1) if x == nil { panic(2) } else { panic(3) } } var _ = func() int { L: print(1) if x == nil { panic(2) } else { goto L } } var _ = func() int { L: print(1) if x == nil { panic(2) } else if x == 1 { return 0 } else if x != 2 { panic(3) } else { goto L } } // if-else chain missing final else is not okay, even if the // conditions cover every possible case. var _ = func() int { print(1) if x == nil { panic(2) } else if x != nil { panic(3) } } // ERROR "missing return" var _ = func() int { print(1) if x == nil { panic(2) } } // ERROR "missing return" var _ = func() int { print(1) if x == nil { panic(2) } else if x == 1 { return 0 } else if x != 1 { panic(3) } } // ERROR "missing return" // for { loops that never break are okay. var _ = func() int { print(1) for {} } var _ = func() int { for { for { break } } } var _ = func() int { for { L: for { break L } } } // for { loops that break are not okay. var _ = func() int { print(1) for { break } } // ERROR "missing return" var _ = func() int { for { for { } break } } // ERROR "missing return" var _ = func() int { L: for { for { break L } } } // ERROR "missing return" // if there's a condition - even "true" - the loops are no longer syntactically terminating var _ = func() int { print(1) for x == nil {} } // ERROR "missing return" var _ = func() int { for x == nil { for { break } } } // ERROR "missing return" var _ = func() int { for x == nil { L: for { break L } } } // ERROR "missing return" var _ = func() int { print(1) for true {} } // ERROR "missing return" var _ = func() int { for true { for { break } } } // ERROR "missing return" var _ = func() int { for true { L: for { break L } } } // ERROR "missing return" // select in which all cases terminate and none break are okay. var _ = func() int { print(1) select{} } var _ = func() int { print(1) select { case <-c: print(2) panic("abc") } } var _ = func() int { print(1) select { case <-c: print(2) for{} } } var _ = func() int { L: print(1) select { case <-c: print(2) panic("abc") case c <- 1: print(2) goto L } } var _ = func() int { print(1) select { case <-c: print(2) panic("abc") default: select{} } } // if any cases don't terminate, the select isn't okay anymore var _ = func() int { print(1) select { case <-c: print(2) } } // ERROR "missing return" var _ = func() int { L: print(1) select { case <-c: print(2) panic("abc") goto L case c <- 1: print(2) } } // ERROR "missing return" var _ = func() int { print(1) select { case <-c: print(2) panic("abc") default: print(2) } } // ERROR "missing return" // if any breaks refer to the select, the select isn't okay anymore, even if they're dead var _ = func() int { print(1) select{ default: break } } // ERROR "missing return" var _ = func() int { print(1) select { case <-c: print(2) panic("abc") break } } // ERROR "missing return" var _ = func() int { print(1) L: select { case <-c: print(2) for{ break L } } } // ERROR "missing return" var _ = func() int { print(1) L: select { case <-c: print(2) panic("abc") case c <- 1: print(2) break L } } // ERROR "missing return" var _ = func() int { print(1) select { case <-c: print(1) panic("abc") default: select{} break } } // ERROR "missing return" // switch with default in which all cases terminate is okay var _ = func() int { print(1) switch x { case 1: print(2) panic(3) default: return 4 } } var _ = func() int { print(1) switch x { default: return 4 case 1: print(2) panic(3) } } var _ = func() int { print(1) switch x { case 1: print(2) fallthrough default: return 4 } } // if no default or some case doesn't terminate, switch is no longer okay var _ = func() int { print(1) switch { } } // ERROR "missing return" var _ = func() int { print(1) switch x { case 1: print(2) panic(3) case 2: return 4 } } // ERROR "missing return" var _ = func() int { print(1) switch x { case 2: return 4 case 1: print(2) panic(3) } } // ERROR "missing return" var _ = func() int { print(1) switch x { case 1: print(2) fallthrough case 2: return 4 } } // ERROR "missing return" var _ = func() int { print(1) switch x { case 1: print(2) panic(3) } } // ERROR "missing return" // if any breaks refer to the switch, switch is no longer okay var _ = func() int { print(1) L: switch x { case 1: print(2) panic(3) break L default: return 4 } } // ERROR "missing return" var _ = func() int { print(1) switch x { default: return 4 break case 1: print(2) panic(3) } } // ERROR "missing return" var _ = func() int { print(1) L: switch x { case 1: print(2) for { break L } default: return 4 } } // ERROR "missing return" // type switch with default in which all cases terminate is okay var _ = func() int { print(1) switch x.(type) { case int: print(2) panic(3) default: return 4 } } var _ = func() int { print(1) switch x.(type) { default: return 4 case int: print(2) panic(3) } } // if no default or some case doesn't terminate, switch is no longer okay var _ = func() int { print(1) switch { } } // ERROR "missing return" var _ = func() int { print(1) switch x.(type) { case int: print(2) panic(3) case float64: return 4 } } // ERROR "missing return" var _ = func() int { print(1) switch x.(type) { case float64: return 4 case int: print(2) panic(3) } } // ERROR "missing return" var _ = func() int { print(1) switch x.(type) { case int: print(2) panic(3) } } // ERROR "missing return" // if any breaks refer to the switch, switch is no longer okay var _ = func() int { print(1) L: switch x.(type) { case int: print(2) panic(3) break L default: return 4 } } // ERROR "missing return" var _ = func() int { print(1) switch x.(type) { default: return 4 break case int: print(2) panic(3) } } // ERROR "missing return" var _ = func() int { print(1) L: switch x.(type) { case int: print(2) for { break L } default: return 4 } } // ERROR "missing return" // again, but without the leading print(1). // testing that everything works when the terminating statement is first. var _ = func() int { } // ERROR "missing return" // return is okay var _ = func() int { return 2 } // goto is okay var _ = func() int { L: goto L } // panic is okay var _ = func() int { panic(2) } // but only builtin panic var _ = func() int { var panic = func(int) {} panic(2) } // ERROR "missing return" // block ending in terminating statement is okay var _ = func() int { { return 2 } } // block ending in terminating statement is okay var _ = func() int { L: { goto L } } // block ending in terminating statement is okay var _ = func() int { { panic(2) } } // adding more code - even though it is dead - now requires a return var _ = func() int { return 2 print(3) } // ERROR "missing return" var _ = func() int { L: goto L print(3) } // ERROR "missing return" var _ = func() int { panic(2) print(3) } // ERROR "missing return" var _ = func() int { { return 2 print(3) } } // ERROR "missing return" var _ = func() int { L: { goto L print(3) } } // ERROR "missing return" var _ = func() int { { panic(2) print(3) } } // ERROR "missing return" var _ = func() int { { return 2 } print(3) } // ERROR "missing return" var _ = func() int { L: { goto L } print(3) } // ERROR "missing return" var _ = func() int { { panic(2) } print(3) } // ERROR "missing return" // even an empty dead block triggers the message, because it // becomes the final statement. var _ = func() int { return 2 {} } // ERROR "missing return" var _ = func() int { L: goto L {} } // ERROR "missing return" var _ = func() int { panic(2) {} } // ERROR "missing return" var _ = func() int { { return 2 {} } } // ERROR "missing return" var _ = func() int { L: { goto L {} } } // ERROR "missing return" var _ = func() int { { panic(2) {} } } // ERROR "missing return" var _ = func() int { { return 2 } {} } // ERROR "missing return" var _ = func() int { L: { goto L } {} } // ERROR "missing return" var _ = func() int { { panic(2) } {} } // ERROR "missing return" // if-else chain with final else and all terminating is okay var _ = func() int { if x == nil { panic(2) } else { panic(3) } } var _ = func() int { L: if x == nil { panic(2) } else { goto L } } var _ = func() int { L: if x == nil { panic(2) } else if x == 1 { return 0 } else if x != 2 { panic(3) } else { goto L } } // if-else chain missing final else is not okay, even if the // conditions cover every possible case. var _ = func() int { if x == nil { panic(2) } else if x != nil { panic(3) } } // ERROR "missing return" var _ = func() int { if x == nil { panic(2) } } // ERROR "missing return" var _ = func() int { if x == nil { panic(2) } else if x == 1 { return 0 } else if x != 1 { panic(3) } } // ERROR "missing return" // for { loops that never break are okay. var _ = func() int { for {} } var _ = func() int { for { for { break } } } var _ = func() int { for { L: for { break L } } } // for { loops that break are not okay. var _ = func() int { for { break } } // ERROR "missing return" var _ = func() int { for { for { } break } } // ERROR "missing return" var _ = func() int { L: for { for { break L } } } // ERROR "missing return" // if there's a condition - even "true" - the loops are no longer syntactically terminating var _ = func() int { for x == nil {} } // ERROR "missing return" var _ = func() int { for x == nil { for { break } } } // ERROR "missing return" var _ = func() int { for x == nil { L: for { break L } } } // ERROR "missing return" var _ = func() int { for true {} } // ERROR "missing return" var _ = func() int { for true { for { break } } } // ERROR "missing return" var _ = func() int { for true { L: for { break L } } } // ERROR "missing return" // select in which all cases terminate and none break are okay. var _ = func() int { select{} } var _ = func() int { select { case <-c: print(2) panic("abc") } } var _ = func() int { select { case <-c: print(2) for{} } } var _ = func() int { L: select { case <-c: print(2) panic("abc") case c <- 1: print(2) goto L } } var _ = func() int { select { case <-c: print(2) panic("abc") default: select{} } } // if any cases don't terminate, the select isn't okay anymore var _ = func() int { select { case <-c: print(2) } } // ERROR "missing return" var _ = func() int { L: select { case <-c: print(2) panic("abc") goto L case c <- 1: print(2) } } // ERROR "missing return" var _ = func() int { select { case <-c: print(2) panic("abc") default: print(2) } } // ERROR "missing return" // if any breaks refer to the select, the select isn't okay anymore, even if they're dead var _ = func() int { select{ default: break } } // ERROR "missing return" var _ = func() int { select { case <-c: print(2) panic("abc") break } } // ERROR "missing return" var _ = func() int { L: select { case <-c: print(2) for{ break L } } } // ERROR "missing return" var _ = func() int { L: select { case <-c: print(2) panic("abc") case c <- 1: print(2) break L } } // ERROR "missing return" var _ = func() int { select { case <-c: panic("abc") default: select{} break } } // ERROR "missing return" // switch with default in which all cases terminate is okay var _ = func() int { switch x { case 1: print(2) panic(3) default: return 4 } } var _ = func() int { switch x { default: return 4 case 1: print(2) panic(3) } } var _ = func() int { switch x { case 1: print(2) fallthrough default: return 4 } } // if no default or some case doesn't terminate, switch is no longer okay var _ = func() int { switch { } } // ERROR "missing return" var _ = func() int { switch x { case 1: print(2) panic(3) case 2: return 4 } } // ERROR "missing return" var _ = func() int { switch x { case 2: return 4 case 1: print(2) panic(3) } } // ERROR "missing return" var _ = func() int { switch x { case 1: print(2) fallthrough case 2: return 4 } } // ERROR "missing return" var _ = func() int { switch x { case 1: print(2) panic(3) } } // ERROR "missing return" // if any breaks refer to the switch, switch is no longer okay var _ = func() int { L: switch x { case 1: print(2) panic(3) break L default: return 4 } } // ERROR "missing return" var _ = func() int { switch x { default: return 4 break case 1: print(2) panic(3) } } // ERROR "missing return" var _ = func() int { L: switch x { case 1: print(2) for { break L } default: return 4 } } // ERROR "missing return" // type switch with default in which all cases terminate is okay var _ = func() int { switch x.(type) { case int: print(2) panic(3) default: return 4 } } var _ = func() int { switch x.(type) { default: return 4 case int: print(2) panic(3) } } // if no default or some case doesn't terminate, switch is no longer okay var _ = func() int { switch { } } // ERROR "missing return" var _ = func() int { switch x.(type) { case int: print(2) panic(3) case float64: return 4 } } // ERROR "missing return" var _ = func() int { switch x.(type) { case float64: return 4 case int: print(2) panic(3) } } // ERROR "missing return" var _ = func() int { switch x.(type) { case int: print(2) panic(3) } } // ERROR "missing return" // if any breaks refer to the switch, switch is no longer okay var _ = func() int { L: switch x.(type) { case int: print(2) panic(3) break L default: return 4 } } // ERROR "missing return" var _ = func() int { switch x.(type) { default: return 4 break case int: print(2) panic(3) } } // ERROR "missing return" var _ = func() int { L: switch x.(type) { case int: print(2) for { break L } default: return 4 } } // ERROR "missing return" var _ = func() int { switch x.(type) { default: return 4 case int, float64: print(2) panic(3) } } /**/	32.69 KB	2024-02-02 18:09
📄 rotate.go // skip // NOTE: the actual tests to run are rotate[0123].go // 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. // Generate test of shift and rotate by constants. // The output is compiled and run. // // The integer type depends on the value of mode (rotate direction, // signedness). package main import ( "bufio" "flag" "fmt" "os" "strings" ) func main() { flag.Parse() b := bufio.NewWriter(os.Stdout) defer b.Flush() fmt.Fprintf(b, "%s\n", prolog) for logBits := uint(3); logBits <= 6; logBits++ { typ := fmt.Sprintf("int%d", 1<<logBits) fmt.Fprint(b, strings.Replace(checkFunc, "XXX", typ, -1)) fmt.Fprint(b, strings.Replace(checkFunc, "XXX", "u"+typ, -1)) gentest(b, 1<<logBits, mode&1 != 0, mode&2 != 0) } } const prolog = ` package main import ( "fmt" "os" ) var ( i8 int8 = 0x12 i16 int16 = 0x1234 i32 int32 = 0x12345678 i64 int64 = 0x123456789abcdef0 ui8 uint8 = 0x12 ui16 uint16 = 0x1234 ui32 uint32 = 0x12345678 ui64 uint64 = 0x123456789abcdef0 ni8 = ^i8 ni16 = ^i16 ni32 = ^i32 ni64 = ^i64 nui8 = ^ui8 nui16 = ^ui16 nui32 = ^ui32 nui64 = ^ui64 ) var nfail = 0 func main() { if nfail > 0 { fmt.Printf("BUG\n") } } ` const checkFunc = ` func check_XXX(desc string, have, want XXX) { if have != want { nfail++ fmt.Printf("%s = %T(%#x), want %T(%#x)\n", desc, have, have, want, want) if nfail >= 100 { fmt.Printf("BUG: stopping after 100 failures\n") os.Exit(0) } } } ` var ( uop = [2]func(x, y uint64) uint64{ func(x, y uint64) uint64 { return x \| y }, func(x, y uint64) uint64 { return x ^ y }, } iop = [2]func(x, y int64) int64{ func(x, y int64) int64 { return x \| y }, func(x, y int64) int64 { return x ^ y }, } cop = [2]byte{'\|', '^'} ) func gentest(b *bufio.Writer, bits uint, unsigned, inverted bool) { fmt.Fprintf(b, "func init() {\n") defer fmt.Fprintf(b, "}\n") n := 0 // Generate tests for left/right and right/left. for l := uint(0); l <= bits; l++ { for r := uint(0); r <= bits; r++ { for o, op := range cop { typ := fmt.Sprintf("int%d", bits) v := fmt.Sprintf("i%d", bits) if unsigned { typ = "u" + typ v = "u" + v } v0 := int64(0x123456789abcdef0) if inverted { v = "n" + v v0 = ^v0 } expr1 := fmt.Sprintf("%s<<%d %c %s>>%d", v, l, op, v, r) expr2 := fmt.Sprintf("%s>>%d %c %s<<%d", v, r, op, v, l) var result string if unsigned { v := uint64(v0) >> (64 - bits) v = uop[o](v<<l, v>>r) v <<= 64 - bits v >>= 64 - bits result = fmt.Sprintf("%#x", v) } else { v := int64(v0) >> (64 - bits) v = iop[o](v<<l, v>>r) v <<= 64 - bits v >>= 64 - bits result = fmt.Sprintf("%#x", v) } fmt.Fprintf(b, "\tcheck_%s(%q, %s, %s(%s))\n", typ, expr1, expr1, typ, result) fmt.Fprintf(b, "\tcheck_%s(%q, %s, %s(%s))\n", typ, expr2, expr2, typ, result) // Chop test into multiple functions so that there's not one // enormous function to compile/link. // All the functions are named init so we don't have to do // anything special to call them. ☺ if n++; n >= 50 { fmt.Fprintf(b, "}\n") fmt.Fprintf(b, "func init() {\n") n = 0 } } } } }	3.27 KB	2024-02-02 18:09
📄 rotate0.go // runoutput ./rotate.go // 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. // Generate test of bit rotations. // The output is compiled and run. package main const mode = 0	286 B	2024-02-02 18:09
📄 rotate1.go // runoutput ./rotate.go // 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. // Generate test of bit rotations. // The output is compiled and run. package main const mode = 1	286 B	2024-02-02 18:09
📄 rotate2.go // runoutput ./rotate.go // 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. // Generate test of bit rotations. // The output is compiled and run. package main const mode = 2	286 B	2024-02-02 18:09
📄 rotate3.go // runoutput ./rotate.go // 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. // Generate test of bit rotations. // The output is compiled and run. package main const mode = 3	286 B	2024-02-02 18:09
📄 rune.go // compile // 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. // Test rune constants, expressions and types. // Compiles but does not run. package rune var ( r0 = 'a' r1 = 'a'+1 r2 = 1+'a' r3 = 'a'*2 r4 = 'a'/2 r5 = 'a'<<1 r6 = 'b'<<2 r7 int32 r = []rune{r0, r1, r2, r3, r4, r5, r6, r7} ) var ( f0 = 1.2 f1 = 1.2/'a' f = []float64{f0, f1} ) var ( i0 = 1 i1 = 1<<'\x01' i = []int{i0, i1} ) const ( maxRune = '\U0010FFFF' ) var ( b0 = maxRune < r0 b = []bool{b0} )	603 B	2024-02-02 18:09
📁 runtime	-	2024-02-02 18:09
📄 runtime.go // errorcheck // Copyright 2009 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 that even if a file imports runtime, // it cannot get at the low-level runtime definitions // known to the compiler. For normal packages // the compiler doesn't even record the lower case // functions in its symbol table, but some functions // in runtime are hard-coded into the compiler. // Does not compile. package main import "runtime" func main() { runtime.printbool(true) // ERROR "unexported\|undefined" }	600 B	2024-02-02 18:09
📄 shift1.go // errorcheck // 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. // Test illegal shifts. // Issue 1708, illegal cases. // Does not compile. package p func f(x int) int { return 0 } func g(x interface{}) int { return 0 } func h(x float64) int { return 0 } // from the spec var ( s uint = 33 u = 1.0 << s // ERROR "invalid operation\|shift of non-integer operand" v float32 = 1 << s // ERROR "invalid" ) // non-constant shift expressions var ( e1 = g(2.0 << s) // ERROR "invalid\|shift of non-integer operand" f1 = h(2 << s) // ERROR "invalid" g1 int64 = 1.1 << s // ERROR "truncated\|must be integer" ) // constant shift expressions const c uint = 65 var ( a2 int = 1.0 << c // ERROR "overflow" b2 = 1.0 << c // ERROR "overflow" d2 = f(1.0 << c) // ERROR "overflow" ) var ( // issues 4882, 4936. a3 = 1.0<<s + 0 // ERROR "invalid\|shift of non-integer operand" // issue 4937 b3 = 1<<s + 1 + 1.0 // ERROR "invalid\|shift of non-integer operand" // issue 5014 c3 = complex(1<<s, 0) // ERROR "invalid\|shift of type float64" d3 int = complex(1<<s, 3) // ERROR "non-integer\|cannot use.*as type int" "shift of type float64\|must be integer" e3 = real(1 << s) // ERROR "invalid" f3 = imag(1 << s) // ERROR "invalid" ) // from the spec func _() { var ( s uint = 33 i = 1 << s // 1 has type int j int32 = 1 << s // 1 has type int32; j == 0 k = uint64(1 << s) // 1 has type uint64; k == 1<<33 m int = 1.0 << s // 1.0 has type int n = 1.0<<s != i // 1.0 has type int; n == false if ints are 32bits in size o = 1<<s == 2<<s // 1 and 2 have type int; o == true if ints are 32bits in size // next test only fails on 32bit systems // p = 1<<s == 1<<33 // illegal if ints are 32bits in size: 1 has type int, but 1<<33 overflows int u = 1.0 << s // ERROR "non-integer\|float64" u1 = 1.0<<s != 0 // ERROR "non-integer\|float64" u2 = 1<<s != 1.0 // ERROR "non-integer\|float64" v float32 = 1 << s // ERROR "non-integer\|float32" w int64 = 1.0 << 33 // 1.0<<33 is a constant shift expression _, _, _, _, _, _, _, _, _, _ = j, k, m, n, o, u, u1, u2, v, w ) // non constants arguments trigger a different path f2 := 1.2 s2 := "hi" _ = f2 << 2 // ERROR "shift of type float64\|non-integer\|must be integer" _ = s2 << 2 // ERROR "shift of type string\|non-integer\|must be integer" } // shifts in comparisons w/ untyped operands var ( _ = 1<<s == 1 _ = 1<<s == 1. // ERROR "invalid\|shift of type float64" _ = 1.<<s == 1 // ERROR "invalid\|shift of type float64" _ = 1.<<s == 1. // ERROR "invalid\|non-integer\|shift of type float64" _ = 1<<s+1 == 1 _ = 1<<s+1 == 1. // ERROR "invalid\|shift of type float64" _ = 1<<s+1. == 1 // ERROR "invalid\|shift of type float64" _ = 1<<s+1. == 1. // ERROR "invalid\|shift of type float64" _ = 1.<<s+1 == 1 // ERROR "invalid\|shift of type float64" _ = 1.<<s+1 == 1. // ERROR "invalid\|shift of type float64" _ = 1.<<s+1. == 1 // ERROR "invalid\|shift of type float64" _ = 1.<<s+1. == 1. // ERROR "invalid\|non-integer\|shift of type float64" _ = 1<<s == 1<<s _ = 1<<s == 1.<<s // ERROR "invalid\|shift of type float64" _ = 1.<<s == 1<<s // ERROR "invalid\|shift of type float64" _ = 1.<<s == 1.<<s // ERROR "invalid\|non-integer\|shift of type float64" _ = 1<<s+1<<s == 1 _ = 1<<s+1<<s == 1. // ERROR "invalid\|shift of type float64" _ = 1<<s+1.<<s == 1 // ERROR "invalid\|shift of type float64" _ = 1<<s+1.<<s == 1. // ERROR "invalid\|shift of type float64" _ = 1.<<s+1<<s == 1 // ERROR "invalid\|shift of type float64" _ = 1.<<s+1<<s == 1. // ERROR "invalid\|shift of type float64" _ = 1.<<s+1.<<s == 1 // ERROR "invalid\|shift of type float64" _ = 1.<<s+1.<<s == 1. // ERROR "invalid\|non-integer\|shift of type float64" _ = 1<<s+1<<s == 1<<s+1<<s _ = 1<<s+1<<s == 1<<s+1.<<s // ERROR "invalid\|shift of type float64" _ = 1<<s+1<<s == 1.<<s+1<<s // ERROR "invalid\|shift of type float64" _ = 1<<s+1<<s == 1.<<s+1.<<s // ERROR "invalid\|shift of type float64" _ = 1<<s+1.<<s == 1<<s+1<<s // ERROR "invalid\|shift of type float64" _ = 1<<s+1.<<s == 1<<s+1.<<s // ERROR "invalid\|shift of type float64" _ = 1<<s+1.<<s == 1.<<s+1<<s // ERROR "invalid\|shift of type float64" _ = 1<<s+1.<<s == 1.<<s+1.<<s // ERROR "invalid\|non-integer\|shift of type float64" _ = 1.<<s+1<<s == 1<<s+1<<s // ERROR "invalid\|shift of type float64" _ = 1.<<s+1<<s == 1<<s+1.<<s // ERROR "invalid\|shift of type float64" _ = 1.<<s+1<<s == 1.<<s+1<<s // ERROR "invalid\|shift of type float64" _ = 1.<<s+1<<s == 1.<<s+1.<<s // ERROR "invalid\|non-integer\|shift of type float64" _ = 1.<<s+1.<<s == 1<<s+1<<s // ERROR "invalid\|shift of type float64" _ = 1.<<s+1.<<s == 1<<s+1.<<s // ERROR "invalid\|non-integer\|shift of type float64" _ = 1.<<s+1.<<s == 1.<<s+1<<s // ERROR "invalid\|non-integer\|shift of type float64" _ = 1.<<s+1.<<s == 1.<<s+1.<<s // ERROR "invalid\|non-integer\|shift of type float64" ) // shifts in comparisons w/ typed operands var ( x int _ = 1<<s == x _ = 1.<<s == x _ = 1.1<<s == x // ERROR "truncated\|must be integer" _ = 1<<s+x == 1 _ = 1<<s+x == 1. _ = 1<<s+x == 1.1 // ERROR "truncated" _ = 1.<<s+x == 1 _ = 1.<<s+x == 1. _ = 1.<<s+x == 1.1 // ERROR "truncated" _ = 1.1<<s+x == 1 // ERROR "truncated\|must be integer" _ = 1.1<<s+x == 1. // ERROR "truncated\|must be integer" _ = 1.1<<s+x == 1.1 // ERROR "truncated\|must be integer" _ = 1<<s == x<<s _ = 1.<<s == x<<s _ = 1.1<<s == x<<s // ERROR "truncated\|must be integer" ) // shifts as operands in non-arithmetic operations and as arguments func _() { var s uint var a []int _ = a[1<<s] _ = a[1.] _ = a[1.<<s] _ = a[1.1<<s] // ERROR "integer\|shift of type float64" _ = make([]int, 1) _ = make([]int, 1.) _ = make([]int, 1.<<s) _ = make([]int, 1.1<<s) // ERROR "non-integer\|truncated\|must be integer" _ = float32(1) _ = float32(1 << s) // ERROR "non-integer\|shift of type float32\|must be integer" _ = float32(1.) _ = float32(1. << s) // ERROR "non-integer\|shift of type float32\|must be integer" _ = float32(1.1 << s) // ERROR "non-integer\|shift of type float32\|must be integer" _ = append(a, 1<<s) _ = append(a, 1.<<s) _ = append(a, 1.1<<s) // ERROR "truncated\|must be integer" var b []float32 _ = append(b, 1<<s) // ERROR "non-integer\|type float32" _ = append(b, 1.<<s) // ERROR "non-integer\|type float32" _ = append(b, 1.1<<s) // ERROR "non-integer\|type float32\|must be integer" _ = complex(1.<<s, 0) // ERROR "non-integer\|shift of type float64\|must be integer" _ = complex(1.1<<s, 0) // ERROR "non-integer\|shift of type float64\|must be integer" _ = complex(0, 1.<<s) // ERROR "non-integer\|shift of type float64\|must be integer" _ = complex(0, 1.1<<s) // ERROR "non-integer\|shift of type float64\|must be integer" var a4 float64 var b4 int _ = complex(1<<s, a4) // ERROR "non-integer\|shift of type float64\|must be integer" _ = complex(1<<s, b4) // ERROR "invalid\|non-integer\|" var m1 map[int]string delete(m1, 1<<s) delete(m1, 1.<<s) delete(m1, 1.1<<s) // ERROR "truncated\|shift of type float64\|must be integer" var m2 map[float32]string delete(m2, 1<<s) // ERROR "invalid\|cannot use 1 << s as type float32" delete(m2, 1.<<s) // ERROR "invalid\|cannot use 1 << s as type float32" delete(m2, 1.1<<s) // ERROR "invalid\|cannot use 1.1 << s as type float32" } // shifts of shifts func _() { var s uint _ = 1 << (1 << s) _ = 1 << (1. << s) _ = 1 << (1.1 << s) // ERROR "non-integer\|truncated\|must be integer" _ = 1. << (1 << s) // ERROR "non-integer\|shift of type float64\|must be integer" _ = 1. << (1. << s) // ERROR "non-integer\|shift of type float64\|must be integer" _ = 1.1 << (1.1 << s) // ERROR "invalid\|non-integer\|truncated" _ = (1 << s) << (1 << s) _ = (1 << s) << (1. << s) _ = (1 << s) << (1.1 << s) // ERROR "truncated\|must be integer" _ = (1. << s) << (1 << s) // ERROR "non-integer\|shift of type float64\|must be integer" _ = (1. << s) << (1. << s) // ERROR "non-integer\|shift of type float64\|must be integer" _ = (1.1 << s) << (1.1 << s) // ERROR "invalid\|non-integer\|truncated" var x int x = 1 << (1 << s) x = 1 << (1. << s) x = 1 << (1.1 << s) // ERROR "truncated\|must be integer" x = 1. << (1 << s) x = 1. << (1. << s) x = 1.1 << (1.1 << s) // ERROR "truncated\|must be integer" x = (1 << s) << (1 << s) x = (1 << s) << (1. << s) x = (1 << s) << (1.1 << s) // ERROR "truncated\|must be integer" x = (1. << s) << (1 << s) x = (1. << s) << (1. << s) x = (1.1 << s) << (1.1 << s) // ERROR "truncated\|must be integer" var y float32 y = 1 << (1 << s) // ERROR "non-integer\|type float32" y = 1 << (1. << s) // ERROR "non-integer\|type float32" y = 1 << (1.1 << s) // ERROR "invalid\|truncated\|float32" y = 1. << (1 << s) // ERROR "non-integer\|type float32" y = 1. << (1. << s) // ERROR "non-integer\|type float32" y = 1.1 << (1.1 << s) // ERROR "invalid\|truncated\|float32" var z complex128 z = (1 << s) << (1 << s) // ERROR "non-integer\|type complex128" z = (1 << s) << (1. << s) // ERROR "non-integer\|type complex128" z = (1 << s) << (1.1 << s) // ERROR "invalid\|truncated\|complex128" z = (1. << s) << (1 << s) // ERROR "non-integer\|type complex128\|must be integer" z = (1. << s) << (1. << s) // ERROR "non-integer\|type complex128\|must be integer" z = (1.1 << s) << (1.1 << s) // ERROR "invalid\|truncated\|complex128" _, _, _ = x, y, z }	9.43 KB	2024-02-02 18:09
📄 shift2.go // compile // 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. // Test legal shifts. // Issue 1708, legal cases. // Compiles but does not run. package p func f(x int) int { return 0 } func g(x interface{}) int { return 0 } func h(x float64) int { return 0 } // from the spec var ( s uint = 33 i = 1 << s // 1 has type int j int32 = 1 << s // 1 has type int32; j == 0 k = uint64(1 << s) // 1 has type uint64; k == 1<<33 l = g(1 << s) // 1 has type int m int = 1.0 << s // legal: 1.0 has type int w int64 = 1.0 << 33 // legal: 1.0<<33 is a constant shift expression ) // non-constant shift expressions var ( a1 int = 2.0 << s // typeof(2.0) is int in this context => legal shift d1 = f(2.0 << s) // typeof(2.0) is int in this context => legal shift ) // constant shift expressions const c uint = 5 var ( a2 int = 2.0 << c // a2 == 64 (type int) b2 = 2.0 << c // b2 == 64 (untyped integer) _ = f(b2) // verify b2 has type int c2 float64 = 2 << c // c2 == 64.0 (type float64) d2 = f(2.0 << c) // == f(64) e2 = g(2.0 << c) // == g(int(64)) f2 = h(2 << c) // == h(float64(64.0)) )	1.31 KB	2024-02-02 18:09
📄 shift3.go // run // Copyright 2022 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 that the compiler's noder uses the correct type // for RHS shift operands that are untyped. Must compile; // run for good measure. package main import ( "fmt" "math" ) func f(x, y int) { if x != y { panic(fmt.Sprintf("%d != %d", x, y)) } } func main() { var x int = 1 f(x<<1, 2) f(x<<1., 2) f(x<<(1+0i), 2) f(x<<0i, 1) f(x<<(1<<x), 4) f(x<<(1.<<x), 4) f(x<<((1+0i)<<x), 4) f(x<<(0i<<x), 1) // corner cases const M = math.MaxUint f(x<<(M+0), 0) // shift by untyped int representable as uint f(x<<(M+0.), 0) // shift by untyped float representable as uint f(x<<(M+0.+0i), 0) // shift by untyped complex representable as uint }	834 B	2024-02-02 18:09
📄 sieve.go // build // Copyright 2009 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 basic concurrency: the classic prime sieve. // Do not run - loops forever. package main // Send the sequence 2, 3, 4, ... to channel 'ch'. func Generate(ch chan<- int) { for i := 2; ; i++ { ch <- i // Send 'i' to channel 'ch'. } } // Copy the values from channel 'in' to channel 'out', // removing those divisible by 'prime'. func Filter(in <-chan int, out chan<- int, prime int) { for { i := <-in // Receive value of new variable 'i' from 'in'. if i%prime != 0 { out <- i // Send 'i' to channel 'out'. } } } // The prime sieve: Daisy-chain Filter processes together. func Sieve() { ch := make(chan int) // Create a new channel. go Generate(ch) // Start Generate() as a subprocess. for { prime := <-ch print(prime, "\n") ch1 := make(chan int) go Filter(ch, ch1, prime) ch = ch1 } } func main() { Sieve() }	1 KB	2024-02-02 18:09
📄 sigchld.go // run //go:build !plan9 && !windows && !wasip1 // Copyright 2009 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 that a program can survive SIGCHLD. package main import "syscall" func main() { syscall.Kill(syscall.Getpid(), syscall.SIGCHLD) println("survived SIGCHLD") }	381 B	2024-02-02 18:09
📄 sigchld.out survived SIGCHLD	17 B	2024-02-02 18:09
📄 simassign.go // run // Copyright 2009 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 simultaneous assignment. package main var a, b, c, d, e, f, g, h, i int func printit() { println(a, b, c, d, e, f, g, h, i) } func testit(permuteok bool) bool { if a+b+c+d+e+f+g+h+i != 45 { print("sum does not add to 45\n") printit() return false } return permuteok \|\| a == 1 && b == 2 && c == 3 && d == 4 && e == 5 && f == 6 && g == 7 && h == 8 && i == 9 } func swap(x, y int) (u, v int) { return y, x } func main() { a = 1 b = 2 c = 3 d = 4 e = 5 f = 6 g = 7 h = 8 i = 9 if !testit(false) { panic("init val\n") } for z := 0; z < 100; z++ { a, b, c, d, e, f, g, h, i = b, c, d, a, i, e, f, g, h if !testit(z%20 != 19) { print("on ", z, "th iteration\n") printit() panic("fail") } } if !testit(false) { print("final val\n") printit() panic("fail") } a, b = swap(1, 2) if a != 2 \|\| b != 1 { panic("bad swap") } a, b = swap(swap(a, b)) if a != 2 \|\| b != 1 { panic("bad swap") } }	1.12 KB	2024-02-02 18:09
📄 sizeof.go // run // 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 "unsafe" type T struct { X int } var t T func isUintptr(uintptr) {} type T2 struct { A int32 U2 } type U2 struct { B int32 C int32 } var t2 T2 var p2 T2 func main() { // Test unsafe.Sizeof, unsafe.Alignof, and unsafe.Offsetof all return uintptr. isUintptr(unsafe.Sizeof(t)) isUintptr(unsafe.Alignof(t)) isUintptr(unsafe.Offsetof(t.X)) // Test correctness of Offsetof with respect to embedded fields (issue 4909). if unsafe.Offsetof(t2.C) != 8 { println(unsafe.Offsetof(t2.C), "!= 8") panic("unsafe.Offsetof(t2.C) != 8") } if unsafe.Offsetof(p2.C) != 8 { println(unsafe.Offsetof(p2.C), "!= 8") panic("unsafe.Offsetof(p2.C) != 8") } if unsafe.Offsetof(t2.U2.C) != 4 { println(unsafe.Offsetof(t2.U2.C), "!= 4") panic("unsafe.Offsetof(t2.U2.C) != 4") } if unsafe.Offsetof(p2.U2.C) != 4 { println(unsafe.Offsetof(p2.U2.C), "!= 4") panic("unsafe.Offsetof(p2.U2.C) != 4") } testDeep() testNotEmbedded() } type ( S1 struct { A int64 S2 } S2 struct { B int64 S3 } S3 struct { C int64 S4 } S4 struct { D int64 S5 } S5 struct { E int64 S6 } S6 struct { F int64 S7 } S7 struct { G int64 S8 } S8 struct { H int64 S1 } ) func testDeep() { var s1 S1 switch { case unsafe.Offsetof(s1.A) != 0: panic("unsafe.Offsetof(s1.A) != 0") case unsafe.Offsetof(s1.B) != 8: panic("unsafe.Offsetof(s1.B) != 8") case unsafe.Offsetof(s1.C) != 16: panic("unsafe.Offsetof(s1.C) != 16") case unsafe.Offsetof(s1.D) != 24: panic("unsafe.Offsetof(s1.D) != 24") case unsafe.Offsetof(s1.E) != 32: panic("unsafe.Offsetof(s1.E) != 32") case unsafe.Offsetof(s1.F) != 40: panic("unsafe.Offsetof(s1.F) != 40") case unsafe.Offsetof(s1.G) != 48: panic("unsafe.Offsetof(s1.G) != 48") case unsafe.Offsetof(s1.H) != 56: panic("unsafe.Offsetof(s1.H) != 56") case unsafe.Offsetof(s1.S1) != 64: panic("unsafe.Offsetof(s1.S1) != 64") case unsafe.Offsetof(s1.S1.S2.S3.S4.S5.S6.S7.S8.S1.S2) != 8: panic("unsafe.Offsetof(s1.S1.S2.S3.S4.S5.S6.S7.S8.S1.S2) != 8") } } func testNotEmbedded() { type T2 struct { B int32 C int32 } type T1 struct { A int32 T2 } type T struct { Dummy int32 F T1 P T1 } var t T var p T switch { case unsafe.Offsetof(t.F.B) != 4: panic("unsafe.Offsetof(t.F.B) != 4") case unsafe.Offsetof(t.F.C) != 8: panic("unsafe.Offsetof(t.F.C) != 8") case unsafe.Offsetof(t.P.B) != 4: panic("unsafe.Offsetof(t.P.B) != 4") case unsafe.Offsetof(t.P.C) != 8: panic("unsafe.Offsetof(t.P.C) != 8") case unsafe.Offsetof(p.F.B) != 4: panic("unsafe.Offsetof(p.F.B) != 4") case unsafe.Offsetof(p.F.C) != 8: panic("unsafe.Offsetof(p.F.C) != 8") case unsafe.Offsetof(p.P.B) != 4: panic("unsafe.Offsetof(p.P.B) != 4") case unsafe.Offsetof(p.P.C) != 8: panic("unsafe.Offsetof(p.P.C) != 8") } }	2.95 KB	2024-02-02 18:09
📄 slice3.go // runoutput // 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. // Test run-time behavior of 3-index slice expressions. package main import ( "bufio" "fmt" "os" "strconv" ) var bout bufio.Writer func main() { bout = bufio.NewWriter(os.Stdout) fmt.Fprintf(bout, "%s", programTop) fmt.Fprintf(bout, "func main() {\n") index := []string{ "0", "1", "2", "3", "10", "20", "vminus1", "v0", "v1", "v2", "v3", "v10", "v20", } parse := func(s string) (n int, isconst bool) { if s == "vminus1" { return -1, false } isconst = true if s[0] == 'v' { isconst = false s = s[1:] } n, _ = strconv.Atoi(s) return n, isconst } const Cap = 10 // cap of slice, array for _, base := range []string{"array", "slice"} { for _, i := range index { iv, iconst := parse(i) for _, j := range index { jv, jconst := parse(j) for _, k := range index { kv, kconst := parse(k) // Avoid errors that would make the program not compile. // Those are tested by slice3err.go. switch { case iconst && jconst && iv > jv, jconst && kconst && jv > kv, iconst && kconst && iv > kv, iconst && base == "array" && iv > Cap, jconst && base == "array" && jv > Cap, kconst && base == "array" && kv > Cap: continue } expr := base + "[" + i + ":" + j + ":" + k + "]" var xbase, xlen, xcap int if iv > jv \|\| jv > kv \|\| kv > Cap \|\| iv < 0 \|\| jv < 0 \|\| kv < 0 { xbase, xlen, xcap = -1, -1, -1 } else { xbase = iv xlen = jv - iv xcap = kv - iv } fmt.Fprintf(bout, "\tcheckSlice(%q, func() []byte { return %s }, %d, %d, %d)\n", expr, expr, xbase, xlen, xcap) } } } } fmt.Fprintf(bout, "\tif !ok { os.Exit(1) }\n") fmt.Fprintf(bout, "}\n") bout.Flush() } var programTop = ` package main import ( "fmt" "os" "unsafe" ) var ok = true var ( array = new([10]byte) slice = array[:] vminus1 = -1 v0 = 0 v1 = 1 v2 = 2 v3 = 3 v4 = 4 v5 = 5 v10 = 10 v20 = 20 ) func notOK() { if ok { println("BUG:") ok = false } } func checkSlice(desc string, f func() []byte, xbase, xlen, xcap int) { defer func() { if err := recover(); err != nil { if xbase >= 0 { notOK() println(desc, " unexpected panic: ", fmt.Sprint(err)) } } // "no panic" is checked below }() x := f() arrayBase := uintptr(unsafe.Pointer(array)) raw := (*[3]uintptr)(unsafe.Pointer(&x)) base, len, cap := raw[0] - arrayBase, raw[1], raw[2] if xbase < 0 { notOK() println(desc, "=", base, len, cap, "want panic") return } if cap != 0 && base != uintptr(xbase) \|\| base >= 10 \|\| len != uintptr(xlen) \|\| cap != uintptr(xcap) { notOK() if cap == 0 { println(desc, "=", base, len, cap, "want", "0-9", xlen, xcap) } else { println(desc, "=", base, len, cap, "want", xbase, xlen, xcap) } } } `	2.92 KB	2024-02-02 18:09
📄 slice3err.go // errorcheck // 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. package p var array *[10]int var slice []int var str string var i, j, k int func f() { // check what missing arguments are allowed _ = array[:] _ = array[i:] _ = array[:j] _ = array[i:j] _ = array[::] // ERROR "middle index required in 3-index slice\|invalid slice indices" "final index required in 3-index slice" _ = array[i::] // ERROR "middle index required in 3-index slice\|invalid slice indices" "final index required in 3-index slice" _ = array[:j:] // ERROR "final index required in 3-index slice\|invalid slice indices" _ = array[i:j:] // ERROR "final index required in 3-index slice\|invalid slice indices" _ = array[::k] // ERROR "middle index required in 3-index slice\|invalid slice indices" _ = array[i::k] // ERROR "middle index required in 3-index slice\|invalid slice indices" _ = array[:j:k] _ = array[i:j:k] _ = slice[:] _ = slice[i:] _ = slice[:j] _ = slice[i:j] _ = slice[::] // ERROR "middle index required in 3-index slice\|invalid slice indices" "final index required in 3-index slice" _ = slice[i::] // ERROR "middle index required in 3-index slice\|invalid slice indices" "final index required in 3-index slice" _ = slice[:j:] // ERROR "final index required in 3-index slice\|invalid slice indices" _ = slice[i:j:] // ERROR "final index required in 3-index slice\|invalid slice indices" _ = slice[::k] // ERROR "middle index required in 3-index slice\|invalid slice indices" _ = slice[i::k] // ERROR "middle index required in 3-index slice\|invalid slice indices" _ = slice[:j:k] _ = slice[i:j:k] _ = str[:] _ = str[i:] _ = str[:j] _ = str[i:j] _ = str[::] // ERROR "3-index slice of string" "middle index required in 3-index slice" "final index required in 3-index slice" _ = str[i::] // ERROR "3-index slice of string" "middle index required in 3-index slice" "final index required in 3-index slice" _ = str[:j:] // ERROR "3-index slice of string" "final index required in 3-index slice" _ = str[i:j:] // ERROR "3-index slice of string" "final index required in 3-index slice" _ = str[::k] // ERROR "3-index slice of string" "middle index required in 3-index slice" _ = str[i::k] // ERROR "3-index slice of string" "middle index required in 3-index slice" _ = str[:j:k] // ERROR "3-index slice of string" _ = str[i:j:k] // ERROR "3-index slice of string" // check invalid indices _ = array[1:2] _ = array[2:1] // ERROR "invalid slice index\|invalid slice indices\|inverted slice" _ = array[2:2] _ = array[i:1] _ = array[1:j] _ = array[1:2:3] _ = array[1:3:2] // ERROR "invalid slice index\|invalid slice indices\|inverted slice" _ = array[2:1:3] // ERROR "invalid slice index\|invalid slice indices\|inverted slice" _ = array[2:3:1] // ERROR "invalid slice index\|invalid slice indices\|inverted slice" _ = array[3:1:2] // ERROR "invalid slice index\|invalid slice indices\|inverted slice" _ = array[3:2:1] // ERROR "invalid slice index\|invalid slice indices\|inverted slice" _ = array[i:1:2] _ = array[i:2:1] // ERROR "invalid slice index\|invalid slice indices\|inverted slice" _ = array[1:j:2] _ = array[2:j:1] // ERROR "invalid slice index\|invalid slice indices" _ = array[1:2:k] _ = array[2:1:k] // ERROR "invalid slice index\|invalid slice indices\|inverted slice" _ = slice[1:2] _ = slice[2:1] // ERROR "invalid slice index\|invalid slice indices\|inverted slice" _ = slice[2:2] _ = slice[i:1] _ = slice[1:j] _ = slice[1:2:3] _ = slice[1:3:2] // ERROR "invalid slice index\|invalid slice indices\|inverted slice" _ = slice[2:1:3] // ERROR "invalid slice index\|invalid slice indices\|inverted slice" _ = slice[2:3:1] // ERROR "invalid slice index\|invalid slice indices\|inverted slice" _ = slice[3:1:2] // ERROR "invalid slice index\|invalid slice indices\|inverted slice" _ = slice[3:2:1] // ERROR "invalid slice index\|invalid slice indices\|inverted slice" _ = slice[i:1:2] _ = slice[i:2:1] // ERROR "invalid slice index\|invalid slice indices\|inverted slice" _ = slice[1:j:2] _ = slice[2:j:1] // ERROR "invalid slice index\|invalid slice indices" _ = slice[1:2:k] _ = slice[2:1:k] // ERROR "invalid slice index\|invalid slice indices\|inverted slice" _ = str[1:2] _ = str[2:1] // ERROR "invalid slice index\|invalid slice indices\|inverted slice" _ = str[2:2] _ = str[i:1] _ = str[1:j] // check out of bounds indices on array _ = array[11:11] // ERROR "out of bounds" _ = array[11:12] // ERROR "out of bounds" _ = array[11:] // ERROR "out of bounds" _ = array[:11] // ERROR "out of bounds" _ = array[1:11] // ERROR "out of bounds" _ = array[1:11:12] // ERROR "out of bounds" _ = array[1:2:11] // ERROR "out of bounds" _ = array[1:11:3] // ERROR "out of bounds\|invalid slice index" _ = array[11:2:3] // ERROR "out of bounds\|inverted slice\|invalid slice index" _ = array[11:12:13] // ERROR "out of bounds" // slice bounds not checked _ = slice[11:11] _ = slice[11:12] _ = slice[11:] _ = slice[:11] _ = slice[1:11] _ = slice[1:11:12] _ = slice[1:2:11] _ = slice[1:11:3] // ERROR "invalid slice index\|invalid slice indices" _ = slice[11:2:3] // ERROR "invalid slice index\|invalid slice indices\|inverted slice" _ = slice[11:12:13] }	5.19 KB	2024-02-02 18:09
📄 slicecap.go // 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. package main import "unsafe" var ( hello = "hello" bytes = []byte{1, 2, 3, 4, 5} ints = []int32{1, 2, 3, 4, 5} five = 5 ok = true ) func notOK() { if ok { println("BUG:") ok = false } } func checkString(desc, s string) { p1 := (uintptr)(unsafe.Pointer(&s)) p2 := (uintptr)(unsafe.Pointer(&hello)) if p1-p2 >= 5 { notOK() println("string", desc, "has invalid base") } } func checkBytes(desc string, s []byte) { p1 := (uintptr)(unsafe.Pointer(&s)) p2 := (uintptr)(unsafe.Pointer(&bytes)) if p1-p2 >= 5 { println("byte slice", desc, "has invalid base") } } func checkInts(desc string, s []int32) { p1 := (uintptr)(unsafe.Pointer(&s)) p2 := (uintptr)(unsafe.Pointer(&ints)) if p1-p2 >= 5*4 { println("int slice", desc, "has invalid base") } } func main() { { x := hello checkString("x", x) checkString("x[5:]", x[5:]) checkString("x[five:]", x[five:]) checkString("x[5:five]", x[5:five]) checkString("x[five:5]", x[five:5]) checkString("x[five:five]", x[five:five]) checkString("x[1:][2:][2:]", x[1:][2:][2:]) y := x[4:] checkString("y[1:]", y[1:]) } { x := bytes checkBytes("x", x) checkBytes("x[5:]", x[5:]) checkBytes("x[five:]", x[five:]) checkBytes("x[5:five]", x[5:five]) checkBytes("x[five:5]", x[five:5]) checkBytes("x[five:five]", x[five:five]) checkBytes("x[1:][2:][2:]", x[1:][2:][2:]) y := x[4:] checkBytes("y[1:]", y[1:]) } { x := ints checkInts("x", x) checkInts("x[5:]", x[5:]) checkInts("x[five:]", x[five:]) checkInts("x[5:five]", x[5:five]) checkInts("x[five:5]", x[five:5]) checkInts("x[five:five]", x[five:five]) checkInts("x[1:][2:][2:]", x[1:][2:][2:]) y := x[4:] checkInts("y[1:]", y[1:]) } }	1.85 KB	2024-02-02 18:09
📄 sliceopt.go // errorcheck -0 -d=append,slice // 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. // Check optimization results for append and slicing. package main func a1(x []int, y int) []int { x = append(x, y) // ERROR "append: len-only update $in local slice$$" return x } func a2(x []int, y int) []int { return append(x, y) } func a3(x []int, y int) { x = append(x, y) // ERROR "append: len-only update$" } func s1(x []int, xs string, i, j int) { var z []int z = (x)[0:] // ERROR "slice: omit slice operation$" println(z) var zs string zs = (*xs)[0:] // ERROR "slice: omit slice operation$" println(zs) }	735 B	2024-02-02 18:09
📄 solitaire.go // build // Copyright 2010 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 general operation by solving a peg solitaire game. // A version of this is in the Go playground. // Don't run it - produces too much output. // This program solves the (English) peg solitaire board game. // See also: http://en.wikipedia.org/wiki/Peg_solitaire package main const N = 11 + 1 // length of a board row (+1 for newline) // The board must be surrounded by 2 illegal fields in each direction // so that move() doesn't need to check the board boundaries. Periods // represent illegal fields, ● are pegs, and ○ are holes. var board = []rune( `........... ........... ....●●●.... ....●●●.... ..●●●●●●●.. ..●●●○●●●.. ..●●●●●●●.. ....●●●.... ....●●●.... ........... ........... `) // center is the position of the center hole if there is a single one; // otherwise it is -1. var center int func init() { n := 0 for pos, field := range board { if field == '○' { center = pos n++ } } if n != 1 { center = -1 // no single hole } } var moves int // number of times move is called // move tests if there is a peg at position pos that can jump over another peg // in direction dir. If the move is valid, it is executed and move returns true. // Otherwise, move returns false. func move(pos, dir int) bool { moves++ if board[pos] == '●' && board[pos+dir] == '●' && board[pos+2dir] == '○' { board[pos] = '○' board[pos+dir] = '○' board[pos+2dir] = '●' return true } return false } // unmove reverts a previously executed valid move. func unmove(pos, dir int) { board[pos] = '●' board[pos+dir] = '●' board[pos+2*dir] = '○' } // solve tries to find a sequence of moves such that there is only one peg left // at the end; if center is >= 0, that last peg must be in the center position. // If a solution is found, solve prints the board after each move in a backward // fashion (i.e., the last board position is printed first, all the way back to // the starting board position). func solve() bool { var last, n int for pos, field := range board { // try each board position if field == '●' { // found a peg for _, dir := range [...]int{-1, -N, +1, +N} { // try each direction if move(pos, dir) { // a valid move was found and executed, // see if this new board has a solution if solve() { unmove(pos, dir) println(string(board)) return true } unmove(pos, dir) } } last = pos n++ } } // tried each possible move if n == 1 && (center < 0 \|\| last == center) { // there's only one peg left println(string(board)) return true } // no solution found for this board return false } func main() { if !solve() { println("no solution found") } println(moves, "moves tried") }	2.9 KB	2024-02-02 18:09
📄 stack.go // run // Copyright 2009 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 stack splitting code. // Try to tickle stack splitting bugs by doing // go, defer, and closure calls at different stack depths. package main type T [20]int func g(c chan int, t T) { s := 0 for i := 0; i < len(t); i++ { s += t[i] } c <- s } func d(t T) { s := 0 for i := 0; i < len(t); i++ { s += t[i] } if s != len(t) { println("bad defer", s) panic("fail") } } func f0() { // likely to make a new stack for f0, // because the call to f1 puts 3000 bytes // in our frame. f1() } func f1() [3000]byte { // likely to make a new stack for f1, // because 3000 bytes were used by f0 // and we need 3000 more for the call // to f2. if the call to morestack in f1 // does not pass the frame size, the new // stack (default size 5k) will not be big // enough for the frame, and the morestack // check in f2 will die, if we get that far // without faulting. f2() return [3000]byte{} } func f2() [3000]byte { // just take up space return [3000]byte{} } var c = make(chan int) var t T var b = []byte{1, 2, 3, 4, 5, 6, 7, 8, 9, 10} func recur(n int) { ss := string(b) if len(ss) != len(b) { panic("bad []byte -> string") } go g(c, t) f0() s := <-c if s != len(t) { println("bad go", s) panic("fail") } f := func(t T) int { s := 0 for i := 0; i < len(t); i++ { s += t[i] } s += n return s } s = f(t) if s != len(t)+n { println("bad func", s, "at level", n) panic("fail") } if n > 0 { recur(n - 1) } defer d(t) } func main() { for i := 0; i < len(t); i++ { t[i] = 1 } recur(8000) }	1.69 KB	2024-02-02 18:09
📄 stackobj.go // 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. package main import ( "fmt" "runtime" ) type HeapObj [8]int64 type StkObj struct { h HeapObj } var n int var c int = -1 func gc() { // encourage heap object to be collected, and have its finalizer run. runtime.GC() runtime.GC() runtime.GC() n++ } func main() { f() gc() // prior to stack objects, heap object is not collected until here if c < 0 { panic("heap object never collected") } if c != 1 { panic(fmt.Sprintf("expected collection at phase 1, got phase %d", c)) } } func f() { var s StkObj s.h = new(HeapObj) runtime.SetFinalizer(s.h, func(h HeapObj) { // Remember at what phase the heap object was collected. c = n }) g(&s) gc() } func g(s *StkObj) { gc() // heap object is still live here runtime.KeepAlive(s) gc() // heap object should be collected here }	975 B	2024-02-02 18:09
📄 stackobj2.go // 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. package main import ( "fmt" "runtime" ) // linked list up the stack, to test lots of stack objects. type T struct { // points to a heap object. Test will make sure it isn't freed. data int64 // next pointer for a linked list of stack objects next T // duplicate of next, to stress test the pointer buffers // used during stack tracing. next2 T } func main() { makelist(nil, 10000) } func makelist(x T, n int64) { if n%2 != 0 { panic("must be multiple of 2") } if n == 0 { runtime.GC() i := int64(1) for ; x != nil; x, i = x.next, i+1 { // Make sure x.data hasn't been collected. if got := x.data; got != i { panic(fmt.Sprintf("bad data want %d, got %d", i, got)) } } return } // Put 2 objects in each frame, to test intra-frame pointers. // Use both orderings to ensure the linked list isn't always in address order. var a, b T if n%3 == 0 { a.data = newInt(n) a.next = x a.next2 = x b.data = newInt(n - 1) b.next = &a b.next2 = &a x = &b } else { b.data = newInt(n) b.next = x b.next2 = x a.data = newInt(n - 1) a.next = &b a.next2 = &b x = &a } makelist(x, n-2) } // big enough and pointer-y enough to not be tinyalloc'd type NotTiny struct { n int64 p byte } // newInt allocates n on the heap and returns a pointer to it. func newInt(n int64) int64 { h := &NotTiny{n: n} p := &h.n escape = p return p } var escape int64	1.55 KB	2024-02-02 18:09
📄 stackobj3.go // 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. // This test makes sure that ambiguously live arguments work correctly. package main import ( "runtime" ) type HeapObj [8]int64 type StkObj struct { h HeapObj } var n int var c int = -1 func gc() { // encourage heap object to be collected, and have its finalizer run. runtime.GC() runtime.GC() runtime.GC() n++ } var null StkObj var sink HeapObj //go:noinline func use(p StkObj) { } //go:noinline func f(s StkObj, b bool) { var p StkObj if b { p = &s } else { p = &null } // use is required here to prevent the conditional // code above from being executed after the first gc() call. use(p) // If b==false, h should be collected here. gc() // 0 sink = p.h gc() // 1 sink = nil // If b==true, h should be collected here. gc() // 2 } func fTrue() { var s StkObj s.h = new(HeapObj) c = -1 n = 0 runtime.SetFinalizer(s.h, func(h HeapObj) { // Remember at what phase the heap object was collected. c = n }) f(s, true) if c != 2 { panic("bad liveness") } } func fFalse() { var s StkObj s.h = new(HeapObj) c = -1 n = 0 runtime.SetFinalizer(s.h, func(h HeapObj) { // Remember at what phase the heap object was collected. c = n }) f(s, false) if c != 0 { panic("bad liveness") } } func main() { fTrue() fFalse() }	1.42 KB	2024-02-02 18:09
📄 strcopy.go // 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. // Test that string([]byte(string)) makes a copy and doesn't reduce to // nothing. (Issue 25834) package main import ( "reflect" "unsafe" ) func main() { var ( buf = make([]byte, 2<<10) large = string(buf) sub = large[10:12] subcopy = string([]byte(sub)) subh = (reflect.StringHeader)(unsafe.Pointer(&sub)) subcopyh = (reflect.StringHeader)(unsafe.Pointer(&subcopy)) ) if subh.Data == subcopyh.Data { panic("sub and subcopy have the same underlying array") } }	674 B	2024-02-02 18:09
📄 strength.go // runoutput // 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. // Generate test of strength reduction for multiplications // with constants. Especially useful for amd64/386. package main import "fmt" func testMul(fact, bits int) string { n := fmt.Sprintf("testMul_%d_%d", fact, bits) fmt.Printf("func %s(s int%d) {\n", n, bits) want := 0 for i := 0; i < 200; i++ { fmt.Printf(` if want, got := int%d(%d), s%d; want != got { failed = true fmt.Printf("got %d %%d == %%d, wanted %d\n", s, got) } `, bits, want, i, i, want) want += fact } fmt.Printf("}\n") return fmt.Sprintf("%s(%d)", n, fact) } func main() { fmt.Printf("package main\n") fmt.Printf("import \"fmt\"\n") fmt.Printf("var failed = false\n") f1 := testMul(17, 32) f2 := testMul(131, 64) fmt.Printf("func main() {\n") fmt.Println(f1) fmt.Println(f2) fmt.Printf("if failed {\n panic(\"multiplication failed\")\n}\n") fmt.Printf("}\n") }	1.02 KB	2024-02-02 18:09
📁 stress	-	2024-02-02 18:09
📄 string_lit.go // run // Copyright 2009 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 string literal syntax. package main import "os" var ecode int func assert(a, b, c string) { if a != b { ecode = 1 print("FAIL: ", c, ": ", a, "!=", b, "\n") var max int = len(a) if len(b) > max { max = len(b) } for i := 0; i < max; i++ { ac := 0 bc := 0 if i < len(a) { ac = int(a[i]) } if i < len(b) { bc = int(b[i]) } if ac != bc { print("\ta[", i, "] = ", ac, "; b[", i, "] =", bc, "\n") } } panic("string_lit") } } const ( gx1 = "aä本☺" gx2 = "aä\xFF\xFF本☺" gx2fix = "aä\uFFFD\uFFFD本☺" ) var ( gr1 = []rune(gx1) gr2 = []rune(gx2) gb1 = []byte(gx1) gb2 = []byte(gx2) ) func main() { ecode = 0 s := "" + " " + "'`" + "a" + "ä" + "本" + "\a\b\f\n\r\t\v\\\"" + "\000\123\x00\xca\xFE\u0123\ubabe\U0000babe" + `` + ` ` + `'"` + `a` + `ä` + `本` + `\a\b\f\n\r\t\v\\\'` + `\000\123\x00\xca\xFE\u0123\ubabe\U0000babe` + `\x\u\U\` assert("", ``, "empty") assert(" ", " ", "blank") assert("\x61", "a", "lowercase a") assert("\x61", `a`, "lowercase a (backquote)") assert("\u00e4", "ä", "a umlaut") assert("\u00e4", `ä`, "a umlaut (backquote)") assert("\u672c", "本", "nihon") assert("\u672c", `本`, "nihon (backquote)") assert("\x07\x08\x0c\x0a\x0d\x09\x0b\x5c\x22", "\a\b\f\n\r\t\v\\\"", "backslashes") assert("\\a\\b\\f\\n\\r\\t\\v\\\\\\\"", `\a\b\f\n\r\t\v\\\"`, "backslashes (backquote)") assert("\x00\x53\000\xca\376S몾몾", "\000\123\x00\312\xFE\u0053\ubabe\U0000babe", "backslashes 2") assert("\\000\\123\\x00\\312\\xFE\\u0123\\ubabe\\U0000babe", `\000\123\x00\312\xFE\u0123\ubabe\U0000babe`, "backslashes 2 (backquote)") assert("\\x\\u\\U\\", `\x\u\U\`, "backslash 3 (backquote)") // test large and surrogate-half runes. perhaps not the most logical place for these tests. var r int32 r = 0x10ffff // largest rune value s = string(r) assert(s, "\xf4\x8f\xbf\xbf", "largest rune") r = 0x10ffff + 1 s = string(r) assert(s, "\xef\xbf\xbd", "too-large rune") r = 0xD800 s = string(r) assert(s, "\xef\xbf\xbd", "surrogate rune min") r = 0xDFFF s = string(r) assert(s, "\xef\xbf\xbd", "surrogate rune max") r = -1 s = string(r) assert(s, "\xef\xbf\xbd", "negative rune") // the large rune tests again, this time using constants instead of a variable. // these conversions will be done at compile time. s = string(0x10ffff) // largest rune value assert(s, "\xf4\x8f\xbf\xbf", "largest rune constant") s = string(0x10ffff + 1) assert(s, "\xef\xbf\xbd", "too-large rune constant") s = string(0xD800) assert(s, "\xef\xbf\xbd", "surrogate rune min constant") s = string(0xDFFF) assert(s, "\xef\xbf\xbd", "surrogate rune max constant") s = string(-1) assert(s, "\xef\xbf\xbd", "negative rune") // the large rune tests yet again, with a slice. rs := []rune{0x10ffff, 0x10ffff + 1, 0xD800, 0xDFFF, -1} s = string(rs) assert(s, "\xf4\x8f\xbf\xbf\xef\xbf\xbd\xef\xbf\xbd\xef\xbf\xbd\xef\xbf\xbd", "large rune slice") assert(string(gr1), gx1, "global ->[]rune") assert(string(gr2), gx2fix, "global invalid ->[]rune") assert(string(gb1), gx1, "->[]byte") assert(string(gb2), gx2, "global invalid ->[]byte") var ( r1 = []rune(gx1) r2 = []rune(gx2) b1 = []byte(gx1) b2 = []byte(gx2) ) assert(string(r1), gx1, "->[]rune") assert(string(r2), gx2fix, "invalid ->[]rune") assert(string(b1), gx1, "->[]byte") assert(string(b2), gx2, "invalid ->[]byte") os.Exit(ecode) }	3.58 KB	2024-02-02 18:09
📄 stringrange.go // run // Copyright 2009 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 range over strings. package main import ( "fmt" "os" "unicode/utf8" ) func main() { s := "\000\123\x00\xca\xFE\u0123\ubabe\U0000babe\U0010FFFFx" expect := []rune{0, 0123, 0, 0xFFFD, 0xFFFD, 0x123, 0xbabe, 0xbabe, 0x10FFFF, 'x'} offset := 0 var i int var c rune ok := true cnum := 0 for i, c = range s { r, size := utf8.DecodeRuneInString(s[i:len(s)]) // check it another way if i != offset { fmt.Printf("unexpected offset %d not %d\n", i, offset) ok = false } if r != expect[cnum] { fmt.Printf("unexpected rune %d from DecodeRuneInString: %x not %x\n", i, r, expect[cnum]) ok = false } if c != expect[cnum] { fmt.Printf("unexpected rune %d from range: %x not %x\n", i, r, expect[cnum]) ok = false } offset += size cnum++ } if i != len(s)-1 { fmt.Println("after loop i is", i, "not", len(s)-1) ok = false } i = 12345 c = 23456 for i, c = range "" { } if i != 12345 { fmt.Println("range empty string assigned to index:", i) ok = false } if c != 23456 { fmt.Println("range empty string assigned to value:", c) ok = false } for _, c := range "a\xed\xa0\x80a" { if c != 'a' && c != utf8.RuneError { fmt.Printf("surrogate UTF-8 does not error: %U\n", c) ok = false } } if !ok { fmt.Println("BUG: stringrange") os.Exit(1) } }	1.45 KB	2024-02-02 18:09
📄 struct0.go // run // 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. // Test zero length structs. // Used to not be evaluated. // Issue 2232. package main func recv(c chan interface{}) struct{} { return (<-c).(struct{}) } var m = make(map[interface{}]int) func recv1(c chan interface{}) { defer rec() m[(<-c).(struct{})] = 0 } func rec() { recover() } func main() { c := make(chan interface{}) go recv(c) c <- struct{}{} go recv1(c) c <- struct{}{} }	565 B	2024-02-02 18:09
📄 switch.go // run // Copyright 2009 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 switch statements. package main import "os" func assert(cond bool, msg string) { if !cond { print("assertion fail: ", msg, "\n") panic(1) } } func main() { i5 := 5 i7 := 7 hello := "hello" switch true { case i5 < 5: assert(false, "<") case i5 == 5: assert(true, "!") case i5 > 5: assert(false, ">") } switch { case i5 < 5: assert(false, "<") case i5 == 5: assert(true, "!") case i5 > 5: assert(false, ">") } switch x := 5; true { case i5 < x: assert(false, "<") case i5 == x: assert(true, "!") case i5 > x: assert(false, ">") } switch x := 5; true { case i5 < x: assert(false, "<") case i5 == x: assert(true, "!") case i5 > x: assert(false, ">") } switch i5 { case 0: assert(false, "0") case 1: assert(false, "1") case 2: assert(false, "2") case 3: assert(false, "3") case 4: assert(false, "4") case 5: assert(true, "5") case 6: assert(false, "6") case 7: assert(false, "7") case 8: assert(false, "8") case 9: assert(false, "9") default: assert(false, "default") } switch i5 { case 0, 1, 2, 3, 4: assert(false, "4") case 5: assert(true, "5") case 6, 7, 8, 9: assert(false, "9") default: assert(false, "default") } switch i5 { case 0: case 1: case 2: case 3: case 4: assert(false, "4") case 5: assert(true, "5") case 6: case 7: case 8: case 9: default: assert(i5 == 5, "good") } switch i5 { case 0: dummy := 0 _ = dummy fallthrough case 1: dummy := 0 _ = dummy fallthrough case 2: dummy := 0 _ = dummy fallthrough case 3: dummy := 0 _ = dummy fallthrough case 4: dummy := 0 _ = dummy assert(false, "4") case 5: dummy := 0 _ = dummy fallthrough case 6: dummy := 0 _ = dummy fallthrough case 7: dummy := 0 _ = dummy fallthrough case 8: dummy := 0 _ = dummy fallthrough case 9: dummy := 0 _ = dummy fallthrough default: dummy := 0 _ = dummy assert(i5 == 5, "good") } fired := false switch i5 { case 0: dummy := 0 _ = dummy fallthrough // tests scoping of cases case 1: dummy := 0 _ = dummy fallthrough case 2: dummy := 0 _ = dummy fallthrough case 3: dummy := 0 _ = dummy fallthrough case 4: dummy := 0 _ = dummy assert(false, "4") case 5: dummy := 0 _ = dummy fallthrough case 6: dummy := 0 _ = dummy fallthrough case 7: dummy := 0 _ = dummy fallthrough case 8: dummy := 0 _ = dummy fallthrough case 9: dummy := 0 _ = dummy fallthrough default: dummy := 0 _ = dummy fired = !fired assert(i5 == 5, "good") } assert(fired, "fired") count := 0 switch i5 { case 0: count = count + 1 fallthrough case 1: count = count + 1 fallthrough case 2: count = count + 1 fallthrough case 3: count = count + 1 fallthrough case 4: count = count + 1 assert(false, "4") case 5: count = count + 1 fallthrough case 6: count = count + 1 fallthrough case 7: count = count + 1 fallthrough case 8: count = count + 1 fallthrough case 9: count = count + 1 fallthrough default: assert(i5 == count, "good") } assert(fired, "fired") switch hello { case "wowie": assert(false, "wowie") case "hello": assert(true, "hello") case "jumpn": assert(false, "jumpn") default: assert(false, "default") } fired = false switch i := i5 + 2; i { case i7: fired = true default: assert(false, "fail") } assert(fired, "var") // switch on nil-only comparison types switch f := func() {}; f { case nil: assert(false, "f should not be nil") default: } switch m := make(map[int]int); m { case nil: assert(false, "m should not be nil") default: } switch a := make([]int, 1); a { case nil: assert(false, "m should not be nil") default: } // switch on interface. switch i := interface{}("hello"); i { case 42: assert(false, `i should be "hello"`) case "hello": assert(true, "hello") default: assert(false, `i should be "hello"`) } // switch on implicit bool converted to interface // was broken: see issue 3980 switch i := interface{}(true); { case i: assert(true, "true") case false: assert(false, "i should be true") default: assert(false, "i should be true") } // switch on interface with constant cases differing by type. // was rejected by compiler: see issue 4781 type T int type B bool type F float64 type S string switch i := interface{}(float64(1.0)); i { case nil: assert(false, "i should be float64(1.0)") case (int)(nil): assert(false, "i should be float64(1.0)") case 1: assert(false, "i should be float64(1.0)") case T(1): assert(false, "i should be float64(1.0)") case F(1.0): assert(false, "i should be float64(1.0)") case 1.0: assert(true, "true") case "hello": assert(false, "i should be float64(1.0)") case S("hello"): assert(false, "i should be float64(1.0)") case true, B(false): assert(false, "i should be float64(1.0)") case false, B(true): assert(false, "i should be float64(1.0)") } // switch on array. switch ar := [3]int{1, 2, 3}; ar { case [3]int{1, 2, 3}: assert(true, "[1 2 3]") case [3]int{4, 5, 6}: assert(false, "ar should be [1 2 3]") default: assert(false, "ar should be [1 2 3]") } // switch on channel switch c1, c2 := make(chan int), make(chan int); c1 { case nil: assert(false, "c1 did not match itself") case c2: assert(false, "c1 did not match itself") case c1: assert(true, "chan") default: assert(false, "c1 did not match itself") } // empty switch switch { } // empty switch with default case. fired = false switch { default: fired = true } assert(fired, "fail") // Default and fallthrough. count = 0 switch { default: count++ fallthrough case false: count++ } assert(count == 2, "fail") // fallthrough to default, which is not at end. count = 0 switch i5 { case 5: count++ fallthrough default: count++ case 6: count++ } assert(count == 2, "fail") i := 0 switch x := 5; { case i < x: os.Exit(0) case i == x: case i > x: os.Exit(1) } // Unified IR converts the tag and all case values to empty // interface, when any of the case values aren't assignable to the // tag value's type. Make sure that `case nil:` compares against the // tag type's nil value (i.e., `(int)(nil)`), not nil interface // (i.e., `any(nil)`). switch (*int)(nil) { case nil: // ok case any(nil): assert(false, "case any(nil) matched") default: assert(false, "default matched") } }	6.53 KB	2024-02-02 18:09
📄 switch2.go // 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. // Verify that erroneous switch statements are detected by the compiler. // Does not compile. package main func f() { switch { case 0; // ERROR "expecting := or = or : or comma\|expected :" } switch { case 0; // ERROR "expecting := or = or : or comma\|expected :" default: } switch { case 0: case 0: default: } switch { case 0: f(); case 0: case 0: f() case 0: // ERROR "unexpected case at end of statement" } switch { case 0: f(); default: case 0: f() default: // ERROR "unexpected default at end of statement" } switch { if x: // ERROR "expected case or default or }" } }	775 B	2024-02-02 18:09
📄 switch3.go // errorcheck // 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. // Verify that erroneous switch statements are detected by the compiler. // Does not compile. package main type I interface { M() } func bad() { var i I var s string switch i { case s: // ERROR "mismatched types string and I\|incompatible types" } switch s { case i: // ERROR "mismatched types I and string\|incompatible types" } var m, m1 map[int]int switch m { case nil: case m1: // ERROR "can only compare map m to nil\|map can only be compared to nil\|cannot compare" default: } var a, a1 []int switch a { case nil: case a1: // ERROR "can only compare slice a to nil\|slice can only be compared to nil\|cannot compare" default: } var f, f1 func() switch f { case nil: case f1: // ERROR "can only compare func f to nil\|func can only be compared to nil\|cannot compare" default: } var ar, ar1 [4]func() switch ar { // ERROR "cannot switch on" case ar1: default: } var st, st1 struct{ f func() } switch st { // ERROR "cannot switch on" case st1: } } func good() { var i interface{} var s string switch i { case s: } switch s { case i: } }	1.24 KB	2024-02-02 18:09
📄 switch4.go // errorcheck // 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. // Verify that erroneous switch statements are detected by the compiler. // Does not compile. package main type I interface { M() } func bad() { i5 := 5 switch i5 { case 5: fallthrough // ERROR "cannot fallthrough final case in switch" } } func good() { var i interface{} var s string switch i { case s: } switch s { case i: } }	526 B	2024-02-02 18:09
📄 switch5.go // errorcheck // 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. // Verify that switch statements with duplicate cases are detected by the compiler. // Does not compile. package main func f0(x int) { switch x { case 0: case 0: // ERROR "duplicate case (0 in switch)?" } switch x { case 0: case int(0): // ERROR "duplicate case (int.0. .value 0. in switch)?" } } func f1(x float32) { switch x { case 5: case 5: // ERROR "duplicate case (5 in switch)?" case 5.0: // ERROR "duplicate case (5 in switch)?" } } func f2(s string) { switch s { case "": case "": // ERROR "duplicate case (.. in switch)?" case "abc": case "abc": // ERROR "duplicate case (.abc. in switch)?" } } func f3(e interface{}) { switch e { case 0: case 0: // ERROR "duplicate case (0 in switch)?" case int64(0): case float32(10): case float32(10): // ERROR "duplicate case (float32$10$ .value 10. in switch)?" case float64(10): case float64(10): // ERROR "duplicate case (float64$10$ .value 10. in switch)?" } } func f5(a [1]int) { switch a { case [1]int{0}: case [1]int{0}: // OK -- see issue 15896 } } // Ensure duplicate const bool clauses are accepted. func f6() int { switch { case 0 == 0: return 0 case 1 == 1: // Intentionally OK, even though a duplicate of the above const true return 1 } return 2 } // Ensure duplicates in ranges are detected (issue #17517). func f7(a int) { switch a { case 0: case 0, 1: // ERROR "duplicate case 0" case 1, 2, 3, 4: // ERROR "duplicate case 1" } } // Ensure duplicates with simple literals are printed as they were // written, not just their values. Particularly useful for runes. func f8(r rune) { const x = 10 switch r { case 33, 33: // ERROR "duplicate case (33 in switch)?" case 34, '"': // ERROR "duplicate case '"' .value 34. in switch" case 35, rune('#'): // ERROR "duplicate case (rune.'#'. .value 35. in switch)?" case 36, rune(36): // ERROR "duplicate case (rune.36. .value 36. in switch)?" case 37, '$'+1: // ERROR "duplicate case ('\$' \+ 1 .value 37. in switch)?" case 'b': case 'a', 'b', 'c', 'd': // ERROR "duplicate case ('b' .value 98.)?" case x, x: // ERROR "duplicate case (x .value 10.)?" } }	2.25 KB	2024-02-02 18:09
📄 switch6.go // errorcheck // 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. // Check the compiler's switch handling that happens // at typechecking time. // This must be separate from other checks, // because errors during typechecking // prevent other errors from being discovered. package main // Verify that type switch statements with impossible cases are detected by the compiler. func f0(e error) { switch e.(type) { case int: // ERROR "impossible type switch case: (int\n\t)?e $.type error$ cannot have dynamic type int $missing method Error$" } } // Verify that the compiler rejects multiple default cases. func f1(e interface{}) { switch e { default: default: // ERROR "multiple defaults( in switch)?" } switch e.(type) { default: default: // ERROR "multiple defaults( in switch)?" } } type I interface { Foo() } type X int func (X) Foo() {} func f2() { var i I switch i.(type) { case X: // ERROR "impossible type switch case: (X\n\t)?i $.*type I$ cannot have dynamic type X $method Foo has pointer receiver$" } }	1.13 KB	2024-02-02 18:09
📄 switch7.go // errorcheck // 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. // Verify that type switch statements with duplicate cases are detected // by the compiler. // Does not compile. package main import "fmt" func f4(e interface{}) { switch e.(type) { case int: case int: // ERROR "duplicate case int in type switch" case int64: case error: case error: // ERROR "duplicate case error in type switch" case fmt.Stringer: case fmt.Stringer: // ERROR "duplicate case fmt.Stringer in type switch" case struct { i int "tag1" }: case struct { i int "tag2" }: case struct { // ERROR "duplicate case struct { i int .tag1. } in type switch\|duplicate case" i int "tag1" }: } }	796 B	2024-02-02 18:09
📁 syntax	-	2024-02-02 18:09
📄 tighten.go // errorcheck -0 -d=ssa/tighten/debug=1 //go:build arm64 // Copyright 2023 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 ( e any ts uint16 ) func moveValuesWithMemoryArg(len int) { for n := 0; n < len; n++ { // Load of e.data is lowed as a MOVDload op, which has a memory // argument. It's moved near where it's used. _ = e != ts // ERROR "MOVDload is moved$" "MOVDaddr is moved$" } }	513 B	2024-02-02 18:09
📄 tinyfin.go // 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 finalizers work for tiny (combined) allocations. package main import ( "runtime" "time" ) func main() { // Does not work on gccgo due to partially conservative GC. // Try to enable when we have fully precise GC. if runtime.Compiler == "gccgo" { return } const N = 100 finalized := make(chan int32, N) for i := 0; i < N; i++ { x := new(int32) // subject to tiny alloc x = int32(i) // the closure must be big enough to be combined runtime.SetFinalizer(x, func(p int32) { finalized <- p }) } runtime.GC() count := 0 done := make([]bool, N) timeout := time.After(5time.Second) for { select { case <-timeout: println("timeout,", count, "finalized so far") panic("not all finalizers are called") case x := <-finalized: // Check that p points to the correct subobject of the tiny allocation. // It's a bit tricky, because we can't capture another variable // with the expected value (it would be combined as well). if x < 0 \|\| x >= N { println("got", x) panic("corrupted") } if done[x] { println("got", x) panic("already finalized") } done[x] = true count++ if count > N/10*9 { // Some of the finalizers may not be executed, // if the outermost allocations are combined with something persistent. // Currently 4 int32's are combined into a 16-byte block, // ensure that most of them are finalized. return } } } }	1.57 KB	2024-02-02 18:09
📄 torture.go // 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. // Various tests for expressions with high complexity. package main // Concatenate 16 4-bit integers into a 64-bit number. func concat(s [16]byte) uint64 { r := (((((((((((((((uint64(s[0])<<4\| uint64(s[1]))<<4\| uint64(s[2]))<<4\| uint64(s[3]))<<4\| uint64(s[4]))<<4\| uint64(s[5]))<<4\| uint64(s[6]))<<4\| uint64(s[7]))<<4\| uint64(s[8]))<<4\| uint64(s[9]))<<4\| uint64(s[10]))<<4\| uint64(s[11]))<<4\| uint64(s[12]))<<4\| uint64(s[13]))<<4\| uint64(s[14]))<<4 \| uint64(s[15])) return r } // Compute the determinant of a 4x4-matrix by the sum // over all index permutations. func determinant(m [4][4]float64) float64 { return m[0][0]m[1][1]m[2][2]m[3][3] - m[0][0]m[1][1]m[2][3]m[3][2] - m[0][0]m[1][2]m[2][1]m[3][3] + m[0][0]m[1][2]m[2][3]m[3][1] + m[0][0]m[1][3]m[2][1]m[3][2] - m[0][0]m[1][3]m[2][2]m[3][1] - m[0][1]m[1][0]m[2][2]m[3][3] + m[0][1]m[1][0]m[2][3]m[3][2] + m[0][1]m[1][2]m[2][0]m[3][3] - m[0][1]m[1][2]m[2][3]m[3][0] - m[0][1]m[1][3]m[2][0]m[3][2] + m[0][1]m[1][3]m[2][2]m[3][0] + m[0][2]m[1][0]m[2][1]m[3][3] - m[0][2]m[1][0]m[2][3]m[3][1] - m[0][2]m[1][1]m[2][0]m[3][3] + m[0][2]m[1][1]m[2][3]m[3][0] + m[0][2]m[1][3]m[2][0]m[3][1] - m[0][2]m[1][3]m[2][1]m[3][0] - m[0][3]m[1][0]m[2][1]m[3][2] + m[0][3]m[1][0]m[2][2]m[3][1] + m[0][3]m[1][1]m[2][0]m[3][2] - m[0][3]m[1][1]m[2][2]m[3][0] - m[0][3]m[1][2]m[2][0]m[3][1] + m[0][3]m[1][2]m[2][1]m[3][0] } // Compute the determinant of a 4x4-matrix by the sum // over all index permutations. func determinantInt(m [4][4]int) int { return m[0][0]m[1][1]m[2][2]m[3][3] - m[0][0]m[1][1]m[2][3]m[3][2] - m[0][0]m[1][2]m[2][1]m[3][3] + m[0][0]m[1][2]m[2][3]m[3][1] + m[0][0]m[1][3]m[2][1]m[3][2] - m[0][0]m[1][3]m[2][2]m[3][1] - m[0][1]m[1][0]m[2][2]m[3][3] + m[0][1]m[1][0]m[2][3]m[3][2] + m[0][1]m[1][2]m[2][0]m[3][3] - m[0][1]m[1][2]m[2][3]m[3][0] - m[0][1]m[1][3]m[2][0]m[3][2] + m[0][1]m[1][3]m[2][2]m[3][0] + m[0][2]m[1][0]m[2][1]m[3][3] - m[0][2]m[1][0]m[2][3]m[3][1] - m[0][2]m[1][1]m[2][0]m[3][3] + m[0][2]m[1][1]m[2][3]m[3][0] + m[0][2]m[1][3]m[2][0]m[3][1] - m[0][2]m[1][3]m[2][1]m[3][0] - m[0][3]m[1][0]m[2][1]m[3][2] + m[0][3]m[1][0]m[2][2]m[3][1] + m[0][3]m[1][1]m[2][0]m[3][2] - m[0][3]m[1][1]m[2][2]m[3][0] - m[0][3]m[1][2]m[2][0]m[3][1] + m[0][3]m[1][2]m[2][1]m[3][0] } // Compute the determinant of a 4x4-matrix by the sum // over all index permutations. func determinantByte(m [4][4]byte) byte { return m[0][0]m[1][1]m[2][2]m[3][3] - m[0][0]m[1][1]m[2][3]m[3][2] - m[0][0]m[1][2]m[2][1]m[3][3] + m[0][0]m[1][2]m[2][3]m[3][1] + m[0][0]m[1][3]m[2][1]m[3][2] - m[0][0]m[1][3]m[2][2]m[3][1] - m[0][1]m[1][0]m[2][2]m[3][3] + m[0][1]m[1][0]m[2][3]m[3][2] + m[0][1]m[1][2]m[2][0]m[3][3] - m[0][1]m[1][2]m[2][3]m[3][0] - m[0][1]m[1][3]m[2][0]m[3][2] + m[0][1]m[1][3]m[2][2]m[3][0] + m[0][2]m[1][0]m[2][1]m[3][3] - m[0][2]m[1][0]m[2][3]m[3][1] - m[0][2]m[1][1]m[2][0]m[3][3] + m[0][2]m[1][1]m[2][3]m[3][0] + m[0][2]m[1][3]m[2][0]m[3][1] - m[0][2]m[1][3]m[2][1]m[3][0] - m[0][3]m[1][0]m[2][1]m[3][2] + m[0][3]m[1][0]m[2][2]m[3][1] + m[0][3]m[1][1]m[2][0]m[3][2] - m[0][3]m[1][1]m[2][2]m[3][0] - m[0][3]m[1][2]m[2][0]m[3][1] + m[0][3]m[1][2]m[2][1]m[3][0] } type A []A // A sequence of constant indexings. func IndexChain1(s A) A { return s[0][0][0][0][0][0][0][0][0][0][0][0][0][0][0][0] } // A sequence of non-constant indexings. func IndexChain2(s A, i int) A { return s[i][i][i][i][i][i][i][i][i][i][i][i][i][i][i][i] } // Another sequence of indexings. func IndexChain3(s []int) int { return s[s[s[s[s[s[s[s[s[s[s[s[s[s[s[s[s[s[s[s[s[0]]]]]]]]]]]]]]]]]]]]] } // A right-leaning tree of byte multiplications. func righttree(a, b, c, d uint8) uint8 { return a (b * (c * (d * (a * (b * (c * (d * (a * (b * (c * (d * (a * (b * (c * (d * (a * (b * (c * (d * a * (b * (c * d))))))))))))))))))))) } // A left-leaning tree of byte multiplications. func lefttree(a, b, c, d uint8) uint8 { return ((((((((((((((((((a * b) * c) * d * a) * b) * c) * d * a) * b) * c) * d * a) * b) * c) * d * a) * b) * c) * d * a) * b) * c) * d) } type T struct { Next I } type I interface{} // A chains of type assertions. func ChainT(t T) T { return t. Next.(T). Next.(T). Next.(T). Next.(T). Next.(T). Next.(T). Next.(T). Next.(T). Next.(T). Next.(T). Next.(T). Next.(T). Next.(T). Next.(T). Next.(T). Next.(T). Next.(T). Next.(T). Next.(T). Next.(T) } type U struct { Children []J } func (u U) Child(n int) J { return u.Children[n] } type J interface { Child(n int) J } func ChainUAssert(u U) U { return u.Child(0).(U). Child(0).(U). Child(0).(U). Child(0).(U). Child(0).(U). Child(0).(U). Child(0).(U). Child(0).(U). Child(0).(U). Child(0).(U). Child(0).(U). Child(0).(U). Child(0).(U). Child(0).(U). Child(0).(U). Child(0).(U). Child(0).(U). Child(0).(U). Child(0).(U). Child(0).(U). Child(0).(U). Child(0).(U) } func ChainUNoAssert(u U) U { return u.Child(0). Child(0). Child(0). Child(0). Child(0). Child(0). Child(0). Child(0). Child(0). Child(0). Child(0). Child(0). Child(0). Child(0). Child(0). Child(0). Child(0). Child(0). Child(0). Child(0). Child(0). Child(0).(U) } // Type assertions and slice indexing. See issue 4207. func ChainAssertIndex(u U) J { return u. Children[0].(U). Children[0].(U). Children[0].(U). Children[0].(U). Children[0].(U). Children[0].(U). Children[0].(U). Children[0].(U). Children[0].(U). Children[0].(U). Children[0].(U). Children[0].(U). Children[0].(U). Children[0] } type UArr struct { Children [2]J } func (u UArr) Child(n int) J { return u.Children[n] } func ChainAssertArrayIndex(u UArr) J { return u. Children[0].(UArr). Children[0].(UArr). Children[0].(UArr). Children[0].(UArr). Children[0].(UArr). Children[0].(UArr). Children[0].(UArr). Children[0].(UArr). Children[0].(UArr). Children[0].(UArr). Children[0].(UArr). Children[0].(UArr). Children[0].(UArr). Children[0] } type UArrPtr struct { Children [2]J } func (u UArrPtr) Child(n int) J { return u.Children[n] } func ChainAssertArrayptrIndex(u UArrPtr) J { return u. Children[0].(UArrPtr). Children[0].(UArrPtr). Children[0].(UArrPtr). Children[0].(UArrPtr). Children[0].(UArrPtr). Children[0].(UArrPtr). Children[0].(UArrPtr). Children[0].(UArrPtr). Children[0].(UArrPtr). Children[0].(UArrPtr). Children[0].(UArrPtr). Children[0].(UArrPtr). Children[0].(UArrPtr). Children[0] } // Chains of divisions. See issue 4201. func ChainDiv(a, b int) int { return a / b / a / b / a / b / a / b / a / b / a / b / a / b / a / b / a / b / a / b / a / b / a / b } func ChainDivRight(a, b int) int { return a / (b / (a / (b / (a / (b / (a / (b / (a / (b / (a / (b / (a / (b / (a / (b / (a / (b / (a / b)))))))))))))))))) } func ChainDivConst(a int) int { return a / 17 / 17 / 17 / 17 / 17 / 17 / 17 / 17 / 17 / 17 / 17 } func ChainMulBytes(a, b, c byte) byte { return a(a(a(a(a(a(a(a(ab+c)+c)+c)+c)+c)+c)+c)+c) + c } func ChainCap() { select { case <-make(chan int, cap(make(chan int, cap(make(chan int, cap(make(chan int, cap(make(chan int))))))))): default: } }	7.69 KB	2024-02-02 18:09
📄 turing.go // run // Copyright 2009 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 simulating a Turing machine, sort of. package main // brainfuck var p, pc int var a [30000]byte const prog = "++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.!" func scan(dir int) { for nest := dir; dir*nest > 0; pc += dir { switch prog[pc+dir] { case ']': nest-- case '[': nest++ } } } func main() { r := "" for { switch prog[pc] { case '>': p++ case '<': p-- case '+': a[p]++ case '-': a[p]-- case '.': r += string(a[p]) case '[': if a[p] == 0 { scan(1) } case ']': if a[p] != 0 { scan(-1) } default: if r != "Hello World!\n" { panic(r) } return } pc++ } }	893 B	2024-02-02 18:09
📄 typecheck.go // errorcheck // 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. // Verify that the Go compiler will not // die after running into an undefined // type in the argument list for a // function. // Does not compile. package main func mine(int b) int { // ERROR "undefined.b" return b + 2 // ERROR "undefined.b" } func main() { mine() // ERROR "not enough arguments" c = mine() // ERROR "undefined.*c\|not enough arguments" }	543 B	2024-02-02 18:09
📄 typecheckloop.go // 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. // Verify that constant definition loops are caught during // typechecking and that the errors print correctly. package main const A = 1 + B // ERROR "constant definition loop\n.A uses B\n.B uses C\n.C uses A\|initialization cycle" const B = C - 1 // ERROR "constant definition loop\n.B uses C\n.*C uses B\|initialization cycle" const C = A + B + 1	528 B	2024-02-02 18:09
📁 typeparam	-	2024-02-02 18:09
📄 typeswitch.go // run // Copyright 2009 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 simple type switches, including chans, maps etc. package main import "os" const ( Bool = iota Int Float String Struct Chan Array Map Func Last ) type S struct { a int } var s S = S{1234} var c = make(chan int) var a = []int{0, 1, 2, 3} var m = make(map[string]int) func assert(b bool, s string) { if !b { println(s) os.Exit(1) } } func f(i int) interface{} { switch i { case Bool: return true case Int: return 7 case Float: return 7.4 case String: return "hello" case Struct: return s case Chan: return c case Array: return a case Map: return m case Func: return f } panic("bad type number") } func main() { for i := Bool; i < Last; i++ { switch x := f(i).(type) { case bool: assert(x == true && i == Bool, "bool") case int: assert(x == 7 && i == Int, "int") case float64: assert(x == 7.4 && i == Float, "float64") case string: assert(x == "hello" && i == String, "string") case S: assert(x.a == 1234 && i == Struct, "struct") case chan int: assert(x == c && i == Chan, "chan") case []int: assert(x[3] == 3 && i == Array, "array") case map[string]int: assert(x != nil && i == Map, "map") case func(i int) interface{}: assert(x != nil && i == Func, "fun") default: assert(false, "unknown") } } // boolean switch (has had bugs in past; worth writing down) switch { case true: assert(true, "switch 2 bool") default: assert(false, "switch 2 unknown") } switch true { case true: assert(true, "switch 3 bool") default: assert(false, "switch 3 unknown") } switch false { case false: assert(true, "switch 4 bool") default: assert(false, "switch 4 unknown") } }	1.83 KB	2024-02-02 18:09
📄 typeswitch1.go // run // Copyright 2009 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 simple type switches on basic types. package main import "fmt" const ( a = iota b c d e ) var x = []int{1, 2, 3} func f(x int, len byte) { len = byte(x) } func whatis(x interface{}) string { switch xx := x.(type) { default: return fmt.Sprint("default ", xx) case int, int8, int16, int32: return fmt.Sprint("signed ", xx) case int64: return fmt.Sprint("signed64 ", int64(xx)) case uint, uint8, uint16, uint32: return fmt.Sprint("unsigned ", xx) case uint64: return fmt.Sprint("unsigned64 ", uint64(xx)) case nil: return fmt.Sprint("nil ", xx) } panic("not reached") } func whatis1(x interface{}) string { xx := x switch xx.(type) { default: return fmt.Sprint("default ", xx) case int, int8, int16, int32: return fmt.Sprint("signed ", xx) case int64: return fmt.Sprint("signed64 ", xx.(int64)) case uint, uint8, uint16, uint32: return fmt.Sprint("unsigned ", xx) case uint64: return fmt.Sprint("unsigned64 ", xx.(uint64)) case nil: return fmt.Sprint("nil ", xx) } panic("not reached") } func check(x interface{}, s string) { w := whatis(x) if w != s { fmt.Println("whatis", x, "=>", w, "!=", s) panic("fail") } w = whatis1(x) if w != s { fmt.Println("whatis1", x, "=>", w, "!=", s) panic("fail") } } func main() { check(1, "signed 1") check(uint(1), "unsigned 1") check(int64(1), "signed64 1") check(uint64(1), "unsigned64 1") check(1.5, "default 1.5") check(nil, "nil <nil>") }	1.6 KB	2024-02-02 18:09
📄 typeswitch2.go // errorcheck // Copyright 2009 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. // Verify that various erroneous type switches are caught by the compiler. // Does not compile. package main import "io" func whatis(x interface{}) string { switch x.(type) { case int: return "int" case int: // ERROR "duplicate" return "int8" case io.Reader: return "Reader1" case io.Reader: // ERROR "duplicate" return "Reader2" case interface { r() w() }: return "rw" case interface { // ERROR "duplicate" w() r() }: return "wr" } return "" }	655 B	2024-02-02 18:09
📄 typeswitch2b.go // 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. // Verify that various erroneous type switches are caught by the compiler. // Does not compile. package main func notused(x interface{}) { // The first t is in a different scope than the 2nd t; it cannot // be accessed (=> declared and not used error); but it is legal // to declare it. switch t := 0; t := x.(type) { // ERROR "declared and not used" case int: _ = t // this is using the t of "t := x.(type)" } }	598 B	2024-02-02 18:09
📄 typeswitch3.go // errorcheck // 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. // Verify that erroneous type switches are caught by the compiler. // Issue 2700, among other things. // Does not compile. package main import ( "io" ) type I interface { M() } func main() { var x I switch x.(type) { case string: // ERROR "impossible" println("FAIL") } // Issue 2700: if the case type is an interface, nothing is impossible var r io.Reader _, _ = r.(io.Writer) switch r.(type) { case io.Writer: } // Issue 2827. switch _ := r.(type) { // ERROR "invalid variable name _\|no new variables?" } } func noninterface() { var i int switch i.(type) { // ERROR "cannot type switch on non-interface value\|not an interface" case string: case int: } type S struct { name string } var s S switch s.(type) { // ERROR "cannot type switch on non-interface value\|not an interface" } }	999 B	2024-02-02 18:09
📁 uintptrescapes.dir	-	2024-02-02 18:09
📄 uintptrescapes.go // rundir // 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. // Test that the go:uintptrescapes comment works as expected. package ignored	250 B	2024-02-02 18:09
📄 uintptrescapes2.go // errorcheck -0 -l -m -live // 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. // Test escape analysis and liveness inferred for uintptrescapes functions. package p import ( "unsafe" ) //go:uintptrescapes func F1(a uintptr) {} // ERROR "escaping uintptr" //go:uintptrescapes func F2(a ...uintptr) {} // ERROR "escaping ...uintptr" //go:uintptrescapes func F3(uintptr) {} // ERROR "escaping uintptr" //go:uintptrescapes func F4(...uintptr) {} // ERROR "escaping ...uintptr" type T struct{} //go:uintptrescapes func (T) M1(a uintptr) {} // ERROR "escaping uintptr" //go:uintptrescapes func (T) M2(a ...uintptr) {} // ERROR "escaping ...uintptr" func TestF1() { var t int // ERROR "moved to heap" F1(uintptr(unsafe.Pointer(&t))) // ERROR "live at call to F1: .?autotmp" "stack object .autotmp_[0-9]+ unsafe.Pointer$" } func TestF3() { var t2 int // ERROR "moved to heap" F3(uintptr(unsafe.Pointer(&t2))) // ERROR "live at call to F3: .?autotmp" "stack object .autotmp_[0-9]+ unsafe.Pointer$" } func TestM1() { var t T var v int // ERROR "moved to heap" t.M1(uintptr(unsafe.Pointer(&v))) // ERROR "live at call to T.M1: .?autotmp" "stack object .autotmp_[0-9]+ unsafe.Pointer$" } func TestF2() { var v int // ERROR "moved to heap" F2(0, 1, uintptr(unsafe.Pointer(&v)), 2) // ERROR "live at call to newobject: .?autotmp" "live at call to F2: .?autotmp" "escapes to heap" "stack object .autotmp_[0-9]+ unsafe.Pointer$" } func TestF4() { var v2 int // ERROR "moved to heap" F4(0, 1, uintptr(unsafe.Pointer(&v2)), 2) // ERROR "live at call to newobject: .?autotmp" "live at call to F4: .?autotmp" "escapes to heap" "stack object .autotmp_[0-9]+ unsafe.Pointer$" } func TestM2() { var t T var v int // ERROR "moved to heap" t.M2(0, 1, uintptr(unsafe.Pointer(&v)), 2) // ERROR "live at call to newobject: .?autotmp" "live at call to T.M2: .?autotmp" "escapes to heap" "stack object .autotmp_[0-9]+ unsafe.Pointer$" }	2.16 KB	2024-02-02 18:09
📄 uintptrescapes3.go // 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. // Test that //go:uintptrescapes works for methods. package main import ( "fmt" "runtime" "unsafe" ) var callback func() //go:noinline //go:uintptrescapes func F(ptr uintptr) { callback() } //go:noinline //go:uintptrescapes func Fv(ptrs ...uintptr) { callback() } type T struct{} //go:noinline //go:uintptrescapes func (T) M(ptr uintptr) { callback() } //go:noinline //go:uintptrescapes func (T) Mv(ptrs ...uintptr) { callback() } // Each test should pass uintptr(ptr) as an argument to a function call, // which in turn should call callback. The callback checks that ptr is kept alive. var tests = []func(ptr unsafe.Pointer){ func(ptr unsafe.Pointer) { F(uintptr(ptr)) }, func(ptr unsafe.Pointer) { Fv(uintptr(ptr)) }, func(ptr unsafe.Pointer) { T{}.M(uintptr(ptr)) }, func(ptr unsafe.Pointer) { T{}.Mv(uintptr(ptr)) }, } func main() { for i, test := range tests { finalized := false ptr := new([64]byte) runtime.SetFinalizer(ptr, func(*[64]byte) { finalized = true }) callback = func() { runtime.GC() if finalized { fmt.Printf("test #%d failed\n", i) } } test(unsafe.Pointer(ptr)) } }	1.28 KB	2024-02-02 18:09
📄 uintptrkeepalive.go // errorcheck -std // Copyright 2022 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 p //go:uintptrkeepalive func missingNosplit(uintptr) { // ERROR "go:uintptrkeepalive requires go:nosplit" }	297 B	2024-02-02 18:09
📄 undef.go // errorcheck // Copyright 2010 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 line numbers in error messages. // Does not compile. package main var ( _ = x // ERROR "undefined.x" _ = x // ERROR "undefined.x" _ = x // ERROR "undefined.x" ) type T struct { y int } func foo() T { return &T{y: 99} } func bar() int { return y } // ERROR "undefined.y" type T1 struct { y1 int } func foo1() T1 { return &T1{y1: 99} } var y1 = 2 func bar1() int { return y1 } func f1(val interface{}) { switch v := val.(type) { default: println(v) } } func f2(val interface{}) { switch val.(type) { default: println(v) // ERROR "undefined.*v" } }	758 B	2024-02-02 18:09
📄 unsafe_slice_data.go // run // Copyright 2022 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 ( "fmt" "reflect" "unsafe" ) func main() { var s = []byte("abc") sh1 := (reflect.SliceHeader)(unsafe.Pointer(&s)) ptr2 := unsafe.Pointer(unsafe.SliceData(s)) if ptr2 != unsafe.Pointer(sh1.Data) { panic(fmt.Errorf("unsafe.SliceData %p != %p", ptr2, unsafe.Pointer(sh1.Data))) } }	481 B	2024-02-02 18:09
📄 unsafe_string.go // run // Copyright 2022 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 ( "unsafe" ) func main() { hello := [5]byte{'m', 'o', 's', 'h', 'i'} if unsafe.String(&hello[0], uint64(len(hello))) != "moshi" { panic("unsafe.String convert error") } }	367 B	2024-02-02 18:09
📄 unsafe_string_data.go // run // Copyright 2022 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 ( "fmt" "reflect" "unsafe" ) func main() { var s = "abc" sh1 := (*reflect.StringHeader)(unsafe.Pointer(&s)) ptr2 := unsafe.Pointer(unsafe.StringData(s)) if ptr2 != unsafe.Pointer(sh1.Data) { panic(fmt.Errorf("unsafe.StringData ret %p != %p", ptr2, unsafe.Pointer(sh1.Data))) } }	479 B	2024-02-02 18:09
📄 unsafebuiltins.go // run // Copyright 2021 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 ( "math" "unsafe" ) const maxUintptr = 1 << (8 * unsafe.Sizeof(uintptr(0))) func main() { var p [10]byte // unsafe.Add { p1 := unsafe.Pointer(&p[1]) assert(unsafe.Add(p1, 1) == unsafe.Pointer(&p[2])) assert(unsafe.Add(p1, -1) == unsafe.Pointer(&p[0])) } // unsafe.Slice { s := unsafe.Slice(&p[0], len(p)) assert(&s[0] == &p[0]) assert(len(s) == len(p)) assert(cap(s) == len(p)) // nil pointer with zero length returns nil assert(unsafe.Slice((int)(nil), 0) == nil) // nil pointer with positive length panics mustPanic(func() { _ = unsafe.Slice((int)(nil), 1) }) // negative length var neg int = -1 mustPanic(func() { _ = unsafe.Slice(new(byte), neg) }) // length too large var tooBig uint64 = math.MaxUint64 mustPanic(func() { _ = unsafe.Slice(new(byte), tooBig) }) // size overflows address space mustPanic(func() { _ = unsafe.Slice(new(uint64), maxUintptr/8) }) mustPanic(func() { _ = unsafe.Slice(new(uint64), maxUintptr/8+1) }) // sliced memory overflows address space last := (byte)(unsafe.Pointer(^uintptr(0))) _ = unsafe.Slice(last, 1) mustPanic(func() { _ = unsafe.Slice(last, 2) }) } // unsafe.String { s := unsafe.String(&p[0], len(p)) assert(s == string(p[:])) assert(len(s) == len(p)) // the empty string assert(unsafe.String(nil, 0) == "") // nil pointer with positive length panics mustPanic(func() { _ = unsafe.String(nil, 1) }) // negative length var neg int = -1 mustPanic(func() { _ = unsafe.String(new(byte), neg) }) // length too large var tooBig uint64 = math.MaxUint64 mustPanic(func() { _ = unsafe.String(new(byte), tooBig) }) // string memory overflows address space last := (byte)(unsafe.Pointer(^uintptr(0))) _ = unsafe.String(last, 1) mustPanic(func() { _ = unsafe.String(last, 2) }) } // unsafe.StringData { var s = "string" assert(string(unsafe.Slice(unsafe.StringData(s), len(s))) == s) } //unsafe.SliceData { var s = []byte("slice") assert(unsafe.String(unsafe.SliceData(s), len(s)) == string(s)) } } func assert(ok bool) { if !ok { panic("FAIL") } } func mustPanic(f func()) { defer func() { assert(recover() != nil) }() f() }	2.33 KB	2024-02-02 18:09
📄 used.go // errorcheck // 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 p import "unsafe" const C = 1 var x, x1, x2 int var b bool var s string var c chan int var cp complex128 var slice []int var array [2]int var bytes []byte var runes []rune var r rune func f0() {} func f1() int { return 1 } func f2() (int, int) { return 1, 1 } type T struct{ X int } func (T) M1() int { return 1 } func (T) M0() {} func (T) M() {} var t T var tp T type I interface{ M() } var i I var m map[int]int func _() { // Note: if the next line changes to x, the error silences the x+x etc below! x1 // ERROR "x1 . not used" nil // ERROR "nil .* not used" C // ERROR "C .* not used" 1 // ERROR "1 .* not used" x + x // ERROR "x \+ x .* not used" x - x // ERROR "x - x .* not used" x \| x // ERROR "x \\| x .* not used" "a" + s // ERROR ".a. \+ s .* not used" &x // ERROR "&x .* not used" b && b // ERROR "b && b .* not used" append(slice, 1) // ERROR "append$slice, 1$ .* not used" string(bytes) // ERROR "string$bytes$ .* not used" string(runes) // ERROR "string$runes$ .* not used" f0() // ok f1() // ok f2() // ok _ = f0() // ERROR "f0 .used as value" _ = f1() // ok _, _ = f2() // ok _ = f2() // ERROR "assignment mismatch: 1 variable but f2 returns 2 values\|cannot assign" _ = f1(), 0 // ERROR "assignment mismatch: 1 variable but 2 values\|cannot assign" T.M0 // ERROR "T.M0 . not used" t.M0 // ERROR "t.M0 .* not used" cap // ERROR "use of builtin cap not in function call\|must be called" cap(slice) // ERROR "cap$slice$ .* not used" close(c) // ok _ = close(c) // ERROR "close$c$ .used as value" func() {} // ERROR "func literal . not used\|is not used" X{} // ERROR "undefined: X" map[string]int{} // ERROR "map\[string\]int{} .* not used" struct{}{} // ERROR "struct ?{}{} .* not used" [1]int{} // ERROR "\[1\]int{} .* not used" []int{} // ERROR "\[\]int{} .* not used" &struct{}{} // ERROR "&struct ?{}{} .* not used" float32(x) // ERROR "float32$x$ .* not used" I(t) // ERROR "I$t$ .* not used" int(x) // ERROR "int$x$ .* not used" copy(slice, slice) // ok _ = copy(slice, slice) // ok delete(m, 1) // ok _ = delete(m, 1) // ERROR "delete$m, 1$ .used as value" t.X // ERROR "t.X . not used" tp.X // ERROR "tp.X .* not used" t.M // ERROR "t.M .* not used" I.M // ERROR "I.M .* not used" i.(T) // ERROR "i.$T$ .* not used" x == x // ERROR "x == x .* not used" x != x // ERROR "x != x .* not used" x != x // ERROR "x != x .* not used" x < x // ERROR "x < x .* not used" x >= x // ERROR "x >= x .* not used" x > x // ERROR "x > x .* not used" tp // ERROR "\tp .* not used" slice[0] // ERROR "slice\[0\] .* not used" m[1] // ERROR "m\[1\] .* not used" len(slice) // ERROR "len$slice$ .* not used" make(chan int) // ERROR "make$chan int$ .* not used" make(map[int]int) // ERROR "make$map\[int\]int$ .* not used" make([]int, 1) // ERROR "make$\[\]int, 1$ .* not used" x * x // ERROR "x \* x .* not used" x / x // ERROR "x / x .* not used" x % x // ERROR "x % x .* not used" x << x // ERROR "x << x .* not used" x >> x // ERROR "x >> x .* not used" x & x // ERROR "x & x .* not used" x &^ x // ERROR "x &\^ x .* not used" new(int) // ERROR "new$int$ .* not used" !b // ERROR "!b .* not used" ^x // ERROR "\^x .* not used" +x // ERROR "\+x .* not used" -x // ERROR "-x .* not used" b \|\| b // ERROR "b \\|\\| b .* not used" panic(1) // ok _ = panic(1) // ERROR "panic$1$ .used as value" print(1) // ok _ = print(1) // ERROR "print$1$ .used as value" println(1) // ok _ = println(1) // ERROR "println$1$ .used as value" c <- 1 // ok slice[1:1] // ERROR "slice\[1:1\] . not used" array[1:1] // ERROR "array\[1:1\] .* not used" s[1:1] // ERROR "s\[1:1\] .* not used" slice[1:1:1] // ERROR "slice\[1:1:1\] .* not used" array[1:1:1] // ERROR "array\[1:1:1\] .* not used" recover() // ok <-c // ok string(r) // ERROR "string$r$ .* not used" iota // ERROR "undefined: iota\|cannot use iota" real(cp) // ERROR "real$cp$ .* not used" imag(cp) // ERROR "imag$cp$ .* not used" complex(1, 2) // ERROR "complex$1, 2$ .* not used" unsafe.Alignof(t.X) // ERROR "unsafe.Alignof$t.X$ .* not used" unsafe.Offsetof(t.X) // ERROR "unsafe.Offsetof$t.X$ .* not used" unsafe.Sizeof(t) // ERROR "unsafe.Sizeof$t$ .* not used" _ = int // ERROR "type int is not an expression\|not an expression" (x) // ERROR "x .* not used\|not used" _ = new(x2) // ERROR "x2 is not a type\|not a type" // Disabled due to issue #43125. // _ = new(1 + 1) // DISABLED "1 \+ 1 is not a type" }	5.96 KB	2024-02-02 18:09
📄 utf.go // run // Copyright 2009 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 UTF-8 in strings and character constants. package main import "unicode/utf8" func main() { var chars [6]rune chars[0] = 'a' chars[1] = 'b' chars[2] = 'c' chars[3] = '\u65e5' chars[4] = '\u672c' chars[5] = '\u8a9e' s := "" for i := 0; i < 6; i++ { s += string(chars[i]) } var l = len(s) for w, i, j := 0, 0, 0; i < l; i += w { var r rune r, w = utf8.DecodeRuneInString(s[i:len(s)]) if w == 0 { panic("zero width in string") } if r != chars[j] { panic("wrong value from string") } j++ } // encoded as bytes: 'a' 'b' 'c' e6 97 a5 e6 9c ac e8 aa 9e const L = 12 if L != l { panic("wrong length constructing array") } a := make([]byte, L) a[0] = 'a' a[1] = 'b' a[2] = 'c' a[3] = 0xe6 a[4] = 0x97 a[5] = 0xa5 a[6] = 0xe6 a[7] = 0x9c a[8] = 0xac a[9] = 0xe8 a[10] = 0xaa a[11] = 0x9e for w, i, j := 0, 0, 0; i < L; i += w { var r rune r, w = utf8.DecodeRune(a[i:L]) if w == 0 { panic("zero width in bytes") } if r != chars[j] { panic("wrong value from bytes") } j++ } }	1.19 KB	2024-02-02 18:09
📄 varerr.go // errorcheck // Copyright 2010 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. // Verify that a couple of illegal variable declarations are caught by the compiler. // Does not compile. package main func main() { _ = asdf // ERROR "undefined.*asdf" new = 1 // ERROR "use of builtin new not in function call\|invalid left hand side\|must be called" }	449 B	2024-02-02 18:09
📄 varinit.go // run // Copyright 2009 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 var x = x + 1 works. package main func main() { var x int = 1 if x != 1 { print("found ", x, ", expected 1\n") panic("fail") } { var x int = x + 1 if x != 2 { print("found ", x, ", expected 2\n") panic("fail") } } { x := x + 1 if x != 2 { print("found ", x, ", expected 2\n") panic("fail") } } }	509 B	2024-02-02 18:09
📄 winbatch.go // run // 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. // Check that batch files are maintained as CRLF files (consistent // behavior on all operating systems). See golang.org/issue/37791. package main import ( "bytes" "fmt" "io/ioutil" "log" "os" "path/filepath" "runtime" "strings" ) func main() { // Ensure that the GOROOT/src/all.bat file exists and has strict CRLF line endings. enforceBatchStrictCRLF(filepath.Join(runtime.GOROOT(), "src", "all.bat")) // Walk the entire Go repository source tree (without GOROOT/pkg), // skipping directories that start with "." and named "testdata", // and ensure all .bat files found have exact CRLF line endings. err := filepath.WalkDir(runtime.GOROOT(), func(path string, d os.DirEntry, err error) error { if err != nil { return err } if d.IsDir() && (strings.HasPrefix(d.Name(), ".") \|\| d.Name() == "testdata") { return filepath.SkipDir } if path == filepath.Join(runtime.GOROOT(), "pkg") { // GOROOT/pkg is known to contain generated artifacts, not source code. // Skip it to avoid false positives. (Also see golang.org/issue/37929.) return filepath.SkipDir } if filepath.Ext(d.Name()) == ".bat" { enforceBatchStrictCRLF(path) } return nil }) if err != nil { log.Fatalln(err) } } func enforceBatchStrictCRLF(path string) { b, err := ioutil.ReadFile(path) if err != nil { log.Fatalln(err) } cr, lf := bytes.Count(b, []byte{13}), bytes.Count(b, []byte{10}) crlf := bytes.Count(b, []byte{13, 10}) if cr != crlf \|\| lf != crlf { if rel, err := filepath.Rel(runtime.GOROOT(), path); err == nil { // Make the test failure more readable by showing a path relative to GOROOT. path = rel } fmt.Printf("Windows batch file %s does not use strict CRLF line termination.\n", path) fmt.Printf("Please convert it to CRLF before checking it in due to golang.org/issue/37791.\n") os.Exit(1) } }	1.97 KB	2024-02-02 18:09
📄 writebarrier.go // errorcheck -0 -l -d=wb // 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. // Test where write barriers are and are not emitted. package p import "unsafe" func f(x *byte, y byte) { x = y // no barrier (dead store) z := y // no barrier x = z // ERROR "write barrier" } func f1(x []byte, y []byte) { x = y // no barrier (dead store) z := y // no barrier x = z // ERROR "write barrier" } func f1a(x []byte, y []byte) { x = y // ERROR "write barrier" z := y // no barrier x = z // ERROR "write barrier" } func f2(x interface{}, y interface{}) { x = y // no barrier (dead store) z := y // no barrier x = z // ERROR "write barrier" } func f2a(x interface{}, y interface{}) { x = y // no barrier (dead store) z := y // no barrier x = z // ERROR "write barrier" } func f3(x string, y string) { x = y // no barrier (dead store) z := y // no barrier x = z // ERROR "write barrier" } func f3a(x string, y string) { x = y // ERROR "write barrier" z := y // no barrier x = z // ERROR "write barrier" } func f4(x [2]string, y [2]string) { x = y // ERROR "write barrier" z := y // no barrier x = z // ERROR "write barrier" } func f4a(x [2]string, y [2]string) { x = y // ERROR "write barrier" z := y // no barrier x = z // ERROR "write barrier" } type T struct { X int Y int M map[int]int } func f5(t, u T) { t.X = &u.Y // ERROR "write barrier" } func f6(t T) { t.M = map[int]int{1: 2} // ERROR "write barrier" } func f7(x, y int) []int { var z [3]int i := 0 z[i] = x // ERROR "write barrier" i++ z[i] = y // ERROR "write barrier" i++ return z[:i] } func f9(x interface{}, v byte) { x = v // ERROR "write barrier" } func f10(x byte, f func(interface{})) { f(x) } func f11(x unsafe.Pointer, y unsafe.Pointer) { x = unsafe.Pointer(uintptr(y) + 1) // ERROR "write barrier" } func f12(x []int, y int) []int { // write barrier for storing y in x's underlying array x = append(x, y) // ERROR "write barrier" return x } func f12a(x []int, y int) []int { // y not a pointer, so no write barriers in this function x = append(x, y) return x } func f13(x []int, y []int) { y = append(x, 1) // ERROR "write barrier" } func f14(y []int) { y = append(y, 1) // ERROR "write barrier" } type T1 struct { X int } func f15(x []T1, y T1) []T1 { return append(x, y) // ERROR "write barrier" } type T8 struct { X [8]int } func f16(x []T8, y T8) []T8 { return append(x, y) // ERROR "write barrier" } func t1(i interface{}) int { // From issue 14306, make sure we have write barriers in a type switch // where the assigned variable escapes. switch x := i.(type) { case int: // ERROR "write barrier" return &x } switch y := i.(type) { case *int: // no write barrier here return y } return nil } type T17 struct { f func(T17) } func f17(x T17) { // Originally from golang.org/issue/13901, but the hybrid // barrier requires both to have barriers. x.f = f17 // ERROR "write barrier" x.f = func(y T17) { y = x } // ERROR "write barrier" } type T18 struct { a []int s string } func f18(p T18, x []int) { p.a = p.a[:5] // no barrier x = (x)[0:5] // no barrier p.a = p.a[3:5] // ERROR "write barrier" p.a = p.a[1:2:3] // ERROR "write barrier" p.s = p.s[8:9] // ERROR "write barrier" x = (x)[3:5] // ERROR "write barrier" } func f19(x, y int, i int) int { // Constructing a temporary slice on the stack should not // require any write barriers. See issue 14263. a := []int{x, y} // no barrier return a[i] } func f20(x, y int, i int) []int { // ... but if that temporary slice escapes, then the // write barriers are necessary. a := []int{x, y} // ERROR "write barrier" return a } var x21 int var y21 struct { x int } var z21 int // f21x: Global -> heap pointer updates must have write barriers. func f21a(x int) { x21 = x // ERROR "write barrier" y21.x = x // ERROR "write barrier" } func f21b(x int) { x21 = &z21 // ERROR "write barrier" y21.x = &z21 // ERROR "write barrier" } func f21c(x int) { y21 = struct{ x int }{x} // ERROR "write barrier" } func f22(x int) (y int) { // pointer write on stack should have no write barrier. // this is a case that the frontend failed to eliminate. p := &y p = x // no barrier return } type T23 struct { p int a int } var t23 T23 var i23 int // f23x: zeroing global needs write barrier for the hybrid barrier. func f23a() { t23 = T23{} // ERROR "write barrier" } func f23b() { // also test partial assignments t23 = T23{a: 1} // ERROR "write barrier" } func f23c() { t23 = T23{} // no barrier (dead store) // also test partial assignments t23 = T23{p: &i23} // ERROR "write barrier" } var g int func f24() *int { p := new(int) p = &g // no write barrier here return p } func f25() []string { return []string{"abc", "def", "ghi"} // no write barrier here } type T26 struct { a, b, c int d, e, f int } var g26 int func f26(p int) T26 { // see issue 29573 return &T26{ a: 5, b: 6, c: 7, d: &g26, // no write barrier: global ptr e: nil, // no write barrier: nil ptr f: p, // ERROR "write barrier" } } func f27(p int) []interface{} { return []interface{}{ nil, // no write barrier: zeroed memory, nil ptr (T26)(nil), // no write barrier: zeroed memory, type ptr & nil ptr &g26, // no write barrier: zeroed memory, type ptr & global ptr 7, // no write barrier: zeroed memory, type ptr & global ptr p, // ERROR "write barrier" } } var g28 [256]uint64 func f28() []interface{} { return []interface{}{ false, // no write barrier true, // no write barrier 0, // no write barrier 1, // no write barrier uint8(127), // no write barrier int8(-4), // no write barrier &g28[5], // no write barrier } }	5.88 KB	2024-02-02 18:09
📄 zerodivide.go // run // Copyright 2010 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 that zero division causes a panic. package main import ( "fmt" "math" "runtime" "strings" ) type ErrorTest struct { name string fn func() err string } var ( i, j, k int = 0, 0, 1 i8, j8, k8 int8 = 0, 0, 1 i16, j16, k16 int16 = 0, 0, 1 i32, j32, k32 int32 = 0, 0, 1 i64, j64, k64 int64 = 0, 0, 1 bb = []int16{2, 0} u, v, w uint = 0, 0, 1 u8, v8, w8 uint8 = 0, 0, 1 u16, v16, w16 uint16 = 0, 0, 1 u32, v32, w32 uint32 = 0, 0, 1 u64, v64, w64 uint64 = 0, 0, 1 up, vp, wp uintptr = 0, 0, 1 f, g, h float64 = 0, 0, 1 f32, g32, h32 float32 = 0, 0, 1 f64, g64, h64, inf, negInf, nan float64 = 0, 0, 1, math.Inf(1), math.Inf(-1), math.NaN() c, d, e complex128 = 0 + 0i, 0 + 0i, 1 + 1i c64, d64, e64 complex64 = 0 + 0i, 0 + 0i, 1 + 1i c128, d128, e128 complex128 = 0 + 0i, 0 + 0i, 1 + 1i ) // Fool gccgo into thinking that these variables can change. func NotCalled() { i++ j++ k++ i8++ j8++ k8++ i16++ j16++ k16++ i32++ j32++ k32++ i64++ j64++ k64++ u++ v++ w++ u8++ v8++ w8++ u16++ v16++ w16++ u32++ v32++ w32++ u64++ v64++ w64++ up++ vp++ wp++ f += 1 g += 1 h += 1 f32 += 1 g32 += 1 h32 += 1 f64 += 1 g64 += 1 h64 += 1 c += 1 + 1i d += 1 + 1i e += 1 + 1i c64 += 1 + 1i d64 += 1 + 1i e64 += 1 + 1i c128 += 1 + 1i d128 += 1 + 1i e128 += 1 + 1i } var tmp interface{} // We could assign to _ but the compiler optimizes it too easily. func use(v interface{}) { tmp = v } // Verify error/no error for all types. var errorTests = []ErrorTest{ // All integer divide by zero should error. ErrorTest{"int 0/0", func() { use(i / j) }, "divide"}, ErrorTest{"int8 0/0", func() { use(i8 / j8) }, "divide"}, ErrorTest{"int16 0/0", func() { use(i16 / j16) }, "divide"}, ErrorTest{"int32 0/0", func() { use(i32 / j32) }, "divide"}, ErrorTest{"int64 0/0", func() { use(i64 / j64) }, "divide"}, ErrorTest{"int 1/0", func() { use(k / j) }, "divide"}, ErrorTest{"int8 1/0", func() { use(k8 / j8) }, "divide"}, ErrorTest{"int16 1/0", func() { use(k16 / j16) }, "divide"}, ErrorTest{"int32 1/0", func() { use(k32 / j32) }, "divide"}, ErrorTest{"int64 1/0", func() { use(k64 / j64) }, "divide"}, // From issue 5790, we should ensure that _ assignments // still evaluate and generate zerodivide panics. ErrorTest{"int16 _ = bb[0]/bb[1]", func() { _ = bb[0] / bb[1] }, "divide"}, ErrorTest{"uint 0/0", func() { use(u / v) }, "divide"}, ErrorTest{"uint8 0/0", func() { use(u8 / v8) }, "divide"}, ErrorTest{"uint16 0/0", func() { use(u16 / v16) }, "divide"}, ErrorTest{"uint32 0/0", func() { use(u32 / v32) }, "divide"}, ErrorTest{"uint64 0/0", func() { use(u64 / v64) }, "divide"}, ErrorTest{"uintptr 0/0", func() { use(up / vp) }, "divide"}, ErrorTest{"uint 1/0", func() { use(w / v) }, "divide"}, ErrorTest{"uint8 1/0", func() { use(w8 / v8) }, "divide"}, ErrorTest{"uint16 1/0", func() { use(w16 / v16) }, "divide"}, ErrorTest{"uint32 1/0", func() { use(w32 / v32) }, "divide"}, ErrorTest{"uint64 1/0", func() { use(w64 / v64) }, "divide"}, ErrorTest{"uintptr 1/0", func() { use(wp / vp) }, "divide"}, // All float64ing divide by zero should not error. ErrorTest{"float64 0/0", func() { use(f / g) }, ""}, ErrorTest{"float32 0/0", func() { use(f32 / g32) }, ""}, ErrorTest{"float64 0/0", func() { use(f64 / g64) }, ""}, ErrorTest{"float64 1/0", func() { use(h / g) }, ""}, ErrorTest{"float32 1/0", func() { use(h32 / g32) }, ""}, ErrorTest{"float64 1/0", func() { use(h64 / g64) }, ""}, ErrorTest{"float64 inf/0", func() { use(inf / g64) }, ""}, ErrorTest{"float64 -inf/0", func() { use(negInf / g64) }, ""}, ErrorTest{"float64 nan/0", func() { use(nan / g64) }, ""}, // All complex divide by zero should not error. ErrorTest{"complex 0/0", func() { use(c / d) }, ""}, ErrorTest{"complex64 0/0", func() { use(c64 / d64) }, ""}, ErrorTest{"complex128 0/0", func() { use(c128 / d128) }, ""}, ErrorTest{"complex 1/0", func() { use(e / d) }, ""}, ErrorTest{"complex64 1/0", func() { use(e64 / d64) }, ""}, ErrorTest{"complex128 1/0", func() { use(e128 / d128) }, ""}, } func error_(fn func()) (error string) { defer func() { if e := recover(); e != nil { error = e.(runtime.Error).Error() } }() fn() return "" } type FloatTest struct { f, g float64 out float64 } var float64Tests = []FloatTest{ FloatTest{0, 0, nan}, FloatTest{nan, 0, nan}, FloatTest{inf, 0, inf}, FloatTest{negInf, 0, negInf}, } func alike(a, b float64) bool { switch { case math.IsNaN(a) && math.IsNaN(b): return true case a == b: return math.Signbit(a) == math.Signbit(b) } return false } func main() { bad := false for _, t := range errorTests { err := error_(t.fn) switch { case t.err == "" && err == "": // fine case t.err != "" && err == "": if !bad { bad = true fmt.Printf("BUG\n") } fmt.Printf("%s: expected %q; got no error\n", t.name, t.err) case t.err == "" && err != "": if !bad { bad = true fmt.Printf("BUG\n") } fmt.Printf("%s: expected no error; got %q\n", t.name, err) case t.err != "" && err != "": if !strings.Contains(err, t.err) { if !bad { bad = true fmt.Printf("BUG\n") } fmt.Printf("%s: expected %q; got %q\n", t.name, t.err, err) continue } } } // At this point we know we don't error on the values we're testing for _, t := range float64Tests { x := t.f / t.g if !alike(x, t.out) { if !bad { bad = true fmt.Printf("BUG\n") } fmt.Printf("%v/%v: expected %g error; got %g\n", t.f, t.g, t.out, x) } } if bad { panic("zerodivide") } }	5.71 KB	2024-02-02 18:09
📄 zerosize.go // run // Copyright 2023 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 that zero-sized variables get same address as // runtime.zerobase. package main var x, y [0]int var p, q = new([0]int), new([0]int) // should get &runtime.zerobase func main() { if &x != &y { // Failing for now. x and y are at same address, but compiler optimizes &x==&y to false. Skip. // print("&x=", &x, " &y=", &y, " &x==&y = ", &x==&y, "\n") // panic("FAIL") } if p != q { print("p=", p, " q=", q, " p==q = ", p==q, "\n") panic("FAIL") } if &x != p { print("&x=", &x, " p=", p, " &x==p = ", &x==p, "\n") panic("FAIL") } if &y != p { print("&y=", &y, " p=", p, " &y==p = ", &y==p, "\n") panic("FAIL") } }	814 B	2024-02-02 18:09

Edit File:

Terminal