qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-23 07:30:05 -07:00
Code Releases Activity

runtime: remove maxstring

Browse Source 
Before this CL the runtime prevented printing of overlong strings with the print
function when the length of the string was determined to be corrupted.
Corruption was checked by comparing the string size against the limit
which was stored in maxstring.

However maxstring was not updated everywhere were go strings were created
e.g. for string constants during compile time. Thereby the check for maximum
string length prevented the printing of some valid strings.

The protection maxstring provided did not warrant the bookkeeping
and global synchronization needed to keep maxstring updated to the
correct limit everywhere.

Fixes #16999

Change-Id: I62cc2f4362f333f75b77f199ce1a71aac0ff7aeb
Reviewed-on: https://go-review.googlesource.com/28813
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
This commit is contained in:
Martin Möhrmann 2016-09-06 10:38:16 +02:00 committed by Brad Fitzpatrick
parent fd975c6aa5
commit 252093f120
4 changed files with 2 additions and 38 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/runtime/export_test.go
View File

@ -167,9 +167,6 @@ func GostringW(w []uint16) (s string) {
return
}
var Gostringnocopy = gostringnocopy
var Maxstring = &maxstring
type Uintreg sys.Uintreg
var Open = open

4
src/runtime/print.go
View File

@ -199,10 +199,6 @@ func printpointer(p unsafe.Pointer) {
}
func printstring(s string) {
if uintptr(len(s)) > maxstring {
gwrite(bytes("[string too long]"))
return
}
gwrite(bytes(s))
}

20
src/runtime/string.go
View File

@ -4,10 +4,7 @@
package runtime
import (
"runtime/internal/atomic"
"unsafe"
)
import "unsafe"
// The constant is known to the compiler.
// There is no fundamental theory behind this number.
@ -253,12 +250,7 @@ func rawstring(size int) (s string, b []byte) {
*(*slice)(unsafe.Pointer(&b)) = slice{p, size, size}
for {
ms := maxstring
if uintptr(size) <= ms || atomic.Casuintptr((*uintptr)(unsafe.Pointer(&maxstring)), ms, uintptr(size)) {
return
}
}
return
}
// rawbyteslice allocates a new byte slice. The byte slice is not zeroed.
@ -371,18 +363,10 @@ func findnullw(s *uint16) int {
return l
}
var maxstring uintptr = 256 // a hint for print
//go:nosplit
func gostringnocopy(str *byte) string {
ss := stringStruct{str: unsafe.Pointer(str), len: findnull(str)}
s := *(*string)(unsafe.Pointer(&ss))
for {
ms := maxstring
if uintptr(len(s)) <= ms || atomic.Casuintptr(&maxstring, ms, uintptr(len(s))) {
break
}
}
return s
}

13
src/runtime/string_test.go
View File

@ -162,19 +162,6 @@ func TestLargeStringConcat(t *testing.T) {
}
}
func TestGostringnocopy(t *testing.T) {
max := *runtime.Maxstring
b := make([]byte, max+10)
for i := uintptr(0); i < max+9; i++ {
b[i] = 'a'
}
_ = runtime.Gostringnocopy(&b[0])
newmax := *runtime.Maxstring
if newmax != max+9 {
t.Errorf("want %d, got %d", max+9, newmax)
}
}
func TestCompareTempString(t *testing.T) {
s := strings.Repeat("x", sizeNoStack)
b := []byte(s)