Source file src/runtime/error.go

     1  // Copyright 2010 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package runtime
     6  
     7  import "internal/bytealg"
     8  
     9  // The Error interface identifies a run time error.
    10  type Error interface {
    11  	error
    12  
    13  	// RuntimeError is a no-op function but
    14  	// serves to distinguish types that are run time
    15  	// errors from ordinary errors: a type is a
    16  	// run time error if it has a RuntimeError method.
    17  	RuntimeError()
    18  }
    19  
    20  // A TypeAssertionError explains a failed type assertion.
    21  type TypeAssertionError struct {
    22  	_interface    *_type
    23  	concrete      *_type
    24  	asserted      *_type
    25  	missingMethod string // one method needed by Interface, missing from Concrete
    26  }
    27  
    28  func (*TypeAssertionError) RuntimeError() {}
    29  
    30  func (e *TypeAssertionError) Error() string {
    31  	inter := "interface"
    32  	if e._interface != nil {
    33  		inter = e._interface.string()
    34  	}
    35  	as := e.asserted.string()
    36  	if e.concrete == nil {
    37  		return "interface conversion: " + inter + " is nil, not " + as
    38  	}
    39  	cs := e.concrete.string()
    40  	if e.missingMethod == "" {
    41  		msg := "interface conversion: " + inter + " is " + cs + ", not " + as
    42  		if cs == as {
    43  			// provide slightly clearer error message
    44  			if e.concrete.pkgpath() != e.asserted.pkgpath() {
    45  				msg += " (types from different packages)"
    46  			} else {
    47  				msg += " (types from different scopes)"
    48  			}
    49  		}
    50  		return msg
    51  	}
    52  	return "interface conversion: " + cs + " is not " + as +
    53  		": missing method " + e.missingMethod
    54  }
    55  
    56  // itoa converts val to a decimal representation. The result is
    57  // written somewhere within buf and the location of the result is returned.
    58  // buf must be at least 20 bytes.
    59  //
    60  //go:nosplit
    61  func itoa(buf []byte, val uint64) []byte {
    62  	i := len(buf) - 1
    63  	for val >= 10 {
    64  		buf[i] = byte(val%10 + '0')
    65  		i--
    66  		val /= 10
    67  	}
    68  	buf[i] = byte(val + '0')
    69  	return buf[i:]
    70  }
    71  
    72  // An errorString represents a runtime error described by a single string.
    73  type errorString string
    74  
    75  func (e errorString) RuntimeError() {}
    76  
    77  func (e errorString) Error() string {
    78  	return "runtime error: " + string(e)
    79  }
    80  
    81  type errorAddressString struct {
    82  	msg  string  // error message
    83  	addr uintptr // memory address where the error occurred
    84  }
    85  
    86  func (e errorAddressString) RuntimeError() {}
    87  
    88  func (e errorAddressString) Error() string {
    89  	return "runtime error: " + e.msg
    90  }
    91  
    92  // Addr returns the memory address where a fault occurred.
    93  // The address provided is best-effort.
    94  // The veracity of the result may depend on the platform.
    95  // Errors providing this method will only be returned as
    96  // a result of using runtime/debug.SetPanicOnFault.
    97  func (e errorAddressString) Addr() uintptr {
    98  	return e.addr
    99  }
   100  
   101  // plainError represents a runtime error described a string without
   102  // the prefix "runtime error: " after invoking errorString.Error().
   103  // See Issue #14965.
   104  type plainError string
   105  
   106  func (e plainError) RuntimeError() {}
   107  
   108  func (e plainError) Error() string {
   109  	return string(e)
   110  }
   111  
   112  // A boundsError represents an indexing or slicing operation gone wrong.
   113  type boundsError struct {
   114  	x int64
   115  	y int
   116  	// Values in an index or slice expression can be signed or unsigned.
   117  	// That means we'd need 65 bits to encode all possible indexes, from -2^63 to 2^64-1.
   118  	// Instead, we keep track of whether x should be interpreted as signed or unsigned.
   119  	// y is known to be nonnegative and to fit in an int.
   120  	signed bool
   121  	code   boundsErrorCode
   122  }
   123  
   124  type boundsErrorCode uint8
   125  
   126  const (
   127  	boundsIndex boundsErrorCode = iota // s[x], 0 <= x < len(s) failed
   128  
   129  	boundsSliceAlen // s[?:x], 0 <= x <= len(s) failed
   130  	boundsSliceAcap // s[?:x], 0 <= x <= cap(s) failed
   131  	boundsSliceB    // s[x:y], 0 <= x <= y failed (but boundsSliceA didn't happen)
   132  
   133  	boundsSlice3Alen // s[?:?:x], 0 <= x <= len(s) failed
   134  	boundsSlice3Acap // s[?:?:x], 0 <= x <= cap(s) failed
   135  	boundsSlice3B    // s[?:x:y], 0 <= x <= y failed (but boundsSlice3A didn't happen)
   136  	boundsSlice3C    // s[x:y:?], 0 <= x <= y failed (but boundsSlice3A/B didn't happen)
   137  
   138  	boundsConvert // (*[x]T)(s), 0 <= x <= len(s) failed
   139  	// Note: in the above, len(s) and cap(s) are stored in y
   140  )
   141  
   142  // boundsErrorFmts provide error text for various out-of-bounds panics.
   143  // Note: if you change these strings, you should adjust the size of the buffer
   144  // in boundsError.Error below as well.
   145  var boundsErrorFmts = [...]string{
   146  	boundsIndex:      "index out of range [%x] with length %y",
   147  	boundsSliceAlen:  "slice bounds out of range [:%x] with length %y",
   148  	boundsSliceAcap:  "slice bounds out of range [:%x] with capacity %y",
   149  	boundsSliceB:     "slice bounds out of range [%x:%y]",
   150  	boundsSlice3Alen: "slice bounds out of range [::%x] with length %y",
   151  	boundsSlice3Acap: "slice bounds out of range [::%x] with capacity %y",
   152  	boundsSlice3B:    "slice bounds out of range [:%x:%y]",
   153  	boundsSlice3C:    "slice bounds out of range [%x:%y:]",
   154  	boundsConvert:    "cannot convert slice with length %y to pointer to array with length %x",
   155  }
   156  
   157  // boundsNegErrorFmts are overriding formats if x is negative. In this case there's no need to report y.
   158  var boundsNegErrorFmts = [...]string{
   159  	boundsIndex:      "index out of range [%x]",
   160  	boundsSliceAlen:  "slice bounds out of range [:%x]",
   161  	boundsSliceAcap:  "slice bounds out of range [:%x]",
   162  	boundsSliceB:     "slice bounds out of range [%x:]",
   163  	boundsSlice3Alen: "slice bounds out of range [::%x]",
   164  	boundsSlice3Acap: "slice bounds out of range [::%x]",
   165  	boundsSlice3B:    "slice bounds out of range [:%x:]",
   166  	boundsSlice3C:    "slice bounds out of range [%x::]",
   167  }
   168  
   169  func (e boundsError) RuntimeError() {}
   170  
   171  func appendIntStr(b []byte, v int64, signed bool) []byte {
   172  	if signed && v < 0 {
   173  		b = append(b, '-')
   174  		v = -v
   175  	}
   176  	var buf [20]byte
   177  	b = append(b, itoa(buf[:], uint64(v))...)
   178  	return b
   179  }
   180  
   181  func (e boundsError) Error() string {
   182  	fmt := boundsErrorFmts[e.code]
   183  	if e.signed && e.x < 0 {
   184  		fmt = boundsNegErrorFmts[e.code]
   185  	}
   186  	// max message length is 99: "runtime error: slice bounds out of range [::%x] with capacity %y"
   187  	// x can be at most 20 characters. y can be at most 19.
   188  	b := make([]byte, 0, 100)
   189  	b = append(b, "runtime error: "...)
   190  	for i := 0; i < len(fmt); i++ {
   191  		c := fmt[i]
   192  		if c != '%' {
   193  			b = append(b, c)
   194  			continue
   195  		}
   196  		i++
   197  		switch fmt[i] {
   198  		case 'x':
   199  			b = appendIntStr(b, e.x, e.signed)
   200  		case 'y':
   201  			b = appendIntStr(b, int64(e.y), true)
   202  		}
   203  	}
   204  	return string(b)
   205  }
   206  
   207  type stringer interface {
   208  	String() string
   209  }
   210  
   211  // printany prints an argument passed to panic.
   212  // If panic is called with a value that has a String or Error method,
   213  // it has already been converted into a string by preprintpanics.
   214  func printany(i any) {
   215  	switch v := i.(type) {
   216  	case nil:
   217  		print("nil")
   218  	case bool:
   219  		print(v)
   220  	case int:
   221  		print(v)
   222  	case int8:
   223  		print(v)
   224  	case int16:
   225  		print(v)
   226  	case int32:
   227  		print(v)
   228  	case int64:
   229  		print(v)
   230  	case uint:
   231  		print(v)
   232  	case uint8:
   233  		print(v)
   234  	case uint16:
   235  		print(v)
   236  	case uint32:
   237  		print(v)
   238  	case uint64:
   239  		print(v)
   240  	case uintptr:
   241  		print(v)
   242  	case float32:
   243  		print(v)
   244  	case float64:
   245  		print(v)
   246  	case complex64:
   247  		print(v)
   248  	case complex128:
   249  		print(v)
   250  	case string:
   251  		print(v)
   252  	default:
   253  		printanycustomtype(i)
   254  	}
   255  }
   256  
   257  func printanycustomtype(i any) {
   258  	eface := efaceOf(&i)
   259  	typestring := eface._type.string()
   260  
   261  	switch eface._type.kind {
   262  	case kindString:
   263  		print(typestring, `("`, *(*string)(eface.data), `")`)
   264  	case kindBool:
   265  		print(typestring, "(", *(*bool)(eface.data), ")")
   266  	case kindInt:
   267  		print(typestring, "(", *(*int)(eface.data), ")")
   268  	case kindInt8:
   269  		print(typestring, "(", *(*int8)(eface.data), ")")
   270  	case kindInt16:
   271  		print(typestring, "(", *(*int16)(eface.data), ")")
   272  	case kindInt32:
   273  		print(typestring, "(", *(*int32)(eface.data), ")")
   274  	case kindInt64:
   275  		print(typestring, "(", *(*int64)(eface.data), ")")
   276  	case kindUint:
   277  		print(typestring, "(", *(*uint)(eface.data), ")")
   278  	case kindUint8:
   279  		print(typestring, "(", *(*uint8)(eface.data), ")")
   280  	case kindUint16:
   281  		print(typestring, "(", *(*uint16)(eface.data), ")")
   282  	case kindUint32:
   283  		print(typestring, "(", *(*uint32)(eface.data), ")")
   284  	case kindUint64:
   285  		print(typestring, "(", *(*uint64)(eface.data), ")")
   286  	case kindUintptr:
   287  		print(typestring, "(", *(*uintptr)(eface.data), ")")
   288  	case kindFloat32:
   289  		print(typestring, "(", *(*float32)(eface.data), ")")
   290  	case kindFloat64:
   291  		print(typestring, "(", *(*float64)(eface.data), ")")
   292  	case kindComplex64:
   293  		print(typestring, *(*complex64)(eface.data))
   294  	case kindComplex128:
   295  		print(typestring, *(*complex128)(eface.data))
   296  	default:
   297  		print("(", typestring, ") ", eface.data)
   298  	}
   299  }
   300  
   301  // panicwrap generates a panic for a call to a wrapped value method
   302  // with a nil pointer receiver.
   303  //
   304  // It is called from the generated wrapper code.
   305  func panicwrap() {
   306  	pc := getcallerpc()
   307  	name := funcname(findfunc(pc))
   308  	// name is something like "main.(*T).F".
   309  	// We want to extract pkg ("main"), typ ("T"), and meth ("F").
   310  	// Do it by finding the parens.
   311  	i := bytealg.IndexByteString(name, '(')
   312  	if i < 0 {
   313  		throw("panicwrap: no ( in " + name)
   314  	}
   315  	pkg := name[:i-1]
   316  	if i+2 >= len(name) || name[i-1:i+2] != ".(*" {
   317  		throw("panicwrap: unexpected string after package name: " + name)
   318  	}
   319  	name = name[i+2:]
   320  	i = bytealg.IndexByteString(name, ')')
   321  	if i < 0 {
   322  		throw("panicwrap: no ) in " + name)
   323  	}
   324  	if i+2 >= len(name) || name[i:i+2] != ")." {
   325  		throw("panicwrap: unexpected string after type name: " + name)
   326  	}
   327  	typ := name[:i]
   328  	meth := name[i+2:]
   329  	panic(plainError("value method " + pkg + "." + typ + "." + meth + " called using nil *" + typ + " pointer"))
   330  }
   331  

View as plain text