From 3526cf586be92cb4c741aed54ccfd37cf00ddfc5 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Mon, 24 Aug 2015 23:52:03 -0700 Subject: [dev.ssa] cmd/compile: implement OSLICESTR Add a new function and generic operation to handle bounds checking for slices. Unlike the index bounds checking the index can be equal to the upper bound. Do gc-friendly slicing that generates proper code for 0-length result slices. This is a takeover of Alexandru's original change, (https://go-review.googlesource.com/#/c/12764/) submittable now that the decompose phase is in. Change-Id: I17d164cf42ed7839f84ca949c6ad3289269c9160 Reviewed-on: https://go-review.googlesource.com/13903 Reviewed-by: David Chase --- src/cmd/compile/internal/gc/testdata/string_ssa.go | 92 ++++++++++++++++++++++ 1 file changed, 92 insertions(+) create mode 100644 src/cmd/compile/internal/gc/testdata/string_ssa.go (limited to 'src/cmd/compile/internal/gc/testdata/string_ssa.go') diff --git a/src/cmd/compile/internal/gc/testdata/string_ssa.go b/src/cmd/compile/internal/gc/testdata/string_ssa.go new file mode 100644 index 0000000000..5987412933 --- /dev/null +++ b/src/cmd/compile/internal/gc/testdata/string_ssa.go @@ -0,0 +1,92 @@ +// string_ssa.go tests string operations. +package main + +var failed = false + +func testStringSlice1_ssa(a string, i, j int) string { + switch { // prevent inlining + } + return a[i:] +} + +func testStringSlice2_ssa(a string, i, j int) string { + switch { // prevent inlining + } + return a[:j] +} + +func testStringSlice12_ssa(a string, i, j int) string { + switch { // prevent inlining + } + return a[i:j] +} + +func testStringSlice() { + tests := [...]struct { + fn func(string, int, int) string + s string + low, high int + want string + }{ + // -1 means the value is not used. + {testStringSlice1_ssa, "foobar", 0, -1, "foobar"}, + {testStringSlice1_ssa, "foobar", 3, -1, "bar"}, + {testStringSlice1_ssa, "foobar", 6, -1, ""}, + {testStringSlice2_ssa, "foobar", -1, 0, ""}, + {testStringSlice2_ssa, "foobar", -1, 3, "foo"}, + {testStringSlice2_ssa, "foobar", -1, 6, "foobar"}, + {testStringSlice12_ssa, "foobar", 0, 6, "foobar"}, + {testStringSlice12_ssa, "foobar", 0, 0, ""}, + {testStringSlice12_ssa, "foobar", 6, 6, ""}, + {testStringSlice12_ssa, "foobar", 1, 5, "ooba"}, + {testStringSlice12_ssa, "foobar", 3, 3, ""}, + {testStringSlice12_ssa, "", 0, 0, ""}, + } + + for i, t := range tests { + if got := t.fn(t.s, t.low, t.high); t.want != got { + println("#", i, " ", t.s, "[", t.low, ":", t.high, "] = ", got, " want ", t.want) + failed = true + } + } +} + +type prefix struct { + prefix string +} + +func (p *prefix) slice_ssa() { + p.prefix = p.prefix[:3] +} + +func testStructSlice() { + switch { + } + p := &prefix{"prefix"} + p.slice_ssa() + if "pre" != p.prefix { + println("wrong field slice: wanted %s got %s", "pre", p.prefix) + } +} + +func testStringSlicePanic() { + defer func() { + if r := recover(); r != nil { + println("paniced as expected") + } + }() + + str := "foobar" + println("got ", testStringSlice12_ssa(str, 3, 9)) + println("expected to panic, but didn't") + failed = true +} + +func main() { + testStringSlice() + testStringSlicePanic() + + if failed { + panic("failed") + } +} -- cgit v1.3 From e0e4068c6e6cebb586bbffa36962c7fc6cb595e0 Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Wed, 26 Aug 2015 18:40:52 -0500 Subject: [dev.ssa] cmd/compile: implement len(map) Implement len(map) values. Change-Id: If92be96ec9a7a86aeb3ce566d6758aab01c2fa7d Reviewed-on: https://go-review.googlesource.com/13961 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 38 ++++++++++++++++- src/cmd/compile/internal/gc/testdata/map_ssa.go | 47 ++++++++++++++++++++++ src/cmd/compile/internal/gc/testdata/string_ssa.go | 4 ++ 3 files changed, 87 insertions(+), 2 deletions(-) create mode 100644 src/cmd/compile/internal/gc/testdata/map_ssa.go (limited to 'src/cmd/compile/internal/gc/testdata/string_ssa.go') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 0c0a6a36da..d672eb58e0 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1440,8 +1440,7 @@ func (s *state) expr(n *Node) *ssa.Value { case n.Left.Type.IsString(): // string; not reachable for OCAP return s.newValue1(ssa.OpStringLen, Types[TINT], s.expr(n.Left)) case n.Left.Type.IsMap(): - s.Unimplementedf("unhandled len(map)") - return nil + return s.lenMap(n, s.expr(n.Left)) case n.Left.Type.IsChan(): if n.Op == OCAP { s.Unimplementedf("unhandled cap(chan)") @@ -1998,6 +1997,41 @@ func (s *state) uintTofloat(cvttab *u2fcvtTab, n *Node, x *ssa.Value, ft, tt *Ty return s.variable(n, n.Type) } +func (s *state) lenMap(n *Node, x *ssa.Value) *ssa.Value { + // if n == nil { + // return 0 + // } else { + // return *((*int)n) + // } + lenType := n.Type + cmp := s.newValue2(ssa.OpEqPtr, Types[TBOOL], x, s.zeroVal(lenType)) + b := s.endBlock() + b.Kind = ssa.BlockIf + b.Control = cmp + b.Likely = ssa.BranchUnlikely + + bThen := s.f.NewBlock(ssa.BlockPlain) + bElse := s.f.NewBlock(ssa.BlockPlain) + bAfter := s.f.NewBlock(ssa.BlockPlain) + + // length of a nil map is zero + addEdge(b, bThen) + s.startBlock(bThen) + s.vars[n] = s.zeroVal(lenType) + s.endBlock() + addEdge(bThen, bAfter) + + // the length is stored in the first word + addEdge(b, bElse) + s.startBlock(bElse) + s.vars[n] = s.newValue2(ssa.OpLoad, lenType, x, s.mem()) + s.endBlock() + addEdge(bElse, bAfter) + + s.startBlock(bAfter) + return s.variable(n, lenType) +} + // checkgoto checks that a goto from from to to does not // jump into a block or jump over variable declarations. // It is a copy of checkgoto in the pre-SSA backend, diff --git a/src/cmd/compile/internal/gc/testdata/map_ssa.go b/src/cmd/compile/internal/gc/testdata/map_ssa.go new file mode 100644 index 0000000000..41c949a9f2 --- /dev/null +++ b/src/cmd/compile/internal/gc/testdata/map_ssa.go @@ -0,0 +1,47 @@ +// 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. + +// map_ssa.go tests map operations. +package main + +import "fmt" + +var failed = false + +func lenMap_ssa(v map[int]int) int { + switch { // prevent inlining + + } + return len(v) +} + +func testLenMap() { + + v := make(map[int]int) + v[0] = 0 + v[1] = 0 + v[2] = 0 + + if want, got := 3, lenMap_ssa(v); got != want { + fmt.Printf("expected len(map) = %d, got %d", want, got) + failed = true + } +} + +func testLenNilMap() { + + var v map[int]int + if want, got := 0, lenMap_ssa(v); got != want { + fmt.Printf("expected len(nil) = %d, got %d", want, got) + failed = true + } +} +func main() { + testLenMap() + testLenNilMap() + + if failed { + panic("failed") + } +} diff --git a/src/cmd/compile/internal/gc/testdata/string_ssa.go b/src/cmd/compile/internal/gc/testdata/string_ssa.go index 5987412933..efc734e1a2 100644 --- a/src/cmd/compile/internal/gc/testdata/string_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/string_ssa.go @@ -1,3 +1,7 @@ +// 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. + // string_ssa.go tests string operations. package main -- cgit v1.3 From c684d4d26c3197039ac2c2f53a862f25dc7d1112 Mon Sep 17 00:00:00 2001 From: Alexandru Moșoi Date: Tue, 8 Sep 2015 18:18:59 +0200 Subject: [dev.ssa] cmd/compile/internal/ssa: fix string slice types. Change-Id: I28bc6373bb42d9abf4f179664dbaab8d514a6ab9 Reviewed-on: https://go-review.googlesource.com/14376 Reviewed-by: Keith Randall --- src/cmd/compile/internal/gc/ssa.go | 4 +-- src/cmd/compile/internal/gc/testdata/string_ssa.go | 30 ++++++++++++++++++++++ 2 files changed, 32 insertions(+), 2 deletions(-) (limited to 'src/cmd/compile/internal/gc/testdata/string_ssa.go') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 70990bbd18..a554a1dfd9 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1722,12 +1722,12 @@ func (s *state) expr(n *Node) *ssa.Value { if n.Right.Left == nil { low = zero } else { - low = s.expr(n.Right.Left) + low = s.extendIndex(s.expr(n.Right.Left)) } if n.Right.Right == nil { high = len } else { - high = s.expr(n.Right.Right) + high = s.extendIndex(s.expr(n.Right.Right)) } // Panic if slice indices are not in bounds. diff --git a/src/cmd/compile/internal/gc/testdata/string_ssa.go b/src/cmd/compile/internal/gc/testdata/string_ssa.go index efc734e1a2..448433acd3 100644 --- a/src/cmd/compile/internal/gc/testdata/string_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/string_ssa.go @@ -86,9 +86,39 @@ func testStringSlicePanic() { failed = true } +const _Accuracy_name = "BelowExactAbove" + +var _Accuracy_index = [...]uint8{0, 5, 10, 15} + +func testSmallIndexType_ssa(i int) string { + switch { // prevent inlining + } + return _Accuracy_name[_Accuracy_index[i]:_Accuracy_index[i+1]] +} + +func testSmallIndexType() { + tests := []struct { + i int + want string + }{ + {0, "Below"}, + {1, "Exact"}, + {2, "Above"}, + } + + for i, t := range tests { + if got := testSmallIndexType_ssa(t.i); got != t.want { + println("#", i, "got ", got, ", wanted", t.want) + failed = true + } + } +} + func main() { testStringSlice() testStringSlicePanic() + testStructSlice() + testSmallIndexType() if failed { panic("failed") -- cgit v1.3 From c7081409bb58edc0fcbccbba230b1667845e94a6 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Thu, 10 Sep 2015 10:01:15 -0700 Subject: [dev.ssa] cmd/compile/internal/ssa: fix string index MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Change-Id: I984d3e0410ac38c4e42ae8e3670ea47e2140de76 Reviewed-on: https://go-review.googlesource.com/14466 Reviewed-by: Alexandru Moșoi Reviewed-by: Todd Neal --- src/cmd/compile/internal/gc/ssa.go | 23 ++++++------ src/cmd/compile/internal/gc/testdata/string_ssa.go | 41 ++++++++++++++++++++++ 2 files changed, 54 insertions(+), 10 deletions(-) (limited to 'src/cmd/compile/internal/gc/testdata/string_ssa.go') diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go index 70350e0e2c..0551ddbf08 100644 --- a/src/cmd/compile/internal/gc/ssa.go +++ b/src/cmd/compile/internal/gc/ssa.go @@ -1693,19 +1693,22 @@ func (s *state) expr(n *Node) *ssa.Value { a := s.expr(n.Left) i := s.expr(n.Right) i = s.extendIndex(i) - var elemtype *Type - var len *ssa.Value if n.Left.Type.IsString() { - len = s.newValue1(ssa.OpStringLen, Types[TINT], a) - elemtype = Types[TUINT8] + if !n.Bounded { + len := s.newValue1(ssa.OpStringLen, Types[TINT], a) + s.boundsCheck(i, len) + } + ptrtyp := Ptrto(Types[TUINT8]) + ptr := s.newValue1(ssa.OpStringPtr, ptrtyp, a) + ptr = s.newValue2(ssa.OpAddPtr, ptrtyp, ptr, i) + return s.newValue2(ssa.OpLoad, Types[TUINT8], ptr, s.mem()) } else { - len = s.constInt(Types[TINT], n.Left.Type.Bound) - elemtype = n.Left.Type.Type - } - if !n.Bounded { - s.boundsCheck(i, len) + if !n.Bounded { + len := s.constInt(Types[TINT], n.Left.Type.Bound) + s.boundsCheck(i, len) + } + return s.newValue2(ssa.OpArrayIndex, n.Left.Type.Type, a, i) } - return s.newValue2(ssa.OpArrayIndex, elemtype, a, i) } else { // slice p := s.addr(n) return s.newValue2(ssa.OpLoad, n.Left.Type.Type, p, s.mem()) diff --git a/src/cmd/compile/internal/gc/testdata/string_ssa.go b/src/cmd/compile/internal/gc/testdata/string_ssa.go index 448433acd3..0ff6ce1a12 100644 --- a/src/cmd/compile/internal/gc/testdata/string_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/string_ssa.go @@ -70,6 +70,7 @@ func testStructSlice() { p.slice_ssa() if "pre" != p.prefix { println("wrong field slice: wanted %s got %s", "pre", p.prefix) + failed = true } } @@ -114,11 +115,51 @@ func testSmallIndexType() { } } +func testStringElem_ssa(s string, i int) byte { + switch { // prevent inlining + } + return s[i] +} + +func testStringElem() { + tests := []struct { + s string + i int + n byte + }{ + {"foobar", 3, 98}, + {"foobar", 0, 102}, + {"foobar", 5, 114}, + } + for _, t := range tests { + if got := testStringElem_ssa(t.s, t.i); got != t.n { + print("testStringElem \"", t.s, "\"[", t.i, "]=", got, ", wanted ", t.n, "\n") + failed = true + } + } +} + +func testStringElemConst_ssa(i int) byte { + switch { // prevent inlining + } + s := "foobar" + return s[i] +} + +func testStringElemConst() { + if got := testStringElemConst_ssa(3); got != 98 { + println("testStringElemConst=", got, ", wanted 98") + failed = true + } +} + func main() { testStringSlice() testStringSlicePanic() testStructSlice() testSmallIndexType() + testStringElem() + testStringElemConst() if failed { panic("failed") -- cgit v1.3 From 09ffa0c4c772ff119d42820a8d90aba8b481397c Mon Sep 17 00:00:00 2001 From: Todd Neal Date: Sun, 6 Dec 2015 21:25:24 -0600 Subject: [dev.ssa] test: use new go:noinline feature Replace old mechanisms for preventing inlining with go:noinline. Change-Id: I021a6450e6d644ec1042594730a9c64d695949a1 Reviewed-on: https://go-review.googlesource.com/17500 Reviewed-by: Brad Fitzpatrick --- src/cmd/compile/internal/gc/testdata/append_ssa.go | 7 +- .../internal/gc/testdata/arithBoundary_ssa.go | 159 ++++++++++----------- src/cmd/compile/internal/gc/testdata/arith_ssa.go | 48 +++---- src/cmd/compile/internal/gc/testdata/array_ssa.go | 15 +- src/cmd/compile/internal/gc/testdata/chan_ssa.go | 9 +- .../compile/internal/gc/testdata/closure_ssa.go | 3 +- src/cmd/compile/internal/gc/testdata/fp_ssa.go | 57 +++----- .../internal/gc/testdata/gen/arithBoundaryGen.go | 4 +- src/cmd/compile/internal/gc/testdata/map_ssa.go | 4 +- src/cmd/compile/internal/gc/testdata/short_ssa.go | 2 +- src/cmd/compile/internal/gc/testdata/string_ssa.go | 18 +-- 11 files changed, 138 insertions(+), 188 deletions(-) (limited to 'src/cmd/compile/internal/gc/testdata/string_ssa.go') diff --git a/src/cmd/compile/internal/gc/testdata/append_ssa.go b/src/cmd/compile/internal/gc/testdata/append_ssa.go index dba81736c8..03cd219c32 100644 --- a/src/cmd/compile/internal/gc/testdata/append_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/append_ssa.go @@ -9,14 +9,13 @@ import "fmt" var failed = false +//go:noinline func appendOne_ssa(a []int, x int) []int { - switch { // prevent inlining - } return append(a, x) } + +//go:noinline func appendThree_ssa(a []int, x, y, z int) []int { - switch { // prevent inlining - } return append(a, x, y, z) } diff --git a/src/cmd/compile/internal/gc/testdata/arithBoundary_ssa.go b/src/cmd/compile/internal/gc/testdata/arithBoundary_ssa.go index 9f1b9a4a60..929e4e1f0b 100644 --- a/src/cmd/compile/internal/gc/testdata/arithBoundary_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/arithBoundary_ssa.go @@ -35,204 +35,203 @@ type itd8 struct { add, sub, mul, div, mod int8 } +//go:noinline func add_uint64_ssa(a, b uint64) uint64 { - switch { - } // prevent inlining return a + b } + +//go:noinline func sub_uint64_ssa(a, b uint64) uint64 { - switch { - } // prevent inlining return a - b } + +//go:noinline func div_uint64_ssa(a, b uint64) uint64 { - switch { - } // prevent inlining return a / b } + +//go:noinline func mod_uint64_ssa(a, b uint64) uint64 { - switch { - } // prevent inlining return a % b } + +//go:noinline func mul_uint64_ssa(a, b uint64) uint64 { - switch { - } // prevent inlining return a * b } + +//go:noinline func add_int64_ssa(a, b int64) int64 { - switch { - } // prevent inlining return a + b } + +//go:noinline func sub_int64_ssa(a, b int64) int64 { - switch { - } // prevent inlining return a - b } + +//go:noinline func div_int64_ssa(a, b int64) int64 { - switch { - } // prevent inlining return a / b } + +//go:noinline func mod_int64_ssa(a, b int64) int64 { - switch { - } // prevent inlining return a % b } + +//go:noinline func mul_int64_ssa(a, b int64) int64 { - switch { - } // prevent inlining return a * b } + +//go:noinline func add_uint32_ssa(a, b uint32) uint32 { - switch { - } // prevent inlining return a + b } + +//go:noinline func sub_uint32_ssa(a, b uint32) uint32 { - switch { - } // prevent inlining return a - b } + +//go:noinline func div_uint32_ssa(a, b uint32) uint32 { - switch { - } // prevent inlining return a / b } + +//go:noinline func mod_uint32_ssa(a, b uint32) uint32 { - switch { - } // prevent inlining return a % b } + +//go:noinline func mul_uint32_ssa(a, b uint32) uint32 { - switch { - } // prevent inlining return a * b } + +//go:noinline func add_int32_ssa(a, b int32) int32 { - switch { - } // prevent inlining return a + b } + +//go:noinline func sub_int32_ssa(a, b int32) int32 { - switch { - } // prevent inlining return a - b } + +//go:noinline func div_int32_ssa(a, b int32) int32 { - switch { - } // prevent inlining return a / b } + +//go:noinline func mod_int32_ssa(a, b int32) int32 { - switch { - } // prevent inlining return a % b } + +//go:noinline func mul_int32_ssa(a, b int32) int32 { - switch { - } // prevent inlining return a * b } + +//go:noinline func add_uint16_ssa(a, b uint16) uint16 { - switch { - } // prevent inlining return a + b } + +//go:noinline func sub_uint16_ssa(a, b uint16) uint16 { - switch { - } // prevent inlining return a - b } + +//go:noinline func div_uint16_ssa(a, b uint16) uint16 { - switch { - } // prevent inlining return a / b } + +//go:noinline func mod_uint16_ssa(a, b uint16) uint16 { - switch { - } // prevent inlining return a % b } + +//go:noinline func mul_uint16_ssa(a, b uint16) uint16 { - switch { - } // prevent inlining return a * b } + +//go:noinline func add_int16_ssa(a, b int16) int16 { - switch { - } // prevent inlining return a + b } + +//go:noinline func sub_int16_ssa(a, b int16) int16 { - switch { - } // prevent inlining return a - b } + +//go:noinline func div_int16_ssa(a, b int16) int16 { - switch { - } // prevent inlining return a / b } + +//go:noinline func mod_int16_ssa(a, b int16) int16 { - switch { - } // prevent inlining return a % b } + +//go:noinline func mul_int16_ssa(a, b int16) int16 { - switch { - } // prevent inlining return a * b } + +//go:noinline func add_uint8_ssa(a, b uint8) uint8 { - switch { - } // prevent inlining return a + b } + +//go:noinline func sub_uint8_ssa(a, b uint8) uint8 { - switch { - } // prevent inlining return a - b } + +//go:noinline func div_uint8_ssa(a, b uint8) uint8 { - switch { - } // prevent inlining return a / b } + +//go:noinline func mod_uint8_ssa(a, b uint8) uint8 { - switch { - } // prevent inlining return a % b } + +//go:noinline func mul_uint8_ssa(a, b uint8) uint8 { - switch { - } // prevent inlining return a * b } + +//go:noinline func add_int8_ssa(a, b int8) int8 { - switch { - } // prevent inlining return a + b } + +//go:noinline func sub_int8_ssa(a, b int8) int8 { - switch { - } // prevent inlining return a - b } + +//go:noinline func div_int8_ssa(a, b int8) int8 { - switch { - } // prevent inlining return a / b } + +//go:noinline func mod_int8_ssa(a, b int8) int8 { - switch { - } // prevent inlining return a % b } + +//go:noinline func mul_int8_ssa(a, b int8) int8 { - switch { - } // prevent inlining return a * b } diff --git a/src/cmd/compile/internal/gc/testdata/arith_ssa.go b/src/cmd/compile/internal/gc/testdata/arith_ssa.go index f6f123c0be..af31245505 100644 --- a/src/cmd/compile/internal/gc/testdata/arith_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/arith_ssa.go @@ -17,9 +17,9 @@ func test64BitConstMult() { failed = true } } + +//go:noinline func test64BitConstMult_ssa(a, b int64) int64 { - switch { // prevent inlining - } return 34359738369*a + b*34359738370 } @@ -32,9 +32,9 @@ func test64BitConstAdd() { failed = true } } + +//go:noinline func test64BitConstAdd_ssa(a, b int64) int64 { - switch { // prevent inlining - } return a + 575815584948629622 + b + 2991856197886747025 } @@ -47,9 +47,9 @@ func testRegallocCVSpill() { failed = true } } + +//go:noinline func testRegallocCVSpill_ssa(a, b, c, d int8) int8 { - switch { // prevent inlining - } return a + -32 + b + 63*c*-87*d } @@ -105,45 +105,38 @@ func testBitwiseLogic() { } } +//go:noinline func testBitwiseAnd_ssa(a, b uint32) uint32 { - switch { // prevent inlining - } return a & b } +//go:noinline func testBitwiseOr_ssa(a, b uint32) uint32 { - switch { // prevent inlining - } return a | b } +//go:noinline func testBitwiseXor_ssa(a, b uint32) uint32 { - switch { // prevent inlining - } return a ^ b } +//go:noinline func testBitwiseLsh_ssa(a int32, b, c uint32) int32 { - switch { // prevent inlining - } return a << b << c } +//go:noinline func testBitwiseRsh_ssa(a int32, b, c uint32) int32 { - switch { // prevent inlining - } return a >> b >> c } +//go:noinline func testBitwiseRshU_ssa(a uint32, b, c uint32) uint32 { - switch { // prevent inlining - } return a >> b >> c } +//go:noinline func testShiftCX_ssa() int { - switch { - } // prevent inlining v1 := uint8(3) v4 := (v1 * v1) ^ v1 | v1 - v1 - v1&v1 ^ uint8(3+2) + v1*1>>0 - v1 | 1 | v1<<(2*3|0-0*0^1) v5 := v4>>(3-0-uint(3)) | v1 | v1 + v1 ^ v4<<(0+1|3&1)<<(uint64(1)<<0*2*0<<0) ^ v1 @@ -172,9 +165,8 @@ func testSubqToNegq() { } } +//go:noinline func testSubqToNegq_ssa(a, b, c, d, e, f, g, h, i, j, k int64) int64 { - switch { // prevent inlining - } return a + 8207351403619448057 - b - 1779494519303207690 + c*8810076340510052032*d - 4465874067674546219 - e*4361839741470334295 - f + 8688847565426072650*g*8065564729145417479 } @@ -187,9 +179,8 @@ func testOcom() { } } +//go:noinline func testOcom_ssa(a, b int32) (int32, int32) { - switch { // prevent inlining - } return ^^^^a, ^^^^^b } @@ -201,21 +192,19 @@ func lrot1_ssa(w uint8, x uint16, y uint32, z uint64) (a uint8, b uint16, c uint return } +//go:noinline func lrot2_ssa(w, n uint32) uint32 { // Want to be sure that a "rotate by 32" which // is really 0 | (w >> 0) == w // is correctly compiled. - switch { // prevents inlining - } return (w << n) | (w >> (32 - n)) } +//go:noinline func lrot3_ssa(w uint32) uint32 { // Want to be sure that a "rotate by 32" which // is really 0 | (w >> 0) == w // is correctly compiled. - switch { // prevents inlining - } return (w << 32) | (w >> (32 - 32)) } @@ -244,9 +233,8 @@ func testLrot() { } +//go:noinline func sub1_ssa() uint64 { - switch { - } // prevent inlining v1 := uint64(3) // uint64 return v1*v1 - (v1&v1)&v1 } diff --git a/src/cmd/compile/internal/gc/testdata/array_ssa.go b/src/cmd/compile/internal/gc/testdata/array_ssa.go index d7004ff26a..0334339d43 100644 --- a/src/cmd/compile/internal/gc/testdata/array_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/array_ssa.go @@ -2,23 +2,20 @@ package main var failed = false +//go:noinline func testSliceLenCap12_ssa(a [10]int, i, j int) (int, int) { - switch { // prevent inlining - } b := a[i:j] return len(b), cap(b) } +//go:noinline func testSliceLenCap1_ssa(a [10]int, i, j int) (int, int) { - switch { // prevent inlining - } b := a[i:] return len(b), cap(b) } +//go:noinline func testSliceLenCap2_ssa(a [10]int, i, j int) (int, int) { - switch { // prevent inlining - } b := a[:j] return len(b), cap(b) } @@ -55,9 +52,8 @@ func testSliceLenCap() { } } +//go:noinline func testSliceGetElement_ssa(a [10]int, i, j, p int) int { - switch { // prevent inlining - } return a[i:j][p] } @@ -81,9 +77,8 @@ func testSliceGetElement() { } } +//go:noinline func testSliceSetElement_ssa(a *[10]int, i, j, p, x int) { - switch { // prevent inlining - } (*a)[i:j][p] = x } diff --git a/src/cmd/compile/internal/gc/testdata/chan_ssa.go b/src/cmd/compile/internal/gc/testdata/chan_ssa.go index c527ba95be..0766fcda5b 100644 --- a/src/cmd/compile/internal/gc/testdata/chan_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/chan_ssa.go @@ -9,16 +9,13 @@ import "fmt" var failed = false +//go:noinline func lenChan_ssa(v chan int) int { - switch { // prevent inlining - - } return len(v) } -func capChan_ssa(v chan int) int { - switch { // prevent inlining - } +//go:noinline +func capChan_ssa(v chan int) int { return cap(v) } diff --git a/src/cmd/compile/internal/gc/testdata/closure_ssa.go b/src/cmd/compile/internal/gc/testdata/closure_ssa.go index ac1e51a23e..70181bc24b 100644 --- a/src/cmd/compile/internal/gc/testdata/closure_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/closure_ssa.go @@ -9,9 +9,8 @@ import "fmt" var failed = false +//go:noinline func testCFunc_ssa() int { - switch { // prevent inlining - } a := 0 b := func() { switch { diff --git a/src/cmd/compile/internal/gc/testdata/fp_ssa.go b/src/cmd/compile/internal/gc/testdata/fp_ssa.go index e7480a1138..cfbdcda251 100644 --- a/src/cmd/compile/internal/gc/testdata/fp_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/fp_ssa.go @@ -1466,118 +1466,99 @@ func expectCx64(s string, x, expected complex64) int { return 0 } +//go:noinline func cx128sum_ssa(a, b complex128) complex128 { - switch { // prevent inlining - } return a + b } +//go:noinline func cx128diff_ssa(a, b complex128) complex128 { - switch { // prevent inlining - } return a - b } +//go:noinline func cx128prod_ssa(a, b complex128) complex128 { - switch { // prevent inlining - } return a * b } +//go:noinline func cx128quot_ssa(a, b complex128) complex128 { - switch { // prevent inlining - } return a / b } +//go:noinline func cx128neg_ssa(a complex128) complex128 { - switch { // prevent inlining - } return -a } +//go:noinline func cx128real_ssa(a complex128) float64 { - switch { // prevent inlining - } return real(a) } +//go:noinline func cx128imag_ssa(a complex128) float64 { - switch { // prevent inlining - } return imag(a) } +//go:noinline func cx128cnst_ssa(a complex128) complex128 { - switch { // prevent inlining - } b := 2 + 3i return a * b } +//go:noinline func cx64sum_ssa(a, b complex64) complex64 { - switch { // prevent inlining - } return a + b } +//go:noinline func cx64diff_ssa(a, b complex64) complex64 { - switch { // prevent inlining - } return a - b } +//go:noinline func cx64prod_ssa(a, b complex64) complex64 { - switch { // prevent inlining - } return a * b } +//go:noinline func cx64quot_ssa(a, b complex64) complex64 { - switch { // prevent inlining - } return a / b } +//go:noinline func cx64neg_ssa(a complex64) complex64 { - switch { // prevent inlining - } return -a } +//go:noinline func cx64real_ssa(a complex64) float32 { - switch { // prevent inlining - } return real(a) } +//go:noinline func cx64imag_ssa(a complex64) float32 { - switch { // prevent inlining - } return imag(a) } +//go:noinline func cx128eq_ssa(a, b complex128) bool { - switch { // prevent inlining - } return a == b } +//go:noinline func cx128ne_ssa(a, b complex128) bool { - switch { // prevent inlining - } return a != b } +//go:noinline func cx64eq_ssa(a, b complex64) bool { - switch { // prevent inlining - } return a == b } +//go:noinline func cx64ne_ssa(a, b complex64) bool { - switch { // prevent inlining - } return a != b } diff --git a/src/cmd/compile/internal/gc/testdata/gen/arithBoundaryGen.go b/src/cmd/compile/internal/gc/testdata/gen/arithBoundaryGen.go index 19bb04b6f1..7c7d721a23 100644 --- a/src/cmd/compile/internal/gc/testdata/gen/arithBoundaryGen.go +++ b/src/cmd/compile/internal/gc/testdata/gen/arithBoundaryGen.go @@ -109,8 +109,8 @@ func main() { // the function being tested testFunc, err := template.New("testFunc").Parse( - `func {{.Name}}_{{.Stype}}_ssa(a, b {{.Stype}}) {{.Stype}} { - switch{} // prevent inlining + `//go:noinline + func {{.Name}}_{{.Stype}}_ssa(a, b {{.Stype}}) {{.Stype}} { return a {{.SymFirst}} b } `) diff --git a/src/cmd/compile/internal/gc/testdata/map_ssa.go b/src/cmd/compile/internal/gc/testdata/map_ssa.go index 41c949a9f2..4a466003c7 100644 --- a/src/cmd/compile/internal/gc/testdata/map_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/map_ssa.go @@ -9,10 +9,8 @@ import "fmt" var failed = false +//go:noinline func lenMap_ssa(v map[int]int) int { - switch { // prevent inlining - - } return len(v) } diff --git a/src/cmd/compile/internal/gc/testdata/short_ssa.go b/src/cmd/compile/internal/gc/testdata/short_ssa.go index 1aa7d3e677..fcec1baf09 100644 --- a/src/cmd/compile/internal/gc/testdata/short_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/short_ssa.go @@ -18,10 +18,10 @@ func or_ssa(arg1, arg2 bool) bool { var rightCalled bool +//go:noinline func rightCall(v bool) bool { rightCalled = true return v - select {} // hack to prevent inlining panic("unreached") } diff --git a/src/cmd/compile/internal/gc/testdata/string_ssa.go b/src/cmd/compile/internal/gc/testdata/string_ssa.go index 0ff6ce1a12..a949fbcefb 100644 --- a/src/cmd/compile/internal/gc/testdata/string_ssa.go +++ b/src/cmd/compile/internal/gc/testdata/string_ssa.go @@ -7,21 +7,18 @@ package main var failed = false +//go:noinline func testStringSlice1_ssa(a string, i, j int) string { - switch { // prevent inlining - } return a[i:] } +//go:noinline func testStringSlice2_ssa(a string, i, j int) string { - switch { // prevent inlining - } return a[:j] } +//go:noinline func testStringSlice12_ssa(a string, i, j int) string { - switch { // prevent inlining - } return a[i:j] } @@ -91,9 +88,8 @@ const _Accuracy_name = "BelowExactAbove" var _Accuracy_index = [...]uint8{0, 5, 10, 15} +//go:noinline func testSmallIndexType_ssa(i int) string { - switch { // prevent inlining - } return _Accuracy_name[_Accuracy_index[i]:_Accuracy_index[i+1]] } @@ -115,9 +111,8 @@ func testSmallIndexType() { } } +//go:noinline func testStringElem_ssa(s string, i int) byte { - switch { // prevent inlining - } return s[i] } @@ -139,9 +134,8 @@ func testStringElem() { } } +//go:noinline func testStringElemConst_ssa(i int) byte { - switch { // prevent inlining - } s := "foobar" return s[i] } -- cgit v1.3