runtime: somewhat better checkptr error messages

They're still lacking in details, but at least better than being
printed as raw interface values.

Updates #22218.

Change-Id: I4fd813253afdd6455c0c9b5a05c61659805abad1
Reviewed-on: https://go-review.googlesource.com/c/go/+/202677
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>

diff --git a/src/runtime/checkptr.go b/src/runtime/checkptr.go
index d1fc651509d2158ded14dad93cb97d41c659b122..94581ba5c9bb212a899c26b89af1ac2c85eeb2de 100644 (file)
--- a/src/runtime/checkptr.go
+++ b/src/runtime/checkptr.go
@@ -6,33 +6,45 @@ package runtime
 
 import "unsafe"
 
-type ptrAlign struct {
+type ptrAlignError struct {
        ptr  unsafe.Pointer
        elem *_type
        n    uintptr
 }
 
+func (e ptrAlignError) RuntimeError() {}
+
+func (e ptrAlignError) Error() string {
+       return "runtime error: unsafe pointer conversion"
+}
+
 func checkptrAlignment(p unsafe.Pointer, elem *_type, n uintptr) {
        // Check that (*[n]elem)(p) is appropriately aligned.
        // TODO(mdempsky): What about fieldAlign?
        if uintptr(p)&(uintptr(elem.align)-1) != 0 {
-               panic(ptrAlign{p, elem, n})
+               panic(ptrAlignError{p, elem, n})
        }
 
        // Check that (*[n]elem)(p) doesn't straddle multiple heap objects.
        if size := n * elem.size; size > 1 && checkptrBase(p) != checkptrBase(add(p, size-1)) {
-               panic(ptrAlign{p, elem, n})
+               panic(ptrAlignError{p, elem, n})
        }
 }
 
-type ptrArith struct {
+type ptrArithError struct {
        ptr       unsafe.Pointer
        originals []unsafe.Pointer
 }
 
+func (e ptrArithError) RuntimeError() {}
+
+func (e ptrArithError) Error() string {
+       return "runtime error: unsafe pointer arithmetic"
+}
+
 func checkptrArithmetic(p unsafe.Pointer, originals []unsafe.Pointer) {
        if 0 < uintptr(p) && uintptr(p) < minLegalPointer {
-               panic(ptrArith{p, originals})
+               panic(ptrArithError{p, originals})
        }
 
        // Check that if the computed pointer p points into a heap
@@ -49,7 +61,7 @@ func checkptrArithmetic(p unsafe.Pointer, originals []unsafe.Pointer) {
                }
        }
 
-       panic(ptrArith{p, originals})
+       panic(ptrArithError{p, originals})
 }
 
 func checkptrBase(p unsafe.Pointer) uintptr {