From d016330241c526f09b5ec70cdf17bfd0c257006b Mon Sep 17 00:00:00 2001 From: Alessandro Arzilli Date: Tue, 5 Feb 2019 08:49:49 +0100 Subject: [PATCH] runtime: whitelist debugCall32..debugCall65536 in debugCallCheck Whitelists functions debugCall32 through debugCall65536 in runtime.debugCallCheck so that any instruction inside those functions is considered a safe point. This is useful for implementing nested function calls. For example when evaluating: f(g(x)) The debugger should: 1. initiate the call to 'f' until the entry point of 'f', 2. complete the call to 'g(x)' 3. copy the return value of 'g(x)' in the arguments of 'f' 4. complete the call to 'f' Similarly for: f().amethod() The debugger should initiate the call to '.amethod()', then initiate and complete the call to f(), copy the return value to the arguments of '.amethod()' and finish its call. However in this example, unlike the other example, it may be impossible to determine the entry point of '.amethod()' until after 'f()' is evaluated, which means that the call to 'f()' needs to be initiated while stopped inside a debugCall... function. Change-Id: I575c23542709cedb1a171d63576f7e11069c7674 Reviewed-on: https://go-review.googlesource.com/c/go/+/161137 TryBot-Result: Gobot Gobot Reviewed-by: Heschi Kreinick --- src/runtime/asm_amd64.s | 2 ++ src/runtime/debugcall.go | 22 +++++++++++++++++++++- 2 files changed, 23 insertions(+), 1 deletion(-) diff --git a/src/runtime/asm_amd64.s b/src/runtime/asm_amd64.s index e5b987858d..1cca0c794b 100644 --- a/src/runtime/asm_amd64.s +++ b/src/runtime/asm_amd64.s @@ -1612,6 +1612,8 @@ restore: RET +// runtime.debugCallCheck assumes that functions defined with the +// DEBUG_CALL_FN macro are safe points to inject calls. #define DEBUG_CALL_FN(NAME,MAXSIZE) \ TEXT NAME(SB),WRAPPER,$MAXSIZE-0; \ NO_LOCAL_POINTERS; \ diff --git a/src/runtime/debugcall.go b/src/runtime/debugcall.go index d26e3c26b9..f03d2358eb 100644 --- a/src/runtime/debugcall.go +++ b/src/runtime/debugcall.go @@ -46,12 +46,32 @@ func debugCallCheck(pc uintptr) string { return } + name := funcname(f) + + switch name { + case "debugCall32", + "debugCall64", + "debugCall128", + "debugCall256", + "debugCall512", + "debugCall1024", + "debugCall2048", + "debugCall4096", + "debugCall8192", + "debugCall16384", + "debugCall32768", + "debugCall65536": + // These functions are whitelisted so that the debugger can initiate multiple function calls. + // See: https://golang.org/cl/161137/ + return + } + // Disallow calls from the runtime. We could // potentially make this condition tighter (e.g., not // when locks are held), but there are enough tightly // coded sequences (e.g., defer handling) that it's // better to play it safe. - if name, pfx := funcname(f), "runtime."; len(name) > len(pfx) && name[:len(pfx)] == pfx { + if pfx := "runtime."; len(name) > len(pfx) && name[:len(pfx)] == pfx { ret = debugCallRuntime return } -- 2.50.0