perf tools: Consolidate symbol resolving across all tools
authorArnaldo Carvalho de Melo <acme@redhat.com>
Fri, 27 Nov 2009 18:29:23 +0000 (16:29 -0200)
committerIngo Molnar <mingo@elte.hu>
Fri, 27 Nov 2009 19:22:02 +0000 (20:22 +0100)
Now we have a very high level routine for simple tools to
process IP sample events:

int event__preprocess_sample(const event_t *self,
     struct addr_location *al,
     symbol_filter_t filter)

It receives the event itself and will insert new threads in the
global threads list and resolve the map and symbol, filling all
this info into the new addr_location struct, so that tools like
annotate and report can further process the event by creating
hist_entries in their specific way (with or without callgraphs,
etc).

It in turn uses the new next layer function:

void thread__find_addr_location(struct thread *self, u8 cpumode,
enum map_type type, u64 addr,
struct addr_location *al,
symbol_filter_t filter)

This one will, given a thread (userspace or the kernel kthread
one), will find the given type (MAP__FUNCTION now, MAP__VARIABLE
too in the near future) at the given cpumode, taking vdsos into
account (userspace hit, but kernel symbol) and will fill all
these details in the addr_location given.

Tools that need a more compact API for plain function
resolution, like 'kmem', can use this other one:

struct symbol *thread__find_function(struct thread *self, u64 addr,
     symbol_filter_t filter)

So, to resolve a kernel symbol, that is all the 'kmem' tool
needs, its just a matter of calling:

sym = thread__find_function(kthread, addr, NULL);

The 'filter' parameter is needed because we do lazy
parsing/loading of ELF symtabs or /proc/kallsyms.

With this we remove more code duplication all around, which is
always good, huh? :-)

Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Frédéric Weisbecker <fweisbec@gmail.com>
Cc: John Kacur <jkacur@redhat.com>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Paul Mackerras <paulus@samba.org>
LKML-Reference: <1259346563-12568-12-git-send-email-acme@infradead.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
12 files changed:
tools/perf/builtin-annotate.c
tools/perf/builtin-kmem.c
tools/perf/builtin-report.c
tools/perf/builtin-top.c
tools/perf/util/event.c
tools/perf/util/event.h
tools/perf/util/hist.c
tools/perf/util/hist.h
tools/perf/util/symbol.c
tools/perf/util/symbol.h
tools/perf/util/thread.c
tools/perf/util/thread.h

index 7d39bd2b19b83d4b59973f68a04d7531c0249967..7f85c6e159a46ee3778b682947ca409491fa4fd4 100644 (file)
@@ -124,71 +124,30 @@ static void hist_hit(struct hist_entry *he, u64 ip)
                        h->ip[offset]);
 }
 
-static int hist_entry__add(struct thread *thread, struct map *map,
-                          struct symbol *sym, u64 ip, u64 count, char level)
+static int hist_entry__add(struct addr_location *al, u64 count)
 {
        bool hit;
-       struct hist_entry *he = __hist_entry__add(thread, map, sym, NULL, ip,
-                                                 count, level, &hit);
+       struct hist_entry *he = __hist_entry__add(al, NULL, count, &hit);
        if (he == NULL)
                return -ENOMEM;
-       hist_hit(he, ip);
+       hist_hit(he, al->addr);
        return 0;
 }
 
 static int process_sample_event(event_t *event)
 {
-       char level;
-       u64 ip = event->ip.ip;
-       struct map *map = NULL;
-       struct symbol *sym = NULL;
-       struct thread *thread = threads__findnew(event->ip.pid);
+       struct addr_location al;
 
        dump_printf("(IP, %d): %d: %p\n", event->header.misc,
-                   event->ip.pid, (void *)(long)ip);
+                   event->ip.pid, (void *)(long)event->ip.ip);
 
