Patchwork btrace: check for indirect jump return in _Unwind_RaiseException

login
register
mail settings
Submitter Metzger, Markus T
Date Sept. 27, 2018, 7:42 a.m.
Message ID <1538034149-12136-1-git-send-email-markus.t.metzger@intel.com>
Download mbox | patch
Permalink /patch/29559/
State New
Headers show

Comments

Metzger, Markus T - Sept. 27, 2018, 7:42 a.m.
Some versions of _Unwind_RaiseException, e.g. on Fedora 28, use an
indirect jump to return to the exception handler.

This messes up the output of "record function-call-history /c" since the
return is interpreted as cross-function goto.  It had been detected by
gdb.btrace/exception.exp.

Add a heuristic for "_Unwind_*" functions to interpret an indirect jump
that ends in one of our caller functions as return to the first instance
of that function in our call stack.

Signed-off-by: Markus Metzger  <markus.t.metzger@intel.com>

gdb/
	* btrace.c (ftrace_update_function): Add indirect jump heuristic.
---
 gdb/btrace.c | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

Patch

diff --git a/gdb/btrace.c b/gdb/btrace.c
index e25f047ce24..d3ad0ab7de8 100644
--- a/gdb/btrace.c
+++ b/gdb/btrace.c
@@ -620,6 +620,20 @@  ftrace_update_function (struct btrace_thread_info *btinfo, CORE_ADDR pc)
 	    if (start == pc)
 	      return ftrace_new_tailcall (btinfo, mfun, fun);
 
+	    /* Some versions of _Unwind_RaiseException use an indirect
+	       jump to 'return' to the exception handler of the caller
+	       handling the exception instead of a return.  Let's restrict
+	       this heuristic to that and related functions.  */
+	    const char *fname = ftrace_print_function_name (bfun);
+	    if (strncmp (fname, "_Unwind_", strlen ("_Unwind_")) == 0)
+	      {
+		struct btrace_function *caller
+		  = ftrace_find_call_by_number (btinfo, bfun->up);
+		caller = ftrace_find_caller (btinfo, caller, mfun, fun);
+		if (caller != NULL)
+		  return ftrace_new_return (btinfo, mfun, fun);
+	      }
+
 	    /* If we can't determine the function for PC, we treat a jump at
 	       the end of the block as tail call if we're switching functions
 	       and as an intra-function branch if we don't.  */