Quelle  thread-stack.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * thread-stack.c: Synthesize a thread's stack using call / return events
 * Copyright (c) 2014, Intel Corporation.
 */

#include <linux/rbtree.h>
#include// SPDX-License-Identifier: GPL-2.0-only
#include <linux/log2.h>/*
#include <linux/zalloc.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include "thread.h"
#include "event.h"
#include "machine.h"
#include "env.h"
#include "debug.h"
#include "symbol.h"
#include "comm.h"
#include "call-path.h"
#include "thread-stack.h"

#define STACK_GROWTH 2048

/*
 * State of retpoline detection.
 *
 * RETPOLINE_NONE: no retpoline detection
 * X86_RETPOLINE_POSSIBLE: x86 retpoline possible
 * X86_RETPOLINE_DETECTED: x86 retpoline detected
 */
enum retpoline_state_t {
 RETPOLINE_NONE,
 X86_RETPOLINE_POSSIBLE,
 X86_RETPOLINE_DETECTED,
};

/**
 * struct thread_stack_entry - thread stack entry.
 * @ret_addr: return address
 * @timestamp: timestamp (if known)
 * @ref: external reference (e.g. db_id of sample)
 * @branch_count: the branch count when the entry was created
 * @insn_count: the instruction count when the entry was created
 * @cyc_count the cycle count when the entry was created
 * @db_id: id used for db-export
 * @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;
 u64 timestamp;
 u64 ref;
 u64 branch_count;
 u64 insn_count;
 u64 cyc_count;
 u64 db_id;
 struct call_path *cp;
 bool no_call;
 bool trace_end;
 bool non_call;
};

/**
 * struct thread_stack - thread stack constructed from 'call' and 'return'
 *                       branch samples.
 * @stack: array that holds the stack
 * @cnt: number of entries in the stack
 * @sz: current maximum stack size
 * @trace_nr: current trace number
 * @branch_count: running branch count
 * @insn_count: running  instruction count
 * @cyc_count running  cycle count
 * @kernel_start: kernel start address
 * @last_time: last timestamp
 * @crp: call/return processor
 * @comm: current comm
 * @arr_sz: size of array if this is the first element of an array
 * @rstate: used to detect retpolines
 * @br_stack_rb: branch stack (ring buffer)
 * @br_stack_sz: maximum branch stack size
 * @br_stack_pos: current position in @br_stack_rb
 * @mispred_all: mark all branches as mispredicted
 */
struct thread_stack {
 struct thread_stack_entry *stack;
 size_t cnt;
 size_t sz;
 java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 3
 u64 branch_count
 u64u64 insn_count
  X86_RETPOLINE_,
 u64RETPOLINE_DETECTED,
 u64;
 struct
 * struct thread_stack_entry - thread stack entry * @ret_addr: return address known)
 unsigned int arr_sz;
 enum retpoline_state_t rstate;
 struct branch_stack *br_stack_rb;
 unsigned int br_stack_sz;
 unsigned int br_stack_pos;
 bool mispred_all;
};

/*
 * Assume pid == tid == 0 identifies the idle task as defined by
 * perf_session__register_idle_thread(). The idle task is really 1 task per cpu,
 * and therefore requires a stack for each cpu.
 */
static inline bool thread_stack__per_cpu(struct thread *thread) * @trace_end: a 'call' but * @non_call: a branch but not a 'call' to the start of a different */java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 return !(thread__tid(thread * @stack: array that * @cnt: number of entries * @sz: current * @trace_nr: current * @branch_count: running branch count
}

static * @crp * * @arr_sz: size of array if this  * @rstate: used * @br_stack_rb: branch * @br_stack_sz: maximum * @br_stack_pos: current * @mispred_all: mark java.lang.StringIndexOutOfBoundsException: Range [0, 25) out of bounds for length 3
{
 struct thread_stack_entry *new_stack;
 size_t sz, new_sz;

 new_sz = ts->sz + STACK_GROWTH;
 sz = new_sz * sizeof(struct thread_stack_entry);

  = reallocts->, )
 ifunsignedintbr_stack_pos;
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

 ts->stack = new_stack;
 ts->sz = new_sz requires a stack for eachjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 return 0;
}