-       if (thread == NULL) {
+       if (event__preprocess_sample(event, &al, symbol_filter) < 0) {
                fprintf(stderr, "problem processing %d event, skipping it.\n",
                        event->header.type);
                return -1;
        }
 
-       dump_printf(" ... thread: %s:%d\n", thread->comm, thread->pid);
-
-       if (event->header.misc & PERF_RECORD_MISC_KERNEL) {
-               level = 'k';
-               sym = kernel_maps__find_function(ip, &map, symbol_filter);
-               dump_printf(" ...... dso: %s\n",
-                           map ? map->dso->long_name : "<not found>");
-       } else if (event->header.misc & PERF_RECORD_MISC_USER) {
-               level = '.';
-               map = thread__find_map(thread, MAP__FUNCTION, ip);
-               if (map != NULL) {
-                       ip = map->map_ip(map, ip);
-                       sym = map__find_symbol(map, ip, symbol_filter);
-               } else {
-                       /*
-                        * If this is outside of all known maps,
-                        * and is a negative address, try to look it
-                        * up in the kernel dso, as it might be a
-                        * vsyscall or vdso (which executes in user-mode).
-                        *
-                        * XXX This is nasty, we should have a symbol list in
-                        * the "[vdso]" dso, but for now lets use the old
-                        * trick of looking in the whole kernel symbol list.
-                        */
-                       if ((long long)ip < 0)
-                               sym = kernel_maps__find_function(ip, &map,
-                                                                symbol_filter);
-               }
-               dump_printf(" ...... dso: %s\n",
-                           map ? map->dso->long_name : "<not found>");
-       } else {
-               level = 'H';
-               dump_printf(" ...... dso: [hypervisor]\n");
-       }
-
-       if (hist_entry__add(thread, map, sym, ip, 1, level)) {
+       if (hist_entry__add(&al, 1)) {
                fprintf(stderr, "problem incrementing symbol count, "
                                "skipping event\n");
                return -1;
index e7294c8fc62017a6d5d86f9d334a165ccf5744e8..047fef74bd5276425360dd5e2c3d22cf9d27984a 100644 (file)
@@ -420,7 +420,7 @@ static void __print_result(struct rb_root *root, int n_lines, int is_caller)
                if (is_caller) {
                        addr = data->call_site;
                        if (!raw_ip)
-                               sym = kernel_maps__find_function(addr, NULL, NULL);
+                               sym = thread__find_function(kthread, addr, NULL);
                } else
                        addr = data->ptr;
 
index 01ef35cac5f954d890897d6cfdbb27067612b761..383c4ab4f9af06e6cfaa0e6f6e358aa63e1d1d68 100644 (file)
@@ -408,55 +408,6 @@ static int thread__set_comm_adjust(struct thread *self, const char *comm)
        return 0;
 }
 
-
-static struct symbol *
-resolve_symbol(struct thread *thread, struct map **mapp, u64 *ipp)
-{
-       struct map *map = mapp ? *mapp : NULL;
-       u64 ip = *ipp;
-
-       if (map)
-               goto got_map;
-
-       if (!thread)
-               return NULL;
-
-       map = thread__find_map(thread, MAP__FUNCTION, ip);
-       if (map != NULL) {
-               /*
-                * We have to do this here as we may have a dso
-                * with no symbol hit that has a name longer than
-                * the ones with symbols sampled.
-                */
-               if (!sort_dso.elide && !map->dso->slen_calculated)
-                       dso__calc_col_width(map->dso);
-
-               if (mapp)
-                       *mapp = map;
-got_map:
-               ip = map->map_ip(map, ip);
-       } else {
-               /*
-                * If this is outside of all known maps,
-                * and is a negative address, try to look it
-                * up in the kernel dso, as it might be a
-                * vsyscall or vdso (which executes in user-mode).
-                *
-                * XXX This is nasty, we should have a symbol list in
-                * the "[vdso]" dso, but for now lets use the old
-                * trick of looking in the whole kernel symbol list.
-                */
-               if ((long long)ip < 0)
-                       return kernel_maps__find_function(ip, mapp, NULL);
-       }
-       dump_printf(" ...... dso: %s\n",
-                   map ? map->dso->long_name : "<not found>");
-       dump_printf(" ...... map: %Lx -> %Lx\n", *ipp, ip);
-       *ipp  = ip;
-
-       return map ? map__find_symbol(map, ip, NULL) : NULL;
-}
-
 static int call__match(struct symbol *sym)
 {
        if (sym->name && !regexec(&parent_regex, sym->name, 0, NULL, 0))
@@ -469,7 +420,7 @@ static struct symbol **resolve_callchain(struct thread *thread,
                                         struct ip_callchain *chain,
                                         struct symbol **parent)
 {
-       u64 context = PERF_CONTEXT_MAX;
+       u8 cpumode = PERF_RECORD_MISC_USER;
        struct symbol **syms = NULL;
        unsigned int i;
 
@@ -483,30 +434,31 @@ static struct symbol **resolve_callchain(struct thread *thread,
 
        for (i = 0; i < chain->nr; i++) {
                u64 ip = chain->ips[i];
-               struct symbol *sym = NULL;
+               struct addr_location al;
 
                if (ip >= PERF_CONTEXT_MAX) {
-                       context = ip;
+                       switch (ip) {
+                       case PERF_CONTEXT_HV:
+                               cpumode = PERF_RECORD_MISC_HYPERVISOR;  break;
+                       case PERF_CONTEXT_KERNEL:
+                               cpumode = PERF_RECORD_MISC_KERNEL;      break;
+                       case PERF_CONTEXT_USER:
+                               cpumode = PERF_RECORD_MISC_USER;        break;
+                       default:
+                               break;
+                       }
                        continue;
                }
 
-               switch (context) {
-               case PERF_CONTEXT_HV:
-                       break;
-               case PERF_CONTEXT_KERNEL:
-                       sym = kernel_maps__find_function(ip, NULL, NULL);
-                       break;
-               default:
-                       sym = resolve_symbol(thread, NULL, &ip);
-                       break;
-               }
-
-               if (sym) {
-                       if (sort__has_parent && !*parent && call__match(sym))
-                               *parent = sym;
+               thread__find_addr_location(thread, cpumode, MAP__FUNCTION,
+                                          ip, &al, NULL);
+               if (al.sym != NULL) {
+                       if (sort__has_parent && !*parent &&
+                           call__match(al.sym))
+                               *parent = al.sym;
                        if (!callchain)
                                break;
-                       syms[i] = sym;
+                       syms[i] = al.sym;
                }
        }
 
@@ -517,20 +469,17 @@ static struct symbol **resolve_callchain(struct thread *thread,
  * collect histogram counts
  */
 
-static int
-hist_entry__add(struct thread *thread, struct map *map,
-               struct symbol *sym, u64 ip, struct ip_callchain *chain,
-               char level, u64 count)
+static int hist_entry__add(struct addr_location *al,
+                          struct ip_callchain *chain, u64 count)
 {
        struct symbol **syms = NULL, *parent = NULL;
        bool hit;
        struct hist_entry *he;
 
        if ((sort__has_parent || callchain) && chain)
-               syms = resolve_callchain(thread, chain, &parent);
+               syms = resolve_callchain(al->thread, chain, &parent);
 
-       he = __hist_entry__add(thread, map, sym, parent,
-                              ip, count, level, &hit);
+       he = __hist_entry__add(al, parent, count, &hit);
        if (he == NULL)
                return -ENOMEM;
 
@@ -656,14 +605,12 @@ static int validate_chain(struct ip_callchain *chain, event_t *event)
 
 static int process_sample_event(event_t *event)
 {
-       char level;
-       struct symbol *sym = NULL;
        u64 ip = event->ip.ip;
        u64 period = 1;
-       struct map *map = NULL;
        void *more_data = event->ip.__more_data;
        struct ip_callchain *chain = NULL;
        int cpumode;
+       struct addr_location al;
        struct thread *thread = threads__findnew(event->ip.pid);
 
        if (sample_type & PERF_SAMPLE_PERIOD) {
@@ -709,32 +656,26 @@ static int process_sample_event(event_t *event)
 
        cpumode = event->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
 
-       if (cpumode == PERF_RECORD_MISC_KERNEL) {
-               level = 'k';
-               sym = kernel_maps__find_function(ip, &map, NULL);
-               dump_printf(" ...... dso: %s\n",
-                           map ? map->dso->long_name : "<not found>");
-       } else if (cpumode == PERF_RECORD_MISC_USER) {
-               level = '.';
-               sym = resolve_symbol(thread, &map, &ip);
-
-       } else {
-               level = 'H';
-               dump_printf(" ...... dso: [hypervisor]\n");
-       }
+       thread__find_addr_location(thread, cpumode,
+                                  MAP__FUNCTION, ip, &al, NULL);
+       /*
+        * We have to do this here as we may have a dso with no symbol hit that
+        * has a name longer than the ones with symbols sampled.
+        */
+       if (al.map && !sort_dso.elide && !al.map->dso->slen_calculated)
+               dso__calc_col_width(al.map->dso);
 
        if (dso_list &&
-           (!map || !map->dso ||
-            !(strlist__has_entry(dso_list, map->dso->short_name) ||
-              (map->dso->short_name != map->dso->long_name &&
-               strlist__has_entry(dso_list, map->dso->long_name)))))
+           (!al.map || !al.map->dso ||
+            !(strlist__has_entry(dso_list, al.map->dso->short_name) ||
+              (al.map->dso->short_name != al.map->dso->long_name &&
+               strlist__has_entry(dso_list, al.map->dso->long_name)))))
                return 0;
 
-       if (sym_list && sym && !strlist__has_entry(sym_list, sym->name))
+       if (sym_list && al.sym && !strlist__has_entry(sym_list, al.sym->name))
                return 0;
 
-       if (hist_entry__add(thread, map, sym, ip,
-                           chain, level, period)) {
+       if (hist_entry__add(&al, chain, period)) {
                pr_debug("problem incrementing symbol count, skipping event\n");
                return -1;
        }
index 7a3c0c7aad3d663ed2860ee9f28d085455934e2f..e0a374d0e43a8da197177a7ccccbc3ada6349a2e 100644 (file)
@@ -929,55 +929,28 @@ static int symbol_filter(struct map *map, struct symbol *sym)
 static void event__process_sample(const event_t *self, int counter)
 {
        u64 ip = self->ip.ip;
-       struct map *map;
        struct sym_entry *syme;
-       struct symbol *sym;
+       struct addr_location al;
        u8 origin = self->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
 
        switch (origin) {
-       case PERF_RECORD_MISC_USER: {
-               struct thread *thread;
-
+       case PERF_RECORD_MISC_USER:
                if (hide_user_symbols)
                        return;
-
-               thread = threads__findnew(self->ip.pid);
-               if (thread == NULL)
-                       return;
-
-               map = thread__find_map(thread, MAP__FUNCTION, ip);
-               if (map != NULL) {
-                       ip = map->map_ip(map, ip);
-                       sym = map__find_symbol(map, ip, symbol_filter);
-                       if (sym == NULL)
-                               return;
-                       userspace_samples++;
-                       break;
-               }
-       }
-               /*
-                * If this is outside of all known maps,
-                * and is a negative address, try to look it
-                * up in the kernel dso, as it might be a
-                * vsyscall or vdso (which executes in user-mode).
-                */
-               if ((long long)ip >= 0)
-                       return;
-               /* Fall thru */
+               break;
        case PERF_RECORD_MISC_KERNEL:
                if (hide_kernel_symbols)
                        return;
-
-               sym = kernel_maps__find_function(ip, &map, symbol_filter);
-               if (sym == NULL)
-                       return;
                break;
        default:
                return;
        }
 
-       syme = symbol__priv(sym);
+       if (event__preprocess_sample(self, &al, symbol_filter) < 0 ||
+           al.sym == NULL)
+               return;
 
+       syme = symbol__priv(al.sym);
        if (!syme->skip) {
                syme->count[counter]++;
                syme->origin = origin;
@@ -986,8 +959,9 @@ static void event__process_sample(const event_t *self, int counter)
                if (list_empty(&syme->node) || !syme->node.next)
                        __list_insert_active_sym(syme);
                pthread_mutex_unlock(&active_symbols_lock);
+               if (origin == PERF_RECORD_MISC_USER)
+                       ++userspace_samples;
                ++samples;
-               return;
        }
 }
 
index 70b4aa03b47205cf3d857ed7e99995fb9a5ed7ed..233d7ad9bd7ff8946c81d781e9d9d47d2e2d24bc 100644 (file)
@@ -249,3 +249,65 @@ int event__process_task(event_t *self)
 
        return 0;
 }
+
+void thread__find_addr_location(struct thread *self, u8 cpumode,
+                               enum map_type type, u64 addr,
+                               struct addr_location *al,
+                               symbol_filter_t filter)
+{
+       struct thread *thread = al->thread = self;
+
+       al->addr = addr;
+
+       if (cpumode & PERF_RECORD_MISC_KERNEL) {
+               al->level = 'k';
+               thread = kthread;
+       } else if (cpumode & PERF_RECORD_MISC_USER)
+               al->level = '.';
+       else {
+               al->level = 'H';
+               al->map = NULL;
+               al->sym = NULL;
+               return;
+       }
+try_again:
+       al->map = thread__find_map(thread, type, al->addr);
+       if (al->map == NULL) {
+               /*
+                * If this is outside of all known maps, and is a negative
+                * address, try to look it up in the kernel dso, as it might be
+                * a vsyscall or vdso (which executes in user-mode).
+                *
+                * XXX This is nasty, we should have a symbol list in the
+                * "[vdso]" dso, but for now lets use the old trick of looking
+                * in the whole kernel symbol list.
+                */
+               if ((long long)al->addr < 0 && thread != kthread) {
+                       thread = kthread;
+                       goto try_again;
+               }
+               al->sym = NULL;
+       } else {
+               al->addr = al->map->map_ip(al->map, al->addr);
+               al->sym = map__find_symbol(al->map, al->addr, filter);
+       }
+}
+
+int event__preprocess_sample(const event_t *self, struct addr_location *al,
+                            symbol_filter_t filter)
+{
+       u8 cpumode = self->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
+       struct thread *thread = threads__findnew(self->ip.pid);
+
+       if (thread == NULL)
+               return -1;
+
+       dump_printf(" ... thread: %s:%d\n", thread->comm, thread->pid);
+
+       thread__find_addr_location(thread, cpumode, MAP__FUNCTION,
+                                  self->ip.ip, al, filter);
+       dump_printf(" ...... dso: %s\n",
+                   al->map ? al->map->dso->long_name :
+                       al->level == 'H' ? "[hypervisor]" : "<not found>");
+       return 0;
+}
index 13c12c75f970cc377c24af1e2700912eda5ae39e..a4cc8105cf675f42285896e674dd81193da7582b 100644 (file)
@@ -152,4 +152,8 @@ int event__process_lost(event_t *self);
 int event__process_mmap(event_t *self);
 int event__process_task(event_t *self);
 
+struct addr_location;
+int event__preprocess_sample(const event_t *self, struct addr_location *al,
+                            symbol_filter_t filter);
+
 #endif /* __PERF_RECORD_H */
index f26cd9ba00fd348e4bfe4bd427d4c92b7fc75a18..0ebf6ee16caa4f4714aedce18ddb77eb1592962e 100644 (file)
@@ -14,20 +14,19 @@ struct callchain_param      callchain_param = {
  * histogram, sorted on item, collects counts
  */
 
-struct hist_entry *__hist_entry__add(struct thread *thread, struct map *map,
-                                    struct symbol *sym,
+struct hist_entry *__hist_entry__add(struct addr_location *al,
                                     struct symbol *sym_parent,
-                                    u64 ip, u64 count, char level, bool *hit)
+                                    u64 count, bool *hit)
 {
        struct rb_node **p = &hist.rb_node;
        struct rb_node *parent = NULL;
        struct hist_entry *he;
        struct hist_entry entry = {
-               .thread = thread,
-               .map    = map,
-               .sym    = sym,
-               .ip     = ip,
-               .level  = level,
+               .thread = al->thread,
+               .map    = al->map,
+               .sym    = al->sym,
+               .ip     = al->addr,
+               .level  = al->level,
                .count  = count,
                .parent = sym_parent,
        };
index ac2149c559b0c0cb10cc02a3ab95b9f93c2b9a39..3020db0c92927354168c129c63bbf5d474ca793f 100644 (file)
@@ -36,9 +36,9 @@ extern unsigned long total_fork;
 extern unsigned long total_unknown;
 extern unsigned long total_lost;
 
-struct hist_entry *__hist_entry__add(struct thread *thread, struct map *map,
-                                    struct symbol *sym, struct symbol *parent,
-                                    u64 ip, u64 count, char level, bool *hit);
+struct hist_entry *__hist_entry__add(struct addr_location *al,
+                                    struct symbol *parent,
+                                    u64 count, bool *hit);
 extern int64_t hist_entry__cmp(struct hist_entry *, struct hist_entry *);
 extern int64_t hist_entry__collapse(struct hist_entry *, struct hist_entry *);
 extern void hist_entry__free(struct hist_entry *);
index b788c2f5d672d8c69e075b9548f881b4ea086ef1..fffcb937cdcb207f470f1bf335f1e316e283bc12 100644 (file)
@@ -43,7 +43,8 @@ static struct symbol_conf symbol_conf__defaults = {
        .try_vmlinux_path = true,
 };
 
-static struct thread kthread_mem, *kthread = &kthread_mem;
+static struct thread kthread_mem;
+struct thread *kthread = &kthread_mem;
 
 bool dso__loaded(const struct dso *self, enum map_type type)
 {
@@ -1178,29 +1179,6 @@ out:
        return ret;
 }
 
-static struct symbol *thread__find_symbol(struct thread *self, u64 ip,
-                                         enum map_type type, struct map **mapp,
-                                         symbol_filter_t filter)
-{
-       struct map *map = thread__find_map(self, type, ip);
-
-       if (mapp)
-               *mapp = map;
-
-       if (map) {
-               ip = map->map_ip(map, ip);
-               return map__find_symbol(map, ip, filter);
-       }
-
-       return NULL;
-}
-
-struct symbol *kernel_maps__find_function(u64 ip, struct map **mapp,
-                                         symbol_filter_t filter)
-{
-       return thread__find_symbol(kthread, ip, MAP__FUNCTION, mapp, filter);
-}
-
 static struct map *thread__find_map_by_name(struct thread *self, char *name)
 {
        struct rb_node *nd;
index 3f9e4a4d83ddad13f035224f5574a41d1bf3b50c..17003efa0b39ab072f6656109cddd434fe248d9a 100644 (file)
@@ -63,6 +63,14 @@ static inline void *symbol__priv(struct symbol *self)
        return ((void *)self) - symbol__priv_size;
 }
 
+struct addr_location {
+       struct thread *thread;
+       struct map    *map;
+       struct symbol *sym;
+       u64           addr;
+       char          level;
+};
+
 struct dso {
        struct list_head node;
        struct rb_root   symbols[MAP__NR_TYPES];
@@ -105,6 +113,8 @@ size_t kernel_maps__fprintf(FILE *fp);
 
 int symbol__init(struct symbol_conf *conf);
 
+struct thread;
+struct thread *kthread;
 extern struct list_head dsos__user, dsos__kernel;
 extern struct dso *vdso;
 #endif /* __PERF_SYMBOL */
index 2229f82cd630ab2d72ec26eb4d2162479381b42c..603f5610861b841cc1a526dc1f1566a0c943d56f 100644 (file)
@@ -285,3 +285,15 @@ size_t threads__fprintf(FILE *fp)
 
        return ret;
 }
+
+struct symbol *thread__find_symbol(struct thread *self,
+                                  enum map_type type, u64 addr,
+                                  symbol_filter_t filter)
+{
+       struct map *map = thread__find_map(self, type, addr);
+
+       if (map != NULL)
+               return map__find_symbol(map, map->map_ip(map, addr), filter);
+
+       return NULL;
+}
index 59b0d9b577d66729db57b65e5ef7dd6aeacb830e..686d6e914d9e3711bfb1ea8e53e6b275715f2837 100644 (file)
@@ -27,19 +27,30 @@ size_t thread__fprintf_maps(struct thread *self, FILE *fp);
 size_t threads__fprintf(FILE *fp);
 
 void maps__insert(struct rb_root *maps, struct map *map);
-struct map *maps__find(struct rb_root *maps, u64 ip);
-
-struct symbol *kernel_maps__find_function(const u64 ip, struct map **mapp,
-                                         symbol_filter_t filter);
+struct map *maps__find(struct rb_root *maps, u64 addr);
 
 static inline struct map *thread__find_map(struct thread *self,
-                                          enum map_type type, u64 ip)
+                                          enum map_type type, u64 addr)
 {
-       return self ? maps__find(&self->maps[type], ip) : NULL;
+       return self ? maps__find(&self->maps[type], addr) : NULL;
 }
 
 static inline void __thread__insert_map(struct thread *self, struct map *map)
 {
         maps__insert(&self->maps[map->type], map);
 }
+
+void thread__find_addr_location(struct thread *self, u8 cpumode,
+                               enum map_type type, u64 addr,
+                               struct addr_location *al,
+                               symbol_filter_t filter);
+struct symbol *thread__find_symbol(struct thread *self,
+                                  enum map_type type, u64 addr,
+                                  symbol_filter_t filter);
+
+static inline struct symbol *
+thread__find_function(struct thread *self, u64 addr, symbol_filter_t filter)
+{
+       return thread__find_symbol(self, MAP__FUNCTION, addr, filter);
+}
 #endif /* __PERF_THREAD_H */