interp: say why a rollback happened (#5989)

When interp cannot evaluate an initializer at compile time it rolls back and runs it at runtime. The only record of why is the recoverable error printed by -internal-dumpssa, and most rollbacks share one sentinel, "unsupported instruction (to be emitted at runtime)". It covers a branch on a value only known at runtime, an instruction that cannot be emitted at runtime, a goroutine that would block, and a function with a defer, so the cause has to be reconstructed by reading the surrounding IR.

This change builds the error at the point of rollback, naming the cause, the instruction where relevant, and the function being interpreted, for example "interp: cannot emit instruction at runtime: icmp (in main.init$1)". Sentinels that are compared by identity are unchanged. The unused errMapAlreadyCreated is removed.

Each rollback now allocates its own error. BenchmarkRecoverableErrors shows one extra allocation per rollback (+0.73% allocs/op, +0.88% B/op) and no change in time.

Author: davecheney

interp/compiler.go

@@ -51,7 +51,11 @@ func (inst *instruction) String() string {
 	for i, op := range inst.operands {
 		operands[i] = op.String()
 	}
+	return inst.opcodeName() + " " + strings.Join(operands, " ")
+}
 
+// opcodeName returns the name of the instruction's opcode.
+func (inst *instruction) opcodeName() string {
 	name := ""
 	if inst.branch {
 		name = "br"
@@ -61,7 +65,7 @@ func (inst *instruction) String() string {
 	if name == "" {
 		name = "<unknown op>"
 	}
-	return name + " " + strings.Join(operands, " ")
+	return name
 }
 
 // compileFunction compiles a given LLVM function to an easier to interpret

interp/errors.go

@@ -13,22 +13,26 @@ import (
 
 type recoverableError struct {
 	msg string
+	op  string // instruction involved, if any
+	fn  string // function being interpreted, if known
 }
 
 func (e *recoverableError) Error() string {
-	return e.msg
+	s := e.msg
+	if e.op != "" {
+		s += ": " + e.op
+	}
+	if e.fn != "" {
+		s += " (in " + e.fn + ")"
+	}
+	return s
 }
 
 // These errors are expected during normal execution and can be recovered from
 // by running the affected function at runtime instead of compile time.
 var (
-	errIntegerAsPointer       = &recoverableError{msg: "interp: trying to use an integer as a pointer (memory-mapped I/O?)"}
-	errUnsupportedInst        = &recoverableError{msg: "interp: unsupported instruction"}
-	errUnsupportedRuntimeInst = &recoverableError{msg: "interp: unsupported instruction (to be emitted at runtime)"}
-	errDeferUnsupported       = &recoverableError{msg: "interp: cannot partially evaluate a function with defer"}
-	errMapAlreadyCreated      = &recoverableError{msg: "interp: map already created"}
-	errLoopUnrolled           = &recoverableError{msg: "interp: loop unrolled"}
-	errLoopTooLong            = &recoverableError{msg: "interp: loop ran too many iterations"}
+	errIntegerAsPointer = &recoverableError{msg: "interp: trying to use an integer as a pointer (memory-mapped I/O?)"}
+	errUnsupportedInst  = &recoverableError{msg: "interp: unsupported instruction"}
 
 	// This is one of the errors that can be returned from toLLVMValue when the
 	// passed type does not fit the data to serialize. It is recoverable by

interp/interp_test.go

@@ -234,3 +234,52 @@ func TestInterpPartialPointer(t *testing.T) {
 		t.Errorf("expected %v, got %v", errUnsupportedInst, err)
 	}
 }
+
+// TestInterpRollbackReason checks that the error that makes interp roll back
+// names its cause and the function being interpreted.
+func TestInterpRollbackReason(t *testing.T) {
+	t.Parallel()
+	path := filepath.Join(t.TempDir(), "rollback.ll")
+	ir := `target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64--linux"
+
+define i64 @fill(i64 %n) {
+entry:
+  br label %loop
+loop:
+  %i = phi i64 [ 0, %entry ], [ %next, %loop ]
+  %next = add i64 %i, 1
+  %done = icmp eq i64 %next, %n
+  br i1 %done, label %exit, label %loop
+exit:
+  ret i64 %next
+}
+`
+	if err := os.WriteFile(path, []byte(ir), 0o666); err != nil {
+		t.Fatal(err)
+	}
+	ctx := llvm.NewContext()
+	defer ctx.Dispose()
+	buf, err := llvm.NewMemoryBufferFromFile(path)
+	if err != nil {
+		t.Fatal(err)
+	}
+	mod, err := ctx.ParseIR(buf)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer mod.Dispose()
+
+	r := newRunner(mod, time.Minute, 10, false)
+	defer r.dispose()
+	_, _, runErr := r.run(r.getFunction(mod.NamedFunction("fill")), []value{literalValue{uint64(100)}}, nil, "")
+	if runErr == nil {
+		t.Fatal("expected the loop limit to stop interpretation")
+	}
+	if !isRecoverableError(runErr.Err) {
+		t.Errorf("expected a recoverable error, got %v", runErr.Err)
+	}
+	if want := "interp: loop ran too many iterations (in fill)"; runErr.Err.Error() != want {
+		t.Errorf("expected %q, got %q", want, runErr.Err.Error())
+	}
+}

interp/interpreter.go

@@ -57,7 +57,8 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 			}
 			blockCounts[currentBB]++
 			if r.maxLoopIterations > 0 && blockCounts[currentBB] > r.maxLoopIterations {
-				return nil, mem, r.errorAt(bb.instructions[0], errLoopTooLong)
+				err := &recoverableError{msg: "interp: loop ran too many iterations", fn: fn.name}
+				return nil, mem, r.errorAt(bb.instructions[0], err)
 			}
 
 			if len(mem.instructions) != startRTInsts {
@@ -66,7 +67,8 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 					// Avoid doing this, as it can result in a large amount of extra machine code.
 					// This currently uses the branch from the last block, as there is no available information to give a better location.
 					lastBBInsts := fn.blocks[lastBB].instructions
-					return nil, mem, r.errorAt(lastBBInsts[len(lastBBInsts)-1], errLoopUnrolled)
+					err := &recoverableError{msg: "interp: loop unrolled", fn: fn.name}
+					return nil, mem, r.errorAt(lastBBInsts[len(lastBBInsts)-1], err)
 				}
 
 				// Flag the last block as having run stuff at runtime.
@@ -221,7 +223,8 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 		switch inst.opcode {
 		case llvm.Ret:
 			if !fn.deferFrame.IsNil() && len(mem.instructions) != 0 {
-				return nil, mem, r.errorAt(inst, errDeferUnsupported)
+				err := &recoverableError{msg: "interp: cannot partially evaluate a function with defer", fn: fn.name}
+				return nil, mem, r.errorAt(inst, err)
 			}
 			if time.Since(r.start) > r.timeout {
 				// Running for more than the allowed timeout; This shouldn't happen, but it does.
@@ -368,7 +371,8 @@ func (r *runner) run(fn *function, params []value, parentMem *memoryView, indent
 				}
 			case callFn.name == "internal/task.Pause":
 				// Task scheduling isn't possible at compile time.
-				return nil, mem, r.errorAt(inst, errUnsupportedRuntimeInst)
+				err := &recoverableError{msg: "interp: goroutine would block", fn: fn.name}
+				return nil, mem, r.errorAt(inst, err)
 			case callFn.name == "runtime.fastrand" || callFn.name == "runtime.fastrand64":
 				// Use a local sequence instead of the global RNG state. The
 				// state is replaced by initRand before initAll runs anyway.
@@ -1177,7 +1181,8 @@ func intOperands(r *runner, lhs, rhs value) (int64, int64, error) {
 
 func (r *runner) runAtRuntime(fn *function, inst instruction, locals []value, mem *memoryView, indent string) *Error {
 	if !fn.deferFrame.IsNil() {
-		return r.errorAt(inst, errDeferUnsupported)
+		err := &recoverableError{msg: "interp: cannot partially evaluate a function with defer", op: inst.opcodeName(), fn: fn.name}
+		return r.errorAt(inst, err)
 	}
 	numOperands := inst.llvmInst.OperandsCount()
 	operands := make([]llvm.Value, numOperands)
@@ -1286,7 +1291,12 @@ func (r *runner) runAtRuntime(fn *function, inst instruction, locals []value, me
 	case llvm.ZExt:
 		result = r.builder.CreateZExt(operands[0], inst.llvmInst.Type(), inst.name)
 	default:
-		return r.errorAt(inst, errUnsupportedRuntimeInst)
+		if inst.branch || inst.opcode == llvm.Switch || inst.opcode == llvm.IndirectBr {
+			err := &recoverableError{msg: "interp: branch on a value not known at compile time", fn: fn.name}
+			return r.errorAt(inst, err)
+		}
+		err := &recoverableError{msg: "interp: cannot emit instruction at runtime", op: inst.opcodeName(), fn: fn.name}
+		return r.errorAt(inst, err)
 	}
 	locals[inst.localIndex] = localValue{result}
 	mem.instructions = append(mem.instructions, result)