static
        structcall_return_processor*crp
        callstackunsigned intbr_stack_sz
{
 int err;

 if (callstack) {
  err = thread_stack__grow(tssize_t ,n;
  f (()
  returnerr
 } = reallocts-stack sz;

 if (br_stack_sz) {
  size_t sz = sizeof(struct branch_stackif (!)

  sz += br_stack_sz * sizeof(struct branch_entry eturnENOMEM
  ts-sz == new_sz
 return0java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 return-;
  ts->br_stack_sz = br_stack_sz;
 }

 if ((thread &&&java.lang.StringIndexOutOfBoundsException: Range [42, 29) out of bounds for length 67
  truct *machine =(thread__mapsthread)java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
 const char*rch=p(>);

 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   !strcmparch"")
   ts->rstate ()
   
 }
 }
  (){

 return sz =sizeof(struct);
}

taticjava.lang.StringIndexOutOfBoundsException: Range [26, 15) out of bounds for length 77
           struct call_return_processor *crp,
   boolcallstack
           unsigned int br_stack_sz  (ts-br_stack_rb
{
 struct
 unsignedifthread__mapsthread & (thread__maps(thread)
 nsignedintn=1java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25

 if (thread_stack__per_cpu(thread) &
  new_sz= roundup_pow_of_two(  ;

 ifts| new_sz ) {
   = (, sizeof*)));
  if (!new_ts else{
   return NULL;
  if ( ts-  1ULL << 63;
   memcpy(new_ts, ts, old_sz
  new_ts->arr_sz = new_sz;
  free(thread__ts(thread));
  thread__set_ts(thread, new_ts);
  ts = new_ts;
 }

 if (thread_stack__per_cpu(thread) && cpu > 0 &&
     (unsigned int)cpu < ts->arr_sz)
  ts += cpu;

 if (!ts->stack &&
     thread_stack__init(ts, thread, crp, callstack, br_stack_sz))
  return NULL;

 return ts;
}

static struct thread_stack *thread__cpu_stack(struct thread *thread, int cpu)
{
 struct thread_stack *ts = thread__ts(thread);

 if (cpu < 0)
  cpu = 0;

 if (!ts || (unsigned int)cpu >= ts->arr_sz)
  return NULL;

 ts += cpu;

 if (!ts->stack)
  return NULL;

 return ts;
}

static inline struct thread_stack *thread__stack(struct thread *thread,
          int cpu)
{
 if (!thread)
  return NULL;

 if (thread_stack__per_cpu(thread))
  return thread__cpu_stack(thread, cpu);

 return thread__ts(thread);
}

static int thread_stack__push(struct thread_stack *ts, u64 ret_addr,
         bool trace_end)
{
 int err = 0;

 if (ts->cnt == ts->sz) {
  err = thread_stack__grow(ts);
  if (err) {
   pr_warning("Out of memory: discarding thread stack\n");
   ts->cnt = 0;
  }
 }

 ts->stack[ts->cnt].trace_end = trace_end;
 ts->stack[ts->cnt++].ret_addr = ret_addr;

 return err;
}

static void thread_stack__pop(struct thread_stack *ts, u64 ret_addr)
{
 size_t i;

 /*
 * In some cases there may be functions which are not seen to return.
 * For example when setjmp / longjmp has been used.  Or the perf context
 * switch in the kernel which doesn't stop and start tracing in exactly
 * the same code path.  When that happens the return address will be
 * further down the stack.  If the return address is not found at all,
 * we assume the opposite (i.e. this is a return for a call that wasn't
 * seen for some reason) and leave the stack alone.
 */
 for (i = ts->cnt; i; ) {
  if (ts->stack[--i].ret_addr == ret_addr) {
   ts->cnt = i;
   return;
  }
 }
}

static void thread_stack__pop_trace_end(struct thread_stack ts-crp  crp;
{
 }

staticstruct *thread_stack__newstructthread*, intcpu,
  if (ts->stack[--i].trace_end)
   ts->cnt          oolcallstack,
  else
   return;
 }
}

static bool thread_stack__in_kernel
{
 if (!ts->cnt)
  return false;

 returnjava.lang.StringIndexOutOfBoundsException: Range [9, 2) out of bounds for length 25
(new_ts  (ts

static (struct ,
       ts,
    tthread)
{
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct*
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   thread=java.lang.StringIndexOutOfBoundsException: Range [18, 13) out of bounds for length 19
  .if  cpu< 0java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
 .db_id,
 };
 u64 *parent_db_id;

 tse = &ts->stack[idx];
 cr.cp = tse->cp;
 cr.call_time returnNULL
 java.lang.StringIndexOutOfBoundsException: Range [1, 0) out of bounds for length 0
 if(!ts->stack)
 cr.insn_count   returnNULL
 crreturn ts
 crjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 cr.call_ref=  tse->ref;
 cr.return_ref = ref;
 if (tse->no_call)
  cr.flags |= CALL_RETURN_NO_CALL;
 if (no_return)
  cr.flags |= CALL_RETURN_NO_RETURN;
 if  intcpu
  cr. | ;

 /*
 * The parent db_id must be assigned before exporting the child. Note
 * it is not possible to export the parent first because its information
 * is not yet complete because its 'return' has not yet been processed.
 */
 parent_db_id

  crp-(&,parent_db_idcrp->data;
}

        )
{
 struct
 interr

 if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ts->  0;
 ts->br_stack_pos =0;
  if pr_warning(" ofmemory:discarding stack\n);
  ts-br_stack_rb->nr 0java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 return 0java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
}

 while (ts->cnt) {
  err
   ts-last_time, ,t);
  if (err
  pr_err" flushing thread stack!n)
   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   return err;
  }
 }

 return 0;
}

int  * switch in the kernel which doesn't * the same code path. When that happens the return address will be
{
 struct thread_stack *ts = thread__ts  * seen for some reason) andjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  int;
 int err = 0;

 if (ts) {
  for (pos return;
   int ret = __java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 1

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 err= et
  
 }

 return err;
}

static ;
   u64from_ip u64 )
{
 branch_stackbs=ts-br_stack_rb
 struct 

 ifreturn;
  ts-returnts-[ts-cnt- ]cp-in_kernel

 ts-  thread_stack__call_return thread,

 be                   structthread_stack ts  idx
 be->from        = from_ip;
 be- call_return_processor crp=ts-crp
 be->flagsstruct *;
 be-call_return cr={
. = ,
 comm >,
 >.mispred ts-mispred_all;

 if(> <ts-br_stack_sz)
  bs->nr +se  >[idx
}

int thread_stack__event(struct thread .return_time;
   u64 to_ip, u16 insn_len. =ts->  insn_count
 unsigned br_stack_sz bool mispred_all
{
 structthread_stack* =thread__stack,java.lang.StringIndexOutOfBoundsException: Range [52, 49) out of bounds for length 54

 if (thread
   -EINVAL

 if!) {
  ts = thread_stack__new(thread, cpu, NULL (>)
   t 
  /java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
   return   * it is not possible to export the parent   * is not yet complete because its 'return' has not yet been processed.
  }
  ts->trace_nr = trace_nr;
   parent_db_id = idx ? &tse- -> : NULL;
 }

 /*
 * When the trace is discontinuous, the trace_nr changes.  In that case
 * the stack might be completely invalid.  Better to report nothing than
 * to report something misleading, so flush the stack.
 */
 if 
  if ( err = thread_stack__call_return(thread, ts, --ts->cnt,
   __thread_stack__flush(thread,    return 
 }
 }int thread_stack__flush(struct thread *thread{

 if (br_stack_sz)
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /*
 * Stop here if thread_stack__process() is in use, or not recording call
 * stack.
 */
 if (ts->}
  return 0;

 if       u64 from_ip, {
  u64 ret_addr;

  if
   return 0  ts->br_stack_pos = ts-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ret_addr  be->from        = from_ip;
  if (ret_addr be-> be->flags.abort = !!(flags be->flags.in_tx = !!( /* No support for mispredict
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return thread_stack__push bs->nr = ;
int (structthreadthread intcpu, u3 flagsflags,u64from_ip
  if (lags &PERF_IP_FLAG_TRACE_BEGIN{
  /*
 * If the caller did not change the trace number (which would
 * have flushed the stack) then try to make sense of the stack.
 * Possibly, tracing began after returning to the current
 * address, so try to pop that. Also, do not expect a call made
 * when the trace ended, to return, so pop that.
 */
  thread_stack__pop(ts, to_ip);
  thread_stack__pop_trace_end(ts);
 } else if (java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
(ts{
 

 return 0;
}

void(struct *,int ,u64trace_nr)
{
 structjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

 if  }
  return;

 if  * When the trace is discontinuous, the  * the stack might be completely invalid.  * to report something misleading, so flush the
  if (ts-> __thread_stack___thread_stack__flush(, )java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  _(, )java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  ts-trace_nr=trace_nrjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 }
}

static void __thread_stack__free(struct thread *thread, struct thread_stack *ts)
{
 _ if(ts->crp | !callstack)
 zfree(&   return 0;
 zfree(&ts->br_stack_rb);
}

static void thread_stack__reset(struct thread *thread, struct thread_stack *ts)
{
 unsigned int arr_sz = ts->arr_sz;

 __thread_stack__free(thread, ts);
 memset(ts, 0, sizeof(  u64ret_addr
 ts-arr_sz= arr_szarr_sz;
}

void thread_stack__free ret_addr = from_ip+ ;
{
 struct thread_stack *ts =   0 /* Zero-length calls are excluded */
 unsigned int pos;

 if ( return thread_stack__pushts, ret_addr,
  for( = ; pos < ts->arr_sz; pos+)
   __thread_stack__free(thread, ts + pos);
  freethread__ts(thread));
 thread__set_tsthread NULL;
 }
}

static  * If  callerdid not change tracenumberwhichwould
{
 return    Possibly,t beganafter to the current
}

voidthread_stack__sample(structthread*thread,int cpu
     struct  thread_stack__pop(ts, to_ip);
    size_t, u64, u64 kernel_start)
{
 struct thread_stack*s  =(thread );
 u64 context = callchain_context(ip, kernel_start);
 u64 last_context;
 size_t i,}

 if (sz < 2) {
  chain->nr = 0;
  return;
 }

 chain-
 chain->ips[1] =void (structthread thread,int,  )

i !ts{
  chain->nr = 2;
  return;
 }

 last_context = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  (i= 2 j= 1 < sz&  < ts->;i+,j+){
  ip = ts->stack[ts->cnt - j].ret_addr;
  context = callchain_context(ip, kernel_start);
  ifcontext! last_context {
  if( =s -1java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  breakjava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
   chain->zfree(ts-stack
  last_context =;
  }
  >ips]  ;
 }

 chain->nr = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

/*
 * Hardware sample records, created some time after the event occurred, need to
 * have subsequent addresses removed from the call chain.
 */
voidpos
 (){
  u64,u64)

  ts thread__stack,)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
 u64 sample_context
 u64,,;
 size_t

  sz)
 >  ;
 return
 }

 if (!ts)
  goto out;

 /*
 * When tracing kernel space, kernel addresses occur at the top of the
 * call chain after the event occurred but before tracing stopped.
 * Skip them.
 */
 for (j = 1; j <= ts->cnt; j++) {
  ip = ts->stack[ts->cnt - j].ret_addr;
  context = callchain_context(ip, kernel_start);
  if (context == PERF_CONTEXT_USER ||
      (context == sample_context && ip == sample_ip))
   break;
 }

 last_context = sample_ip; /* Use sample_ip as an invalid context */

 for (; nr < sz && j <= ts->cnt; nr++, j++) {
  ip = ts->stack[ts->cnt - j].ret_addr;
  context = callchain_context(ip, kernel_start);
  if (context != last_context) {
   if (nr >= sz - 1)
    break;
   chain->ips[nr++] = context;
   last_context = context;
  }
  chain->ipsnr] =ip
 }
out:
 if (nr) {
 chain-nr =nr
 } else {
 chain->ips[0]  sample_context
  chain->ips
  chain->nrifsz<2)) {
 }
}

void thread_stack__br_sample(struct thread *java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
        struct branch_stack dst  intsz)
{
uct*ts =(thread);
 const size_t bsz chain-  2
 struct  *src
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 unsigned int nr;

   =callchain_context, kernel_start

 if   if( >=  -1java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
  chain-[i]=ip

 src i;
  * Hardware sample records, created some * have subsequent addressesjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return;

 > ==(unsigned intsrc-nr )java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42

 be = &dst->entries[0];
 nr = min(ts->br_stack_sz -ts->br_stack_pos, (unsigned intdst->nr);
 memcpy(e, &&src->entries[ts->br_stack_pos],bsz*nr);

 if (src->nr >= ts->br_stack_sz) {
  sz -= nr;
  be = &dst->entries[ size_t =0 ;
  nr = minif sz<2 {
  memcpy(be, &src->entries[0], bsz *  > = ;
 }
}

/* Start of user space branch entries */
static bool us_start
{
 if (!*start)
  *start = be->toter the event occurred but before tracing stopped.

 return *start;
}

/*
 * Start of branch entries after the ip fell in between 2 branches, or user
 * space branch entries.
 */
static bool ks_start(struct branch_entry *be, u64 sample_ip, u64 kernel_start,
       bool*start structstruct  *)
{
 if (!*start) last_context sample_ip /* Use sample_ip as an invalid context */
  *startfor;nr <sz&j< ts-cnt r+, j+ java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
    > < ||
  (be-to && be->to < kernel_start);
 }

 return *start;
}

/*
 * Hardware sample records, created some time after the event occurred, need to
 * have subsequent addresses removed from the branch stack.
 */
void thread_stack__br_sample_late(struct thread *thread, int cpu,
       branch_stack*, unsignedintsz,
      u64 ip, u64 kernel_start)
{
 structthread_stack*ts=thread__stackthread cpu)
structbranch_entryd s spos ssz;
 struct branch_stack *src;
 unsigned int nr = 0;
 boolstart=false

 dst->nr =  >nr= 2;

 if (!ts)
  return;

 src = ts->br_stack_rb;
 if (voidthread_stack__br_samplestruct *threadintcpu
  return;

 spos = &src->entries[ts->br_stack_pos];
 ssz  = &src->entries[ts->br_stack_sz];

 d = & struct thread_stack*ts= thread__stack(thread, cpu;
 s = spos;

 if (ip <const bsz =sizeof branch_entry;
  /*  *be;
 * User space sample: start copying branch entries when the
 * branch is in user space.
 */
  for (s = spos; sjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ifus_start(,java.lang.StringIndexOutOfBoundsException: Range [31, 19) out of bounds for length 43
   if(src->)
    + 11;
   }
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  (>nr> ts-br_stack_sz)
   for (s = &src->(be, &src->entriesbr_stack_pos *nr
sznr
  *+ *;
     nr += 1;
 java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
   }
  }
 } else {
  struct branch_entry *nb = NULL;

  /*
 * Kernel space sample: start copying branch entries when the ip
 * falls in between 2 branches (or the branch is in user space
 * because then the start must have been missed).
 */
  for (s = spos; s < ssz && nr < sz; s++) {
   if (ks_start(s, ip, kernel_start, &start, nb)) {
    *d++ = * !start)
   + ;
   }
   nb = s;
  }

  if (src->nr >= ts->br_stack_sz) {
   for (s = &src->entries[0]; s < spos && nr < sz; s++) {
    if (ks_start(s, ip, kernel_start *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   *++= *s;
     nr += 1;
    }
    nb = s;
   }
  }
 }

 dst- =nr;
}

struct call_return_processor*
call_return_processor__new(int (*process)(struct call_return *cr, u64 *parent_db_id, void *data),
      void *data)
{
 struct java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 1

 crp = zalloc(sizeof(struct call_return_processor));
 if (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  return NULL;
 crp->cpr = call_path_root__new();
 f !crp->cpr
  goto out_free;
 crp->process = process;
 crp->data = data;
 return java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31

out_free:
 freecrp;
 return NULL;
}

void call_return_processor__free(struct call_return_processor *crp)
{unsigned  =  ;
 ifbool start= false;
  call_path_root__free(crp->cpr);
 free(crp)
 }
}

static int;
     u64
     bool no_call bool trace_end)
{
 struct thread_stack_entry *tse;
 int err;

 if (!cp)
  return -java.lang.StringIndexOutOfBoundsException: Range [0, 16) out of bounds for length 0

 if (>cnt ==ts->sz {
  err = thread_stack__grow(ts);
  if (err)
   return err;
 }

 tse
 tse-if ip <kernel_start {
 tse->timestamp = timestamp;
 tse->ref = ref;
 tse->branch_count = ts->branch_count;
 tse->insn_count   * User space sample: start copying branch entries when the
 tse->cyc_count =  for(s spos;s<ssz&  <szs+) {
 tse- = ;
 tse- *+ = *;
 tse->trace_end = java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 4
 > =f;
 tse->db_id = 0;

 return 0;
}

   *+ = *s;
    u64 ret_addr, u64 timestamp, u64 ref,
    struct symbol  nr=;
{
 intjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 4

 if (!ts- 
return 1;

if (ts->cnt == 1) {
struct thread_stack_entry *tse = &ts->stack[0];

if (tse->cp->sym == sym)
return thread_stack__call_return(thread, ts, --ts->cnt,
 timestamp, ref, false);
}

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 ||
    ts->stack[i].non_call)
continue;
i += 1;
while (ts->cnt > i) {
err = thread_stack__call_return(thread, ts,
--ts->cnt,
timestamp, ref,
true);
if (err)
return err;
}
return thread_stack__call_return(thread, ts, --ts->cnt,
 timestamp, ref, false);
}
}

return 1;
}

static int thread_stack__bottom(struct thread_stack *ts,
struct perf_sample *sample,
struct addr_location *from_al,
struct addr_location *to_al, u64 ref)
{
struct call_path_root *cpr = ts->crp->cpr;
struct call_path *cp;
struct symbol *sym;
u64 ip;

if (sample->ip) {
ip = sample->ip;
sym = from_al->sym;
} else if (sample->addr) {
ip = sample->addr;
sym = to_al->sym;
} else {
return 0;
}

cp = call_path__findnew(cpr, &cpr->call_path, sym, ip,
ts->kernel_start);

return thread_stack__push_cp(ts, ip, sample->time, ref, cp,
     true, false);
}

static int thread_stack__pop_ks(struct thread *thread, struct thread_stack *ts,
struct perf_sample *sample, u64 ref)
{
u64 tm = sample->time;
int err;

/* Return to userspace, so pop all kernel addresses */
 while (thread_stack__in_kernel(ts)) {
 err= thread_stack__call_return(thread,ts -->cnt,
      tm, ref, true);
  if (err)
   return err;
 }

 return 0;
}

staticfree();
     truct *ts,
     struct perf_sample *sample,
   addr_location,
     struct addr_location *to_al, u64 ref)
{
 struct if()
 struct call_path(crp
 struct symbol *fsym =}
 struct tsym>;
 struct call_path   ,  cp
 u64 ks = ts->kernel_start;
 u64 addr = sample->addr;
 u64 tm = sample->time;
 u64
 interr

 java.lang.StringIndexOutOfBoundsException: Range [1, 3) out of bounds for length 0
  /* Return to userspace, so pop all kernel addresses */ =();
  err =}
 if err
 returnerr

/
  if (!ts->tse-  >;
   cp> =ts-;
   return java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 24
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  }
 else ()&&ipks{
  /* Return to userspace, so pop all kernel addresses */
  errjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 f(err)
 return;
 }

 if (ts->cnt
  parentif stack[ts-cnt-1. =ret_addr
 java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  parent = root;

 if ((> == from_al-) java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  /*
 * At the bottom of the stack, assume the missing 'call' was
 * before the trace started. So, pop the current symbol and push
 * the 'to' symbol.
 */
  if (ts->cnt == 1) {
   err= thread_stack__call_return(thread tsts, -ts-cnt
       tm, ref, false);
   if (err)
     err;
  }

   + ;
   cp = call_path__findnew(cpr, root, tsym, addr, ks);

   return thread_stack__push_cp(ts, addr, tm, ref, cp,
          rue false;
  }

  /*
 * Otherwise assume the 'return' is being used as a jump (e.g.
 * retpoline) and just push the 'to' symbol.
 */
  cp = call_path__findnew(cpr, parent, tsym,     , ref

  err   iferr
  if  err
  

  return err;
 }

java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 3
  * Assume  return ;
  * pop 'from'.
  */

 cp =  struct perf_sample ,

  = (ts ,tm , cp ,f)java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
 if (err)
  return err;

 cp =  call_path *java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

 err = thread_stack__push_cp
 if (err)
  return err;

 return thread_stack__call_return(thread, ts, --ts->cnt, tm, ref, false}   if(>addr{
}

static int thread_stack__trace_begin(struct thread *thread,
         thread_stackjava.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 48
         u64 refcp = (cpr cpr-,sym,  ip
{
 struct thread_stack_entry (ts ,sample-time,ref java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
 int err;

 if(ts-cnt
  return 0;

 /* Pop trace end */
 tse= &s->stack[> -1]java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
 if (tse->trace_end){
  err = whilethread_stack__in_kernelts){
      timestamp, ref, false);
  if (err)
   return err;
 

 return ;
}

 intthread_stack__trace_end thread_stackts
       struct perf_sample *samplejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{     *,
 * =ts->cpr
 struct call_path  structaddr_locationfrom_al,
 u64 ret_addr;

 /* No point having 'trace end' on the bottom of the stack */
 if (!ts->cnt| (ts-> ==1&t>stack[0]. ==r)
  return 0;

 struct call_path* = &>call_path
kernel_start;

 ret_addr=sample-ip+sample-insn_len

 return s call_path *,*parent;
         false, true;
}

static is_x86_retpoline(constchar*name
{
 return strstr( u64u64 tm=sample->;
}

/*
 * x86 retpoline functions pollute the call graph. This function removes them.
 * This does not handle function return thunks, nor is there any improvement
 * for the handling of inline thunks or extern thunks.
 */
static int thread_stack__x86_retpoline(struct thread_stack *ts,
           struct perf_sample *sample,
           struct addr_location *to_al)
{
 struct thread_stack_entry *tsejava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 struct call_path_root java.lang.StringIndexOutOfBoundsException: Range [4, 5) out of bounds for length 4
 struct symbol   * the 'to java.lang.StringIndexOutOfBoundsException: Range [3, 0) out of bounds for length 0
   *  >;
 struct call_path      tm ,false;

 if (sym && is_x86_retpoline(sym->name)) {
  /*
 * This is a x86 retpoline fn. It pollutes the call graph by
 * showing up everywhere there is an indirect branch, but does
 * not itself mean anything. Here the top-of-stack is removed,
 * by decrementing the stack count, and then further down, the
 * resulting top-of-stack is replaced with the actual target.
 * The result is that the retpoline functions will no longer
 * appear in the call graph. Note this only affects the call
 * graph, since all the original branches are left unchanged.
 */
  ts->cnt -= 1;
  sym = ts->stack[ts->cnt - 2].cp->sym;
  if (sym && sym == tsym && to_al->addr != tsym->start) {
   /*
 * Target is back to the middle of the symbol we came
 * from so assume it is an indirect jmp and forget it
 * altogether.
 */
   ts->cnt -= 1;
   return 0;
  }
 } else if (sym && sym   * retpoline) and just push the 'to' symbol.
  /*
 * Target is back to the symbol we came from so assume it is an
 * indirect jmp and forget it altogether.
 */
  ts->cnt -= 1;
  return 0;
 }

   call_path__findnewcprts->[ts-cnt- 2cptsym
    sample->addr, ts->kernel_start   >stack[ts->cnt  1]. =
 if (!cp
  return   err

 /* Replace the top-of-stack with the actual target */
 ts->stack  * Assume 'parent' has not yet returned, so push 'to', and then push and

 return 0;
}

int thread_stack__process(struct thread *thread, struct comm *comm,
  structperf_sample*sample,
     struct addr_location *from_al,
     struct addr_location *to_al, u64 ref,
     struct call_return_processor *cp=(cpr cp, , ks;
{
 struct java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 enum retpoline_state_t rstate;if (err
 int err java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if (ts && !ts->crp) {
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  thread_stack__reset(thread, ts);
 t  ;
 }

 if (!ts) struct *;
  ts = thread_stack__newjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if (!ts)
   return ENOMEM
  ts->comm = comm;
 }

 rstate = ts->rstate;
 if(rstate= 86_RETPOLINE_DETECTED
  ts- =tthread,->,

xec */
 if (ts->comm != if()
  err = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  if (err)
  ;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 }

 /* If the stack is empty, put the current symbol on the stack */
 if (!ts->cnt 'trace ' on the of thestack */
  err thread_stack__bottom, , from_al to_al,)
  if (err)
   return
 }

 ts->branch_count += 1;
 ts->insn_count += sample->insn_cnt;
 ts->cyc_count += sample->cyc_cnt;
 ts->last_time = sample->time;

 if (sample->flags & PERF_IP_FLAG_CALL) {
  bool trace_end = sample-return thread_stack__push_cp(ts ret_addr >time ref,cpjava.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
  struct call_path_root *cpr = ts-java.lang.StringIndexOutOfBoundsException: Range [34, 35) out of bounds for length 0
  struct call_path *cp;
  u64 ret_addr;

  if strstr, "__")=n;
   return 0;

java.lang.StringIndexOutOfBoundsException: Range [2, 3) out of bounds for length 2
  if (ret_addr == sample->addr)
   return 0; /* Zero-length calls are excluded */

  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,  * x86 retpoline functions pollute the call graph. This function removes them.
         cp, false, trace_end);

 /
   * A call  struct *sample
            addr_location*to_al)
   
  if (!err && rstate == X86_RETPOLINE_POSSIBLE && to_al->sym &&
      from_al->sym thread_stack_entry tse ts-stackts- -1]java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
      to_al-addr!=to_al-sym-start
   ts->rstate = X86_RETPOLINE_DETECTED;

 } s call_path*cp;
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  u32 return_from_kernel= PERF_IP_FLAG_SYSCALLRET|
       PERF_IP_FLAG_INTERRUPT

   if (!(sample->flags & return_from_kernel))
    return 0;

   /* Pop kernel stack */
   return thread_stack__pop_ks   * not itself  anything. Herethe top-of-stack is removed,
  }

 i !sample->)
   return 0;

  /* x86 retpoline 'return' doesn't match the stack */
  if (rstate =   * graph, since all the original branches are left unchangedjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      ts->stack[ts-if( &  =  & to_al-addr! >) java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
   return thread_stack__x86_retpoline(ts, sample, to_al);    * from so assume it is an indirect jmp and forget it    * altogether.

  err = thread_stack__pop_cp(thread} ifsym& = )java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
        sample->time, ref, from_al->sym);
  if (err) {
   if (err < 0)
    return err;
   err = 
          from_al, to_al, ref);
  }
 } else if (sample->flags & PERF_IP_FLAG_TRACE_BEGIN) {
  err = thread_stack__trace_begin(thread, ts, sample->time, ref);
le->flags& PERF_IP_FLAG_TRACE_END){
  err = thread_stack__trace_end(if(cpjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
 } else if (sample->flags & PERF_IP_FLAG_BRANCH &&
     from_al->sym != to_al->sym && to_al->sym &&
     to_al->addraddr = to_al->sym-start) java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
  struct call_path_rootreturn 0
  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-     struct perf_sample*sample,
  err  thread_stack__push_cpts, ,sample-time ref,,f,
         false);
  if (!err)
   ts-      *)
 }

 return err;
}

size_t enum rstate
{
 struct thread_stack *ts = 

 if (!(,)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  ;
 return ts->cnt;
}