Merge pull request gopherjs#1446 from Workiva/optimizeCallFrames1

[go1.21] Optimizing call frames

Author: grantnelson-wf

compiler/natives/src/runtime/runtime.go

@@ -130,33 +130,25 @@ var (
 	// PC=0 as "no caller available" (see e.g. log/slog.Record.PC), and packages
 	// using PCs, initialize a uintptr to zero and expect runtime.CallersFrames
 	// and runtime.FuncForPC to treat it as unknown.
-	knownPositions   = map[string]uintptr{}
+	knownPositions   = map[basicFrame]uintptr{}
 	positionCounters = []*Func{nil}
 )
 
-func registerPosition(funcName string, file string, line int, col int) uintptr {
-	key := file + ":" + itoa(line) + ":" + itoa(col)
-	if pc, found := knownPositions[key]; found {
+func registerPosition(frame basicFrame) uintptr {
+	if pc, found := knownPositions[frame]; found {
 		return pc
 	}
 	f := &Func{
-		name: funcName,
-		file: file,
-		line: line,
+		name: frame.FuncName,
+		file: frame.File,
+		line: frame.Line,
 	}
 	pc := uintptr(len(positionCounters))
 	positionCounters = append(positionCounters, f)
-	knownPositions[key] = pc
+	knownPositions[frame] = pc
 	return pc
 }
 
-// itoa converts an integer to a string.
-//
-// Can't use strconv.Itoa() in the `runtime` package due to a cyclic dependency.
-func itoa(i int) string {
-	return js.Global.Get("String").New(i).String()
-}
-
 // basicFrame contains stack trace information extracted from JS stack trace.
 type basicFrame struct {
 	FuncName string
@@ -166,9 +158,13 @@ type basicFrame struct {
 }
 
 func callstack(skip, limit int) []basicFrame {
-	skip = skip + 1 /*skip error message*/ + 1 /*skip callstack's own frame*/
-	lines := js.Global.Get("Error").New().Get("stack").Call("split", "\n").Call("slice", skip, skip+limit)
-	return parseCallstack(lines)
+	if limit <= 0 {
+		return []basicFrame{}
+	}
+
+	skip = skip + 2 // skip callstack's own frame and $callstack's frame
+	lines := js.Global.Call("$callstack", skip, limit)
+	return parseCallstack(lines, limit)
 }
 
 var (
@@ -187,80 +183,33 @@ var (
 	}
 )
 
-func parseCallstack(lines *js.Object) []basicFrame {
+func parseCallstack(lines *js.Object, limit int) []basicFrame {
+	// Parse all the frames skipping frames as needed.
 	frames := []basicFrame{}
 	l := lines.Length()
 	for i := 0; i < l; i++ {
-		frame := ParseCallFrame(lines.Index(i))
-		if hiddenFrames[frame.FuncName] {
+		frame := js.Global.Call("$parseCallFrame", lines.Index(i))
+		funcName := frame.Index(0).String()
+		if hiddenFrames[funcName] {
 			continue
 		}
-		if alias, ok := knownFrames[frame.FuncName]; ok {
-			frame.FuncName = alias
+		if alias, ok := knownFrames[funcName]; ok {
+			funcName = alias
 		}
-		frames = append(frames, frame)
-		if frame.FuncName == "runtime.goexit" {
+		frames = append(frames, basicFrame{
+			FuncName: funcName,
+			File:     frame.Index(1).String(),
+			Line:     frame.Index(2).Int(),
+			Col:      frame.Index(3).Int(),
+		})
+		if funcName == "runtime.goexit" {
 			break // We've reached the bottom of the goroutine stack.
 		}
-	}
-	return frames
-}
-
-// ParseCallFrame is exported for the sake of testing. See this discussion for context https://github.com/gopherjs/gopherjs/pull/1097/files/561e6381406f04ccb8e04ef4effedc5c7887b70f#r776063799
-//
-// TLDR; never use this function!
-func ParseCallFrame(info *js.Object) basicFrame {
-	// FireFox
-	if info.Call("indexOf", "@").Int() >= 0 {
-		split := js.Global.Get("RegExp").New("[@:]")
-		parts := info.Call("split", split)
-		return basicFrame{
-			File:     parts.Call("slice", 1, parts.Length()-2).Call("join", ":").String(),
-			Line:     parts.Index(parts.Length() - 2).Int(),
-			Col:      parts.Index(parts.Length() - 1).Int(),
-			FuncName: parts.Index(0).String(),
-		}
-	}
-
-	// Chrome / Node.js
-	openIdx := info.Call("lastIndexOf", "(").Int()
-	if openIdx == -1 {
-		parts := info.Call("split", ":")
-
-		return basicFrame{
-			File: parts.Call("slice", 0, parts.Length()-2).Call("join", ":").
-				Call("replace", js.Global.Get("RegExp").New(`^\s*at `), "").String(),
-			Line:     parts.Index(parts.Length() - 2).Int(),
-			Col:      parts.Index(parts.Length() - 1).Int(),
-			FuncName: "<none>",
+		if len(frames) >= limit {
+			break // We've reached the requested limit.
 		}
 	}
-
-	var file, funcName string
-	var line, col int
-
-	pos := info.Call("substring", openIdx+1, info.Call("indexOf", ")").Int())
-	parts := pos.Call("split", ":")
-
-	if pos.String() == "<anonymous>" {
-		file = "<anonymous>"
-	} else {
-		file = parts.Call("slice", 0, parts.Length()-2).Call("join", ":").String()
-		line = parts.Index(parts.Length() - 2).Int()
-		col = parts.Index(parts.Length() - 1).Int()
-	}
-	fn := info.Call("substring", info.Call("indexOf", "at ").Int()+3, info.Call("indexOf", " (").Int())
-	if idx := fn.Call("indexOf", "[as ").Int(); idx > 0 {
-		fn = fn.Call("substring", idx+4, fn.Call("indexOf", "]"))
-	}
-	funcName = fn.String()
-
-	return basicFrame{
-		File:     file,
-		Line:     line,
-		Col:      col,
-		FuncName: funcName,
-	}
+	return frames
 }
 
 func Caller(skip int) (pc uintptr, file string, line int, ok bool) {
@@ -269,8 +218,9 @@ func Caller(skip int) (pc uintptr, file string, line int, ok bool) {
 	if len(frames) != 1 {
 		return 0, "", 0, false
 	}
-	pc = registerPosition(frames[0].FuncName, frames[0].File, frames[0].Line, frames[0].Col)
-	return pc, frames[0].File, frames[0].Line, true
+	frame := frames[0]
+	pc = registerPosition(frame)
+	return pc, frame.File, frame.Line, true
 }
 
 // Callers fills the slice pc with the return program counters of function
@@ -293,7 +243,7 @@ func Caller(skip int) (pc uintptr, file string, line int, ok bool) {
 func Callers(skip int, pc []uintptr) int {
 	frames := callstack(skip, len(pc))
 	for i, frame := range frames {
-		pc[i] = registerPosition(frame.FuncName, frame.File, frame.Line, frame.Col)
+		pc[i] = registerPosition(frame)
 	}
 	return len(frames)
 }
@@ -308,7 +258,7 @@ func Callers(skip int, pc []uintptr) int {
 //     For those, FuncForPC returns nil and we emit a Frame with the original PC
 //     and empty symbol fields, like Go will.
 //   - GopherJS's internal frames such as $callDeferred and $goroutine were
-//     already filtered (or aliased) by parseCallstack at capture time, so anything
+//     already filtered (or aliased) by callstack at capture time, so anything
 //     reaching CallersFrames is either a real Go frame or a PC we can't resolve.
 func CallersFrames(callers []uintptr) *Frames {
 	result := Frames{}
@@ -472,7 +422,7 @@ func FuncForPC(pc uintptr) *Func {
 		//     created without a real caller (record.go's PC field)
 		//   - test/fixedbugs/issue29735.go deliberately walks past the
 		//     end of a function looking for the next. This will cause it to
-		//     not secceed at what it is trying to do but will allow the test to pass.
+		//     not succeed at what it is trying to do but will allow the test to pass.
 		//   - test/fixedbugs/issue58300.go and test/fixedbugs/issue58300b.go give
 		//     FuncForPC a function pointer from `reflect.ValueOf(fn).Pointer()`,
 		//     which is not produced by Caller/Callers and so isn't in our table.

compiler/prelude/prelude.js

@@ -89,6 +89,93 @@ if (($global.process !== undefined) && $global.require) {
 }
 var $println = console.log
 
+// $callstack captures a stack trace and returns a list of lines, typically
+// there will be "limit" numbers of lines returned.
+// skip=0 means "the direct caller of $callstack"; limit caps frames captured.
+var $callstack = (skip, limit) => {
+    const oldLimit = Error.stackTraceLimit;
+    var stack;
+    try {
+        Error.stackTraceLimit = skip+limit
+        stack = new Error().stack
+    } finally {
+		Error.stackTraceLimit = oldLimit;
+    }
+
+    // If `new Error().stack` doesn't exist like on older IE versions
+    // or something went wrong getting the stack, just return empty.
+    if (!stack) return [];
+    // Drop any tailing "\n" (and any trailing space before first "at " if there is one).
+    stack = stack.trim();
+    // V8 prepends an "Error" or "Error: msg" header line that isn't a frame.
+    // Firefox and Safari do not. Detect by checking for "@" or starts with "at ".
+    // This check could still be wrong if the Error message itself has an "@" in it,
+    // (e.g. `new Error("a@b")`), however since we are calling `new Error().stack`
+    // it should be fine.
+    const firstNl = stack.indexOf("\n");
+    const firstLine = firstNl >= 0 ? stack.substring(0, firstNl) : stack;
+    if (!firstLine.includes("@") && !firstLine.startsWith("at ")) {
+        skip++; // skip "Error" header line.
+    }
+    
+	// Remove the skipped amount of the stack and the error header if there was one.
+	return stack.split("\n").slice(skip);
+}
+
+// $parseCallFrame parses a call frame string and
+// returns the tuple [funcName, file, line, col].
+var $parseCallFrame = (frame) => {
+    // The first time this is called, compile the regexp,
+    // then reuse it for all following calls.
+    const posRe = /^(.+?)(?::(\d+)(?::(\d+))?)?$/;
+    const parsePos = (fnName, framePos) => {
+        const m = posRe.exec(framePos);
+        if (m) {
+            const file = m[1] || "";
+            const line = m[2] || 0; // Will be read with a js.Object:Int
+            const col  = m[3] || 0; // Will be read with a js.Object:Int
+            return [fnName, file, line, col];
+        }
+        return [fnName, "", 0, 0];
+    }
+    $parseCallFrame = (frame) => {
+        // FireFox
+        const atIdx = frame.indexOf("@")
+        if (atIdx >= 0) {
+            const fnName = frame.substring(0, atIdx) || "<none>";
+            return parsePos(fnName, frame.substring(atIdx + 1));
+        }
+
+	    // Chrome / Node.js
+        const atLeadIdx = frame.indexOf("at ");
+        if (atLeadIdx >= 0) frame = frame.substring(atLeadIdx + 3);
+        const openIdx = frame.lastIndexOf("(");
+        if (openIdx === -1) {
+            // No-parens form: "at file:line:col"
+            return parsePos("<none>", frame);
+        }
+
+        // With-parens form: "at func (file:line:col)"
+        var fnName = frame.substring(0, frame.indexOf("(")).trim();
+        const asIdx = fnName.indexOf("[as ");
+        if (asIdx > 0) {
+            var closeIdx = fnName.indexOf("]");
+            if (closeIdx === -1) closeIdx = fnName.length;
+            fnName = fnName.substring(asIdx+4, closeIdx).trim();
+        }
+
+        var closeIdx = frame.indexOf(")", openIdx);
+        if (closeIdx === -1) closeIdx = frame.length;
+
+        var pos = frame.substring(openIdx + 1, closeIdx);
+        if (pos === "<anonymous>") {
+            return [fnName, "<anonymous>", 0, 0]
+        }
+        return parsePos(fnName, pos);
+    };
+    return $parseCallFrame(frame);
+};
+
 var $callForAllPackages = (methodName) => {
     var names = $keys($packages);
     for (var i = 0; i < names.length; i++) {