runtime: avoid heap allocs for plain errors

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", 3699, 297, 0, 2252},
-		{"microbit", "examples/serial", 2736, 356, 8, 2248},
-		{"wioterminal", "examples/pininterrupt", 7960, 1652, 132, 7480},
+		{"hifive1b", "examples/echo", 3760, 352, 0, 2252},
+		{"microbit", "examples/serial", 2761, 395, 8, 2248},
+		{"wioterminal", "examples/pininterrupt", 7990, 1710, 132, 7480},
 
 		// TODO: also check wasm. Right now this is difficult, because
 		// wasm binaries are run through wasm-opt and therefore the

compiler/compiler.go

@@ -2032,6 +2032,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

@@ -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/panic.go

@@ -84,12 +84,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()
 	}
@@ -98,7 +106,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
 			tinygo_longjmp(frame)
 			// unreachable