compiler: avoid runtime panic string heap allocs

Lower constant-string calls to runtime.runtimePanic and
runtime.runtimePanicAt so they pass a runtime.plainError interface value
to runtimePanicAtMsg. This uses static interface backing storage for
recoverable runtime panics instead of allocating a string header at run
time.

Keep dynamic runtimePanic(msg) as the exact fallback. It constructs the
runtime.Error value only when a recover frame is present, so trap/abort
paths do not eagerly box the string.

Author: jakebailey

builder/sizes_test.go

@@ -42,9 +42,9 @@ func TestBinarySize(t *testing.T) {
 	// This is a small number of very diverse targets that we want to test.
 	tests := []sizeTest{
 		// microcontrollers
-		{"hifive1b", "examples/echo", 4277, 307, 0, 2260},
-		{"microbit", "examples/serial", 2836, 368, 8, 2256},
-		{"wioterminal", "examples/pininterrupt", 8013, 1663, 132, 7488},
+		{"hifive1b", "examples/echo", 4349, 371, 0, 2260},
+		{"microbit", "examples/serial", 2858, 414, 8, 2256},
+		{"wioterminal", "examples/pininterrupt", 8045, 1727, 132, 7488},
 
 		// TODO: also check wasm. Right now this is difficult, because
 		// wasm binaries are run through wasm-opt and therefore the

compiler/compiler.go

@@ -2034,6 +2034,22 @@ func (b *builder) createFunctionCall(instr *ssa.CallCommon) (llvm.Value, error)
 	for _, param := range instr.Args {
 		params = append(params, b.getValue(param, getPos(instr)))
 	}
+	if fn := instr.StaticCallee(); fn != nil {
+		switch b.getFunctionInfo(fn).linkName {
+		case "runtime.runtimePanic":
+			if len(params) == 1 && params[0].IsConstant() {
+				errType := b.program.ImportedPackage("runtime").Members["plainError"].(*ssa.Type).Type()
+				err := b.createMakeInterface(params[0], errType, instr.Pos())
+				return b.createRuntimeCall("runtimePanicValue", []llvm.Value{err, params[0]}, ""), nil
+			}
+		case "runtime.runtimePanicAt":
+			if len(params) == 2 && params[1].IsConstant() {
+				errType := b.program.ImportedPackage("runtime").Members["plainError"].(*ssa.Type).Type()
+				err := b.createMakeInterface(params[1], errType, instr.Pos())
+				return b.createRuntimeCall("runtimePanicAtMsg", []llvm.Value{params[0], err, params[1]}, ""), nil
+			}
+		}
+	}
 
 	// Try to call the function directly for trivially static calls.
 	var callee, context llvm.Value

main_test.go

@@ -140,6 +140,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/panic.go

@@ -86,12 +86,20 @@ 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)
 }
 
 func runtimePanicAt(addr unsafe.Pointer, msg string) {
+	runtimePanicAtMsg(addr, nil, msg)
+}
+
+func runtimePanicValue(err interface{}, msg string) {
+	runtimePanicAtMsg(returnAddress(0), err, msg)
+}
+
+func runtimePanicAtMsg(addr unsafe.Pointer, err interface{}, msg string) {
 	if panicStrategy() == tinygo.PanicStrategyTrap {
 		trap()
 	}
@@ -100,7 +108,10 @@ 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)
+			if err == nil {
+				err = plainError(msg)
+			}
+			frame.PanicValue = err
 			frame.Panicking = panicTrue | (frame.Panicking & panicGoexit)
 			tinygo_longjmp(frame)
 			// unreachable