runtime: pre-box plain errors to avoid allocs

Author: jakebailey

main_test.go

@@ -148,6 +148,23 @@ func TestBuild(t *testing.T) {
 			runTestWithConfig("print.go", t, opts, nil, nil)
 		})
 
+		t.Run("gc=none-runtime-panic", func(t *testing.T) {
+			t.Parallel()
+			opts := optionsFromTarget("cortex-m-qemu", sema)
+			opts.GC = "none"
+			opts.Scheduler = "none"
+			config, err := builder.NewConfig(&opts)
+			if err != nil {
+				t.Fatal(err)
+			}
+			err = Build("testdata/trivialpanic.go", t.TempDir()+"/trivialpanic", config)
+			if err != nil {
+				w := &bytes.Buffer{}
+				diagnostics.CreateDiagnostics(err).WriteTo(w, "")
+				t.Fatal(w.String())
+			}
+		})
+
 		t.Run("ldflags", func(t *testing.T) {
 			t.Parallel()
 			opts := optionsFromTarget("", sema)

src/runtime/chan.go

@@ -207,7 +207,7 @@ func (ch *channel) trySend(value unsafe.Pointer) bool {
 		// Note: we cannot currently recover from this panic.
 		// There's some state in the select statement especially that would be
 		// corrupted if we allowed recovering from this panic.
-		runtimePanic("send on closed channel")
+		runtimePanicAt(returnAddress(0), &errSendOnClosedChannel)
 	}
 
 	// There is no value in the buffer and we have a receiver available. Copy
@@ -264,7 +264,7 @@ func chanSend(ch *channel, value unsafe.Pointer, op *channelOp) {
 	// closed while sending).
 	if t.DataUint32() == chanOperationClosed {
 		// Oops, this channel was closed while sending!
-		runtimePanic("send on closed channel")
+		runtimePanicAt(returnAddress(0), &errSendOnClosedChannel)
 	}
 }
 
@@ -345,7 +345,7 @@ func chanRecv(ch *channel, value unsafe.Pointer, op *channelOp) bool {
 func chanClose(ch *channel) {
 	if ch == nil {
 		// Not allowed by the language spec.
-		runtimePanic("close of nil channel")
+		runtimePanicAt(returnAddress(0), &errCloseOfNilChannel)
 	}
 
 	mask := interrupt.Disable()
@@ -355,7 +355,7 @@ func chanClose(ch *channel) {
 		// Not allowed by the language spec.
 		ch.lock.Unlock()
 		interrupt.Restore(mask)
-		runtimePanic("close of closed channel")
+		runtimePanicAt(returnAddress(0), &errCloseOfClosedChannel)
 	}
 
 	// Proceed all receiving operations that are blocked.

src/runtime/error.go

@@ -7,8 +7,33 @@ type Error interface {
 	RuntimeError()
 }
 
-// plainError is a runtime.Error implementation for plain string messages.
+// plainError backs preallocated runtime.Error values.
 type plainError string
 
-func (e plainError) Error() string { return string(e) }
-func (e plainError) RuntimeError() {}
+func (e *plainError) Error() string { return string(*e) }
+func (e *plainError) RuntimeError() {}
+
+var (
+	errRuntime                               = plainError("runtime error")
+	errDeferInInterrupt                      = plainError("defer in interrupt")
+	errNilPointerDereference                 = plainError("nil pointer dereference")
+	errAssignmentToEntryInNilMap             = plainError("assignment to entry in nil map")
+	errIndexOutOfRange                       = plainError("index out of range")
+	errSliceOutOfRange                       = plainError("slice out of range")
+	errSliceSmallerThanArray                 = plainError("slice smaller than array")
+	errUnsafeSliceStringLenOutOfRange        = plainError("unsafe.Slice/String: len out of range")
+	errNewChannelIsTooBig                    = plainError("new channel is too big")
+	errNegativeShift                         = plainError("negative shift")
+	errDivideByZero                          = plainError("divide by zero")
+	errTryingToDoBlockingOperationInExported = plainError("trying to do blocking operation in exported function")
+	errComparingUncomparableType             = plainError("comparing un-comparable type")
+	errTypeAssertFailed                      = plainError("type assert failed")
+	errSendOnClosedChannel                   = plainError("send on closed channel")
+	errCloseOfNilChannel                     = plainError("close of nil channel")
+	errCloseOfClosedChannel                  = plainError("close of closed channel")
+	errHeapAllocInInterrupt                  = plainError("heap alloc in interrupt")
+	errOutOfMemory                           = plainError("out of memory")
+	errSignal                                = plainError("signal")
+	errIntegerOverflow                       = plainError("integer overflow")
+	errUnsupportedSignalNumber               = plainError("unsupported signal number")
+)

src/runtime/gc_blocks.go

@@ -406,7 +406,7 @@ func alloc(size uintptr, layout unsafe.Pointer) unsafe.Pointer {
 	}
 
 	if interrupt.In() {
-		runtimePanicAt(returnAddress(0), "heap alloc in interrupt")
+		runtimePanicAt(returnAddress(0), &errHeapAllocInInterrupt)
 	}
 
 	// Round the size up to a multiple of blocks, adding space for the header.
@@ -415,7 +415,7 @@ func alloc(size uintptr, layout unsafe.Pointer) unsafe.Pointer {
 	size += bytesPerBlock - 1
 	if size < rawSize {
 		// The size overflowed.
-		runtimePanicAt(returnAddress(0), "out of memory")
+		runtimePanicAt(returnAddress(0), &errOutOfMemory)
 	}
 	neededBlocks := size / bytesPerBlock
 	size = neededBlocks * bytesPerBlock
@@ -464,7 +464,7 @@ func alloc(size uintptr, layout unsafe.Pointer) unsafe.Pointer {
 		// Unfortunately the heap could not be increased. This
 		// happens on baremetal systems for example (where all
 		// available RAM has already been dedicated to the heap).
-		runtimePanicAt(returnAddress(0), "out of memory")
+		runtimePanicAt(returnAddress(0), &errOutOfMemory)
 	}
 
 	// Set the block states.

src/runtime/hashmap.go

@@ -817,7 +817,7 @@ func hashmapInterfaceHash(itf interface{}, seed uintptr) uint32 {
 		}
 		return hash
 	default:
-		runtimePanic("comparing un-comparable type")
+		runtimePanicAt(returnAddress(0), &errComparingUncomparableType)
 		return 0 // unreachable
 	}
 }

src/runtime/interface.go

@@ -77,7 +77,7 @@ func reflectValueEqual(x, y reflectlite.Value) bool {
 	case reflectlite.Interface:
 		return reflectValueEqual(x.Elem(), y.Elem())
 	default:
-		runtimePanic("comparing un-comparable type")
+		runtimePanicAt(returnAddress(0), &errComparingUncomparableType)
 		return false // unreachable
 	}
 }
@@ -86,7 +86,7 @@ func reflectValueEqual(x, y reflectlite.Value) bool {
 // returns false.
 func interfaceTypeAssert(ok bool) {
 	if !ok {
-		runtimePanic("type assert failed")
+		runtimePanicAt(returnAddress(0), &errTypeAssertFailed)
 	}
 }
 

src/runtime/panic.go

@@ -84,12 +84,16 @@ func panicOrGoexit(message interface{}, panicking panicState) {
 
 // Cause a runtime panic, which is (currently) always a string.
 func runtimePanic(msg string) {
-	// As long as this function is inined, llvm.returnaddress(0) will return
+	// As long as this function is inlined, llvm.returnaddress(0) will return
 	// something sensible.
-	runtimePanicAt(returnAddress(0), msg)
+	runtimePanicAtMsg(returnAddress(0), &errRuntime, msg)
 }
 
-func runtimePanicAt(addr unsafe.Pointer, msg string) {
+func runtimePanicAt(addr unsafe.Pointer, err *plainError) {
+	runtimePanicAtMsg(addr, err, err.Error())
+}
+
+func runtimePanicAtMsg(addr unsafe.Pointer, err *plainError, msg string) {
 	if panicStrategy() == tinygo.PanicStrategyTrap {
 		trap()
 	}
@@ -98,7 +102,7 @@ func runtimePanicAt(addr unsafe.Pointer, msg string) {
 		if frame != nil {
 			// Use the normal panic mechanism so that this runtime error
 			// can be recovered with recover().
-			frame.PanicValue = plainError(msg)
+			frame.PanicValue = err
 			frame.Panicking = panicTrue
 			tinygo_longjmp(frame)
 			// unreachable
@@ -131,7 +135,7 @@ func setupDeferFrame(frame *deferFrame, jumpSP unsafe.Pointer) {
 		// Defer is not currently allowed in interrupts.
 		// We could add support for this, but since defer might also allocate
 		// (especially in loops) it might not be a good idea anyway.
-		runtimePanicAt(returnAddress(0), "defer in interrupt")
+		runtimePanicAt(returnAddress(0), &errDeferInInterrupt)
 	}
 	currentTask := task.Current()
 	frame.Previous = (*deferFrame)(currentTask.DeferFrame)
@@ -201,54 +205,54 @@ func _recover(useParentFrame bool) interface{} {
 
 // Panic when trying to dereference a nil pointer.
 func nilPanic() {
-	runtimePanicAt(returnAddress(0), "nil pointer dereference")
+	runtimePanicAt(returnAddress(0), &errNilPointerDereference)
 }
 
 // Panic when trying to add an entry to a nil map
 func nilMapPanic() {
-	runtimePanicAt(returnAddress(0), "assignment to entry in nil map")
+	runtimePanicAt(returnAddress(0), &errAssignmentToEntryInNilMap)
 }
 
 // Panic when trying to access an array or slice out of bounds.
 func lookupPanic() {
-	runtimePanicAt(returnAddress(0), "index out of range")
+	runtimePanicAt(returnAddress(0), &errIndexOutOfRange)
 }
 
 // Panic when trying to slice a slice out of bounds.
 func slicePanic() {
-	runtimePanicAt(returnAddress(0), "slice out of range")
+	runtimePanicAt(returnAddress(0), &errSliceOutOfRange)
 }
 
 // Panic when trying to convert a slice to an array pointer (Go 1.17+) and the
 // slice is shorter than the array.
 func sliceToArrayPointerPanic() {
-	runtimePanicAt(returnAddress(0), "slice smaller than array")
+	runtimePanicAt(returnAddress(0), &errSliceSmallerThanArray)
 }
 
 // Panic when calling unsafe.Slice() (Go 1.17+) or unsafe.String() (Go 1.20+)
 // with a len that's too large (which includes if the ptr is nil and len is
 // nonzero).
 func unsafeSlicePanic() {
-	runtimePanicAt(returnAddress(0), "unsafe.Slice/String: len out of range")
+	runtimePanicAt(returnAddress(0), &errUnsafeSliceStringLenOutOfRange)
 }
 
 // Panic when trying to create a new channel that is too big.
 func chanMakePanic() {
-	runtimePanicAt(returnAddress(0), "new channel is too big")
+	runtimePanicAt(returnAddress(0), &errNewChannelIsTooBig)
 }
 
 // Panic when a shift value is negative.
 func negativeShiftPanic() {
-	runtimePanicAt(returnAddress(0), "negative shift")
+	runtimePanicAt(returnAddress(0), &errNegativeShift)
 }
 
 // Panic when there is a divide by zero.
 func divideByZeroPanic() {
-	runtimePanicAt(returnAddress(0), "divide by zero")
+	runtimePanicAt(returnAddress(0), &errDivideByZero)
 }
 
 func blockingPanic() {
-	runtimePanicAt(returnAddress(0), "trying to do blocking operation in exported function")
+	runtimePanicAt(returnAddress(0), &errTryingToDoBlockingOperationInExported)
 }
 
 //go:linkname fips_fatal crypto/internal/fips140.fatal

src/runtime/runtime_unix.go

@@ -151,11 +151,11 @@ func tinygo_sigpanic() {
 	sig := tinygo_caught_signal
 	switch sig {
 	case sig_SIGSEGV, sig_SIGBUS:
-		runtimePanic("nil pointer dereference")
+		runtimePanicAt(returnAddress(0), &errNilPointerDereference)
 	case sig_SIGFPE:
-		runtimePanic("divide by zero")
+		runtimePanicAt(returnAddress(0), &errDivideByZero)
 	default:
-		runtimePanic("signal")
+		runtimePanicAt(returnAddress(0), &errSignal)
 	}
 }
 
@@ -382,7 +382,7 @@ func signal_enable(s uint32) {
 	if s >= 32 {
 		// TODO: to support higher signal numbers, we need to turn
 		// receivedSignals into a uint32 array.
-		runtimePanicAt(returnAddress(0), "unsupported signal number")
+		runtimePanicAt(returnAddress(0), &errUnsupportedSignalNumber)
 	}
 
 	// This is intentonally a non-atomic store. This is safe, since hasSignals
@@ -399,7 +399,7 @@ func signal_ignore(s uint32) {
 	if s >= 32 {
 		// TODO: to support higher signal numbers, we need to turn
 		// receivedSignals into a uint32 array.
-		runtimePanicAt(returnAddress(0), "unsupported signal number")
+		runtimePanicAt(returnAddress(0), &errUnsupportedSignalNumber)
 	}
 	tinygo_signal_ignore(s)
 }
@@ -409,7 +409,7 @@ func signal_disable(s uint32) {
 	if s >= 32 {
 		// TODO: to support higher signal numbers, we need to turn
 		// receivedSignals into a uint32 array.
-		runtimePanicAt(returnAddress(0), "unsupported signal number")
+		runtimePanicAt(returnAddress(0), &errUnsupportedSignalNumber)
 	}
 	tinygo_signal_disable(s)
 }

src/runtime/runtime_windows.go

@@ -313,11 +313,11 @@ func tinygo_init_exception_handler()
 func tinygo_sigpanic_windows(exceptionCode int32) {
 	switch uint32(exceptionCode) {
 	case _EXCEPTION_ACCESS_VIOLATION, _EXCEPTION_IN_PAGE_ERROR:
-		runtimePanic("nil pointer dereference")
+		runtimePanicAt(returnAddress(0), &errNilPointerDereference)
 	case _EXCEPTION_INT_DIVIDE_BY_ZERO:
-		runtimePanic("divide by zero")
+		runtimePanicAt(returnAddress(0), &errDivideByZero)
 	case _EXCEPTION_INT_OVERFLOW:
-		runtimePanic("integer overflow")
+		runtimePanicAt(returnAddress(0), &errIntegerOverflow)
 	default:
 		runtimePanic("unknown exception")
 	}