2 files changed, 31 insertions, 2 deletions

diff --git a/tools/perf/util/thread-stack.c b/tools/perf/util/thread-stack.c
index 7f8eff018c16..f52c0f90915d 100644
--- a/tools/perf/util/thread-stack.c
+++ b/tools/perf/util/thread-stack.c
@@ -38,6 +38,7 @@
  * @cp: call path
  * @no_call: a 'call' was not seen
  * @trace_end: a 'call' but trace ended
+ * @non_call: a branch but not a 'call' to the start of a different symbol
  */
 struct thread_stack_entry {
         u64 ret_addr;
@@ -47,6 +48,7 @@ struct thread_stack_entry {
         struct call_path *cp;
         bool no_call;
         bool trace_end;
+        bool non_call;
 };
 
 /**
@@ -268,6 +270,8 @@ static int thread_stack__call_return(struct thread *thread,
                 cr.flags |= CALL_RETURN_NO_CALL;
         if (no_return)
                 cr.flags |= CALL_RETURN_NO_RETURN;
+        if (tse->non_call)
+                cr.flags |= CALL_RETURN_NON_CALL;
 
         return crp->process(&cr, crp->data);
 }
@@ -510,6 +514,7 @@ static int thread_stack__push_cp(struct thread_stack *ts, u64 ret_addr,
         tse->cp = cp;
         tse->no_call = no_call;
         tse->trace_end = trace_end;
+        tse->non_call = false;
 
         return 0;
 }
@@ -531,14 +536,16 @@ static int thread_stack__pop_cp(struct thread *thread, struct thread_stack *ts,
                                                          timestamp, ref, false);
         }
 
-        if (ts->stack[ts->cnt - 1].ret_addr == ret_addr) {
+        if (ts->stack[ts->cnt - 1].ret_addr == ret_addr &&
+            !ts->stack[ts->cnt - 1].non_call) {
                 return thread_stack__call_return(thread, ts, --ts->cnt,
                                                  timestamp, ref, false);
         } else {
                 size_t i = ts->cnt - 1;
 
                 while (i--) {
-                        if (ts->stack[i].ret_addr != ret_addr)
+                        if (ts->stack[i].ret_addr != ret_addr ||
+                            ts->stack[i].non_call)
                                 continue;
                         i += 1;
                         while (ts->cnt > i) {
@@ -757,6 +764,25 @@ int thread_stack__process(struct thread *thread, struct comm *comm,
                 err = thread_stack__trace_begin(thread, ts, sample->time, ref);
         } else if (sample->flags & PERF_IP_FLAG_TRACE_END) {
                 err = thread_stack__trace_end(ts, sample, ref);
+        } else if (sample->flags & PERF_IP_FLAG_BRANCH &&
+                   from_al->sym != to_al->sym && to_al->sym &&
+                   to_al->addr == to_al->sym->start) {
+                struct call_path_root *cpr = ts->crp->cpr;
+                struct call_path *cp;
+
+                /*
+                 * The compiler might optimize a call/ret combination by making
+                 * it a jmp. Make that visible by recording on the stack a
+                 * branch to the start of a different symbol. Note, that means
+                 * when a ret pops the stack, all jmps must be popped off first.
+                 */
+                cp = call_path__findnew(cpr, ts->stack[ts->cnt - 1].cp,
+                                        to_al->sym, sample->addr,
+                                        ts->kernel_start);
+                err = thread_stack__push_cp(ts, 0, sample->time, ref, cp, false,
+                                            false);
+                if (!err)
+                        ts->stack[ts->cnt - 1].non_call = true;
         }
 
         return err;
diff --git a/tools/perf/util/thread-stack.h b/tools/perf/util/thread-stack.h
index 1f626f4a1c40..b7c04e19ad41 100644
--- a/tools/perf/util/thread-stack.h
+++ b/tools/perf/util/thread-stack.h
@@ -35,10 +35,13 @@ struct call_path;
  *
  * CALL_RETURN_NO_CALL: 'return' but no matching 'call'
  * CALL_RETURN_NO_RETURN: 'call' but no matching 'return'
+ * CALL_RETURN_NON_CALL: a branch but not a 'call' to the start of a different
+ *                       symbol
  */
 enum {
         CALL_RETURN_NO_CALL     = 1 << 0,
         CALL_RETURN_NO_RETURN   = 1 << 1,
+        CALL_RETURN_NON_CALL    = 1 << 2,
 };
 
 /**