fmt: avoid reflect.Value.Slice to help escape analysis

This is part of a series of CLs that aim to reduce how often
interface arguments escape for the print functions in fmt.

Prior to this change, one reason arguments escape is because
printValue calls reflect.Value.Slice, which causes its
value argument to escape (though at this CL, that is
shrouded in the fmt escape analysis logs by other
printValue escape reasons).

This CL avoids that usage by calling f.Bytes instead,
which is possible because we know f is a slice of bytes
or an addressable array of bytes.

Arguments still escape for other reasons.

Change-Id: Ic3f064117a364007e1dd3197cef9d641abbf784a
Reviewed-on: https://go-review.googlesource.com/c/go/+/524940
TryBot-Result: Gopher Robot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@google.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Auto-Submit: Ian Lance Taylor <iant@google.com>
Run-TryBot: t hepudds <thepudds1460@gmail.com>

diff --git a/src/fmt/print.go b/src/fmt/print.go
index 9225e2e28cca08785499e99ea8d513aebed90167..9c8e331118a5f27014a652e8d8b73f65e81d410d 100644 (file)
--- a/src/fmt/print.go
+++ b/src/fmt/print.go
@@ -872,10 +872,8 @@ func (p *pp) printValue(value reflect.Value, verb rune, depth int) {
                        t := f.Type()
                        if t.Elem().Kind() == reflect.Uint8 {
                                var bytes []byte
-                               if f.Kind() == reflect.Slice {
+                               if f.Kind() == reflect.Slice || f.CanAddr() {
                                        bytes = f.Bytes()
-                               } else if f.CanAddr() {
-                                       bytes = f.Slice(0, f.Len()).Bytes()
                                } else {
                                        // We have an array, but we cannot Slice() a non-addressable array,
                                        // so we build a slice by hand. This is a rare case but it would be nice