50 files changed, 3506 insertions, 1711 deletions
diff --git a/tools/perf/util/PERF-VERSION-GEN b/tools/perf/util/PERF-VERSION-GEN
index 49ece7921914..97d76562a1a0 100755
--- a/tools/perf/util/PERF-VERSION-GEN
+++ b/tools/perf/util/PERF-VERSION-GEN
@@ -5,17 +5,13 @@ if [ $# -eq 1 ]  ; then
 fi
 GVF=${OUTPUT}PERF-VERSION-FILE
-DEF_VER=v0.0.2.PERF
 LF='
 '
-# First see if there is a version file (included in release tarballs),
+# First check if there is a .git to get the version from git describe
-# then try git-describe, then default.
+# otherwise try to get the version from the kernel makefile
-if test -f version
+if test -d ../../.git -o -f ../../.git &&
-then
-        VN=$(cat version) || VN="$DEF_VER"
-elif test -d .git -o -f .git &&
        VN=$(git describe --abbrev=4 HEAD 2>/dev/null) &&
        case "$VN" in
        *$LF*) (exit 1) ;;
@@ -27,7 +23,12 @@ elif test -d .git -o -f .git &&
 then
        VN=$(echo "$VN" | sed -e 's/-/./g');
 else
-        VN="$DEF_VER"
+        eval `grep '^VERSION\s*=' ../../Makefile|tr -d ' '`
+        eval `grep '^PATCHLEVEL\s*=' ../../Makefile|tr -d ' '`
+        eval `grep '^SUBLEVEL\s*=' ../../Makefile|tr -d ' '`
+        eval `grep '^EXTRAVERSION\s*=' ../../Makefile|tr -d ' '`
+        VN="${VERSION}.${PATCHLEVEL}.${SUBLEVEL}${EXTRAVERSION}"
 fi
 VN=$(expr "$VN" : v*'\(.*\)')
diff --git a/tools/perf/util/build-id.c b/tools/perf/util/build-id.c
index 70c5cf87d020..e437edb72417 100644
--- a/tools/perf/util/build-id.c
+++ b/tools/perf/util/build-id.c
@@ -12,6 +12,7 @@
 #include "event.h"
 #include "symbol.h"
 #include <linux/kernel.h>
+#include "debug.h"
 static int build_id__mark_dso_hit(event_t *event, struct perf_session *session)
 {
@@ -34,28 +35,43 @@ static int build_id__mark_dso_hit(event_t *event, struct perf_session *session)
        return 0;
 }
+static int event__exit_del_thread(event_t *self, struct perf_session *session)
+{
+        struct thread *thread = perf_session__findnew(session, self->fork.tid);
+        dump_printf("(%d:%d):(%d:%d)\n", self->fork.pid, self->fork.tid,
+                    self->fork.ppid, self->fork.ptid);
+        if (thread) {
+                rb_erase(&thread->rb_node, &session->threads);
+                session->last_match = NULL;
+                thread__delete(thread);
+        }
+        return 0;
+}
 struct perf_event_ops build_id__mark_dso_hit_ops = {
        .sample = build_id__mark_dso_hit,
        .mmap   = event__process_mmap,
        .fork   = event__process_task,
+        .exit   = event__exit_del_thread,
 };
 char *dso__build_id_filename(struct dso *self, char *bf, size_t size)
 {
        char build_id_hex[BUILD_ID_SIZE * 2 + 1];
-        const char *home;
        if (!self->has_build_id)
                return NULL;
        build_id__sprintf(self->build_id, sizeof(self->build_id), build_id_hex);
-        home = getenv("HOME");
        if (bf == NULL) {
-                if (asprintf(&bf, "%s/%s/.build-id/%.2s/%s", home,
+                if (asprintf(&bf, "%s/.build-id/%.2s/%s", buildid_dir,
-                             DEBUG_CACHE_DIR, build_id_hex, build_id_hex + 2) < 0)
+                             build_id_hex, build_id_hex + 2) < 0)
                        return NULL;
        } else
-                snprintf(bf, size, "%s/%s/.build-id/%.2s/%s", home,
+                snprintf(bf, size, "%s/.build-id/%.2s/%s", buildid_dir,
-                         DEBUG_CACHE_DIR, build_id_hex, build_id_hex + 2);
+                         build_id_hex, build_id_hex + 2);
        return bf;
 }
diff --git a/tools/perf/util/cache.h b/tools/perf/util/cache.h
index 65fe664fddf6..27e9ebe4076e 100644
--- a/tools/perf/util/cache.h
+++ b/tools/perf/util/cache.h
@@ -23,6 +23,7 @@ extern int perf_config(config_fn_t fn, void *);
 extern int perf_config_int(const char *, const char *);
 extern int perf_config_bool(const char *, const char *);
 extern int config_error_nonbool(const char *);
+extern const char *perf_config_dirname(const char *, const char *);
 /* pager.c */
 extern void setup_pager(void);
diff --git a/tools/perf/util/callchain.c b/tools/perf/util/callchain.c
index 62b69ad4aa73..f231f43424d2 100644
--- a/tools/perf/util/callchain.c
+++ b/tools/perf/util/callchain.c
@@ -18,7 +18,7 @@
 #include "util.h"
 #include "callchain.h"
-bool ip_callchain__valid(struct ip_callchain *chain, event_t *event)
+bool ip_callchain__valid(struct ip_callchain *chain, const event_t *event)
 {
        unsigned int chain_size = event->header.size;
        chain_size -= (unsigned long)&event->ip.__more_data - (unsigned long)event;
@@ -230,7 +230,7 @@ fill_node(struct callchain_node *node, struct resolved_chain *chain, int start)
 static void
 add_child(struct callchain_node *parent, struct resolved_chain *chain,
-          int start)
+          int start, u64 period)
 {
        struct callchain_node *new;
@@ -238,7 +238,7 @@ add_child(struct callchain_node *parent, struct resolved_chain *chain,
        fill_node(new, chain, start);
        new->children_hit = 0;
-        new->hit = 1;
+        new->hit = period;
 }
 /*
@@ -248,7 +248,8 @@ add_child(struct callchain_node *parent, struct resolved_chain *chain,
 */
 static void
 split_add_child(struct callchain_node *parent, struct resolved_chain *chain,
-                struct callchain_list *to_split, int idx_parents, int idx_local)
+                struct callchain_list *to_split, int idx_parents, int idx_local,
+                u64 period)
 {
        struct callchain_node *new;
        struct list_head *old_tail;
@@ -275,41 +276,41 @@ split_add_child(struct callchain_node *parent, struct resolved_chain *chain,
        /* create a new child for the new branch if any */
        if (idx_total < chain->nr) {
                parent->hit = 0;
-                add_child(parent, chain, idx_total);
+                add_child(parent, chain, idx_total, period);
-                parent->children_hit++;
+                parent->children_hit += period;
        } else {
-                parent->hit = 1;
+                parent->hit = period;
        }
 }
 static int
 __append_chain(struct callchain_node *root, struct resolved_chain *chain,
-               unsigned int start);
+               unsigned int start, u64 period);
 static void
 __append_chain_children(struct callchain_node *root,
                        struct resolved_chain *chain,
-                        unsigned int start)
+                        unsigned int start, u64 period)
 {
        struct callchain_node *rnode;
        /* lookup in childrens */
        chain_for_each_child(rnode, root) {
-                unsigned int ret = __append_chain(rnode, chain, start);
+                unsigned int ret = __append_chain(rnode, chain, start, period);
                if (!ret)
                        goto inc_children_hit;
        }
        /* nothing in children, add to the current node */
-        add_child(root, chain, start);
+        add_child(root, chain, start, period);
 inc_children_hit:
-        root->children_hit++;
+        root->children_hit += period;
 }
 static int
 __append_chain(struct callchain_node *root, struct resolved_chain *chain,
-               unsigned int start)
+               unsigned int start, u64 period)
 {
        struct callchain_list *cnode;
        unsigned int i = start;
@@ -345,18 +346,18 @@ __append_chain(struct callchain_node *root, struct resolved_chain *chain,
        /* we match only a part of the node. Split it and add the new chain */
        if (i - start < root->val_nr) {
-                split_add_child(root, chain, cnode, start, i - start);
+                split_add_child(root, chain, cnode, start, i - start, period);
                return 0;
        }
        /* we match 100% of the path, increment the hit */
        if (i - start == root->val_nr && i == chain->nr) {
-                root->hit++;
+                root->hit += period;
                return 0;
        }
        /* We match the node and still have a part remaining */
-        __append_chain_children(root, chain, i);
+        __append_chain_children(root, chain, i, period);
        return 0;
 }
@@ -380,7 +381,7 @@ static void filter_context(struct ip_callchain *old, struct resolved_chain *new,
 int append_chain(struct callchain_node *root, struct ip_callchain *chain,
-                 struct map_symbol *syms)
+                 struct map_symbol *syms, u64 period)
 {
        struct resolved_chain *filtered;
@@ -397,7 +398,7 @@ int append_chain(struct callchain_node *root, struct ip_callchain *chain,
        if (!filtered->nr)
                goto end;
-        __append_chain_children(root, filtered, 0);
+        __append_chain_children(root, filtered, 0, period);
 end:
        free(filtered);
diff --git a/tools/perf/util/callchain.h b/tools/perf/util/callchain.h
index 1ca73e4a2723..624a96c636fd 100644
--- a/tools/perf/util/callchain.h
+++ b/tools/perf/util/callchain.h
@@ -49,6 +49,9 @@ static inline void callchain_init(struct callchain_node *node)
        INIT_LIST_HEAD(&node->brothers);
        INIT_LIST_HEAD(&node->children);
        INIT_LIST_HEAD(&node->val);
+        node->parent = NULL;
+        node->hit = 0;
 }
 static inline u64 cumul_hits(struct callchain_node *node)
@@ -58,7 +61,7 @@ static inline u64 cumul_hits(struct callchain_node *node)
 int register_callchain_param(struct callchain_param *param);
 int append_chain(struct callchain_node *root, struct ip_callchain *chain,
-                 struct map_symbol *syms);
+                 struct map_symbol *syms, u64 period);
-bool ip_callchain__valid(struct ip_callchain *chain, event_t *event);
+bool ip_callchain__valid(struct ip_callchain *chain, const event_t *event);
 #endif  /* __PERF_CALLCHAIN_H */
diff --git a/tools/perf/util/config.c b/tools/perf/util/config.c
index dabe892d0e53..e02d78cae70f 100644
--- a/tools/perf/util/config.c
+++ b/tools/perf/util/config.c
@@ -11,6 +11,11 @@
 #define MAXNAME (256)
+#define DEBUG_CACHE_DIR ".debug"
+char buildid_dir[MAXPATHLEN]; /* root dir for buildid, binary cache */
 static FILE *config_file;
 static const char *config_file_name;
 static int config_linenr;
@@ -127,7 +132,7 @@ static int get_value(config_fn_t fn, void *data, char *name, unsigned int len)
                        break;
                if (!iskeychar(c))
                        break;
-                name[len++] = tolower(c);
+                name[len++] = c;
                if (len >= MAXNAME)
                        return -1;
        }
@@ -327,6 +332,13 @@ int perf_config_bool(const char *name, const char *value)
        return !!perf_config_bool_or_int(name, value, &discard);
 }
+const char *perf_config_dirname(const char *name, const char *value)
+{
+        if (!name)
+                return NULL;
+        return value;
+}
 static int perf_default_core_config(const char *var __used, const char *value __used)
 {
        /* Add other config variables here and to Documentation/config.txt. */
@@ -428,3 +440,53 @@ int config_error_nonbool(const char *var)
 {
        return error("Missing value for '%s'", var);
 }
+struct buildid_dir_config {
+        char *dir;
+};
+static int buildid_dir_command_config(const char *var, const char *value,
+                                      void *data)
+{
+        struct buildid_dir_config *c = data;
+        const char *v;
+        /* same dir for all commands */
+        if (!prefixcmp(var, "buildid.") && !strcmp(var + 8, "dir")) {
+                v = perf_config_dirname(var, value);
+                if (!v)
+                        return -1;
+                strncpy(c->dir, v, MAXPATHLEN-1);
+                c->dir[MAXPATHLEN-1] = '\0';
+        }
+        return 0;
+}
+static void check_buildid_dir_config(void)
+{
+        struct buildid_dir_config c;
+        c.dir = buildid_dir;
+        perf_config(buildid_dir_command_config, &c);
+}
+void set_buildid_dir(void)
+{
+        buildid_dir[0] = '\0';
+        /* try config file */
+        check_buildid_dir_config();
+        /* default to $HOME/.debug */
+        if (buildid_dir[0] == '\0') {
+                char *v = getenv("HOME");
+                if (v) {
+                        snprintf(buildid_dir, MAXPATHLEN-1, "%s/%s",
+                                 v, DEBUG_CACHE_DIR);
+                } else {
+                        strncpy(buildid_dir, DEBUG_CACHE_DIR, MAXPATHLEN-1);
+                }
+                buildid_dir[MAXPATHLEN-1] = '\0';
+        }
+        /* for communicating with external commands */
+        setenv("PERF_BUILDID_DIR", buildid_dir, 1);
+}
diff --git a/tools/perf/util/cpumap.c b/tools/perf/util/cpumap.c
index 4e01490e51e5..0f9b8d7a7d7e 100644
--- a/tools/perf/util/cpumap.c
+++ b/tools/perf/util/cpumap.c
@@ -20,7 +20,7 @@ static int default_cpu_map(void)
        return nr_cpus;
 }
-int read_cpu_map(void)
+static int read_all_cpu_map(void)
 {
        FILE *onlnf;
        int nr_cpus = 0;
@@ -57,3 +57,58 @@ int read_cpu_map(void)
        return default_cpu_map();
 }
+int read_cpu_map(const char *cpu_list)
+{
+        unsigned long start_cpu, end_cpu = 0;
+        char *p = NULL;
+        int i, nr_cpus = 0;
+        if (!cpu_list)
+                return read_all_cpu_map();
+        if (!isdigit(*cpu_list))
+                goto invalid;
+        while (isdigit(*cpu_list)) {
+                p = NULL;
+                start_cpu = strtoul(cpu_list, &p, 0);
+                if (start_cpu >= INT_MAX
+                    || (*p != '\0' && *p != ',' && *p != '-'))
+                        goto invalid;
+                if (*p == '-') {
+                        cpu_list = ++p;
+                        p = NULL;
+                        end_cpu = strtoul(cpu_list, &p, 0);
+                        if (end_cpu >= INT_MAX || (*p != '\0' && *p != ','))
+                                goto invalid;
+                        if (end_cpu < start_cpu)
+                                goto invalid;
+                } else {
+                        end_cpu = start_cpu;
+                }
+                for (; start_cpu <= end_cpu; start_cpu++) {
+                        /* check for duplicates */
+                        for (i = 0; i < nr_cpus; i++)
+                                if (cpumap[i] == (int)start_cpu)
+                                        goto invalid;
+                        assert(nr_cpus < MAX_NR_CPUS);
+                        cpumap[nr_cpus++] = (int)start_cpu;
+                }
+                if (*p)
+                        ++p;
+                cpu_list = p;
+        }
+        if (nr_cpus > 0)
+                return nr_cpus;
+        return default_cpu_map();
+invalid:
+        return -1;
+}
diff --git a/tools/perf/util/cpumap.h b/tools/perf/util/cpumap.h
index 86c78bb33098..3e60f56e490e 100644
--- a/tools/perf/util/cpumap.h
+++ b/tools/perf/util/cpumap.h
@@ -1,7 +1,7 @@
 #ifndef __PERF_CPUMAP_H
 #define __PERF_CPUMAP_H
-extern int read_cpu_map(void);
+extern int read_cpu_map(const char *cpu_list);
 extern int cpumap[];
 #endif /* __PERF_CPUMAP_H */
diff --git a/tools/perf/util/debug.c b/tools/perf/util/debug.c
index 6cddff2bc970..f9c7e3ad1aa7 100644
--- a/tools/perf/util/debug.c
+++ b/tools/perf/util/debug.c
@@ -23,7 +23,7 @@ int eprintf(int level, const char *fmt, ...)
        if (verbose >= level) {
                va_start(args, fmt);
                if (use_browser > 0)
-                        ret = browser__show_help(fmt, args);
+                        ret = ui_helpline__show_help(fmt, args);
                else
                        ret = vfprintf(stderr, fmt, args);
                va_end(args);
@@ -86,12 +86,10 @@ void trace_event(event_t *event)
                        dump_printf_color("  ", color);
                        for (j = 0; j < 15-(i & 15); j++)
                                dump_printf_color("   ", color);
-                        for (j = 0; j < (i & 15); j++) {
+                        for (j = i & ~15; j <= i; j++) {
-                                if (isprint(raw_event[i-15+j]))
+                                dump_printf_color("%c", color,
-                                        dump_printf_color("%c", color,
+                                                isprint(raw_event[j]) ?
-                                                          raw_event[i-15+j]);
+                                                raw_event[j] : '.');
-                                else
-                                        dump_printf_color(".", color);
                        }
                        dump_printf_color("\n", color);
                }
diff --git a/tools/perf/util/debug.h b/tools/perf/util/debug.h
index 047ac3324ebe..7a17ee061bcb 100644
--- a/tools/perf/util/debug.h
+++ b/tools/perf/util/debug.h
@@ -14,7 +14,7 @@ void trace_event(event_t *event);
 struct ui_progress;
 #ifdef NO_NEWT_SUPPORT
-static inline int browser__show_help(const char *format __used, va_list ap __used)
+static inline int ui_helpline__show_help(const char *format __used, va_list ap __used)
 {
        return 0;
 }
@@ -30,10 +30,9 @@ static inline void ui_progress__update(struct ui_progress *self __used,
 static inline void ui_progress__delete(struct ui_progress *self __used) {}
 #else
-int browser__show_help(const char *format, va_list ap);
+extern char ui_helpline__last_msg[];
-struct ui_progress *ui_progress__new(const char *title, u64 total);
+int ui_helpline__show_help(const char *format, va_list ap);
-void ui_progress__update(struct ui_progress *self, u64 curr);
+#include "ui/progress.h"
-void ui_progress__delete(struct ui_progress *self);
 #endif
 #endif  /* __PERF_DEBUG_H */
diff --git a/tools/perf/util/event.c b/tools/perf/util/event.c
index 50771b5813ee..dab9e754a281 100644
--- a/tools/perf/util/event.c
+++ b/tools/perf/util/event.c
@@ -151,7 +151,6 @@ static int event__synthesize_mmap_events(pid_t pid, pid_t tgid,
                        continue;
                pbf += n + 3;
                if (*pbf == 'x') { /* vm_exec */
-                        u64 vm_pgoff;
                        char *execname = strchr(bf, '/');
                        /* Catch VDSO */
@@ -162,12 +161,7 @@ static int event__synthesize_mmap_events(pid_t pid, pid_t tgid,
                                continue;
                        pbf += 3;
-                        n = hex2u64(pbf, &vm_pgoff);
+                        n = hex2u64(pbf, &ev.mmap.pgoff);
-                        /* pgoff is in bytes, not pages */
-                        if (n >= 0)
-                                ev.mmap.pgoff = vm_pgoff << getpagesize();
-                        else
-                                ev.mmap.pgoff = 0;
                        size = strlen(execname);
                        execname[size - 1] = '\0'; /* Remove \n */
@@ -340,41 +334,41 @@ int event__synthesize_kernel_mmap(event__handler_t process,
        return process(&ev, session);
 }
-static void thread__comm_adjust(struct thread *self)
+static void thread__comm_adjust(struct thread *self, struct hists *hists)
 {
        char *comm = self->comm;
        if (!symbol_conf.col_width_list_str && !symbol_conf.field_sep &&
            (!symbol_conf.comm_list ||
             strlist__has_entry(symbol_conf.comm_list, comm))) {
-                unsigned int slen = strlen(comm);
+                u16 slen = strlen(comm);
-                if (slen > comms__col_width) {
+                if (hists__new_col_len(hists, HISTC_COMM, slen))
-                        comms__col_width = slen;
+                        hists__set_col_len(hists, HISTC_THREAD, slen + 6);
-                        threads__col_width = slen + 6;
-                }
        }
 }
-static int thread__set_comm_adjust(struct thread *self, const char *comm)
+static int thread__set_comm_adjust(struct thread *self, const char *comm,
+                                   struct hists *hists)
 {
        int ret = thread__set_comm(self, comm);
        if (ret)
                return ret;
-        thread__comm_adjust(self);
+        thread__comm_adjust(self, hists);
        return 0;
 }
 int event__process_comm(event_t *self, struct perf_session *session)
 {
-        struct thread *thread = perf_session__findnew(session, self->comm.pid);
+        struct thread *thread = perf_session__findnew(session, self->comm.tid);
-        dump_printf(": %s:%d\n", self->comm.comm, self->comm.pid);
+        dump_printf(": %s:%d\n", self->comm.comm, self->comm.tid);
-        if (thread == NULL || thread__set_comm_adjust(thread, self->comm.comm)) {
+        if (thread == NULL || thread__set_comm_adjust(thread, self->comm.comm,
+                                                      &session->hists)) {
                dump_printf("problem processing PERF_RECORD_COMM, skipping event.\n");
                return -1;
        }
@@ -456,6 +450,7 @@ static int event__process_kernel_mmap(event_t *self,
                        goto out_problem;
                map->dso->short_name = name;
+                map->dso->sname_alloc = 1;
                map->end = map->start + self->mmap.len;
        } else if (is_kernel_mmap) {
                const char *symbol_name = (self->mmap.filename +
@@ -514,12 +509,13 @@ int event__process_mmap(event_t *self, struct perf_session *session)
        if (machine == NULL)
                goto out_problem;
        thread = perf_session__findnew(session, self->mmap.pid);
+        if (thread == NULL)
+                goto out_problem;
        map = map__new(&machine->user_dsos, self->mmap.start,
                        self->mmap.len, self->mmap.pgoff,
                        self->mmap.pid, self->mmap.filename,
-                        MAP__FUNCTION, session->cwd, session->cwdlen);
+                        MAP__FUNCTION);
+        if (map == NULL)
-        if (thread == NULL || map == NULL)
                goto out_problem;
        thread__insert_map(thread, map);
@@ -532,19 +528,16 @@ out_problem:
 int event__process_task(event_t *self, struct perf_session *session)
 {
-        struct thread *thread = perf_session__findnew(session, self->fork.pid);
+        struct thread *thread = perf_session__findnew(session, self->fork.tid);
-        struct thread *parent = perf_session__findnew(session, self->fork.ppid);
+        struct thread *parent = perf_session__findnew(session, self->fork.ptid);
        dump_printf("(%d:%d):(%d:%d)\n", self->fork.pid, self->fork.tid,
                    self->fork.ppid, self->fork.ptid);
-        /*
-         * A thread clone will have the same PID for both parent and child.
-         */
-        if (thread == parent)
-                return 0;
-        if (self->header.type == PERF_RECORD_EXIT)
+        if (self->header.type == PERF_RECORD_EXIT) {
+                perf_session__remove_thread(session, thread);
                return 0;
+        }
        if (thread == NULL || parent == NULL ||
            thread__fork(thread, parent) < 0) {
@@ -555,6 +548,26 @@ int event__process_task(event_t *self, struct perf_session *session)
        return 0;
 }
+int event__process(event_t *event, struct perf_session *session)
+{
+        switch (event->header.type) {
+        case PERF_RECORD_COMM:
+                event__process_comm(event, session);
+                break;
+        case PERF_RECORD_MMAP:
+                event__process_mmap(event, session);
+                break;
+        case PERF_RECORD_FORK:
+        case PERF_RECORD_EXIT:
+                event__process_task(event, session);
+                break;
+        default:
+                break;
+        }
+        return 0;
+}
 void thread__find_addr_map(struct thread *self,
                           struct perf_session *session, u8 cpumode,
                           enum map_type type, pid_t pid, u64 addr,
@@ -644,27 +657,49 @@ void thread__find_addr_location(struct thread *self,
                al->sym = NULL;
 }
-static void dso__calc_col_width(struct dso *self)
+static void dso__calc_col_width(struct dso *self, struct hists *hists)
 {
        if (!symbol_conf.col_width_list_str && !symbol_conf.field_sep &&
            (!symbol_conf.dso_list ||
             strlist__has_entry(symbol_conf.dso_list, self->name))) {
-                u16 slen = self->short_name_len;
+                u16 slen = dso__name_len(self);
-                if (verbose)
+                hists__new_col_len(hists, HISTC_DSO, slen);
-                        slen = self->long_name_len;
-                if (dsos__col_width < slen)
-                        dsos__col_width = slen;
        }
        self->slen_calculated = 1;
 }
 int event__preprocess_sample(const event_t *self, struct perf_session *session,
-                             struct addr_location *al, symbol_filter_t filter)
+                             struct addr_location *al, struct sample_data *data,
+                             symbol_filter_t filter)
 {
        u8 cpumode = self->header.misc & PERF_RECORD_MISC_CPUMODE_MASK;
-        struct thread *thread = perf_session__findnew(session, self->ip.pid);
+        struct thread *thread;
+        event__parse_sample(self, session->sample_type, data);
+        dump_printf("(IP, %d): %d/%d: %#Lx period: %Ld cpu:%d\n",
+                    self->header.misc, data->pid, data->tid, data->ip,
+                    data->period, data->cpu);
+        if (session->sample_type & PERF_SAMPLE_CALLCHAIN) {
+                unsigned int i;
+                dump_printf("... chain: nr:%Lu\n", data->callchain->nr);
+                if (!ip_callchain__valid(data->callchain, self)) {
+                        pr_debug("call-chain problem with event, "
+                                 "skipping it.\n");
+                        goto out_filtered;
+                }
+                if (dump_trace) {
+                        for (i = 0; i < data->callchain->nr; i++)
+                                dump_printf("..... %2d: %016Lx\n",
+                                            i, data->callchain->ips[i]);
+                }
+        }
+        thread = perf_session__findnew(session, self->ip.pid);
        if (thread == NULL)
                return -1;
@@ -690,6 +725,7 @@ int event__preprocess_sample(const event_t *self, struct perf_session *session,
                    al->map ? al->map->dso->long_name :
                        al->level == 'H' ? "[hypervisor]" : "<not found>");
        al->sym = NULL;
+        al->cpu = data->cpu;
        if (al->map) {
                if (symbol_conf.dso_list &&
@@ -706,16 +742,17 @@ int event__preprocess_sample(const event_t *self, struct perf_session *session,
                 * sampled.
                 */
                if (!sort_dso.elide && !al->map->dso->slen_calculated)
-                        dso__calc_col_width(al->map->dso);
+                        dso__calc_col_width(al->map->dso, &session->hists);
                al->sym = map__find_symbol(al->map, al->addr, filter);
        } else {
                const unsigned int unresolved_col_width = BITS_PER_LONG / 4;
-                if (dsos__col_width < unresolved_col_width &&
+                if (hists__col_len(&session->hists, HISTC_DSO) < unresolved_col_width &&
                    !symbol_conf.col_width_list_str && !symbol_conf.field_sep &&
                    !symbol_conf.dso_list)
-                        dsos__col_width = unresolved_col_width;
+                        hists__set_col_len(&session->hists, HISTC_DSO,
+                                           unresolved_col_width);
        }
        if (symbol_conf.sym_list && al->sym &&
@@ -729,9 +766,9 @@ out_filtered:
        return 0;
 }
-int event__parse_sample(event_t *event, u64 type, struct sample_data *data)
+int event__parse_sample(const event_t *event, u64 type, struct sample_data *data)
 {
-        u64 *array = event->sample.array;
+        const u64 *array = event->sample.array;
        if (type & PERF_SAMPLE_IP) {
                data->ip = event->ip.ip;
@@ -770,7 +807,8 @@ int event__parse_sample(event_t *event, u64 type, struct sample_data *data)
                u32 *p = (u32 *)array;
                data->cpu = *p;
                array++;
-        }
+        } else
+                data->cpu = -1;
        if (type & PERF_SAMPLE_PERIOD) {
                data->period = *array;
diff --git a/tools/perf/util/event.h b/tools/perf/util/event.h
index 8577085db067..8e790dae7026 100644
--- a/tools/perf/util/event.h
+++ b/tools/perf/util/event.h
@@ -154,11 +154,13 @@ int event__process_comm(event_t *self, struct perf_session *session);
 int event__process_lost(event_t *self, struct perf_session *session);
 int event__process_mmap(event_t *self, struct perf_session *session);
 int event__process_task(event_t *self, struct perf_session *session);
+int event__process(event_t *event, struct perf_session *session);
 struct addr_location;
 int event__preprocess_sample(const event_t *self, struct perf_session *session,
-                             struct addr_location *al, symbol_filter_t filter);
+                             struct addr_location *al, struct sample_data *data,
-int event__parse_sample(event_t *event, u64 type, struct sample_data *data);
+                             symbol_filter_t filter);
+int event__parse_sample(const event_t *event, u64 type, struct sample_data *data);
 extern const char *event__name[];
diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c
index 1f62435f96c2..d7e67b167ea3 100644
--- a/tools/perf/util/header.c
+++ b/tools/perf/util/header.c
@@ -16,6 +16,8 @@
 #include "symbol.h"
 #include "debug.h"
+static bool no_buildid_cache = false;
 /*
 * Create new perf.data header attribute:
 */
@@ -385,8 +387,7 @@ static int perf_session__cache_build_ids(struct perf_session *self)
        int ret;
        char debugdir[PATH_MAX];
-        snprintf(debugdir, sizeof(debugdir), "%s/%s", getenv("HOME"),
+        snprintf(debugdir, sizeof(debugdir), "%s", buildid_dir);
-                 DEBUG_CACHE_DIR);
        if (mkdir(debugdir, 0755) != 0 && errno != EEXIST)
                return -1;
@@ -471,7 +472,8 @@ static int perf_header__adds_write(struct perf_header *self, int fd)
                }
                buildid_sec->size = lseek(fd, 0, SEEK_CUR) -
                                          buildid_sec->offset;
-                perf_session__cache_build_ids(session);
+                if (!no_buildid_cache)
+                        perf_session__cache_build_ids(session);
        }
        lseek(fd, sec_start, SEEK_SET);
@@ -1190,3 +1192,8 @@ int event__process_build_id(event_t *self,
                                 session);
        return 0;
 }
+void disable_buildid_cache(void)
+{
+        no_buildid_cache = true;
+}
diff --git a/tools/perf/util/hist.c b/tools/perf/util/hist.c
index cbf7eae2ce09..be22ae6ef055 100644
--- a/tools/perf/util/hist.c
+++ b/tools/perf/util/hist.c
@@ -5,11 +5,61 @@
 #include "sort.h"
 #include <math.h>
+enum hist_filter {
+        HIST_FILTER__DSO,
+        HIST_FILTER__THREAD,
+        HIST_FILTER__PARENT,
+};
 struct callchain_param  callchain_param = {
        .mode   = CHAIN_GRAPH_REL,
        .min_percent = 0.5
 };
+u16 hists__col_len(struct hists *self, enum hist_column col)
+{
+        return self->col_len[col];
+}
+void hists__set_col_len(struct hists *self, enum hist_column col, u16 len)
+{
+        self->col_len[col] = len;
+}
+bool hists__new_col_len(struct hists *self, enum hist_column col, u16 len)
+{
+        if (len > hists__col_len(self, col)) {
+                hists__set_col_len(self, col, len);
+                return true;
+        }
+        return false;
+}
+static void hists__reset_col_len(struct hists *self)
+{
+        enum hist_column col;
+        for (col = 0; col < HISTC_NR_COLS; ++col)
+                hists__set_col_len(self, col, 0);
+}
+static void hists__calc_col_len(struct hists *self, struct hist_entry *h)
+{
+        u16 len;
+        if (h->ms.sym)
+                hists__new_col_len(self, HISTC_SYMBOL, h->ms.sym->namelen);
+        len = thread__comm_len(h->thread);
+        if (hists__new_col_len(self, HISTC_COMM, len))
+                hists__set_col_len(self, HISTC_THREAD, len + 6);
+        if (h->ms.map) {
+                len = dso__name_len(h->ms.map->dso);
+                hists__new_col_len(self, HISTC_DSO, len);
+        }
+}
 static void hist_entry__add_cpumode_period(struct hist_entry *self,
                                           unsigned int cpumode, u64 period)
 {
@@ -43,6 +93,8 @@ static struct hist_entry *hist_entry__new(struct hist_entry *template)
        if (self != NULL) {
                *self = *template;
                self->nr_events = 1;
+                if (self->ms.map)
+                        self->ms.map->referenced = true;
                if (symbol_conf.use_callchain)
                        callchain_init(self->callchain);
        }
@@ -50,11 +102,19 @@ static struct hist_entry *hist_entry__new(struct hist_entry *template)
        return self;
 }
-static void hists__inc_nr_entries(struct hists *self, struct hist_entry *entry)
+static void hists__inc_nr_entries(struct hists *self, struct hist_entry *h)
 {
-        if (entry->ms.sym && self->max_sym_namelen < entry->ms.sym->namelen)
+        if (!h->filtered) {
-                self->max_sym_namelen = entry->ms.sym->namelen;
+                hists__calc_col_len(self, h);
-        ++self->nr_entries;
+                ++self->nr_entries;
+        }
+}
+static u8 symbol__parent_filter(const struct symbol *parent)
+{
+        if (symbol_conf.exclude_other && parent == NULL)
+                return 1 << HIST_FILTER__PARENT;
+        return 0;
 }
 struct hist_entry *__hists__add_entry(struct hists *self,
@@ -70,10 +130,12 @@ struct hist_entry *__hists__add_entry(struct hists *self,
                        .map    = al->map,
                        .sym    = al->sym,
                },
+                .cpu    = al->cpu,
                .ip     = al->addr,
                .level  = al->level,
                .period = period,
                .parent = sym_parent,
+                .filtered = symbol__parent_filter(sym_parent),
        };
        int cmp;
@@ -191,7 +253,7 @@ void hists__collapse_resort(struct hists *self)
        tmp = RB_ROOT;
        next = rb_first(&self->entries);
        self->nr_entries = 0;
-        self->max_sym_namelen = 0;
+        hists__reset_col_len(self);
        while (next) {
                n = rb_entry(next, struct hist_entry, rb_node);
@@ -248,7 +310,7 @@ void hists__output_resort(struct hists *self)
        next = rb_first(&self->entries);
        self->nr_entries = 0;
-        self->max_sym_namelen = 0;
+        hists__reset_col_len(self);
        while (next) {
                n = rb_entry(next, struct hist_entry, rb_node);
@@ -515,8 +577,9 @@ static size_t hist_entry_callchain__fprintf(FILE *fp, struct hist_entry *self,
 }
 int hist_entry__snprintf(struct hist_entry *self, char *s, size_t size,
-                         struct hists *pair_hists, bool show_displacement,
+                         struct hists *hists, struct hists *pair_hists,
-                         long displacement, bool color, u64 session_total)
+                         bool show_displacement, long displacement,
+                         bool color, u64 session_total)
 {
        struct sort_entry *se;
        u64 period, total, period_sys, period_us, period_guest_sys, period_guest_us;
@@ -620,24 +683,25 @@ int hist_entry__snprintf(struct hist_entry *self, char *s, size_t size,
                ret += snprintf(s + ret, size - ret, "%s", sep ?: "  ");
                ret += se->se_snprintf(self, s + ret, size - ret,
-                                       se->se_width ? *se->se_width : 0);
+                                       hists__col_len(hists, se->se_width_idx));
        }
        return ret;
 }
-int hist_entry__fprintf(struct hist_entry *self, struct hists *pair_hists,
+int hist_entry__fprintf(struct hist_entry *self, struct hists *hists,
-                        bool show_displacement, long displacement, FILE *fp,
+                        struct hists *pair_hists, bool show_displacement,
-                        u64 session_total)
+                        long displacement, FILE *fp, u64 session_total)
 {
        char bf[512];
-        hist_entry__snprintf(self, bf, sizeof(bf), pair_hists,
+        hist_entry__snprintf(self, bf, sizeof(bf), hists, pair_hists,
                             show_displacement, displacement,
                             true, session_total);
        return fprintf(fp, "%s\n", bf);
 }
-static size_t hist_entry__fprintf_callchain(struct hist_entry *self, FILE *fp,
+static size_t hist_entry__fprintf_callchain(struct hist_entry *self,
+                                            struct hists *hists, FILE *fp,
                                            u64 session_total)
 {
        int left_margin = 0;
@@ -645,7 +709,7 @@ static size_t hist_entry__fprintf_callchain(struct hist_entry *self, FILE *fp,
        if (sort__first_dimension == SORT_COMM) {
                struct sort_entry *se = list_first_entry(&hist_entry__sort_list,
                                                         typeof(*se), list);
-                left_margin = se->se_width ? *se->se_width : 0;
+                left_margin = hists__col_len(hists, se->se_width_idx);
                left_margin -= thread__comm_len(self->thread);
        }
@@ -716,17 +780,17 @@ size_t hists__fprintf(struct hists *self, struct hists *pair,
                        continue;
                }
                width = strlen(se->se_header);
-                if (se->se_width) {
+                if (symbol_conf.col_width_list_str) {
-                        if (symbol_conf.col_width_list_str) {
+                        if (col_width) {
-                                if (col_width) {
+                                hists__set_col_len(self, se->se_width_idx,
-                                        *se->se_width = atoi(col_width);
+                                                   atoi(col_width));
-                                        col_width = strchr(col_width, ',');
+                                col_width = strchr(col_width, ',');
-                                        if (col_width)
+                                if (col_width)
-                                                ++col_width;
+                                        ++col_width;
-                                }
                        }
-                        width = *se->se_width = max(*se->se_width, width);
                }
+                if (!hists__new_col_len(self, se->se_width_idx, width))
+                        width = hists__col_len(self, se->se_width_idx);
                fprintf(fp, "  %*s", width, se->se_header);
        }
        fprintf(fp, "\n");
@@ -749,9 +813,8 @@ size_t hists__fprintf(struct hists *self, struct hists *pair,
                        continue;
                fprintf(fp, "  ");
-                if (se->se_width)
+                width = hists__col_len(self, se->se_width_idx);
-                        width = *se->se_width;
+                if (width == 0)
-                else
                        width = strlen(se->se_header);
                for (i = 0; i < width; i++)
                        fprintf(fp, ".");
@@ -771,12 +834,12 @@ print_entries:
                                displacement = 0;
                        ++position;
                }
-                ret += hist_entry__fprintf(h, pair, show_displacement,
+                ret += hist_entry__fprintf(h, self, pair, show_displacement,
                                           displacement, fp, self->stats.total_period);
                if (symbol_conf.use_callchain)
-                        ret += hist_entry__fprintf_callchain(h, fp, self->stats.total_period);
+                        ret += hist_entry__fprintf_callchain(h, self, fp,
+                                                             self->stats.total_period);
                if (h->ms.map == NULL && verbose > 1) {
                        __map_groups__fprintf_maps(&h->thread->mg,
                                                   MAP__FUNCTION, verbose, fp);
@@ -789,10 +852,52 @@ print_entries:
        return ret;
 }
-enum hist_filter {
+/*
-        HIST_FILTER__DSO,
+ * See hists__fprintf to match the column widths
-        HIST_FILTER__THREAD,
+ */
-};
+unsigned int hists__sort_list_width(struct hists *self)
+{
+        struct sort_entry *se;
+        int ret = 9; /* total % */
+        if (symbol_conf.show_cpu_utilization) {
+                ret += 7; /* count_sys % */
+                ret += 6; /* count_us % */
+                if (perf_guest) {
+                        ret += 13; /* count_guest_sys % */
+                        ret += 12; /* count_guest_us % */
+                }
+        }
+        if (symbol_conf.show_nr_samples)
+                ret += 11;
+        list_for_each_entry(se, &hist_entry__sort_list, list)
+                if (!se->elide)
+                        ret += 2 + hists__col_len(self, se->se_width_idx);
+        if (verbose) /* Addr + origin */
+                ret += 3 + BITS_PER_LONG / 4;
+        return ret;
+}
+static void hists__remove_entry_filter(struct hists *self, struct hist_entry *h,
+                                       enum hist_filter filter)
+{
+        h->filtered &= ~(1 << filter);
+        if (h->filtered)
+                return;
+        ++self->nr_entries;
+        if (h->ms.unfolded)
+                self->nr_entries += h->nr_rows;
+        h->row_offset = 0;
+        self->stats.total_period += h->period;
+        self->stats.nr_events[PERF_RECORD_SAMPLE] += h->nr_events;
+        hists__calc_col_len(self, h);
+}
 void hists__filter_by_dso(struct hists *self, const struct dso *dso)
 {
@@ -800,7 +905,7 @@ void hists__filter_by_dso(struct hists *self, const struct dso *dso)
        self->nr_entries = self->stats.total_period = 0;
        self->stats.nr_events[PERF_RECORD_SAMPLE] = 0;
-        self->max_sym_namelen = 0;
+        hists__reset_col_len(self);
        for (nd = rb_first(&self->entries); nd; nd = rb_next(nd)) {
                struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
@@ -813,15 +918,7 @@ void hists__filter_by_dso(struct hists *self, const struct dso *dso)
                        continue;
                }
-                h->filtered &= ~(1 << HIST_FILTER__DSO);
+                hists__remove_entry_filter(self, h, HIST_FILTER__DSO);
-                if (!h->filtered) {
-                        ++self->nr_entries;
-                        self->stats.total_period += h->period;
-                        self->stats.nr_events[PERF_RECORD_SAMPLE] += h->nr_events;
-                        if (h->ms.sym &&
-                            self->max_sym_namelen < h->ms.sym->namelen)
-                                self->max_sym_namelen = h->ms.sym->namelen;
-                }
        }
 }
@@ -831,7 +928,7 @@ void hists__filter_by_thread(struct hists *self, const struct thread *thread)
        self->nr_entries = self->stats.total_period = 0;
        self->stats.nr_events[PERF_RECORD_SAMPLE] = 0;
-        self->max_sym_namelen = 0;
+        hists__reset_col_len(self);
        for (nd = rb_first(&self->entries); nd; nd = rb_next(nd)) {
                struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
@@ -840,15 +937,8 @@ void hists__filter_by_thread(struct hists *self, const struct thread *thread)
                        h->filtered |= (1 << HIST_FILTER__THREAD);
                        continue;
                }
-                h->filtered &= ~(1 << HIST_FILTER__THREAD);
-                if (!h->filtered) {
+                hists__remove_entry_filter(self, h, HIST_FILTER__THREAD);
-                        ++self->nr_entries;
-                        self->stats.total_period += h->period;
-                        self->stats.nr_events[PERF_RECORD_SAMPLE] += h->nr_events;
-                        if (h->ms.sym &&
-                            self->max_sym_namelen < h->ms.sym->namelen)
-                                self->max_sym_namelen = h->ms.sym->namelen;
-                }
        }
 }
@@ -893,9 +983,9 @@ int hist_entry__inc_addr_samples(struct hist_entry *self, u64 ip)
        return 0;
 }
-static struct objdump_line *objdump_line__new(s64 offset, char *line)
+static struct objdump_line *objdump_line__new(s64 offset, char *line, size_t privsize)
 {
-        struct objdump_line *self = malloc(sizeof(*self));
+        struct objdump_line *self = malloc(sizeof(*self) + privsize);
        if (self != NULL) {
                self->offset = offset;
@@ -927,7 +1017,7 @@ struct objdump_line *objdump__get_next_ip_line(struct list_head *head,
 }
 static int hist_entry__parse_objdump_line(struct hist_entry *self, FILE *file,
-                                          struct list_head *head)
+                                          struct list_head *head, size_t privsize)
 {
        struct symbol *sym = self->ms.sym;
        struct objdump_line *objdump_line;
@@ -965,16 +1055,20 @@ static int hist_entry__parse_objdump_line(struct hist_entry *self, FILE *file,
                 * Parse hexa addresses followed by ':'
                 */
                line_ip = strtoull(tmp, &tmp2, 16);
-                if (*tmp2 != ':')
+                if (*tmp2 != ':' || tmp == tmp2 || tmp2[1] == '\0')
                        line_ip = -1;
        }
        if (line_ip != -1) {
-                u64 start = map__rip_2objdump(self->ms.map, sym->start);
+                u64 start = map__rip_2objdump(self->ms.map, sym->start),
+                    end = map__rip_2objdump(self->ms.map, sym->end);
                offset = line_ip - start;
+                if (offset < 0 || (u64)line_ip > end)
+                        offset = -1;
        }
-        objdump_line = objdump_line__new(offset, line);
+        objdump_line = objdump_line__new(offset, line, privsize);
        if (objdump_line == NULL) {
                free(line);
                return -1;
@@ -984,7 +1078,8 @@ static int hist_entry__parse_objdump_line(struct hist_entry *self, FILE *file,
        return 0;
 }
-int hist_entry__annotate(struct hist_entry *self, struct list_head *head)
+int hist_entry__annotate(struct hist_entry *self, struct list_head *head,
+                         size_t privsize)
 {
        struct symbol *sym = self->ms.sym;
        struct map *map = self->ms.map;
@@ -1037,7 +1132,7 @@ fallback:
                 dso, dso->long_name, sym, sym->name);
        snprintf(command, sizeof(command),
-                 "objdump --start-address=0x%016Lx --stop-address=0x%016Lx -dS %s|grep -v %s|expand",
+                 "objdump --start-address=0x%016Lx --stop-address=0x%016Lx -dS -C %s|grep -v %s|expand",
                 map__rip_2objdump(map, sym->start),
                 map__rip_2objdump(map, sym->end),
                 filename, filename);
@@ -1049,7 +1144,7 @@ fallback:
                goto out_free_filename;
        while (!feof(file))
-                if (hist_entry__parse_objdump_line(self, file, head) < 0)
+                if (hist_entry__parse_objdump_line(self, file, head, privsize) < 0)
                        break;
        pclose(file);
diff --git a/tools/perf/util/hist.h b/tools/perf/util/hist.h
index 83fa33a7b38b..587d375d3430 100644
--- a/tools/perf/util/hist.h
+++ b/tools/perf/util/hist.h
@@ -56,6 +56,16 @@ struct events_stats {
        u32 nr_unknown_events;
 };
+enum hist_column {
+        HISTC_SYMBOL,
+        HISTC_DSO,
+        HISTC_THREAD,
+        HISTC_COMM,
+        HISTC_PARENT,
+        HISTC_CPU,
+        HISTC_NR_COLS, /* Last entry */
+};
 struct hists {
        struct rb_node          rb_node;
        struct rb_root          entries;
@@ -64,7 +74,7 @@ struct hists {
        u64                     config;
        u64                     event_stream;
        u32                     type;
-        u32                     max_sym_namelen;
+        u16                     col_len[HISTC_NR_COLS];
 };
 struct hist_entry *__hists__add_entry(struct hists *self,
@@ -72,12 +82,13 @@ struct hist_entry *__hists__add_entry(struct hists *self,
                                      struct symbol *parent, u64 period);
 extern int64_t hist_entry__cmp(struct hist_entry *, struct hist_entry *);
 extern int64_t hist_entry__collapse(struct hist_entry *, struct hist_entry *);
-int hist_entry__fprintf(struct hist_entry *self, struct hists *pair_hists,
+int hist_entry__fprintf(struct hist_entry *self, struct hists *hists,
-                        bool show_displacement, long displacement, FILE *fp,
+                        struct hists *pair_hists, bool show_displacement,
-                        u64 total);
+                        long displacement, FILE *fp, u64 total);
 int hist_entry__snprintf(struct hist_entry *self, char *bf, size_t size,
-                         struct hists *pair_hists, bool show_displacement,
+                         struct hists *hists, struct hists *pair_hists,
-                         long displacement, bool color, u64 total);
+                         bool show_displacement, long displacement,
+                         bool color, u64 total);
 void hist_entry__free(struct hist_entry *);
 void hists__output_resort(struct hists *self);
@@ -90,11 +101,16 @@ size_t hists__fprintf(struct hists *self, struct hists *pair,
                      bool show_displacement, FILE *fp);
 int hist_entry__inc_addr_samples(struct hist_entry *self, u64 ip);
-int hist_entry__annotate(struct hist_entry *self, struct list_head *head);
+int hist_entry__annotate(struct hist_entry *self, struct list_head *head,
+                         size_t privsize);
 void hists__filter_by_dso(struct hists *self, const struct dso *dso);
 void hists__filter_by_thread(struct hists *self, const struct thread *thread);
+u16 hists__col_len(struct hists *self, enum hist_column col);
+void hists__set_col_len(struct hists *self, enum hist_column col, u16 len);
+bool hists__new_col_len(struct hists *self, enum hist_column col, u16 len);
 #ifdef NO_NEWT_SUPPORT
 static inline int hists__browse(struct hists *self __used,
                                const char *helpline __used,
@@ -126,4 +142,7 @@ int hist_entry__tui_annotate(struct hist_entry *self);
 int hists__tui_browse_tree(struct rb_root *self, const char *help);
 #endif
+unsigned int hists__sort_list_width(struct hists *self);
 #endif  /* __PERF_HIST_H */
diff --git a/tools/perf/util/include/linux/list.h b/tools/perf/util/include/linux/list.h
index dbe4b814382a..f5ca26e53fbb 100644
--- a/tools/perf/util/include/linux/list.h
+++ b/tools/perf/util/include/linux/list.h
@@ -15,4 +15,12 @@ static inline void list_del_range(struct list_head *begin,
        begin->prev->next = end->next;
        end->next->prev = begin->prev;
 }
+/**
+ * list_for_each_from   -       iterate over a list from one of its nodes
+ * @pos:  the &struct list_head to use as a loop cursor, from where to start
+ * @head: the head for your list.
+ */
+#define list_for_each_from(pos, head) \
+        for (; prefetch(pos->next), pos != (head); pos = pos->next)
 #endif
diff --git a/tools/perf/util/include/linux/types.h b/tools/perf/util/include/linux/types.h
index 196862a81a21..12de3b8112f9 100644
--- a/tools/perf/util/include/linux/types.h
+++ b/tools/perf/util/include/linux/types.h
@@ -6,4 +6,16 @@
 #define DECLARE_BITMAP(name,bits) \
        unsigned long name[BITS_TO_LONGS(bits)]
+struct list_head {
+        struct list_head *next, *prev;
+};
+struct hlist_head {
+        struct hlist_node *first;
+};
+struct hlist_node {
+        struct hlist_node *next, **pprev;
+};
 #endif
diff --git a/tools/perf/util/map.c b/tools/perf/util/map.c
index e672f2fef65b..3a7eb6ec0eec 100644
--- a/tools/perf/util/map.c
+++ b/tools/perf/util/map.c
@@ -17,16 +17,6 @@ static inline int is_anon_memory(const char *filename)
        return strcmp(filename, "//anon") == 0;
 }
-static int strcommon(const char *pathname, char *cwd, int cwdlen)
-{
-        int n = 0;
-        while (n < cwdlen && pathname[n] == cwd[n])
-                ++n;
-        return n;
-}
 void map__init(struct map *self, enum map_type type,
               u64 start, u64 end, u64 pgoff, struct dso *dso)
 {
@@ -39,11 +29,12 @@ void map__init(struct map *self, enum map_type type,
        self->unmap_ip = map__unmap_ip;
        RB_CLEAR_NODE(&self->rb_node);
        self->groups   = NULL;
+        self->referenced = false;
 }
 struct map *map__new(struct list_head *dsos__list, u64 start, u64 len,
                     u64 pgoff, u32 pid, char *filename,
-                     enum map_type type, char *cwd, int cwdlen)
+                     enum map_type type)
 {
        struct map *self = malloc(sizeof(*self));
@@ -52,16 +43,6 @@ struct map *map__new(struct list_head *dsos__list, u64 start, u64 len,
                struct dso *dso;
                int anon;
-                if (cwd) {
-                        int n = strcommon(filename, cwd, cwdlen);
-                        if (n == cwdlen) {
-                                snprintf(newfilename, sizeof(newfilename),
-                                         ".%s", filename + n);
-                                filename = newfilename;
-                        }
-                }
                anon = is_anon_memory(filename);
                if (anon) {
@@ -248,6 +229,39 @@ void map_groups__init(struct map_groups *self)
        self->machine = NULL;
 }
+static void maps__delete(struct rb_root *self)
+{
+        struct rb_node *next = rb_first(self);
+        while (next) {
+                struct map *pos = rb_entry(next, struct map, rb_node);
+                next = rb_next(&pos->rb_node);
+                rb_erase(&pos->rb_node, self);
+                map__delete(pos);
+        }
+}
+static void maps__delete_removed(struct list_head *self)
+{
+        struct map *pos, *n;
+        list_for_each_entry_safe(pos, n, self, node) {
+                list_del(&pos->node);
+                map__delete(pos);
+        }
+}
+void map_groups__exit(struct map_groups *self)
+{
+        int i;
+        for (i = 0; i < MAP__NR_TYPES; ++i) {
+                maps__delete(&self->maps[i]);
+                maps__delete_removed(&self->removed_maps[i]);
+        }
+}
 void map_groups__flush(struct map_groups *self)
 {
        int type;
@@ -374,6 +388,7 @@ int map_groups__fixup_overlappings(struct map_groups *self, struct map *map,
 {
        struct rb_root *root = &self->maps[map->type];
        struct rb_node *next = rb_first(root);
+        int err = 0;
        while (next) {
                struct map *pos = rb_entry(next, struct map, rb_node);
@@ -390,20 +405,16 @@ int map_groups__fixup_overlappings(struct map_groups *self, struct map *map,
                rb_erase(&pos->rb_node, root);
                /*
-                 * We may have references to this map, for instance in some
-                 * hist_entry instances, so just move them to a separate
-                 * list.
-                 */
-                list_add_tail(&pos->node, &self->removed_maps[map->type]);
-                /*
                 * Now check if we need to create new maps for areas not
                 * overlapped by the new map:
                 */
                if (map->start > pos->start) {
                        struct map *before = map__clone(pos);
-                        if (before == NULL)
+                        if (before == NULL) {
-                                return -ENOMEM;
+                                err = -ENOMEM;
+                                goto move_map;
+                        }
                        before->end = map->start - 1;
                        map_groups__insert(self, before);
@@ -414,14 +425,27 @@ int map_groups__fixup_overlappings(struct map_groups *self, struct map *map,
                if (map->end < pos->end) {
                        struct map *after = map__clone(pos);
-                        if (after == NULL)
+                        if (after == NULL) {
-                                return -ENOMEM;
+                                err = -ENOMEM;
+                                goto move_map;
+                        }
                        after->start = map->end + 1;
                        map_groups__insert(self, after);
                        if (verbose >= 2)
                                map__fprintf(after, fp);
                }
+move_map:
+                /*
+                 * If we have references, just move them to a separate list.
+                 */
+                if (pos->referenced)
+                        list_add_tail(&pos->node, &self->removed_maps[map->type]);
+                else
+                        map__delete(pos);
+                if (err)
+                        return err;
        }
        return 0;
@@ -493,6 +517,11 @@ void maps__insert(struct rb_root *maps, struct map *map)
        rb_insert_color(&map->rb_node, maps);
 }
+void maps__remove(struct rb_root *self, struct map *map)
+{
+        rb_erase(&map->rb_node, self);
+}
 struct map *maps__find(struct rb_root *maps, u64 ip)
 {
        struct rb_node **p = &maps->rb_node;
@@ -526,6 +555,31 @@ int machine__init(struct machine *self, const char *root_dir, pid_t pid)
        return self->root_dir == NULL ? -ENOMEM : 0;
 }
+static void dsos__delete(struct list_head *self)
+{
+        struct dso *pos, *n;
+        list_for_each_entry_safe(pos, n, self, node) {
+                list_del(&pos->node);
+                dso__delete(pos);
+        }
+}
+void machine__exit(struct machine *self)
+{
+        map_groups__exit(&self->kmaps);
+        dsos__delete(&self->user_dsos);
+        dsos__delete(&self->kernel_dsos);
+        free(self->root_dir);
+        self->root_dir = NULL;
+}
+void machine__delete(struct machine *self)
+{
+        machine__exit(self);
+        free(self);
+}
 struct machine *machines__add(struct rb_root *self, pid_t pid,
                              const char *root_dir)
 {
diff --git a/tools/perf/util/map.h b/tools/perf/util/map.h
index f39134512829..78575796d5f3 100644
--- a/tools/perf/util/map.h
+++ b/tools/perf/util/map.h
@@ -29,7 +29,8 @@ struct map {
        };
        u64                     start;
        u64                     end;
-        enum map_type           type;
+        u8 /* enum map_type */  type;
+        bool                    referenced;
        u32                     priv;
        u64                     pgoff;
@@ -106,7 +107,7 @@ void map__init(struct map *self, enum map_type type,
               u64 start, u64 end, u64 pgoff, struct dso *dso);
 struct map *map__new(struct list_head *dsos__list, u64 start, u64 len,
                     u64 pgoff, u32 pid, char *filename,
-                     enum map_type type, char *cwd, int cwdlen);
+                     enum map_type type);
 void map__delete(struct map *self);
 struct map *map__clone(struct map *self);
 int map__overlap(struct map *l, struct map *r);
@@ -125,8 +126,10 @@ void map__reloc_vmlinux(struct map *self);
 size_t __map_groups__fprintf_maps(struct map_groups *self,
                                  enum map_type type, int verbose, FILE *fp);
 void maps__insert(struct rb_root *maps, struct map *map);
+void maps__remove(struct rb_root *self, struct map *map);
 struct map *maps__find(struct rb_root *maps, u64 addr);
 void map_groups__init(struct map_groups *self);
+void map_groups__exit(struct map_groups *self);
 int map_groups__clone(struct map_groups *self,
                      struct map_groups *parent, enum map_type type);
 size_t map_groups__fprintf(struct map_groups *self, int verbose, FILE *fp);
@@ -142,6 +145,8 @@ struct machine *machines__find(struct rb_root *self, pid_t pid);
 struct machine *machines__findnew(struct rb_root *self, pid_t pid);
 char *machine__mmap_name(struct machine *self, char *bf, size_t size);
 int machine__init(struct machine *self, const char *root_dir, pid_t pid);
+void machine__exit(struct machine *self);
+void machine__delete(struct machine *self);
 /*
 * Default guest kernel is defined by parameter --guestkallsyms
@@ -163,6 +168,11 @@ static inline void map_groups__insert(struct map_groups *self, struct map *map)
        map->groups = self;
 }
+static inline void map_groups__remove(struct map_groups *self, struct map *map)
+{
+        maps__remove(&self->maps[map->type], map);
+}
 static inline struct map *map_groups__find(struct map_groups *self,
                                           enum map_type type, u64 addr)
 {
diff --git a/tools/perf/util/newt.c b/tools/perf/util/newt.c
deleted file mode 100644
index cf182ca132fe..000000000000
--- a/tools/perf/util/newt.c
+++ /dev/null
@@ -1,1167 +0,0 @@
-#define _GNU_SOURCE
-#include <stdio.h>
-#undef _GNU_SOURCE
-/*
- * slang versions <= 2.0.6 have a "#if HAVE_LONG_LONG" that breaks
- * the build if it isn't defined. Use the equivalent one that glibc
- * has on features.h.
- */
-#include <features.h>
-#ifndef HAVE_LONG_LONG
-#define HAVE_LONG_LONG __GLIBC_HAVE_LONG_LONG
-#endif
-#include <slang.h>
-#include <stdlib.h>
-#include <newt.h>
-#include <sys/ttydefaults.h>
-#include "cache.h"
-#include "hist.h"
-#include "pstack.h"
-#include "session.h"
-#include "sort.h"
-#include "symbol.h"
-#if SLANG_VERSION < 20104
-#define slsmg_printf(msg, args...) SLsmg_printf((char *)msg, ##args)
-#define slsmg_write_nstring(msg, len) SLsmg_write_nstring((char *)msg, len)
-#define sltt_set_color(obj, name, fg, bg) SLtt_set_color(obj,(char *)name,\
-                                                         (char *)fg, (char *)bg)
-#else
-#define slsmg_printf SLsmg_printf
-#define slsmg_write_nstring SLsmg_write_nstring
-#define sltt_set_color SLtt_set_color
-#endif
-struct ui_progress {
-        newtComponent form, scale;
-};
-struct ui_progress *ui_progress__new(const char *title, u64 total)
-{
-        struct ui_progress *self = malloc(sizeof(*self));
-        if (self != NULL) {
-                int cols;
-                newtGetScreenSize(&cols, NULL);
-                cols -= 4;
-                newtCenteredWindow(cols, 1, title);
-                self->form  = newtForm(NULL, NULL, 0);
-                if (self->form == NULL)
-                        goto out_free_self;
-                self->scale = newtScale(0, 0, cols, total);
-                if (self->scale == NULL)
-                        goto out_free_form;
-                newtFormAddComponent(self->form, self->scale);
-                newtRefresh();
-        }
-        return self;
-out_free_form:
-        newtFormDestroy(self->form);
-out_free_self:
-        free(self);
-        return NULL;
-}
-void ui_progress__update(struct ui_progress *self, u64 curr)
-{
-        newtScaleSet(self->scale, curr);
-        newtRefresh();
-}
-void ui_progress__delete(struct ui_progress *self)
-{
-        newtFormDestroy(self->form);
-        newtPopWindow();
-        free(self);
-}
-static void ui_helpline__pop(void)
-{
-        newtPopHelpLine();
-}
-static void ui_helpline__push(const char *msg)
-{
-        newtPushHelpLine(msg);
-}
-static void ui_helpline__vpush(const char *fmt, va_list ap)
-{
-        char *s;
-        if (vasprintf(&s, fmt, ap) < 0)
-                vfprintf(stderr, fmt, ap);
-        else {
-                ui_helpline__push(s);
-                free(s);
-        }
-}
-static void ui_helpline__fpush(const char *fmt, ...)
-{
-        va_list ap;
-        va_start(ap, fmt);
-        ui_helpline__vpush(fmt, ap);
-        va_end(ap);
-}
-static void ui_helpline__puts(const char *msg)
-{
-        ui_helpline__pop();
-        ui_helpline__push(msg);
-}
-static char browser__last_msg[1024];
-int browser__show_help(const char *format, va_list ap)
-{
-        int ret;
-        static int backlog;
-        ret = vsnprintf(browser__last_msg + backlog,
-                        sizeof(browser__last_msg) - backlog, format, ap);
-        backlog += ret;
-        if (browser__last_msg[backlog - 1] == '\n') {
-                ui_helpline__puts(browser__last_msg);
-                newtRefresh();
-                backlog = 0;
-        }
-        return ret;
-}
-static void newt_form__set_exit_keys(newtComponent self)
-{
-        newtFormAddHotKey(self, NEWT_KEY_LEFT);
-        newtFormAddHotKey(self, NEWT_KEY_ESCAPE);
-        newtFormAddHotKey(self, 'Q');
-        newtFormAddHotKey(self, 'q');
-        newtFormAddHotKey(self, CTRL('c'));
-}
-static newtComponent newt_form__new(void)
-{
-        newtComponent self = newtForm(NULL, NULL, 0);
-        if (self)
-                newt_form__set_exit_keys(self);
-        return self;
-}
-static int popup_menu(int argc, char * const argv[])
-{
-        struct newtExitStruct es;
-        int i, rc = -1, max_len = 5;
-        newtComponent listbox, form = newt_form__new();
-        if (form == NULL)
-                return -1;
-        listbox = newtListbox(0, 0, argc, NEWT_FLAG_RETURNEXIT);
-        if (listbox == NULL)
-                goto out_destroy_form;
-        newtFormAddComponent(form, listbox);
-        for (i = 0; i < argc; ++i) {
-                int len = strlen(argv[i]);
-                if (len > max_len)
-                        max_len = len;
-                if (newtListboxAddEntry(listbox, argv[i], (void *)(long)i))
-                        goto out_destroy_form;
-        }
-        newtCenteredWindow(max_len, argc, NULL);
-        newtFormRun(form, &es);
-        rc = newtListboxGetCurrent(listbox) - NULL;
-        if (es.reason == NEWT_EXIT_HOTKEY)
-                rc = -1;
-        newtPopWindow();
-out_destroy_form:
-        newtFormDestroy(form);
-        return rc;
-}
-static int ui__help_window(const char *text)
-{
-        struct newtExitStruct es;
-        newtComponent tb, form = newt_form__new();
-        int rc = -1;
-        int max_len = 0, nr_lines = 0;
-        const char *t;
-        if (form == NULL)
-                return -1;
-        t = text;
-        while (1) {
-                const char *sep = strchr(t, '\n');
-                int len;
-                if (sep == NULL)
-                        sep = strchr(t, '\0');
-                len = sep - t;
-                if (max_len < len)
-                        max_len = len;
-                ++nr_lines;
-                if (*sep == '\0')
-                        break;
-                t = sep + 1;
-        }
-        tb = newtTextbox(0, 0, max_len, nr_lines, 0);
-        if (tb == NULL)
-                goto out_destroy_form;
-        newtTextboxSetText(tb, text);
-        newtFormAddComponent(form, tb);
-        newtCenteredWindow(max_len, nr_lines, NULL);
-        newtFormRun(form, &es);
-        newtPopWindow();
-        rc = 0;
-out_destroy_form:
-        newtFormDestroy(form);
-        return rc;
-}
-static bool dialog_yesno(const char *msg)
-{
-        /* newtWinChoice should really be accepting const char pointers... */
-        char yes[] = "Yes", no[] = "No";
-        return newtWinChoice(NULL, yes, no, (char *)msg) == 1;
-}
-static void ui__error_window(const char *fmt, ...)
-{
-        va_list ap;
-        va_start(ap, fmt);
-        newtWinMessagev((char *)"Error", (char *)"Ok", (char *)fmt, ap);
-        va_end(ap);
-}
-#define HE_COLORSET_TOP         50
-#define HE_COLORSET_MEDIUM      51
-#define HE_COLORSET_NORMAL      52
-#define HE_COLORSET_SELECTED    53
-#define HE_COLORSET_CODE        54
-static int ui_browser__percent_color(double percent, bool current)
-{
-        if (current)
-                return HE_COLORSET_SELECTED;
-        if (percent >= MIN_RED)
-                return HE_COLORSET_TOP;
-        if (percent >= MIN_GREEN)
-                return HE_COLORSET_MEDIUM;
-        return HE_COLORSET_NORMAL;
-}
-struct ui_browser {
-        newtComponent   form, sb;
-        u64             index, first_visible_entry_idx;
-        void            *first_visible_entry, *entries;
-        u16             top, left, width, height;
-        void            *priv;
-        u32             nr_entries;
-};
-static void ui_browser__refresh_dimensions(struct ui_browser *self)
-{
-        int cols, rows;
-        newtGetScreenSize(&cols, &rows);
-        if (self->width > cols - 4)
-                self->width = cols - 4;
-        self->height = rows - 5;
-        if (self->height > self->nr_entries)
-                self->height = self->nr_entries;
-        self->top  = (rows - self->height) / 2;
-        self->left = (cols - self->width) / 2;
-}
-static void ui_browser__reset_index(struct ui_browser *self)
-{
-        self->index = self->first_visible_entry_idx = 0;
-        self->first_visible_entry = NULL;
-}
-static int objdump_line__show(struct objdump_line *self, struct list_head *head,
-                              int width, struct hist_entry *he, int len,
-                              bool current_entry)
-{
-        if (self->offset != -1) {
-                struct symbol *sym = he->ms.sym;
-                unsigned int hits = 0;
-                double percent = 0.0;
-                int color;
-                struct sym_priv *priv = symbol__priv(sym);
-                struct sym_ext *sym_ext = priv->ext;
-                struct sym_hist *h = priv->hist;
-                s64 offset = self->offset;
-                struct objdump_line *next = objdump__get_next_ip_line(head, self);
-                while (offset < (s64)len &&
-                       (next == NULL || offset < next->offset)) {
-                        if (sym_ext) {
-                                percent += sym_ext[offset].percent;
-                        } else
-                                hits += h->ip[offset];
-                        ++offset;
-                }
-                if (sym_ext == NULL && h->sum)
-                        percent = 100.0 * hits / h->sum;
-                color = ui_browser__percent_color(percent, current_entry);
-                SLsmg_set_color(color);
-                slsmg_printf(" %7.2f ", percent);
-                if (!current_entry)
-                        SLsmg_set_color(HE_COLORSET_CODE);
-        } else {
-                int color = ui_browser__percent_color(0, current_entry);
-                SLsmg_set_color(color);
-                slsmg_write_nstring(" ", 9);
-        }
-        SLsmg_write_char(':');
-        slsmg_write_nstring(" ", 8);
-        if (!*self->line)
-                slsmg_write_nstring(" ", width - 18);
-        else
-                slsmg_write_nstring(self->line, width - 18);
-        return 0;
-}
-static int ui_browser__refresh_entries(struct ui_browser *self)
-{
-        struct objdump_line *pos;
-        struct list_head *head = self->entries;
-        struct hist_entry *he = self->priv;
-        int row = 0;
-        int len = he->ms.sym->end - he->ms.sym->start;
-        if (self->first_visible_entry == NULL || self->first_visible_entry == self->entries)
-                self->first_visible_entry = head->next;
-        pos = list_entry(self->first_visible_entry, struct objdump_line, node);
-        list_for_each_entry_from(pos, head, node) {
-                bool current_entry = (self->first_visible_entry_idx + row) == self->index;
-                SLsmg_gotorc(self->top + row, self->left);
-                objdump_line__show(pos, head, self->width,
-                                   he, len, current_entry);
-                if (++row == self->height)
-                        break;
-        }
-        SLsmg_set_color(HE_COLORSET_NORMAL);
-        SLsmg_fill_region(self->top + row, self->left,
-                          self->height - row, self->width, ' ');
-        return 0;
-}
-static int ui_browser__run(struct ui_browser *self, const char *title,
-                           struct newtExitStruct *es)
-{
-        if (self->form) {
-                newtFormDestroy(self->form);
-                newtPopWindow();
-        }
-        ui_browser__refresh_dimensions(self);
-        newtCenteredWindow(self->width + 2, self->height, title);
-        self->form = newt_form__new();
-        if (self->form == NULL)
-                return -1;
-        self->sb = newtVerticalScrollbar(self->width + 1, 0, self->height,
-                                         HE_COLORSET_NORMAL,
-                                         HE_COLORSET_SELECTED);
-        if (self->sb == NULL)
-                return -1;
-        newtFormAddHotKey(self->form, NEWT_KEY_UP);
-        newtFormAddHotKey(self->form, NEWT_KEY_DOWN);
-        newtFormAddHotKey(self->form, NEWT_KEY_PGUP);
-        newtFormAddHotKey(self->form, NEWT_KEY_PGDN);
-        newtFormAddHotKey(self->form, ' ');
-        newtFormAddHotKey(self->form, NEWT_KEY_HOME);
-        newtFormAddHotKey(self->form, NEWT_KEY_END);
-        newtFormAddHotKey(self->form, NEWT_KEY_TAB);
-        newtFormAddHotKey(self->form, NEWT_KEY_RIGHT);
-        if (ui_browser__refresh_entries(self) < 0)
-                return -1;
-        newtFormAddComponent(self->form, self->sb);
-        while (1) {
-                unsigned int offset;
-                newtFormRun(self->form, es);
-                if (es->reason != NEWT_EXIT_HOTKEY)
-                        break;
-                if (is_exit_key(es->u.key))
-                        return es->u.key;
-                switch (es->u.key) {
-                case NEWT_KEY_DOWN:
-                        if (self->index == self->nr_entries - 1)
-                                break;
-                        ++self->index;
-                        if (self->index == self->first_visible_entry_idx + self->height) {
-                                struct list_head *pos = self->first_visible_entry;
-                                ++self->first_visible_entry_idx;
-                                self->first_visible_entry = pos->next;
-                        }
-                        break;
-                case NEWT_KEY_UP:
-                        if (self->index == 0)
-                                break;
-                        --self->index;
-                        if (self->index < self->first_visible_entry_idx) {
-                                struct list_head *pos = self->first_visible_entry;
-                                --self->first_visible_entry_idx;
-                                self->first_visible_entry = pos->prev;
-                        }
-                        break;
-                case NEWT_KEY_PGDN:
-                case ' ':
-                        if (self->first_visible_entry_idx + self->height > self->nr_entries - 1)
-                                break;
-                        offset = self->height;
-                        if (self->index + offset > self->nr_entries - 1)
-                                offset = self->nr_entries - 1 - self->index;
-                        self->index += offset;
-                        self->first_visible_entry_idx += offset;
-                        while (offset--) {
-                                struct list_head *pos = self->first_visible_entry;
-                                self->first_visible_entry = pos->next;
-                        }
-                        break;
-                case NEWT_KEY_PGUP:
-                        if (self->first_visible_entry_idx == 0)
-                                break;
-                        if (self->first_visible_entry_idx < self->height)
-                                offset = self->first_visible_entry_idx;
-                        else
-                                offset = self->height;
-                        self->index -= offset;
-                        self->first_visible_entry_idx -= offset;
-                        while (offset--) {
-                                struct list_head *pos = self->first_visible_entry;
-                                self->first_visible_entry = pos->prev;
-                        }
-                        break;
-                case NEWT_KEY_HOME:
-                        ui_browser__reset_index(self);
-                        break;
-                case NEWT_KEY_END: {
-                        struct list_head *head = self->entries;
-                        offset = self->height - 1;
-                        if (offset > self->nr_entries)
-                                offset = self->nr_entries;
-                        self->index = self->first_visible_entry_idx = self->nr_entries - 1 - offset;
-                        self->first_visible_entry = head->prev;
-                        while (offset-- != 0) {
-                                struct list_head *pos = self->first_visible_entry;
-                                self->first_visible_entry = pos->prev;
-                        }
-                }
-                        break;
-                case NEWT_KEY_RIGHT:
-                case NEWT_KEY_LEFT:
-                case NEWT_KEY_TAB:
-                        return es->u.key;
-                default:
-                        continue;
-                }
-                if (ui_browser__refresh_entries(self) < 0)
-                        return -1;
-        }
-        return 0;
-}
-/*
- * When debugging newt problems it was useful to be able to "unroll"
- * the calls to newtCheckBoxTreeAdd{Array,Item}, so that we can generate
- * a source file with the sequence of calls to these methods, to then
- * tweak the arrays to get the intended results, so I'm keeping this code
- * here, may be useful again in the future.
- */
-#undef NEWT_DEBUG
-static void newt_checkbox_tree__add(newtComponent tree, const char *str,
-                                    void *priv, int *indexes)
-{
-#ifdef NEWT_DEBUG
-        /* Print the newtCheckboxTreeAddArray to tinker with its index arrays */
-        int i = 0, len = 40 - strlen(str);
-        fprintf(stderr,
-                "\tnewtCheckboxTreeAddItem(tree, %*.*s\"%s\", (void *)%p, 0, ",
-                len, len, " ", str, priv);
-        while (indexes[i] != NEWT_ARG_LAST) {
-                if (indexes[i] != NEWT_ARG_APPEND)
-                        fprintf(stderr, " %d,", indexes[i]);
-                else
-                        fprintf(stderr, " %s,", "NEWT_ARG_APPEND");
-                ++i;
-        }
-        fprintf(stderr, " %s", " NEWT_ARG_LAST);\n");
-        fflush(stderr);
-#endif
-        newtCheckboxTreeAddArray(tree, str, priv, 0, indexes);
-}
-static char *callchain_list__sym_name(struct callchain_list *self,
-                                      char *bf, size_t bfsize)
-{
-        if (self->ms.sym)
-                return self->ms.sym->name;
-        snprintf(bf, bfsize, "%#Lx", self->ip);
-        return bf;
-}
-static void __callchain__append_graph_browser(struct callchain_node *self,
-                                              newtComponent tree, u64 total,
-                                              int *indexes, int depth)
-{
-        struct rb_node *node;
-        u64 new_total, remaining;
-        int idx = 0;
-        if (callchain_param.mode == CHAIN_GRAPH_REL)
-                new_total = self->children_hit;
-        else
-                new_total = total;
-        remaining = new_total;
-        node = rb_first(&self->rb_root);
-        while (node) {
-                struct callchain_node *child = rb_entry(node, struct callchain_node, rb_node);
-                struct rb_node *next = rb_next(node);
-                u64 cumul = cumul_hits(child);
-                struct callchain_list *chain;
-                int first = true, printed = 0;
-                int chain_idx = -1;
-                remaining -= cumul;
-                indexes[depth] = NEWT_ARG_APPEND;
-                indexes[depth + 1] = NEWT_ARG_LAST;
-                list_for_each_entry(chain, &child->val, list) {
-                        char ipstr[BITS_PER_LONG / 4 + 1],
-                             *alloc_str = NULL;
-                        const char *str = callchain_list__sym_name(chain, ipstr, sizeof(ipstr));
-                        if (first) {
-                                double percent = cumul * 100.0 / new_total;
-                                first = false;
-                                if (asprintf(&alloc_str, "%2.2f%% %s", percent, str) < 0)
-                                        str = "Not enough memory!";
-                                else
-                                        str = alloc_str;
-                        } else {
-                                indexes[depth] = idx;
-                                indexes[depth + 1] = NEWT_ARG_APPEND;
-                                indexes[depth + 2] = NEWT_ARG_LAST;
-                                ++chain_idx;
-                        }
-                        newt_checkbox_tree__add(tree, str, &chain->ms, indexes);
-                        free(alloc_str);
-                        ++printed;
-                }
-                indexes[depth] = idx;
-                if (chain_idx != -1)
-                        indexes[depth + 1] = chain_idx;
-                if (printed != 0)
-                        ++idx;
-                __callchain__append_graph_browser(child, tree, new_total, indexes,
-                                                  depth + (chain_idx != -1 ? 2 : 1));
-                node = next;
-        }
-}
-static void callchain__append_graph_browser(struct callchain_node *self,
-                                            newtComponent tree, u64 total,
-                                            int *indexes, int parent_idx)
-{
-        struct callchain_list *chain;
-        int i = 0;
-        indexes[1] = NEWT_ARG_APPEND;
-        indexes[2] = NEWT_ARG_LAST;
-        list_for_each_entry(chain, &self->val, list) {
-                char ipstr[BITS_PER_LONG / 4 + 1], *str;
-                if (chain->ip >= PERF_CONTEXT_MAX)
-                        continue;
-                if (!i++ && sort__first_dimension == SORT_SYM)
-                        continue;
-                str = callchain_list__sym_name(chain, ipstr, sizeof(ipstr));
-                newt_checkbox_tree__add(tree, str, &chain->ms, indexes);
-        }
-        indexes[1] = parent_idx;
-        indexes[2] = NEWT_ARG_APPEND;
-        indexes[3] = NEWT_ARG_LAST;
-        __callchain__append_graph_browser(self, tree, total, indexes, 2);
-}
-static void hist_entry__append_callchain_browser(struct hist_entry *self,
-                                                 newtComponent tree, u64 total, int parent_idx)
-{
-        struct rb_node *rb_node;
-        int indexes[1024] = { [0] = parent_idx, };
-        int idx = 0;
-        struct callchain_node *chain;
-        rb_node = rb_first(&self->sorted_chain);
-        while (rb_node) {
-                chain = rb_entry(rb_node, struct callchain_node, rb_node);
-                switch (callchain_param.mode) {
-                case CHAIN_FLAT:
-                        break;
-                case CHAIN_GRAPH_ABS: /* falldown */
-                case CHAIN_GRAPH_REL:
-                        callchain__append_graph_browser(chain, tree, total, indexes, idx++);
-                        break;
-                case CHAIN_NONE:
-                default:
-                        break;
-                }
-                rb_node = rb_next(rb_node);
-        }
-}
-static size_t hist_entry__append_browser(struct hist_entry *self,
-                                         newtComponent tree, u64 total)
-{
-        char s[256];
-        size_t ret;
-        if (symbol_conf.exclude_other && !self->parent)
-                return 0;
-        ret = hist_entry__snprintf(self, s, sizeof(s), NULL,
-                                   false, 0, false, total);
-        if (symbol_conf.use_callchain) {
-                int indexes[2];
-                indexes[0] = NEWT_ARG_APPEND;
-                indexes[1] = NEWT_ARG_LAST;
-                newt_checkbox_tree__add(tree, s, &self->ms, indexes);
-        } else
-                newtListboxAppendEntry(tree, s, &self->ms);
-        return ret;
-}
-int hist_entry__tui_annotate(struct hist_entry *self)
-{
-        struct ui_browser browser;
-        struct newtExitStruct es;
-        struct objdump_line *pos, *n;
-        LIST_HEAD(head);
-        int ret;
-        if (self->ms.sym == NULL)
-                return -1;
-        if (self->ms.map->dso->annotate_warned)
-                return -1;
-        if (hist_entry__annotate(self, &head) < 0) {
-                ui__error_window(browser__last_msg);
-                return -1;
-        }
-        ui_helpline__push("Press <- or ESC to exit");
-        memset(&browser, 0, sizeof(browser));
-        browser.entries = &head;
-        browser.priv = self;
-        list_for_each_entry(pos, &head, node) {
-                size_t line_len = strlen(pos->line);
-                if (browser.width < line_len)
-                        browser.width = line_len;
-                ++browser.nr_entries;
-        }
-        browser.width += 18; /* Percentage */
-        ret = ui_browser__run(&browser, self->ms.sym->name, &es);
-        newtFormDestroy(browser.form);
-        newtPopWindow();
-        list_for_each_entry_safe(pos, n, &head, node) {
-                list_del(&pos->node);
-                objdump_line__free(pos);
-        }
-        ui_helpline__pop();
-        return ret;
-}
-static const void *newt__symbol_tree_get_current(newtComponent self)
-{
-        if (symbol_conf.use_callchain)
-                return newtCheckboxTreeGetCurrent(self);
-        return newtListboxGetCurrent(self);
-}
-static void hist_browser__selection(newtComponent self, void *data)
-{
-        const struct map_symbol **symbol_ptr = data;
-        *symbol_ptr = newt__symbol_tree_get_current(self);
-}
-struct hist_browser {
-        newtComponent           form, tree;
-        const struct map_symbol *selection;
-};
-static struct hist_browser *hist_browser__new(void)
-{
-        struct hist_browser *self = malloc(sizeof(*self));
-        if (self != NULL)
-                self->form = NULL;
-        return self;
-}
-static void hist_browser__delete(struct hist_browser *self)
-{
-        newtFormDestroy(self->form);
-        newtPopWindow();
-        free(self);
-}
-static int hist_browser__populate(struct hist_browser *self, struct hists *hists,
-                                  const char *title)
-{
-        int max_len = 0, idx, cols, rows;
-        struct ui_progress *progress;
-        struct rb_node *nd;
-        u64 curr_hist = 0;
-        char seq[] = ".", unit;
-        char str[256];
-        unsigned long nr_events = hists->stats.nr_events[PERF_RECORD_SAMPLE];
-        if (self->form) {
-                newtFormDestroy(self->form);
-                newtPopWindow();
-        }
-        nr_events = convert_unit(nr_events, &unit);
-        snprintf(str, sizeof(str), "Events: %lu%c                            ",
-                 nr_events, unit);
-        newtDrawRootText(0, 0, str);
-        newtGetScreenSize(NULL, &rows);
-        if (symbol_conf.use_callchain)
-                self->tree = newtCheckboxTreeMulti(0, 0, rows - 5, seq,
-                                                   NEWT_FLAG_SCROLL);
-        else
-                self->tree = newtListbox(0, 0, rows - 5,
-                                        (NEWT_FLAG_SCROLL |
-                                         NEWT_FLAG_RETURNEXIT));
-        newtComponentAddCallback(self->tree, hist_browser__selection,
-                                 &self->selection);
-        progress = ui_progress__new("Adding entries to the browser...",
-                                    hists->nr_entries);
-        if (progress == NULL)
-                return -1;
-        idx = 0;
-        for (nd = rb_first(&hists->entries); nd; nd = rb_next(nd)) {
-                struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
-                int len;
-                if (h->filtered)
-                        continue;
-                len = hist_entry__append_browser(h, self->tree, hists->stats.total_period);
-                if (len > max_len)
-                        max_len = len;
-                if (symbol_conf.use_callchain)
-                        hist_entry__append_callchain_browser(h, self->tree,
-                                                             hists->stats.total_period, idx++);
-                ++curr_hist;
-                if (curr_hist % 5)
-                        ui_progress__update(progress, curr_hist);
-        }
-        ui_progress__delete(progress);
-        newtGetScreenSize(&cols, &rows);
-        if (max_len > cols)
-                max_len = cols - 3;
-        if (!symbol_conf.use_callchain)
-                newtListboxSetWidth(self->tree, max_len);
-        newtCenteredWindow(max_len + (symbol_conf.use_callchain ? 5 : 0),
-                           rows - 5, title);
-        self->form = newt_form__new();
-        if (self->form == NULL)
-                return -1;
-        newtFormAddHotKey(self->form, 'A');
-        newtFormAddHotKey(self->form, 'a');
-        newtFormAddHotKey(self->form, 'D');
-        newtFormAddHotKey(self->form, 'd');
-        newtFormAddHotKey(self->form, 'T');
-        newtFormAddHotKey(self->form, 't');
-        newtFormAddHotKey(self->form, '?');
-        newtFormAddHotKey(self->form, 'H');
-        newtFormAddHotKey(self->form, 'h');
-        newtFormAddHotKey(self->form, NEWT_KEY_F1);
-        newtFormAddHotKey(self->form, NEWT_KEY_RIGHT);
-        newtFormAddHotKey(self->form, NEWT_KEY_TAB);
-        newtFormAddHotKey(self->form, NEWT_KEY_UNTAB);
-        newtFormAddComponents(self->form, self->tree, NULL);
-        self->selection = newt__symbol_tree_get_current(self->tree);
-        return 0;
-}
-static struct hist_entry *hist_browser__selected_entry(struct hist_browser *self)
-{
-        int *indexes;
-        if (!symbol_conf.use_callchain)
-                goto out;
-        indexes = newtCheckboxTreeFindItem(self->tree, (void *)self->selection);
-        if (indexes) {
-                bool is_hist_entry = indexes[1] == NEWT_ARG_LAST;
-                free(indexes);
-                if (is_hist_entry)
-                        goto out;
-        }
-        return NULL;
-out:
-        return container_of(self->selection, struct hist_entry, ms);
-}
-static struct thread *hist_browser__selected_thread(struct hist_browser *self)
-{
-        struct hist_entry *he = hist_browser__selected_entry(self);
-        return he ? he->thread : NULL;
-}
-static int hist_browser__title(char *bf, size_t size, const char *ev_name,
-                               const struct dso *dso, const struct thread *thread)
-{
-        int printed = 0;
-        if (thread)
-                printed += snprintf(bf + printed, size - printed,
-                                    "Thread: %s(%d)",
-                                    (thread->comm_set ?  thread->comm : ""),
-                                    thread->pid);
-        if (dso)
-                printed += snprintf(bf + printed, size - printed,
-                                    "%sDSO: %s", thread ? " " : "",
-                                    dso->short_name);
-        return printed ?: snprintf(bf, size, "Event: %s", ev_name);
-}
-int hists__browse(struct hists *self, const char *helpline, const char *ev_name)
-{
-        struct hist_browser *browser = hist_browser__new();
-        struct pstack *fstack;
-        const struct thread *thread_filter = NULL;
-        const struct dso *dso_filter = NULL;
-        struct newtExitStruct es;
-        char msg[160];
-        int key = -1;
-        if (browser == NULL)
-                return -1;
-        fstack = pstack__new(2);
-        if (fstack == NULL)
-                goto out;
-        ui_helpline__push(helpline);
-        hist_browser__title(msg, sizeof(msg), ev_name,
-                            dso_filter, thread_filter);
-        if (hist_browser__populate(browser, self, msg) < 0)
-                goto out_free_stack;
-        while (1) {
-                const struct thread *thread;
-                const struct dso *dso;
-                char *options[16];
-                int nr_options = 0, choice = 0, i,
-                    annotate = -2, zoom_dso = -2, zoom_thread = -2;
-                newtFormRun(browser->form, &es);
-                thread = hist_browser__selected_thread(browser);
-                dso = browser->selection->map ? browser->selection->map->dso : NULL;
-                if (es.reason == NEWT_EXIT_HOTKEY) {
-                        key = es.u.key;
-                        switch (key) {
-                        case NEWT_KEY_F1:
-                                goto do_help;
-                        case NEWT_KEY_TAB:
-                        case NEWT_KEY_UNTAB:
-                                /*
-                                 * Exit the browser, let hists__browser_tree
-                                 * go to the next or previous
-                                 */
-                                goto out_free_stack;
-                        default:;
-                        }
-                        key = toupper(key);
-                        switch (key) {
-                        case 'A':
-                                if (browser->selection->map == NULL &&
-                                    browser->selection->map->dso->annotate_warned)
-                                        continue;
-                                goto do_annotate;
-                        case 'D':
-                                goto zoom_dso;
-                        case 'T':
-                                goto zoom_thread;
-                        case 'H':
-                        case '?':
-do_help:
-                                ui__help_window("->        Zoom into DSO/Threads & Annotate current symbol\n"
-                                                "<-        Zoom out\n"
-                                                "a         Annotate current symbol\n"
-                                                "h/?/F1    Show this window\n"
-                                                "d         Zoom into current DSO\n"
-                                                "t         Zoom into current Thread\n"
-                                                "q/CTRL+C  Exit browser");
-                                continue;
-                        default:;
-                        }
-                        if (is_exit_key(key)) {
-                                if (key == NEWT_KEY_ESCAPE) {
-                                        if (dialog_yesno("Do you really want to exit?"))
-                                                break;
-                                        else
-                                                continue;
-                                } else
-                                        break;
-                        }
-                        if (es.u.key == NEWT_KEY_LEFT) {
-                                const void *top;
-                                if (pstack__empty(fstack))
-                                        continue;
-                                top = pstack__pop(fstack);
-                                if (top == &dso_filter)
-                                        goto zoom_out_dso;
-                                if (top == &thread_filter)
-                                        goto zoom_out_thread;
-                                continue;
-                        }
-                }
-                if (browser->selection->sym != NULL &&
-                    !browser->selection->map->dso->annotate_warned &&
-                    asprintf(&options[nr_options], "Annotate %s",
-                             browser->selection->sym->name) > 0)
-                        annotate = nr_options++;
-                if (thread != NULL &&
-                    asprintf(&options[nr_options], "Zoom %s %s(%d) thread",
-                             (thread_filter ? "out of" : "into"),
-                             (thread->comm_set ? thread->comm : ""),
-                             thread->pid) > 0)
-                        zoom_thread = nr_options++;
-                if (dso != NULL &&
-                    asprintf(&options[nr_options], "Zoom %s %s DSO",
-                             (dso_filter ? "out of" : "into"),
-                             (dso->kernel ? "the Kernel" : dso->short_name)) > 0)
-                        zoom_dso = nr_options++;
-                options[nr_options++] = (char *)"Exit";
-                choice = popup_menu(nr_options, options);
-                for (i = 0; i < nr_options - 1; ++i)
-                        free(options[i]);
-                if (choice == nr_options - 1)
-                        break;
-                if (choice == -1)
-                        continue;
-                if (choice == annotate) {
-                        struct hist_entry *he;
-do_annotate:
-                        if (browser->selection->map->dso->origin == DSO__ORIG_KERNEL) {
-                                browser->selection->map->dso->annotate_warned = 1;
-                                ui_helpline__puts("No vmlinux file found, can't "
-                                                 "annotate with just a "
-                                                 "kallsyms file");
-                                continue;
-                        }
-                        he = hist_browser__selected_entry(browser);
-                        if (he == NULL)
-                                continue;
-                        hist_entry__tui_annotate(he);
-                } else if (choice == zoom_dso) {
-zoom_dso:
-                        if (dso_filter) {
-                                pstack__remove(fstack, &dso_filter);
-zoom_out_dso:
-                                ui_helpline__pop();
-                                dso_filter = NULL;
-                        } else {
-                                if (dso == NULL)
-                                        continue;
-                                ui_helpline__fpush("To zoom out press <- or -> + \"Zoom out of %s DSO\"",
-                                                   dso->kernel ? "the Kernel" : dso->short_name);
-                                dso_filter = dso;
-                                pstack__push(fstack, &dso_filter);
-                        }
-                        hists__filter_by_dso(self, dso_filter);
-                        hist_browser__title(msg, sizeof(msg), ev_name,
-                                            dso_filter, thread_filter);
-                        if (hist_browser__populate(browser, self, msg) < 0)
-                                goto out;
-                } else if (choice == zoom_thread) {
-zoom_thread:
-                        if (thread_filter) {
-                                pstack__remove(fstack, &thread_filter);
-zoom_out_thread:
-                                ui_helpline__pop();
-                                thread_filter = NULL;
-                        } else {
-                                ui_helpline__fpush("To zoom out press <- or -> + \"Zoom out of %s(%d) thread\"",
-                                                   thread->comm_set ? thread->comm : "",
-                                                   thread->pid);
-                                thread_filter = thread;
-                                pstack__push(fstack, &thread_filter);
-                        }
-                        hists__filter_by_thread(self, thread_filter);
-                        hist_browser__title(msg, sizeof(msg), ev_name,
-                                            dso_filter, thread_filter);
-                        if (hist_browser__populate(browser, self, msg) < 0)
-                                goto out;
-                }
-        }
-out_free_stack:
-        pstack__delete(fstack);
-out:
-        hist_browser__delete(browser);
-        return key;
-}
-int hists__tui_browse_tree(struct rb_root *self, const char *help)
-{
-        struct rb_node *first = rb_first(self), *nd = first, *next;
-        int key = 0;
-        while (nd) {
-                struct hists *hists = rb_entry(nd, struct hists, rb_node);
-                const char *ev_name = __event_name(hists->type, hists->config);
-                key = hists__browse(hists, help, ev_name);
-                if (is_exit_key(key))
-                        break;
-                switch (key) {
-                case NEWT_KEY_TAB:
-                        next = rb_next(nd);
-                        if (next)
-                                nd = next;
-                        break;
-                case NEWT_KEY_UNTAB:
-                        if (nd == first)
-                                continue;
-                        nd = rb_prev(nd);
-                default:
-                        break;
-                }
-        }
-        return key;
-}
-static struct newtPercentTreeColors {
-        const char *topColorFg, *topColorBg;
-        const char *mediumColorFg, *mediumColorBg;
-        const char *normalColorFg, *normalColorBg;
-        const char *selColorFg, *selColorBg;
-        const char *codeColorFg, *codeColorBg;
-} defaultPercentTreeColors = {
-        "red",       "lightgray",
-        "green",     "lightgray",
-        "black",     "lightgray",
-        "lightgray", "magenta",
-        "blue",      "lightgray",
-};
-void setup_browser(void)
-{
-        struct newtPercentTreeColors *c = &defaultPercentTreeColors;
-        if (!isatty(1) || !use_browser || dump_trace) {
-                use_browser = 0;
-                setup_pager();
-                return;
-        }
-        use_browser = 1;
-        newtInit();
-        newtCls();
-        ui_helpline__puts(" ");
-        sltt_set_color(HE_COLORSET_TOP, NULL, c->topColorFg, c->topColorBg);
-        sltt_set_color(HE_COLORSET_MEDIUM, NULL, c->mediumColorFg, c->mediumColorBg);
-        sltt_set_color(HE_COLORSET_NORMAL, NULL, c->normalColorFg, c->normalColorBg);
-        sltt_set_color(HE_COLORSET_SELECTED, NULL, c->selColorFg, c->selColorBg);
-        sltt_set_color(HE_COLORSET_CODE, NULL, c->codeColorFg, c->codeColorBg);
-}
-void exit_browser(bool wait_for_ok)
-{
-        if (use_browser > 0) {
-                if (wait_for_ok) {
-                        char title[] = "Fatal Error", ok[] = "Ok";
-                        newtWinMessage(title, ok, browser__last_msg);
-                }
-                newtFinished();
-        }
-}
diff --git a/tools/perf/util/parse-events.c b/tools/perf/util/parse-events.c
index 9bf0f402ca73..4af5bd59cfd1 100644
--- a/tools/perf/util/parse-events.c
+++ b/tools/perf/util/parse-events.c
@@ -602,8 +602,15 @@ parse_breakpoint_event(const char **strp, struct perf_event_attr *attr)
                        return EVT_FAILED;
        }
-        /* We should find a nice way to override the access type */
+        /*
-        attr->bp_len = HW_BREAKPOINT_LEN_4;
+         * We should find a nice way to override the access length
+         * Provide some defaults for now
+         */
+        if (attr->bp_type == HW_BREAKPOINT_X)
+                attr->bp_len = sizeof(long);
+        else
+                attr->bp_len = HW_BREAKPOINT_LEN_4;
        attr->type = PERF_TYPE_BREAKPOINT;
        return EVT_HANDLED;
diff --git a/tools/perf/util/probe-event.c b/tools/perf/util/probe-event.c
index 914c67095d96..e72f05c3bef0 100644
--- a/tools/perf/util/probe-event.c
+++ b/tools/perf/util/probe-event.c
@@ -1,5 +1,5 @@
 /*
- * probe-event.c : perf-probe definition to kprobe_events format converter
+ * probe-event.c : perf-probe definition to probe_events format converter
 *
 * Written by Masami Hiramatsu <mhiramat@redhat.com>
 *
@@ -120,8 +120,11 @@ static int open_vmlinux(void)
        return open(machine.vmlinux_maps[MAP__FUNCTION]->dso->long_name, O_RDONLY);
 }
-/* Convert trace point to probe point with debuginfo */
+/*
-static int convert_to_perf_probe_point(struct kprobe_trace_point *tp,
+ * Convert trace point to probe point with debuginfo
+ * Currently only handles kprobes.
+ */
+static int kprobe_convert_to_perf_probe(struct probe_trace_point *tp,
                                       struct perf_probe_point *pp)
 {
        struct symbol *sym;
@@ -151,8 +154,8 @@ static int convert_to_perf_probe_point(struct kprobe_trace_point *tp,
 }
 /* Try to find perf_probe_event with debuginfo */
-static int try_to_find_kprobe_trace_events(struct perf_probe_event *pev,
+static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
-                                           struct kprobe_trace_event **tevs,
+                                           struct probe_trace_event **tevs,
                                           int max_tevs)
 {
        bool need_dwarf = perf_probe_event_need_dwarf(pev);
@@ -169,11 +172,11 @@ static int try_to_find_kprobe_trace_events(struct perf_probe_event *pev,
        }
        /* Searching trace events corresponding to probe event */
-        ntevs = find_kprobe_trace_events(fd, pev, tevs, max_tevs);
+        ntevs = find_probe_trace_events(fd, pev, tevs, max_tevs);
        close(fd);
        if (ntevs > 0) {        /* Succeeded to find trace events */
-                pr_debug("find %d kprobe_trace_events.\n", ntevs);
+                pr_debug("find %d probe_trace_events.\n", ntevs);
                return ntevs;
        }
@@ -195,6 +198,65 @@ static int try_to_find_kprobe_trace_events(struct perf_probe_event *pev,
        return ntevs;
 }
+/*
+ * Find a src file from a DWARF tag path. Prepend optional source path prefix
+ * and chop off leading directories that do not exist. Result is passed back as
+ * a newly allocated path on success.
+ * Return 0 if file was found and readable, -errno otherwise.
+ */
+static int get_real_path(const char *raw_path, const char *comp_dir,
+                         char **new_path)
+{
+        const char *prefix = symbol_conf.source_prefix;
+        if (!prefix) {
+                if (raw_path[0] != '/' && comp_dir)
+                        /* If not an absolute path, try to use comp_dir */
+                        prefix = comp_dir;
+                else {
+                        if (access(raw_path, R_OK) == 0) {
+                                *new_path = strdup(raw_path);
+                                return 0;
+                        } else
+                                return -errno;
+                }
+        }
+        *new_path = malloc((strlen(prefix) + strlen(raw_path) + 2));
+        if (!*new_path)
+                return -ENOMEM;
+        for (;;) {
+                sprintf(*new_path, "%s/%s", prefix, raw_path);
+                if (access(*new_path, R_OK) == 0)
+                        return 0;
+                if (!symbol_conf.source_prefix)
+                        /* In case of searching comp_dir, don't retry */
+                        return -errno;
+                switch (errno) {
+                case ENAMETOOLONG:
+                case ENOENT:
+                case EROFS:
+                case EFAULT:
+                        raw_path = strchr(++raw_path, '/');
+                        if (!raw_path) {
+                                free(*new_path);
+                                *new_path = NULL;
+                                return -ENOENT;
+                        }
+                        continue;
+                default:
+                        free(*new_path);
+                        *new_path = NULL;
+                        return -errno;
+                }
+        }
+}
 #define LINEBUF_SIZE 256
 #define NR_ADDITIONAL_LINES 2
@@ -244,6 +306,7 @@ int show_line_range(struct line_range *lr)
        struct line_node *ln;
        FILE *fp;
        int fd, ret;
+        char *tmp;
        /* Search a line range */
        ret = init_vmlinux();
@@ -266,6 +329,15 @@ int show_line_range(struct line_range *lr)
                return ret;
        }
+        /* Convert source file path */
+        tmp = lr->path;
+        ret = get_real_path(tmp, lr->comp_dir, &lr->path);
+        free(tmp);      /* Free old path */
+        if (ret < 0) {
+                pr_warning("Failed to find source file. (%d)\n", ret);
+                return ret;
+        }
        setup_pager();
        if (lr->function)
@@ -308,8 +380,8 @@ end:
 #else   /* !DWARF_SUPPORT */
-static int convert_to_perf_probe_point(struct kprobe_trace_point *tp,
+static int kprobe_convert_to_perf_probe(struct probe_trace_point *tp,
-                                        struct perf_probe_point *pp)
+                                       struct perf_probe_point *pp)
 {
        pp->function = strdup(tp->symbol);
        if (pp->function == NULL)
@@ -320,8 +392,8 @@ static int convert_to_perf_probe_point(struct kprobe_trace_point *tp,
        return 0;
 }
-static int try_to_find_kprobe_trace_events(struct perf_probe_event *pev,
+static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
-                                struct kprobe_trace_event **tevs __unused,
+                                struct probe_trace_event **tevs __unused,
                                int max_tevs __unused)
 {
        if (perf_probe_event_need_dwarf(pev)) {
@@ -557,7 +629,7 @@ static int parse_perf_probe_point(char *arg, struct perf_probe_event *pev)
 /* Parse perf-probe event argument */
 static int parse_perf_probe_arg(char *str, struct perf_probe_arg *arg)
 {
-        char *tmp;
+        char *tmp, *goodname;
        struct perf_probe_arg_field **fieldp;
        pr_debug("parsing arg: %s into ", str);
@@ -580,7 +652,7 @@ static int parse_perf_probe_arg(char *str, struct perf_probe_arg *arg)
                pr_debug("type:%s ", arg->type);
        }
-        tmp = strpbrk(str, "-.");
+        tmp = strpbrk(str, "-.[");
        if (!is_c_varname(str) || !tmp) {
                /* A variable, register, symbol or special value */
                arg->var = strdup(str);
@@ -590,10 +662,11 @@ static int parse_perf_probe_arg(char *str, struct perf_probe_arg *arg)
                return 0;
        }
-        /* Structure fields */
+        /* Structure fields or array element */
        arg->var = strndup(str, tmp - str);
        if (arg->var == NULL)
                return -ENOMEM;
+        goodname = arg->var;
        pr_debug("%s, ", arg->var);
        fieldp = &arg->field;
@@ -601,22 +674,38 @@ static int parse_perf_probe_arg(char *str, struct perf_probe_arg *arg)
                *fieldp = zalloc(sizeof(struct perf_probe_arg_field));
                if (*fieldp == NULL)
                        return -ENOMEM;
-                if (*tmp == '.') {
+                if (*tmp == '[') {      /* Array */
-                        str = tmp + 1;
+                        str = tmp;
-                        (*fieldp)->ref = false;
+                        (*fieldp)->index = strtol(str + 1, &tmp, 0);
-                } else if (tmp[1] == '>') {
-                        str = tmp + 2;
                        (*fieldp)->ref = true;
-                } else {
+                        if (*tmp != ']' || tmp == str + 1) {
-                        semantic_error("Argument parse error: %s\n", str);
+                                semantic_error("Array index must be a"
-                        return -EINVAL;
+                                                " number.\n");
+                                return -EINVAL;
+                        }
+                        tmp++;
+                        if (*tmp == '\0')
+                                tmp = NULL;
+                } else {                /* Structure */
+                        if (*tmp == '.') {
+                                str = tmp + 1;
+                                (*fieldp)->ref = false;
+                        } else if (tmp[1] == '>') {
+                                str = tmp + 2;
+                                (*fieldp)->ref = true;
+                        } else {
+                                semantic_error("Argument parse error: %s\n",
+                                               str);
+                                return -EINVAL;
+                        }
+                        tmp = strpbrk(str, "-.[");
                }
-                tmp = strpbrk(str, "-.");
                if (tmp) {
                        (*fieldp)->name = strndup(str, tmp - str);
                        if ((*fieldp)->name == NULL)
                                return -ENOMEM;
+                        if (*str != '[')
+                                goodname = (*fieldp)->name;
                        pr_debug("%s(%d), ", (*fieldp)->name, (*fieldp)->ref);
                        fieldp = &(*fieldp)->next;
                }
@@ -624,11 +713,13 @@ static int parse_perf_probe_arg(char *str, struct perf_probe_arg *arg)
        (*fieldp)->name = strdup(str);
        if ((*fieldp)->name == NULL)
                return -ENOMEM;
+        if (*str != '[')
+                goodname = (*fieldp)->name;
        pr_debug("%s(%d)\n", (*fieldp)->name, (*fieldp)->ref);
-        /* If no name is specified, set the last field name */
+        /* If no name is specified, set the last field name (not array index)*/
        if (!arg->name) {
-                arg->name = strdup((*fieldp)->name);
+                arg->name = strdup(goodname);
                if (arg->name == NULL)
                        return -ENOMEM;
        }
@@ -693,16 +784,17 @@ bool perf_probe_event_need_dwarf(struct perf_probe_event *pev)
        return false;
 }
-/* Parse kprobe_events event into struct probe_point */
+/* Parse probe_events event into struct probe_point */
-int parse_kprobe_trace_command(const char *cmd, struct kprobe_trace_event *tev)
+static int parse_probe_trace_command(const char *cmd,
+                                        struct probe_trace_event *tev)
 {
-        struct kprobe_trace_point *tp = &tev->point;
+        struct probe_trace_point *tp = &tev->point;
        char pr;
        char *p;
        int ret, i, argc;
        char **argv;
-        pr_debug("Parsing kprobe_events: %s\n", cmd);
+        pr_debug("Parsing probe_events: %s\n", cmd);
        argv = argv_split(cmd, &argc);
        if (!argv) {
                pr_debug("Failed to split arguments.\n");
@@ -734,7 +826,7 @@ int parse_kprobe_trace_command(const char *cmd, struct kprobe_trace_event *tev)
                tp->offset = 0;
        tev->nargs = argc - 2;
-        tev->args = zalloc(sizeof(struct kprobe_trace_arg) * tev->nargs);
+        tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs);
        if (tev->args == NULL) {
                ret = -ENOMEM;
                goto out;
@@ -776,8 +868,11 @@ int synthesize_perf_probe_arg(struct perf_probe_arg *pa, char *buf, size_t len)
        len -= ret;
        while (field) {
-                ret = e_snprintf(tmp, len, "%s%s", field->ref ? "->" : ".",
+                if (field->name[0] == '[')
-                                 field->name);
+                        ret = e_snprintf(tmp, len, "%s", field->name);
+                else
+                        ret = e_snprintf(tmp, len, "%s%s",
+                                         field->ref ? "->" : ".", field->name);
                if (ret <= 0)
                        goto error;
                tmp += ret;
@@ -877,13 +972,13 @@ char *synthesize_perf_probe_command(struct perf_probe_event *pev)
 }
 #endif
-static int __synthesize_kprobe_trace_arg_ref(struct kprobe_trace_arg_ref *ref,
+static int __synthesize_probe_trace_arg_ref(struct probe_trace_arg_ref *ref,
                                             char **buf, size_t *buflen,
                                             int depth)
 {
        int ret;
        if (ref->next) {
-                depth = __synthesize_kprobe_trace_arg_ref(ref->next, buf,
+                depth = __synthesize_probe_trace_arg_ref(ref->next, buf,
                                                         buflen, depth + 1);
                if (depth < 0)
                        goto out;
@@ -901,9 +996,10 @@ out:
 }
-static int synthesize_kprobe_trace_arg(struct kprobe_trace_arg *arg,
+static int synthesize_probe_trace_arg(struct probe_trace_arg *arg,
                                       char *buf, size_t buflen)
 {
+        struct probe_trace_arg_ref *ref = arg->ref;
        int ret, depth = 0;
        char *tmp = buf;
@@ -917,16 +1013,24 @@ static int synthesize_kprobe_trace_arg(struct kprobe_trace_arg *arg,
        buf += ret;
        buflen -= ret;
+        /* Special case: @XXX */
+        if (arg->value[0] == '@' && arg->ref)
+                        ref = ref->next;
        /* Dereferencing arguments */
-        if (arg->ref) {
+        if (ref) {
-                depth = __synthesize_kprobe_trace_arg_ref(arg->ref, &buf,
+                depth = __synthesize_probe_trace_arg_ref(ref, &buf,
                                                          &buflen, 1);
                if (depth < 0)
                        return depth;
        }
        /* Print argument value */
-        ret = e_snprintf(buf, buflen, "%s", arg->value);
+        if (arg->value[0] == '@' && arg->ref)
+                ret = e_snprintf(buf, buflen, "%s%+ld", arg->value,
+                                 arg->ref->offset);
+        else
+                ret = e_snprintf(buf, buflen, "%s", arg->value);
        if (ret < 0)
                return ret;
        buf += ret;
@@ -951,9 +1055,9 @@ static int synthesize_kprobe_trace_arg(struct kprobe_trace_arg *arg,
        return buf - tmp;
 }
-char *synthesize_kprobe_trace_command(struct kprobe_trace_event *tev)
+char *synthesize_probe_trace_command(struct probe_trace_event *tev)
 {
-        struct kprobe_trace_point *tp = &tev->point;
+        struct probe_trace_point *tp = &tev->point;
        char *buf;
        int i, len, ret;
@@ -969,7 +1073,7 @@ char *synthesize_kprobe_trace_command(struct kprobe_trace_event *tev)
                goto error;
        for (i = 0; i < tev->nargs; i++) {
-                ret = synthesize_kprobe_trace_arg(&tev->args[i], buf + len,
+                ret = synthesize_probe_trace_arg(&tev->args[i], buf + len,
                                                  MAX_CMDLEN - len);
                if (ret <= 0)
                        goto error;
@@ -982,7 +1086,7 @@ error:
        return NULL;
 }
-int convert_to_perf_probe_event(struct kprobe_trace_event *tev,
+static int convert_to_perf_probe_event(struct probe_trace_event *tev,
                                struct perf_probe_event *pev)
 {
        char buf[64] = "";
@@ -995,7 +1099,7 @@ int convert_to_perf_probe_event(struct kprobe_trace_event *tev,
                return -ENOMEM;
        /* Convert trace_point to probe_point */
-        ret = convert_to_perf_probe_point(&tev->point, &pev->point);
+        ret = kprobe_convert_to_perf_probe(&tev->point, &pev->point);
        if (ret < 0)
                return ret;
@@ -1008,7 +1112,7 @@ int convert_to_perf_probe_event(struct kprobe_trace_event *tev,
                if (tev->args[i].name)
                        pev->args[i].name = strdup(tev->args[i].name);
                else {
-                        ret = synthesize_kprobe_trace_arg(&tev->args[i],
+                        ret = synthesize_probe_trace_arg(&tev->args[i],
                                                          buf, 64);
                        pev->args[i].name = strdup(buf);
                }
@@ -1059,9 +1163,9 @@ void clear_perf_probe_event(struct perf_probe_event *pev)
        memset(pev, 0, sizeof(*pev));
 }
-void clear_kprobe_trace_event(struct kprobe_trace_event *tev)
+static void clear_probe_trace_event(struct probe_trace_event *tev)
 {
-        struct kprobe_trace_arg_ref *ref, *next;
+        struct probe_trace_arg_ref *ref, *next;
        int i;
        if (tev->event)
@@ -1122,7 +1226,7 @@ static int open_kprobe_events(bool readwrite)
 }
 /* Get raw string list of current kprobe_events */
-static struct strlist *get_kprobe_trace_command_rawlist(int fd)
+static struct strlist *get_probe_trace_command_rawlist(int fd)
 {
        int ret, idx;
        FILE *fp;
@@ -1190,7 +1294,7 @@ static int show_perf_probe_event(struct perf_probe_event *pev)
 int show_perf_probe_events(void)
 {
        int fd, ret;
-        struct kprobe_trace_event tev;
+        struct probe_trace_event tev;
        struct perf_probe_event pev;
        struct strlist *rawlist;
        struct str_node *ent;
@@ -1207,20 +1311,20 @@ int show_perf_probe_events(void)
        if (fd < 0)
                return fd;
-        rawlist = get_kprobe_trace_command_rawlist(fd);
+        rawlist = get_probe_trace_command_rawlist(fd);
        close(fd);
        if (!rawlist)
                return -ENOENT;
        strlist__for_each(ent, rawlist) {
-                ret = parse_kprobe_trace_command(ent->s, &tev);
+                ret = parse_probe_trace_command(ent->s, &tev);
                if (ret >= 0) {
                        ret = convert_to_perf_probe_event(&tev, &pev);
                        if (ret >= 0)
                                ret = show_perf_probe_event(&pev);
                }
                clear_perf_probe_event(&pev);
-                clear_kprobe_trace_event(&tev);
+                clear_probe_trace_event(&tev);
                if (ret < 0)
                        break;
        }
@@ -1230,20 +1334,19 @@ int show_perf_probe_events(void)
 }
 /* Get current perf-probe event names */
-static struct strlist *get_kprobe_trace_event_names(int fd, bool include_group)
+static struct strlist *get_probe_trace_event_names(int fd, bool include_group)
 {
        char buf[128];
        struct strlist *sl, *rawlist;
        struct str_node *ent;
-        struct kprobe_trace_event tev;
+        struct probe_trace_event tev;
        int ret = 0;
        memset(&tev, 0, sizeof(tev));
+        rawlist = get_probe_trace_command_rawlist(fd);
-        rawlist = get_kprobe_trace_command_rawlist(fd);
        sl = strlist__new(true, NULL);
        strlist__for_each(ent, rawlist) {
-                ret = parse_kprobe_trace_command(ent->s, &tev);
+                ret = parse_probe_trace_command(ent->s, &tev);
                if (ret < 0)
                        break;
                if (include_group) {
@@ -1253,7 +1356,7 @@ static struct strlist *get_kprobe_trace_event_names(int fd, bool include_group)
                                ret = strlist__add(sl, buf);
                } else
                        ret = strlist__add(sl, tev.event);
-                clear_kprobe_trace_event(&tev);
+                clear_probe_trace_event(&tev);
                if (ret < 0)
                        break;
        }
@@ -1266,13 +1369,13 @@ static struct strlist *get_kprobe_trace_event_names(int fd, bool include_group)
        return sl;
 }
-static int write_kprobe_trace_event(int fd, struct kprobe_trace_event *tev)
+static int write_probe_trace_event(int fd, struct probe_trace_event *tev)
 {
        int ret = 0;
-        char *buf = synthesize_kprobe_trace_command(tev);
+        char *buf = synthesize_probe_trace_command(tev);
        if (!buf) {
-                pr_debug("Failed to synthesize kprobe trace event.\n");
+                pr_debug("Failed to synthesize probe trace event.\n");
                return -EINVAL;
        }
@@ -1325,12 +1428,12 @@ static int get_new_event_name(char *buf, size_t len, const char *base,
        return ret;
 }
-static int __add_kprobe_trace_events(struct perf_probe_event *pev,
+static int __add_probe_trace_events(struct perf_probe_event *pev,
-                                     struct kprobe_trace_event *tevs,
+                                     struct probe_trace_event *tevs,
                                     int ntevs, bool allow_suffix)
 {
        int i, fd, ret;
-        struct kprobe_trace_event *tev = NULL;
+        struct probe_trace_event *tev = NULL;
        char buf[64];
        const char *event, *group;
        struct strlist *namelist;
@@ -1339,7 +1442,7 @@ static int __add_kprobe_trace_events(struct perf_probe_event *pev,
        if (fd < 0)
                return fd;
        /* Get current event names */
-        namelist = get_kprobe_trace_event_names(fd, false);
+        namelist = get_probe_trace_event_names(fd, false);
        if (!namelist) {
                pr_debug("Failed to get current event list.\n");
                return -EIO;
@@ -1374,7 +1477,7 @@ static int __add_kprobe_trace_events(struct perf_probe_event *pev,
                        ret = -ENOMEM;
                        break;
                }
-                ret = write_kprobe_trace_event(fd, tev);
+                ret = write_probe_trace_event(fd, tev);
                if (ret < 0)
                        break;
                /* Add added event name to namelist */
@@ -1411,21 +1514,21 @@ static int __add_kprobe_trace_events(struct perf_probe_event *pev,
        return ret;
 }
-static int convert_to_kprobe_trace_events(struct perf_probe_event *pev,
+static int convert_to_probe_trace_events(struct perf_probe_event *pev,
-                                          struct kprobe_trace_event **tevs,
+                                          struct probe_trace_event **tevs,
                                          int max_tevs)
 {
        struct symbol *sym;
        int ret = 0, i;
-        struct kprobe_trace_event *tev;
+        struct probe_trace_event *tev;
        /* Convert perf_probe_event with debuginfo */
-        ret = try_to_find_kprobe_trace_events(pev, tevs, max_tevs);
+        ret = try_to_find_probe_trace_events(pev, tevs, max_tevs);
        if (ret != 0)
                return ret;
        /* Allocate trace event buffer */
-        tev = *tevs = zalloc(sizeof(struct kprobe_trace_event));
+        tev = *tevs = zalloc(sizeof(struct probe_trace_event));
        if (tev == NULL)
                return -ENOMEM;
@@ -1438,7 +1541,7 @@ static int convert_to_kprobe_trace_events(struct perf_probe_event *pev,
        tev->point.offset = pev->point.offset;
        tev->nargs = pev->nargs;
        if (tev->nargs) {
-                tev->args = zalloc(sizeof(struct kprobe_trace_arg)
+                tev->args = zalloc(sizeof(struct probe_trace_arg)
                                   * tev->nargs);
                if (tev->args == NULL) {
                        ret = -ENOMEM;
@@ -1479,7 +1582,7 @@ static int convert_to_kprobe_trace_events(struct perf_probe_event *pev,
        return 1;
 error:
-        clear_kprobe_trace_event(tev);
+        clear_probe_trace_event(tev);
        free(tev);
        *tevs = NULL;
        return ret;
@@ -1487,7 +1590,7 @@ error:
 struct __event_package {
        struct perf_probe_event         *pev;
-        struct kprobe_trace_event       *tevs;
+        struct probe_trace_event        *tevs;
        int                             ntevs;
 };
@@ -1503,14 +1606,16 @@ int add_perf_probe_events(struct perf_probe_event *pevs, int npevs,
        /* Init vmlinux path */
        ret = init_vmlinux();
-        if (ret < 0)
+        if (ret < 0) {
+                free(pkgs);
                return ret;
+        }
        /* Loop 1: convert all events */
        for (i = 0; i < npevs; i++) {
                pkgs[i].pev = &pevs[i];
                /* Convert with or without debuginfo */
-                ret  = convert_to_kprobe_trace_events(pkgs[i].pev,
+                ret  = convert_to_probe_trace_events(pkgs[i].pev,
                                                      &pkgs[i].tevs, max_tevs);
                if (ret < 0)
                        goto end;
@@ -1519,24 +1624,27 @@ int add_perf_probe_events(struct perf_probe_event *pevs, int npevs,
        /* Loop 2: add all events */
        for (i = 0; i < npevs && ret >= 0; i++)
-                ret = __add_kprobe_trace_events(pkgs[i].pev, pkgs[i].tevs,
+                ret = __add_probe_trace_events(pkgs[i].pev, pkgs[i].tevs,
                                                pkgs[i].ntevs, force_add);
 end:
-        /* Loop 3: cleanup trace events  */
+        /* Loop 3: cleanup and free trace events  */
-        for (i = 0; i < npevs; i++)
+        for (i = 0; i < npevs; i++) {
                for (j = 0; j < pkgs[i].ntevs; j++)
-                        clear_kprobe_trace_event(&pkgs[i].tevs[j]);
+                        clear_probe_trace_event(&pkgs[i].tevs[j]);
+                free(pkgs[i].tevs);
+        }
+        free(pkgs);
        return ret;
 }
-static int __del_trace_kprobe_event(int fd, struct str_node *ent)
+static int __del_trace_probe_event(int fd, struct str_node *ent)
 {
        char *p;
        char buf[128];
        int ret;
-        /* Convert from perf-probe event to trace-kprobe event */
+        /* Convert from perf-probe event to trace-probe event */
        ret = e_snprintf(buf, 128, "-:%s", ent->s);
        if (ret < 0)
                goto error;
@@ -1562,7 +1670,7 @@ error:
        return ret;
 }
-static int del_trace_kprobe_event(int fd, const char *group,
+static int del_trace_probe_event(int fd, const char *group,
                                  const char *event, struct strlist *namelist)
 {
        char buf[128];
@@ -1579,7 +1687,7 @@ static int del_trace_kprobe_event(int fd, const char *group,
                strlist__for_each_safe(ent, n, namelist)
                        if (strglobmatch(ent->s, buf)) {
                                found++;
-                                ret = __del_trace_kprobe_event(fd, ent);
+                                ret = __del_trace_probe_event(fd, ent);
                                if (ret < 0)
                                        break;
                                strlist__remove(namelist, ent);
@@ -1588,7 +1696,7 @@ static int del_trace_kprobe_event(int fd, const char *group,
                ent = strlist__find(namelist, buf);
                if (ent) {
                        found++;
-                        ret = __del_trace_kprobe_event(fd, ent);
+                        ret = __del_trace_probe_event(fd, ent);
                        if (ret >= 0)
                                strlist__remove(namelist, ent);
                }
@@ -1612,7 +1720,7 @@ int del_perf_probe_events(struct strlist *dellist)
                return fd;
        /* Get current event names */
-        namelist = get_kprobe_trace_event_names(fd, true);
+        namelist = get_probe_trace_event_names(fd, true);
        if (namelist == NULL)
                return -EINVAL;
@@ -1633,7 +1741,7 @@ int del_perf_probe_events(struct strlist *dellist)
                        event = str;
                }
                pr_debug("Group: %s, Event: %s\n", group, event);
-                ret = del_trace_kprobe_event(fd, group, event, namelist);
+                ret = del_trace_probe_event(fd, group, event, namelist);
                free(str);
                if (ret < 0)
                        break;
diff --git a/tools/perf/util/probe-event.h b/tools/perf/util/probe-event.h
index e9db1a214ca4..5af39243a25b 100644
--- a/tools/perf/util/probe-event.h
+++ b/tools/perf/util/probe-event.h
@@ -7,33 +7,33 @@
 extern bool probe_event_dry_run;
 /* kprobe-tracer tracing point */
-struct kprobe_trace_point {
+struct probe_trace_point {
        char            *symbol;        /* Base symbol */
        unsigned long   offset;         /* Offset from symbol */
        bool            retprobe;       /* Return probe flag */
 };
-/* kprobe-tracer tracing argument referencing offset */
+/* probe-tracer tracing argument referencing offset */
-struct kprobe_trace_arg_ref {
+struct probe_trace_arg_ref {
-        struct kprobe_trace_arg_ref     *next;  /* Next reference */
+        struct probe_trace_arg_ref      *next;  /* Next reference */
        long                            offset; /* Offset value */
 };
 /* kprobe-tracer tracing argument */
-struct kprobe_trace_arg {
+struct probe_trace_arg {
        char                            *name;  /* Argument name */
        char                            *value; /* Base value */
        char                            *type;  /* Type name */
-        struct kprobe_trace_arg_ref     *ref;   /* Referencing offset */
+        struct probe_trace_arg_ref      *ref;   /* Referencing offset */
 };
 /* kprobe-tracer tracing event (point + arg) */
-struct kprobe_trace_event {
+struct probe_trace_event {
        char                            *event; /* Event name */
        char                            *group; /* Group name */
-        struct kprobe_trace_point       point;  /* Trace point */
+        struct probe_trace_point        point;  /* Trace point */
        int                             nargs;  /* Number of args */
-        struct kprobe_trace_arg         *args;  /* Arguments */
+        struct probe_trace_arg          *args;  /* Arguments */
 };
 /* Perf probe probing point */
@@ -50,6 +50,7 @@ struct perf_probe_point {
 struct perf_probe_arg_field {
        struct perf_probe_arg_field     *next;  /* Next field */
        char                            *name;  /* Name of the field */
+        long                            index;  /* Array index number */
        bool                            ref;    /* Referencing flag */
 };
@@ -85,31 +86,25 @@ struct line_range {
        int                     end;            /* End line number */
        int                     offset;         /* Start line offset */
        char                    *path;          /* Real path name */
+        char                    *comp_dir;      /* Compile directory */
        struct list_head        line_list;      /* Visible lines */
 };
 /* Command string to events */
 extern int parse_perf_probe_command(const char *cmd,
                                    struct perf_probe_event *pev);
-extern int parse_kprobe_trace_command(const char *cmd,
-                                      struct kprobe_trace_event *tev);
 /* Events to command string */
 extern char *synthesize_perf_probe_command(struct perf_probe_event *pev);
-extern char *synthesize_kprobe_trace_command(struct kprobe_trace_event *tev);
+extern char *synthesize_probe_trace_command(struct probe_trace_event *tev);
 extern int synthesize_perf_probe_arg(struct perf_probe_arg *pa, char *buf,
                                     size_t len);
 /* Check the perf_probe_event needs debuginfo */
 extern bool perf_probe_event_need_dwarf(struct perf_probe_event *pev);
-/* Convert from kprobe_trace_event to perf_probe_event */
-extern int convert_to_perf_probe_event(struct kprobe_trace_event *tev,
-                                       struct perf_probe_event *pev);
 /* Release event contents */
 extern void clear_perf_probe_event(struct perf_probe_event *pev);
-extern void clear_kprobe_trace_event(struct kprobe_trace_event *tev);
 /* Command string to line-range */
 extern int parse_line_range_desc(const char *cmd, struct line_range *lr);
diff --git a/tools/perf/util/probe-finder.c b/tools/perf/util/probe-finder.c
index d964cb199c67..525136684d4e 100644
--- a/tools/perf/util/probe-finder.c
+++ b/tools/perf/util/probe-finder.c
@@ -33,10 +33,10 @@
 #include <ctype.h>
 #include <dwarf-regs.h>
-#include "string.h"
 #include "event.h"
 #include "debug.h"
 #include "util.h"
+#include "symbol.h"
 #include "probe-finder.h"
 /* Kprobe tracer basic type is up to u64 */
@@ -143,12 +143,21 @@ static const char *cu_find_realpath(Dwarf_Die *cu_die, const char *fname)
        return src;
 }
+/* Get DW_AT_comp_dir (should be NULL with older gcc) */
+static const char *cu_get_comp_dir(Dwarf_Die *cu_die)
+{
+        Dwarf_Attribute attr;
+        if (dwarf_attr(cu_die, DW_AT_comp_dir, &attr) == NULL)
+                return NULL;
+        return dwarf_formstring(&attr);
+}
 /* Compare diename and tname */
 static bool die_compare_name(Dwarf_Die *dw_die, const char *tname)
 {
        const char *name;
        name = dwarf_diename(dw_die);
-        return name ? strcmp(tname, name) : -1;
+        return name ? (strcmp(tname, name) == 0) : false;
 }
 /* Get type die, but skip qualifiers and typedef */
@@ -319,7 +328,7 @@ static int __die_find_variable_cb(Dwarf_Die *die_mem, void *data)
        tag = dwarf_tag(die_mem);
        if ((tag == DW_TAG_formal_parameter ||
             tag == DW_TAG_variable) &&
-            (die_compare_name(die_mem, name) == 0))
+            die_compare_name(die_mem, name))
                return DIE_FIND_CB_FOUND;
        return DIE_FIND_CB_CONTINUE;
@@ -338,7 +347,7 @@ static int __die_find_member_cb(Dwarf_Die *die_mem, void *data)
        const char *name = data;
        if ((dwarf_tag(die_mem) == DW_TAG_member) &&
-            (die_compare_name(die_mem, name) == 0))
+            die_compare_name(die_mem, name))
                return DIE_FIND_CB_FOUND;
        return DIE_FIND_CB_SIBLING;
@@ -356,14 +365,50 @@ static Dwarf_Die *die_find_member(Dwarf_Die *st_die, const char *name,
 * Probe finder related functions
 */
+static struct probe_trace_arg_ref *alloc_trace_arg_ref(long offs)
+{
+        struct probe_trace_arg_ref *ref;
+        ref = zalloc(sizeof(struct probe_trace_arg_ref));
+        if (ref != NULL)
+                ref->offset = offs;
+        return ref;
+}
 /* Show a location */
-static int convert_location(Dwarf_Op *op, struct probe_finder *pf)
+static int convert_variable_location(Dwarf_Die *vr_die, struct probe_finder *pf)
 {
+        Dwarf_Attribute attr;
+        Dwarf_Op *op;
+        size_t nops;
        unsigned int regn;
        Dwarf_Word offs = 0;
        bool ref = false;
        const char *regs;
-        struct kprobe_trace_arg *tvar = pf->tvar;
+        struct probe_trace_arg *tvar = pf->tvar;
+        int ret;
+        /* TODO: handle more than 1 exprs */
+        if (dwarf_attr(vr_die, DW_AT_location, &attr) == NULL ||
+            dwarf_getlocation_addr(&attr, pf->addr, &op, &nops, 1) <= 0 ||
+            nops == 0) {
+                /* TODO: Support const_value */
+                pr_err("Failed to find the location of %s at this address.\n"
+                       " Perhaps, it has been optimized out.\n", pf->pvar->var);
+                return -ENOENT;
+        }
+        if (op->atom == DW_OP_addr) {
+                /* Static variables on memory (not stack), make @varname */
+                ret = strlen(dwarf_diename(vr_die));
+                tvar->value = zalloc(ret + 2);
+                if (tvar->value == NULL)
+                        return -ENOMEM;
+                snprintf(tvar->value, ret + 2, "@%s", dwarf_diename(vr_die));
+                tvar->ref = alloc_trace_arg_ref((long)offs);
+                if (tvar->ref == NULL)
+                        return -ENOMEM;
+                return 0;
+        }
        /* If this is based on frame buffer, set the offset */
        if (op->atom == DW_OP_fbreg) {
@@ -405,27 +450,72 @@ static int convert_location(Dwarf_Op *op, struct probe_finder *pf)
                return -ENOMEM;
        if (ref) {
-                tvar->ref = zalloc(sizeof(struct kprobe_trace_arg_ref));
+                tvar->ref = alloc_trace_arg_ref((long)offs);
                if (tvar->ref == NULL)
                        return -ENOMEM;
-                tvar->ref->offset = (long)offs;
        }
        return 0;
 }
 static int convert_variable_type(Dwarf_Die *vr_die,
-                                 struct kprobe_trace_arg *targ)
+                                 struct probe_trace_arg *tvar,
+                                 const char *cast)
 {
+        struct probe_trace_arg_ref **ref_ptr = &tvar->ref;
        Dwarf_Die type;
        char buf[16];
        int ret;
+        /* TODO: check all types */
+        if (cast && strcmp(cast, "string") != 0) {
+                /* Non string type is OK */
+                tvar->type = strdup(cast);
+                return (tvar->type == NULL) ? -ENOMEM : 0;
+        }
        if (die_get_real_type(vr_die, &type) == NULL) {
                pr_warning("Failed to get a type information of %s.\n",
                           dwarf_diename(vr_die));
                return -ENOENT;
        }
+        pr_debug("%s type is %s.\n",
+                 dwarf_diename(vr_die), dwarf_diename(&type));
+        if (cast && strcmp(cast, "string") == 0) {      /* String type */
+                ret = dwarf_tag(&type);
+                if (ret != DW_TAG_pointer_type &&
+                    ret != DW_TAG_array_type) {
+                        pr_warning("Failed to cast into string: "
+                                   "%s(%s) is not a pointer nor array.",
+                                   dwarf_diename(vr_die), dwarf_diename(&type));
+                        return -EINVAL;
+                }
+                if (ret == DW_TAG_pointer_type) {
+                        if (die_get_real_type(&type, &type) == NULL) {
+                                pr_warning("Failed to get a type information.");
+                                return -ENOENT;
+                        }
+                        while (*ref_ptr)
+                                ref_ptr = &(*ref_ptr)->next;
+                        /* Add new reference with offset +0 */
+                        *ref_ptr = zalloc(sizeof(struct probe_trace_arg_ref));
+                        if (*ref_ptr == NULL) {
+                                pr_warning("Out of memory error\n");
+                                return -ENOMEM;
+                        }
+                }
+                if (!die_compare_name(&type, "char") &&
+                    !die_compare_name(&type, "unsigned char")) {
+                        pr_warning("Failed to cast into string: "
+                                   "%s is not (unsigned) char *.",
+                                   dwarf_diename(vr_die));
+                        return -EINVAL;
+                }
+                tvar->type = strdup(cast);
+                return (tvar->type == NULL) ? -ENOMEM : 0;
+        }
        ret = die_get_byte_size(&type) * 8;
        if (ret) {
                /* Check the bitwidth */
@@ -445,8 +535,8 @@ static int convert_variable_type(Dwarf_Die *vr_die,
                                   strerror(-ret));
                        return ret;
                }
-                targ->type = strdup(buf);
+                tvar->type = strdup(buf);
-                if (targ->type == NULL)
+                if (tvar->type == NULL)
                        return -ENOMEM;
        }
        return 0;
@@ -454,22 +544,50 @@ static int convert_variable_type(Dwarf_Die *vr_die,
 static int convert_variable_fields(Dwarf_Die *vr_die, const char *varname,
                                    struct perf_probe_arg_field *field,
-                                    struct kprobe_trace_arg_ref **ref_ptr,
+                                    struct probe_trace_arg_ref **ref_ptr,
                                    Dwarf_Die *die_mem)
 {
-        struct kprobe_trace_arg_ref *ref = *ref_ptr;
+        struct probe_trace_arg_ref *ref = *ref_ptr;
        Dwarf_Die type;
        Dwarf_Word offs;
-        int ret;
+        int ret, tag;
        pr_debug("converting %s in %s\n", field->name, varname);
        if (die_get_real_type(vr_die, &type) == NULL) {
                pr_warning("Failed to get the type of %s.\n", varname);
                return -ENOENT;
        }
+        pr_debug2("Var real type: (%x)\n", (unsigned)dwarf_dieoffset(&type));
-        /* Check the pointer and dereference */
+        tag = dwarf_tag(&type);
-        if (dwarf_tag(&type) == DW_TAG_pointer_type) {
+        if (field->name[0] == '[' &&
+            (tag == DW_TAG_array_type || tag == DW_TAG_pointer_type)) {
+                if (field->next)
+                        /* Save original type for next field */
+                        memcpy(die_mem, &type, sizeof(*die_mem));
+                /* Get the type of this array */
+                if (die_get_real_type(&type, &type) == NULL) {
+                        pr_warning("Failed to get the type of %s.\n", varname);
+                        return -ENOENT;
+                }
+                pr_debug2("Array real type: (%x)\n",
+                         (unsigned)dwarf_dieoffset(&type));
+                if (tag == DW_TAG_pointer_type) {
+                        ref = zalloc(sizeof(struct probe_trace_arg_ref));
+                        if (ref == NULL)
+                                return -ENOMEM;
+                        if (*ref_ptr)
+                                (*ref_ptr)->next = ref;
+                        else
+                                *ref_ptr = ref;
+                }
+                ref->offset += die_get_byte_size(&type) * field->index;
+                if (!field->next)
+                        /* Save vr_die for converting types */
+                        memcpy(die_mem, vr_die, sizeof(*die_mem));
+                goto next;
+        } else if (tag == DW_TAG_pointer_type) {
+                /* Check the pointer and dereference */
                if (!field->ref) {
                        pr_err("Semantic error: %s must be referred by '->'\n",
                               field->name);
@@ -486,7 +604,7 @@ static int convert_variable_fields(Dwarf_Die *vr_die, const char *varname,
                        return -EINVAL;
                }
-                ref = zalloc(sizeof(struct kprobe_trace_arg_ref));
+                ref = zalloc(sizeof(struct probe_trace_arg_ref));
                if (ref == NULL)
                        return -ENOMEM;
                if (*ref_ptr)
@@ -495,10 +613,15 @@ static int convert_variable_fields(Dwarf_Die *vr_die, const char *varname,
                        *ref_ptr = ref;
        } else {
                /* Verify it is a data structure  */
-                if (dwarf_tag(&type) != DW_TAG_structure_type) {
+                if (tag != DW_TAG_structure_type) {
                        pr_warning("%s is not a data structure.\n", varname);
                        return -EINVAL;
                }
+                if (field->name[0] == '[') {
+                        pr_err("Semantic error: %s is not a pointor nor array.",
+                               varname);
+                        return -EINVAL;
+                }
                if (field->ref) {
                        pr_err("Semantic error: %s must be referred by '.'\n",
                               field->name);
@@ -525,6 +648,7 @@ static int convert_variable_fields(Dwarf_Die *vr_die, const char *varname,
        }
        ref->offset += (long)offs;
+next:
        /* Converting next field */
        if (field->next)
                return convert_variable_fields(die_mem, field->name,
@@ -536,51 +660,32 @@ static int convert_variable_fields(Dwarf_Die *vr_die, const char *varname,
 /* Show a variables in kprobe event format */
 static int convert_variable(Dwarf_Die *vr_die, struct probe_finder *pf)
 {
-        Dwarf_Attribute attr;
        Dwarf_Die die_mem;
-        Dwarf_Op *expr;
-        size_t nexpr;
        int ret;
-        if (dwarf_attr(vr_die, DW_AT_location, &attr) == NULL)
+        pr_debug("Converting variable %s into trace event.\n",
-                goto error;
+                 dwarf_diename(vr_die));
-        /* TODO: handle more than 1 exprs */
-        ret = dwarf_getlocation_addr(&attr, pf->addr, &expr, &nexpr, 1);
-        if (ret <= 0 || nexpr == 0)
-                goto error;
-        ret = convert_location(expr, pf);
+        ret = convert_variable_location(vr_die, pf);
        if (ret == 0 && pf->pvar->field) {
                ret = convert_variable_fields(vr_die, pf->pvar->var,
                                              pf->pvar->field, &pf->tvar->ref,
                                              &die_mem);
                vr_die = &die_mem;
        }
-        if (ret == 0) {
+        if (ret == 0)
-                if (pf->pvar->type) {
+                ret = convert_variable_type(vr_die, pf->tvar, pf->pvar->type);
-                        pf->tvar->type = strdup(pf->pvar->type);
-                        if (pf->tvar->type == NULL)
-                                ret = -ENOMEM;
-                } else
-                        ret = convert_variable_type(vr_die, pf->tvar);
-        }
        /* *expr will be cached in libdw. Don't free it. */
        return ret;
-error:
-        /* TODO: Support const_value */
-        pr_err("Failed to find the location of %s at this address.\n"
-               " Perhaps, it has been optimized out.\n", pf->pvar->var);
-        return -ENOENT;
 }
 /* Find a variable in a subprogram die */
 static int find_variable(Dwarf_Die *sp_die, struct probe_finder *pf)
 {
-        Dwarf_Die vr_die;
+        Dwarf_Die vr_die, *scopes;
        char buf[32], *ptr;
-        int ret;
+        int ret, nscopes;
-        /* TODO: Support arrays */
        if (pf->pvar->name)
                pf->tvar->name = strdup(pf->pvar->name);
        else {
@@ -600,25 +705,43 @@ static int find_variable(Dwarf_Die *sp_die, struct probe_finder *pf)
                pf->tvar->value = strdup(pf->pvar->var);
                if (pf->tvar->value == NULL)
                        return -ENOMEM;
-                else
+                if (pf->pvar->type) {
-                        return 0;
+                        pf->tvar->type = strdup(pf->pvar->type);
+                        if (pf->tvar->type == NULL)
+                                return -ENOMEM;
+                }
+                return 0;
        }
        pr_debug("Searching '%s' variable in context.\n",
                 pf->pvar->var);
        /* Search child die for local variables and parameters. */
-        if (!die_find_variable(sp_die, pf->pvar->var, &vr_die)) {
+        if (die_find_variable(sp_die, pf->pvar->var, &vr_die))
+                ret = convert_variable(&vr_die, pf);
+        else {
+                /* Search upper class */
+                nscopes = dwarf_getscopes_die(sp_die, &scopes);
+                if (nscopes > 0) {
+                        ret = dwarf_getscopevar(scopes, nscopes, pf->pvar->var,
+                                                0, NULL, 0, 0, &vr_die);
+                        if (ret >= 0)
+                                ret = convert_variable(&vr_die, pf);
+                        else
+                                ret = -ENOENT;
+                        free(scopes);
+                } else
+                        ret = -ENOENT;
+        }
+        if (ret < 0)
                pr_warning("Failed to find '%s' in this function.\n",
                           pf->pvar->var);
-                return -ENOENT;
+        return ret;
-        }
-        return convert_variable(&vr_die, pf);
 }
 /* Show a probe point to output buffer */
 static int convert_probe_point(Dwarf_Die *sp_die, struct probe_finder *pf)
 {
-        struct kprobe_trace_event *tev;
+        struct probe_trace_event *tev;
        Dwarf_Addr eaddr;
        Dwarf_Die die_mem;
        const char *name;
@@ -683,7 +806,7 @@ static int convert_probe_point(Dwarf_Die *sp_die, struct probe_finder *pf)
        /* Find each argument */
        tev->nargs = pf->pev->nargs;
-        tev->args = zalloc(sizeof(struct kprobe_trace_arg) * tev->nargs);
+        tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs);
        if (tev->args == NULL)
                return -ENOMEM;
        for (i = 0; i < pf->pev->nargs; i++) {
@@ -897,7 +1020,7 @@ static int probe_point_search_cb(Dwarf_Die *sp_die, void *data)
        /* Check tag and diename */
        if (dwarf_tag(sp_die) != DW_TAG_subprogram ||
-            die_compare_name(sp_die, pp->function) != 0)
+            !die_compare_name(sp_die, pp->function))
                return DWARF_CB_OK;
        pf->fname = dwarf_decl_file(sp_die);
@@ -940,9 +1063,9 @@ static int find_probe_point_by_func(struct probe_finder *pf)
        return _param.retval;
 }
-/* Find kprobe_trace_events specified by perf_probe_event from debuginfo */
+/* Find probe_trace_events specified by perf_probe_event from debuginfo */
-int find_kprobe_trace_events(int fd, struct perf_probe_event *pev,
+int find_probe_trace_events(int fd, struct perf_probe_event *pev,
-                             struct kprobe_trace_event **tevs, int max_tevs)
+                             struct probe_trace_event **tevs, int max_tevs)
 {
        struct probe_finder pf = {.pev = pev, .max_tevs = max_tevs};
        struct perf_probe_point *pp = &pev->point;
@@ -952,7 +1075,7 @@ int find_kprobe_trace_events(int fd, struct perf_probe_event *pev,
        Dwarf *dbg;
        int ret = 0;
-        pf.tevs = zalloc(sizeof(struct kprobe_trace_event) * max_tevs);
+        pf.tevs = zalloc(sizeof(struct probe_trace_event) * max_tevs);
        if (pf.tevs == NULL)
                return -ENOMEM;
        *tevs = pf.tevs;
@@ -1096,7 +1219,7 @@ end:
 static int line_range_add_line(const char *src, unsigned int lineno,
                               struct line_range *lr)
 {
-        /* Copy real path */
+        /* Copy source path */
        if (!lr->path) {
                lr->path = strdup(src);
                if (lr->path == NULL)
@@ -1220,7 +1343,7 @@ static int line_range_search_cb(Dwarf_Die *sp_die, void *data)
        struct line_range *lr = lf->lr;
        if (dwarf_tag(sp_die) == DW_TAG_subprogram &&
-            die_compare_name(sp_die, lr->function) == 0) {
+            die_compare_name(sp_die, lr->function)) {
                lf->fname = dwarf_decl_file(sp_die);
                dwarf_decl_line(sp_die, &lr->offset);
                pr_debug("fname: %s, lineno:%d\n", lf->fname, lr->offset);
@@ -1263,6 +1386,7 @@ int find_line_range(int fd, struct line_range *lr)
        size_t cuhl;
        Dwarf_Die *diep;
        Dwarf *dbg;
+        const char *comp_dir;
        dbg = dwarf_begin(fd, DWARF_C_READ);
        if (!dbg) {
@@ -1298,7 +1422,18 @@ int find_line_range(int fd, struct line_range *lr)
                }
                off = noff;
        }
-        pr_debug("path: %lx\n", (unsigned long)lr->path);
+        /* Store comp_dir */
+        if (lf.found) {
+                comp_dir = cu_get_comp_dir(&lf.cu_die);
+                if (comp_dir) {
+                        lr->comp_dir = strdup(comp_dir);
+                        if (!lr->comp_dir)
+                                ret = -ENOMEM;
+                }
+        }
+        pr_debug("path: %s\n", lr->path);
        dwarf_end(dbg);
        return (ret < 0) ? ret : lf.found;
diff --git a/tools/perf/util/probe-finder.h b/tools/perf/util/probe-finder.h
index e1f61dcd18ff..4507d519f183 100644
--- a/tools/perf/util/probe-finder.h
+++ b/tools/perf/util/probe-finder.h
@@ -16,9 +16,9 @@ static inline int is_c_varname(const char *name)
 }
 #ifdef DWARF_SUPPORT
-/* Find kprobe_trace_events specified by perf_probe_event from debuginfo */
+/* Find probe_trace_events specified by perf_probe_event from debuginfo */
-extern int find_kprobe_trace_events(int fd, struct perf_probe_event *pev,
+extern int find_probe_trace_events(int fd, struct perf_probe_event *pev,
-                                    struct kprobe_trace_event **tevs,
+                                    struct probe_trace_event **tevs,
                                    int max_tevs);
 /* Find a perf_probe_point from debuginfo */
@@ -33,7 +33,7 @@ extern int find_line_range(int fd, struct line_range *lr);
 struct probe_finder {
        struct perf_probe_event *pev;           /* Target probe event */
-        struct kprobe_trace_event *tevs;        /* Result trace events */
+        struct probe_trace_event *tevs;         /* Result trace events */
        int                     ntevs;          /* Number of trace events */
        int                     max_tevs;       /* Max number of trace events */
@@ -50,7 +50,7 @@ struct probe_finder {
 #endif
        Dwarf_Op                *fb_ops;        /* Frame base attribute */
        struct perf_probe_arg   *pvar;          /* Current target variable */
-        struct kprobe_trace_arg *tvar;          /* Current result variable */
+        struct probe_trace_arg  *tvar;          /* Current result variable */
 };
 struct line_finder {
diff --git a/tools/perf/util/pstack.h b/tools/perf/util/pstack.h
index 5ad07023504b..4cedea59f518 100644
--- a/tools/perf/util/pstack.h
+++ b/tools/perf/util/pstack.h
@@ -1,6 +1,8 @@
 #ifndef _PERF_PSTACK_
 #define _PERF_PSTACK_
+#include <stdbool.h>
 struct pstack;
 struct pstack *pstack__new(unsigned short max_nr_entries);
 void pstack__delete(struct pstack *self);
diff --git a/tools/perf/util/scripting-engines/trace-event-python.c b/tools/perf/util/scripting-engines/trace-event-python.c
index 81f39cab3aaa..33a632523743 100644
--- a/tools/perf/util/scripting-engines/trace-event-python.c
+++ b/tools/perf/util/scripting-engines/trace-event-python.c
@@ -208,7 +208,7 @@ static void python_process_event(int cpu, void *data,
                                 int size __unused,
                                 unsigned long long nsecs, char *comm)
 {
-        PyObject *handler, *retval, *context, *t, *obj;
+        PyObject *handler, *retval, *context, *t, *obj, *dict = NULL;
        static char handler_name[256];
        struct format_field *field;
        unsigned long long val;
@@ -232,6 +232,14 @@ static void python_process_event(int cpu, void *data,
        sprintf(handler_name, "%s__%s", event->system, event->name);
+        handler = PyDict_GetItemString(main_dict, handler_name);
+        if (handler && !PyCallable_Check(handler))
+                handler = NULL;
+        if (!handler) {
+                dict = PyDict_New();
+                if (!dict)
+                        Py_FatalError("couldn't create Python dict");
+        }
        s = nsecs / NSECS_PER_SEC;
        ns = nsecs - s * NSECS_PER_SEC;
@@ -242,12 +250,20 @@ static void python_process_event(int cpu, void *data,
        PyTuple_SetItem(t, n++, PyString_FromString(handler_name));
        PyTuple_SetItem(t, n++,
                        PyCObject_FromVoidPtr(scripting_context, NULL));
-        PyTuple_SetItem(t, n++, PyInt_FromLong(cpu));
-        PyTuple_SetItem(t, n++, PyInt_FromLong(s));
-        PyTuple_SetItem(t, n++, PyInt_FromLong(ns));
-        PyTuple_SetItem(t, n++, PyInt_FromLong(pid));
-        PyTuple_SetItem(t, n++, PyString_FromString(comm));
+        if (handler) {
+                PyTuple_SetItem(t, n++, PyInt_FromLong(cpu));
+                PyTuple_SetItem(t, n++, PyInt_FromLong(s));
+                PyTuple_SetItem(t, n++, PyInt_FromLong(ns));
+                PyTuple_SetItem(t, n++, PyInt_FromLong(pid));
+                PyTuple_SetItem(t, n++, PyString_FromString(comm));
+        } else {
+                PyDict_SetItemString(dict, "common_cpu", PyInt_FromLong(cpu));
+                PyDict_SetItemString(dict, "common_s", PyInt_FromLong(s));
+                PyDict_SetItemString(dict, "common_ns", PyInt_FromLong(ns));
+                PyDict_SetItemString(dict, "common_pid", PyInt_FromLong(pid));
+                PyDict_SetItemString(dict, "common_comm", PyString_FromString(comm));
+        }
        for (field = event->format.fields; field; field = field->next) {
                if (field->flags & FIELD_IS_STRING) {
                        int offset;
@@ -272,27 +288,31 @@ static void python_process_event(int cpu, void *data,
                                        obj = PyLong_FromUnsignedLongLong(val);
                        }
                }
-                PyTuple_SetItem(t, n++, obj);
+                if (handler)
+                        PyTuple_SetItem(t, n++, obj);
+                else
+                        PyDict_SetItemString(dict, field->name, obj);
        }
+        if (!handler)
+                PyTuple_SetItem(t, n++, dict);
        if (_PyTuple_Resize(&t, n) == -1)
                Py_FatalError("error resizing Python tuple");
-        handler = PyDict_GetItemString(main_dict, handler_name);
+        if (handler) {
-        if (handler && PyCallable_Check(handler)) {
                retval = PyObject_CallObject(handler, t);
                if (retval == NULL)
                        handler_call_die(handler_name);
        } else {
                handler = PyDict_GetItemString(main_dict, "trace_unhandled");
                if (handler && PyCallable_Check(handler)) {
-                        if (_PyTuple_Resize(&t, N_COMMON_FIELDS) == -1)
-                                Py_FatalError("error resizing Python tuple");
                        retval = PyObject_CallObject(handler, t);
                        if (retval == NULL)
                                handler_call_die("trace_unhandled");
                }
+                Py_DECREF(dict);
        }
        Py_DECREF(t);
@@ -548,12 +568,10 @@ static int python_generate_script(const char *outfile)
        }
        fprintf(ofp, "def trace_unhandled(event_name, context, "
-                "common_cpu, common_secs, common_nsecs,\n\t\t"
+                "event_fields_dict):\n");
-                "common_pid, common_comm):\n");
-        fprintf(ofp, "\t\tprint_header(event_name, common_cpu, "
+        fprintf(ofp, "\t\tprint ' '.join(['%%s=%%s'%%(k,str(v))"
-                "common_secs, common_nsecs,\n\t\tcommon_pid, "
+                "for k,v in sorted(event_fields_dict.items())])\n\n");
-                "common_comm)\n\n");
        fprintf(ofp, "def print_header("
                "event_name, cpu, secs, nsecs, pid, comm):\n"
diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c
index 8f83a1835766..fa9d652c2dc3 100644
--- a/tools/perf/util/session.c
+++ b/tools/perf/util/session.c
@@ -27,8 +27,10 @@ static int perf_session__open(struct perf_session *self, bool force)
        self->fd = open(self->filename, O_RDONLY);
        if (self->fd < 0) {
-                pr_err("failed to open file: %s", self->filename);
+                int err = errno;
-                if (!strcmp(self->filename, "perf.data"))
+                pr_err("failed to open %s: %s", self->filename, strerror(err));
+                if (err == ENOENT && !strcmp(self->filename, "perf.data"))
                        pr_err("  (try 'perf record' first)");
                pr_err("\n");
                return -errno;
@@ -77,6 +79,12 @@ int perf_session__create_kernel_maps(struct perf_session *self)
        return ret;
 }
+static void perf_session__destroy_kernel_maps(struct perf_session *self)
+{
+        machine__destroy_kernel_maps(&self->host_machine);
+        machines__destroy_guest_kernel_maps(&self->machines);
+}
 struct perf_session *perf_session__new(const char *filename, int mode, bool force, bool repipe)
 {
        size_t len = filename ? strlen(filename) + 1 : 0;
@@ -90,11 +98,10 @@ struct perf_session *perf_session__new(const char *filename, int mode, bool forc
        memcpy(self->filename, filename, len);
        self->threads = RB_ROOT;
+        INIT_LIST_HEAD(&self->dead_threads);
        self->hists_tree = RB_ROOT;
        self->last_match = NULL;
        self->mmap_window = 32;
-        self->cwd = NULL;
-        self->cwdlen = 0;
        self->machines = RB_ROOT;
        self->repipe = repipe;
        INIT_LIST_HEAD(&self->ordered_samples.samples_head);
@@ -123,14 +130,51 @@ out_delete:
        return NULL;
 }
+static void perf_session__delete_dead_threads(struct perf_session *self)
+{
+        struct thread *n, *t;
+        list_for_each_entry_safe(t, n, &self->dead_threads, node) {
+                list_del(&t->node);
+                thread__delete(t);
+        }
+}
+static void perf_session__delete_threads(struct perf_session *self)
+{
+        struct rb_node *nd = rb_first(&self->threads);
+        while (nd) {
+                struct thread *t = rb_entry(nd, struct thread, rb_node);
+                rb_erase(&t->rb_node, &self->threads);
+                nd = rb_next(nd);
+                thread__delete(t);
+        }
+}
 void perf_session__delete(struct perf_session *self)
 {
        perf_header__exit(&self->header);
+        perf_session__destroy_kernel_maps(self);
+        perf_session__delete_dead_threads(self);
+        perf_session__delete_threads(self);
+        machine__exit(&self->host_machine);
        close(self->fd);
-        free(self->cwd);
        free(self);
 }
+void perf_session__remove_thread(struct perf_session *self, struct thread *th)
+{
+        self->last_match = NULL;
+        rb_erase(&th->rb_node, &self->threads);
+        /*
+         * We may have references to this thread, for instance in some hist_entry
+         * instances, so just move them to a separate list.
+         */
+        list_add_tail(&th->node, &self->dead_threads);
+}
 static bool symbol__match_parent_regex(struct symbol *sym)
 {
        if (sym->name && !regexec(&parent_regex, sym->name, 0, NULL, 0))
@@ -819,23 +863,6 @@ int perf_session__process_events(struct perf_session *self,
        if (perf_session__register_idle_thread(self) == NULL)
                return -ENOMEM;
-        if (!symbol_conf.full_paths) {
-                char bf[PATH_MAX];
-                if (getcwd(bf, sizeof(bf)) == NULL) {
-                        err = -errno;
-out_getcwd_err:
-                        pr_err("failed to get the current directory\n");
-                        goto out_err;
-                }
-                self->cwd = strdup(bf);
-                if (self->cwd == NULL) {
-                        err = -ENOMEM;
-                        goto out_getcwd_err;
-                }
-                self->cwdlen = strlen(self->cwd);
-        }
        if (!self->fd_pipe)
                err = __perf_session__process_events(self,
                                                     self->header.data_offset,
@@ -843,7 +870,7 @@ out_getcwd_err:
                                                     self->size, ops);
        else
                err = __perf_session__process_pipe_events(self, ops);
-out_err:
        return err;
 }
diff --git a/tools/perf/util/session.h b/tools/perf/util/session.h
index 55c6881b218d..9fa0fc2a863f 100644
--- a/tools/perf/util/session.h
+++ b/tools/perf/util/session.h
@@ -26,6 +26,7 @@ struct perf_session {
        unsigned long           size;
        unsigned long           mmap_window;
        struct rb_root          threads;
+        struct list_head        dead_threads;
        struct thread           *last_match;
        struct machine          host_machine;
        struct rb_root          machines;
@@ -99,6 +100,7 @@ int perf_session__create_kernel_maps(struct perf_session *self);
 int do_read(int fd, void *buf, size_t size);
 void perf_session__update_sample_type(struct perf_session *self);
+void perf_session__remove_thread(struct perf_session *self, struct thread *th);
 static inline
 struct machine *perf_session__find_host_machine(struct perf_session *self)
diff --git a/tools/perf/util/sort.c b/tools/perf/util/sort.c
index 2316cb5a4116..b62a553cc67d 100644
--- a/tools/perf/util/sort.c
+++ b/tools/perf/util/sort.c
@@ -1,4 +1,5 @@
 #include "sort.h"
+#include "hist.h"
 regex_t         parent_regex;
 const char      default_parent_pattern[] = "^sys_|^do_page_fault";
@@ -10,10 +11,6 @@ int		sort__has_parent = 0;
 enum sort_type  sort__first_dimension;
-unsigned int dsos__col_width;
-unsigned int comms__col_width;
-unsigned int threads__col_width;
-static unsigned int parent_symbol__col_width;
 char * field_sep;
 LIST_HEAD(hist_entry__sort_list);
@@ -28,12 +25,14 @@ static int hist_entry__sym_snprintf(struct hist_entry *self, char *bf,
                                    size_t size, unsigned int width);
 static int hist_entry__parent_snprintf(struct hist_entry *self, char *bf,
                                       size_t size, unsigned int width);
+static int hist_entry__cpu_snprintf(struct hist_entry *self, char *bf,
+                                    size_t size, unsigned int width);
 struct sort_entry sort_thread = {
        .se_header      = "Command:  Pid",
        .se_cmp         = sort__thread_cmp,
        .se_snprintf    = hist_entry__thread_snprintf,
-        .se_width       = &threads__col_width,
+        .se_width_idx   = HISTC_THREAD,
 };
 struct sort_entry sort_comm = {
@@ -41,27 +40,35 @@ struct sort_entry sort_comm = {
        .se_cmp         = sort__comm_cmp,
        .se_collapse    = sort__comm_collapse,
        .se_snprintf    = hist_entry__comm_snprintf,
-        .se_width       = &comms__col_width,
+        .se_width_idx   = HISTC_COMM,
 };
 struct sort_entry sort_dso = {
        .se_header      = "Shared Object",
        .se_cmp         = sort__dso_cmp,
        .se_snprintf    = hist_entry__dso_snprintf,
-        .se_width       = &dsos__col_width,
+        .se_width_idx   = HISTC_DSO,
 };
 struct sort_entry sort_sym = {
        .se_header      = "Symbol",
        .se_cmp         = sort__sym_cmp,
        .se_snprintf    = hist_entry__sym_snprintf,
+        .se_width_idx   = HISTC_SYMBOL,
 };
 struct sort_entry sort_parent = {
        .se_header      = "Parent symbol",
        .se_cmp         = sort__parent_cmp,
        .se_snprintf    = hist_entry__parent_snprintf,
-        .se_width       = &parent_symbol__col_width,
+        .se_width_idx   = HISTC_PARENT,
+};
+ 
+struct sort_entry sort_cpu = {
+        .se_header      = "CPU",
+        .se_cmp         = sort__cpu_cmp,
+        .se_snprintf    = hist_entry__cpu_snprintf,
+        .se_width_idx   = HISTC_CPU,
 };
 struct sort_dimension {
@@ -76,6 +83,7 @@ static struct sort_dimension sort_dimensions[] = {
        { .name = "dso",        .entry = &sort_dso,     },
        { .name = "symbol",     .entry = &sort_sym,     },
        { .name = "parent",     .entry = &sort_parent,  },
+        { .name = "cpu",        .entry = &sort_cpu,     },
 };
 int64_t cmp_null(void *l, void *r)
@@ -188,7 +196,8 @@ static int hist_entry__sym_snprintf(struct hist_entry *self, char *bf,
        if (verbose) {
                char o = self->ms.map ? dso__symtab_origin(self->ms.map->dso) : '!';
-                ret += repsep_snprintf(bf, size, "%#018llx %c ", self->ip, o);
+                ret += repsep_snprintf(bf, size, "%*Lx %c ",
+                                       BITS_PER_LONG / 4, self->ip, o);
        }
        ret += repsep_snprintf(bf + ret, size - ret, "[%c] ", self->level);
@@ -196,7 +205,8 @@ static int hist_entry__sym_snprintf(struct hist_entry *self, char *bf,
                ret += repsep_snprintf(bf + ret, size - ret, "%s",
                                       self->ms.sym->name);
        else
-                ret += repsep_snprintf(bf + ret, size - ret, "%#016llx", self->ip);
+                ret += repsep_snprintf(bf + ret, size - ret, "%*Lx",
+                                       BITS_PER_LONG / 4, self->ip);
        return ret;
 }
@@ -242,6 +252,20 @@ static int hist_entry__parent_snprintf(struct hist_entry *self, char *bf,
                              self->parent ? self->parent->name : "[other]");
 }
+/* --sort cpu */
+int64_t
+sort__cpu_cmp(struct hist_entry *left, struct hist_entry *right)
+{
+        return right->cpu - left->cpu;
+}
+static int hist_entry__cpu_snprintf(struct hist_entry *self, char *bf,
+                                       size_t size, unsigned int width)
+{
+        return repsep_snprintf(bf, size, "%-*d", width, self->cpu);
+}
 int sort_dimension__add(const char *tok)
 {
        unsigned int i;
@@ -281,6 +305,8 @@ int sort_dimension__add(const char *tok)
                                sort__first_dimension = SORT_SYM;
                        else if (!strcmp(sd->name, "parent"))
                                sort__first_dimension = SORT_PARENT;
+                        else if (!strcmp(sd->name, "cpu"))
+                                sort__first_dimension = SORT_CPU;
                }
                list_add_tail(&sd->entry->list, &hist_entry__sort_list);
diff --git a/tools/perf/util/sort.h b/tools/perf/util/sort.h
index 0d61c4082f43..46e531d09e8b 100644
--- a/tools/perf/util/sort.h
+++ b/tools/perf/util/sort.h
@@ -36,11 +36,14 @@ extern struct sort_entry sort_comm;
 extern struct sort_entry sort_dso;
 extern struct sort_entry sort_sym;
 extern struct sort_entry sort_parent;
-extern unsigned int dsos__col_width;
-extern unsigned int comms__col_width;
-extern unsigned int threads__col_width;
 extern enum sort_type sort__first_dimension;
+/**
+ * struct hist_entry - histogram entry
+ *
+ * @row_offset - offset from the first callchain expanded to appear on screen
+ * @nr_rows - rows expanded in callchain, recalculated on folding/unfolding
+ */
 struct hist_entry {
        struct rb_node          rb_node;
        u64                     period;
@@ -51,7 +54,14 @@ struct hist_entry {
        struct map_symbol       ms;
        struct thread           *thread;
        u64                     ip;
+        s32                     cpu;
        u32                     nr_events;
+        /* XXX These two should move to some tree widget lib */
+        u16                     row_offset;
+        u16                     nr_rows;
+        bool                    init_have_children;
        char                    level;
        u8                      filtered;
        struct symbol           *parent;
@@ -68,7 +78,8 @@ enum sort_type {
        SORT_COMM,
        SORT_DSO,
        SORT_SYM,
-        SORT_PARENT
+        SORT_PARENT,
+        SORT_CPU,
 };
 /*
@@ -84,7 +95,7 @@ struct sort_entry {
        int64_t (*se_collapse)(struct hist_entry *, struct hist_entry *);
        int     (*se_snprintf)(struct hist_entry *self, char *bf, size_t size,
                               unsigned int width);
-        unsigned int *se_width;
+        u8      se_width_idx;
        bool    elide;
 };
@@ -104,6 +115,7 @@ extern int64_t sort__comm_collapse(struct hist_entry *, struct hist_entry *);
 extern int64_t sort__dso_cmp(struct hist_entry *, struct hist_entry *);
 extern int64_t sort__sym_cmp(struct hist_entry *, struct hist_entry *);
 extern int64_t sort__parent_cmp(struct hist_entry *, struct hist_entry *);
+int64_t sort__cpu_cmp(struct hist_entry *left, struct hist_entry *right);
 extern size_t sort__parent_print(FILE *, struct hist_entry *, unsigned int);
 extern int sort_dimension__add(const char *);
 void sort_entry__setup_elide(struct sort_entry *self, struct strlist *list,
diff --git a/tools/perf/util/symbol.c b/tools/perf/util/symbol.c
index 7fd6b151feb5..1a367734e016 100644
--- a/tools/perf/util/symbol.c
+++ b/tools/perf/util/symbol.c
@@ -12,6 +12,7 @@
 #include <fcntl.h>
 #include <unistd.h>
 #include "build-id.h"
+#include "debug.h"
 #include "symbol.h"
 #include "strlist.h"
@@ -25,6 +26,8 @@
 #define NT_GNU_BUILD_ID 3
 #endif
+static bool dso__build_id_equal(const struct dso *self, u8 *build_id);
+static int elf_read_build_id(Elf *elf, void *bf, size_t size);
 static void dsos__add(struct list_head *head, struct dso *dso);
 static struct map *map__new2(u64 start, struct dso *dso, enum map_type type);
 static int dso__load_kernel_sym(struct dso *self, struct map *map,
@@ -40,6 +43,14 @@ struct symbol_conf symbol_conf = {
        .try_vmlinux_path = true,
 };
+int dso__name_len(const struct dso *self)
+{
+        if (verbose)
+                return self->long_name_len;
+        return self->short_name_len;
+}
 bool dso__loaded(const struct dso *self, enum map_type type)
 {
        return self->loaded & (1 << type);
@@ -120,7 +131,8 @@ static void map_groups__fixup_end(struct map_groups *self)
                __map_groups__fixup_end(self, i);
 }
-static struct symbol *symbol__new(u64 start, u64 len, const char *name)
+static struct symbol *symbol__new(u64 start, u64 len, u8 binding,
+                                  const char *name)
 {
        size_t namelen = strlen(name) + 1;
        struct symbol *self = calloc(1, (symbol_conf.priv_size +
@@ -133,6 +145,7 @@ static struct symbol *symbol__new(u64 start, u64 len, const char *name)
        self->start   = start;
        self->end     = len ? start + len - 1 : start;
+        self->binding = binding;
        self->namelen = namelen - 1;
        pr_debug4("%s: %s %#Lx-%#Lx\n", __func__, name, start, self->end);
@@ -149,8 +162,11 @@ void symbol__delete(struct symbol *self)
 static size_t symbol__fprintf(struct symbol *self, FILE *fp)
 {
-        return fprintf(fp, " %llx-%llx %s\n",
+        return fprintf(fp, " %llx-%llx %c %s\n",
-                       self->start, self->end, self->name);
+                       self->start, self->end,
+                       self->binding == STB_GLOBAL ? 'g' :
+                       self->binding == STB_LOCAL  ? 'l' : 'w',
+                       self->name);
 }
 void dso__set_long_name(struct dso *self, char *name)
@@ -215,7 +231,9 @@ void dso__delete(struct dso *self)
        int i;
        for (i = 0; i < MAP__NR_TYPES; ++i)
                symbols__delete(&self->symbols[i]);
-        if (self->long_name != self->name)
+        if (self->sname_alloc)
+                free((char *)self->short_name);
+        if (self->lname_alloc)
                free(self->long_name);
        free(self);
 }
@@ -440,6 +458,14 @@ struct process_kallsyms_args {
        struct dso *dso;
 };
+static u8 kallsyms2elf_type(char type)
+{
+        if (type == 'W')
+                return STB_WEAK;
+        return isupper(type) ? STB_GLOBAL : STB_LOCAL;
+}
 static int map__process_kallsym_symbol(void *arg, const char *name,
                                       char type, u64 start)
 {
@@ -453,7 +479,7 @@ static int map__process_kallsym_symbol(void *arg, const char *name,
        /*
         * Will fix up the end later, when we have all symbols sorted.
         */
-        sym = symbol__new(start, 0, name);
+        sym = symbol__new(start, 0, kallsyms2elf_type(type), name);
        if (sym == NULL)
                return -ENOMEM;
@@ -648,7 +674,7 @@ static int dso__load_perf_map(struct dso *self, struct map *map,
                if (len + 2 >= line_len)
                        continue;
-                sym = symbol__new(start, size, line + len);
+                sym = symbol__new(start, size, STB_GLOBAL, line + len);
                if (sym == NULL)
                        goto out_delete_line;
@@ -860,7 +886,7 @@ static int dso__synthesize_plt_symbols(struct  dso *self, struct map *map,
                                 "%s@plt", elf_sym__name(&sym, symstrs));
                        f = symbol__new(plt_offset, shdr_plt.sh_entsize,
-                                        sympltname);
+                                        STB_GLOBAL, sympltname);
                        if (!f)
                                goto out_elf_end;
@@ -882,7 +908,7 @@ static int dso__synthesize_plt_symbols(struct  dso *self, struct map *map,
                                 "%s@plt", elf_sym__name(&sym, symstrs));
                        f = symbol__new(plt_offset, shdr_plt.sh_entsize,
-                                        sympltname);
+                                        STB_GLOBAL, sympltname);
                        if (!f)
                                goto out_elf_end;
@@ -933,8 +959,28 @@ static bool elf_sec__is_a(GElf_Shdr *self, Elf_Data *secstrs, enum map_type type
        }
 }
+static size_t elf_addr_to_index(Elf *elf, GElf_Addr addr)
+{
+        Elf_Scn *sec = NULL;
+        GElf_Shdr shdr;
+        size_t cnt = 1;
+        while ((sec = elf_nextscn(elf, sec)) != NULL) {
+                gelf_getshdr(sec, &shdr);
+                if ((addr >= shdr.sh_addr) &&
+                    (addr < (shdr.sh_addr + shdr.sh_size)))
+                        return cnt;
+                ++cnt;
+        }
+        return -1;
+}
 static int dso__load_sym(struct dso *self, struct map *map, const char *name,
-                         int fd, symbol_filter_t filter, int kmodule)
+                         int fd, symbol_filter_t filter, int kmodule,
+                         int want_symtab)
 {
        struct kmap *kmap = self->kernel ? map__kmap(map) : NULL;
        struct map *curr_map = map;
@@ -944,31 +990,51 @@ static int dso__load_sym(struct dso *self, struct map *map, const char *name,
        int err = -1;
        uint32_t idx;
        GElf_Ehdr ehdr;
-        GElf_Shdr shdr;
+        GElf_Shdr shdr, opdshdr;
-        Elf_Data *syms;
+        Elf_Data *syms, *opddata = NULL;
        GElf_Sym sym;
-        Elf_Scn *sec, *sec_strndx;
+        Elf_Scn *sec, *sec_strndx, *opdsec;
        Elf *elf;
        int nr = 0;
+        size_t opdidx = 0;
        elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
        if (elf == NULL) {
-                pr_err("%s: cannot read %s ELF file.\n", __func__, name);
+                pr_debug("%s: cannot read %s ELF file.\n", __func__, name);
                goto out_close;
        }
        if (gelf_getehdr(elf, &ehdr) == NULL) {
-                pr_err("%s: cannot get elf header.\n", __func__);
+                pr_debug("%s: cannot get elf header.\n", __func__);
                goto out_elf_end;
        }
+        /* Always reject images with a mismatched build-id: */
+        if (self->has_build_id) {
+                u8 build_id[BUILD_ID_SIZE];
+                if (elf_read_build_id(elf, build_id,
+                                      BUILD_ID_SIZE) != BUILD_ID_SIZE)
+                        goto out_elf_end;
+                if (!dso__build_id_equal(self, build_id))
+                        goto out_elf_end;
+        }
        sec = elf_section_by_name(elf, &ehdr, &shdr, ".symtab", NULL);
        if (sec == NULL) {
+                if (want_symtab)
+                        goto out_elf_end;
                sec = elf_section_by_name(elf, &ehdr, &shdr, ".dynsym", NULL);
                if (sec == NULL)
                        goto out_elf_end;
        }
+        opdsec = elf_section_by_name(elf, &ehdr, &opdshdr, ".opd", &opdidx);
+        if (opdsec)
+                opddata = elf_rawdata(opdsec, NULL);
        syms = elf_getdata(sec, NULL);
        if (syms == NULL)
                goto out_elf_end;
@@ -1013,6 +1079,23 @@ static int dso__load_sym(struct dso *self, struct map *map, const char *name,
                if (!is_label && !elf_sym__is_a(&sym, map->type))
                        continue;
+                /* Reject ARM ELF "mapping symbols": these aren't unique and
+                 * don't identify functions, so will confuse the profile
+                 * output: */
+                if (ehdr.e_machine == EM_ARM) {
+                        if (!strcmp(elf_name, "$a") ||
+                            !strcmp(elf_name, "$d") ||
+                            !strcmp(elf_name, "$t"))
+                                continue;
+                }
+                if (opdsec && sym.st_shndx == opdidx) {
+                        u32 offset = sym.st_value - opdshdr.sh_addr;
+                        u64 *opd = opddata->d_buf + offset;
+                        sym.st_value = *opd;
+                        sym.st_shndx = elf_addr_to_index(elf, sym.st_value);
+                }
                sec = elf_getscn(elf, sym.st_shndx);
                if (!sec)
                        goto out_elf_end;
@@ -1086,7 +1169,8 @@ static int dso__load_sym(struct dso *self, struct map *map, const char *name,
                if (demangled != NULL)
                        elf_name = demangled;
 new_symbol:
-                f = symbol__new(sym.st_value, sym.st_size, elf_name);
+                f = symbol__new(sym.st_value, sym.st_size,
+                                GELF_ST_BIND(sym.st_info), elf_name);
                free(demangled);
                if (!f)
                        goto out_elf_end;
@@ -1151,37 +1235,26 @@ bool __dsos__read_build_ids(struct list_head *head, bool with_hits)
 */
 #define NOTE_ALIGN(n) (((n) + 3) & -4U)
-int filename__read_build_id(const char *filename, void *bf, size_t size)
+static int elf_read_build_id(Elf *elf, void *bf, size_t size)
 {
-        int fd, err = -1;
+        int err = -1;
        GElf_Ehdr ehdr;
        GElf_Shdr shdr;
        Elf_Data *data;
        Elf_Scn *sec;
        Elf_Kind ek;
        void *ptr;
-        Elf *elf;
        if (size < BUILD_ID_SIZE)
                goto out;
-        fd = open(filename, O_RDONLY);
-        if (fd < 0)
-                goto out;
-        elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
-        if (elf == NULL) {
-                pr_debug2("%s: cannot read %s ELF file.\n", __func__, filename);
-                goto out_close;
-        }
        ek = elf_kind(elf);
        if (ek != ELF_K_ELF)
-                goto out_elf_end;
+                goto out;
        if (gelf_getehdr(elf, &ehdr) == NULL) {
                pr_err("%s: cannot get elf header.\n", __func__);
-                goto out_elf_end;
+                goto out;
        }
        sec = elf_section_by_name(elf, &ehdr, &shdr,
@@ -1190,12 +1263,12 @@ int filename__read_build_id(const char *filename, void *bf, size_t size)
                sec = elf_section_by_name(elf, &ehdr, &shdr,
                                          ".notes", NULL);
                if (sec == NULL)
-                        goto out_elf_end;
+                        goto out;
        }
        data = elf_getdata(sec, NULL);
        if (data == NULL)
-                goto out_elf_end;
+                goto out;
        ptr = data->d_buf;
        while (ptr < (data->d_buf + data->d_size)) {
@@ -1217,7 +1290,31 @@ int filename__read_build_id(const char *filename, void *bf, size_t size)
                }
                ptr += descsz;
        }
-out_elf_end:
+out:
+        return err;
+}
+int filename__read_build_id(const char *filename, void *bf, size_t size)
+{
+        int fd, err = -1;
+        Elf *elf;
+        if (size < BUILD_ID_SIZE)
+                goto out;
+        fd = open(filename, O_RDONLY);
+        if (fd < 0)
+                goto out;
+        elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
+        if (elf == NULL) {
+                pr_debug2("%s: cannot read %s ELF file.\n", __func__, filename);
+                goto out_close;
+        }
+        err = elf_read_build_id(elf, bf, size);
        elf_end(elf);
 out_close:
        close(fd);
@@ -1293,11 +1390,11 @@ int dso__load(struct dso *self, struct map *map, symbol_filter_t filter)
 {
        int size = PATH_MAX;
        char *name;
-        u8 build_id[BUILD_ID_SIZE];
        int ret = -1;
        int fd;
        struct machine *machine;
        const char *root_dir;
+        int want_symtab;
        dso__set_loaded(self, map->type);
@@ -1324,13 +1421,18 @@ int dso__load(struct dso *self, struct map *map, symbol_filter_t filter)
                return ret;
        }
-        self->origin = DSO__ORIG_BUILD_ID_CACHE;
+        /* Iterate over candidate debug images.
-        if (dso__build_id_filename(self, name, size) != NULL)
+         * On the first pass, only load images if they have a full symtab.
-                goto open_file;
+         * Failing that, do a second pass where we accept .dynsym also
-more:
+         */
-        do {
+        for (self->origin = DSO__ORIG_BUILD_ID_CACHE, want_symtab = 1;
-                self->origin++;
+             self->origin != DSO__ORIG_NOT_FOUND;
+             self->origin++) {
                switch (self->origin) {
+                case DSO__ORIG_BUILD_ID_CACHE:
+                        if (dso__build_id_filename(self, name, size) == NULL)
+                                continue;
+                        break;
                case DSO__ORIG_FEDORA:
                        snprintf(name, size, "/usr/lib/debug%s.debug",
                                 self->long_name);
@@ -1339,21 +1441,20 @@ more:
                        snprintf(name, size, "/usr/lib/debug%s",
                                 self->long_name);
                        break;
-                case DSO__ORIG_BUILDID:
+                case DSO__ORIG_BUILDID: {
-                        if (filename__read_build_id(self->long_name, build_id,
+                        char build_id_hex[BUILD_ID_SIZE * 2 + 1];
-                                                    sizeof(build_id))) {
-                                char build_id_hex[BUILD_ID_SIZE * 2 + 1];
+                        if (!self->has_build_id)
-                                build_id__sprintf(build_id, sizeof(build_id),
+                                continue;
-                                                  build_id_hex);
-                                snprintf(name, size,
+                        build_id__sprintf(self->build_id,
-                                         "/usr/lib/debug/.build-id/%.2s/%s.debug",
+                                          sizeof(self->build_id),
-                                        build_id_hex, build_id_hex + 2);
+                                          build_id_hex);
-                                if (self->has_build_id)
+                        snprintf(name, size,
-                                        goto compare_build_id;
+                                 "/usr/lib/debug/.build-id/%.2s/%s.debug",
-                                break;
+                                 build_id_hex, build_id_hex + 2);
                        }
-                        self->origin++;
+                        break;
-                        /* Fall thru */
                case DSO__ORIG_DSO:
                        snprintf(name, size, "%s", self->long_name);
                        break;
@@ -1366,36 +1467,41 @@ more:
                        break;
                default:
-                        goto out;
+                        /*
+                         * If we wanted a full symtab but no image had one,
+                         * relax our requirements and repeat the search.
+                         */
+                        if (want_symtab) {
+                                want_symtab = 0;
+                                self->origin = DSO__ORIG_BUILD_ID_CACHE;
+                        } else
+                                continue;
                }
-                if (self->has_build_id) {
+                /* Name is now the name of the next image to try */
-                        if (filename__read_build_id(name, build_id,
-                                                    sizeof(build_id)) < 0)
-                                goto more;
-compare_build_id:
-                        if (!dso__build_id_equal(self, build_id))
-                                goto more;
-                }
-open_file:
                fd = open(name, O_RDONLY);
-        } while (fd < 0);
+                if (fd < 0)
+                        continue;
-        ret = dso__load_sym(self, map, name, fd, filter, 0);
+                ret = dso__load_sym(self, map, name, fd, filter, 0,
-        close(fd);
+                                    want_symtab);
+                close(fd);
-        /*
+                /*
-         * Some people seem to have debuginfo files _WITHOUT_ debug info!?!?
+                 * Some people seem to have debuginfo files _WITHOUT_ debug
-         */
+                 * info!?!?
-        if (!ret)
+                 */
-                goto more;
+                if (!ret)
+                        continue;
-        if (ret > 0) {
+                if (ret > 0) {
-                int nr_plt = dso__synthesize_plt_symbols(self, map, filter);
+                        int nr_plt = dso__synthesize_plt_symbols(self, map, filter);
-                if (nr_plt > 0)
+                        if (nr_plt > 0)
-                        ret += nr_plt;
+                                ret += nr_plt;
+                        break;
+                }
        }
-out:
        free(name);
        if (ret < 0 && strstr(self->name, " (deleted)") != NULL)
                return 0;
@@ -1443,6 +1549,7 @@ static int map_groups__set_modules_path_dir(struct map_groups *self,
 {
        struct dirent *dent;
        DIR *dir = opendir(dir_name);
+        int ret = 0;
        if (!dir) {
                pr_debug("%s: cannot open %s dir\n", __func__, dir_name);
@@ -1465,8 +1572,9 @@ static int map_groups__set_modules_path_dir(struct map_groups *self,
                        snprintf(path, sizeof(path), "%s/%s",
                                 dir_name, dent->d_name);
-                        if (map_groups__set_modules_path_dir(self, path) < 0)
+                        ret = map_groups__set_modules_path_dir(self, path);
-                                goto failure;
+                        if (ret < 0)
+                                goto out;
                } else {
                        char *dot = strrchr(dent->d_name, '.'),
                             dso_name[PATH_MAX];
@@ -1487,17 +1595,19 @@ static int map_groups__set_modules_path_dir(struct map_groups *self,
                                 dir_name, dent->d_name);
                        long_name = strdup(path);
-                        if (long_name == NULL)
+                        if (long_name == NULL) {
-                                goto failure;
+                                ret = -1;
+                                goto out;
+                        }
                        dso__set_long_name(map->dso, long_name);
+                        map->dso->lname_alloc = 1;
                        dso__kernel_module_get_build_id(map->dso, "");
                }
        }
-        return 0;
+out:
-failure:
        closedir(dir);
-        return -1;
+        return ret;
 }
 static char *get_kernel_version(const char *root_dir)
@@ -1653,36 +1763,12 @@ static int dso__load_vmlinux(struct dso *self, struct map *map,
 {
        int err = -1, fd;
-        if (self->has_build_id) {
-                u8 build_id[BUILD_ID_SIZE];
-                if (filename__read_build_id(vmlinux, build_id,
-                                            sizeof(build_id)) < 0) {
-                        pr_debug("No build_id in %s, ignoring it\n", vmlinux);
-                        return -1;
-                }
-                if (!dso__build_id_equal(self, build_id)) {
-                        char expected_build_id[BUILD_ID_SIZE * 2 + 1],
-                             vmlinux_build_id[BUILD_ID_SIZE * 2 + 1];
-                        build_id__sprintf(self->build_id,
-                                          sizeof(self->build_id),
-                                          expected_build_id);
-                        build_id__sprintf(build_id, sizeof(build_id),
-                                          vmlinux_build_id);
-                        pr_debug("build_id in %s is %s while expected is %s, "
-                                 "ignoring it\n", vmlinux, vmlinux_build_id,
-                                 expected_build_id);
-                        return -1;
-                }
-        }
        fd = open(vmlinux, O_RDONLY);
        if (fd < 0)
                return -1;
        dso__set_loaded(self, map->type);
-        err = dso__load_sym(self, map, vmlinux, fd, filter, 0);
+        err = dso__load_sym(self, map, vmlinux, fd, filter, 0, 0);
        close(fd);
        if (err > 0)
@@ -1745,7 +1831,12 @@ static int dso__load_kernel_sym(struct dso *self, struct map *map,
        if (symbol_conf.vmlinux_name != NULL) {
                err = dso__load_vmlinux(self, map,
                                        symbol_conf.vmlinux_name, filter);
-                goto out_try_fixup;
+                if (err > 0) {
+                        dso__set_long_name(self,
+                                           strdup(symbol_conf.vmlinux_name));
+                        goto out_fixup;
+                }
+                return err;
        }
        if (vmlinux_path != NULL) {
@@ -1806,7 +1897,6 @@ do_kallsyms:
                pr_debug("Using %s for symbols\n", kallsyms_filename);
        free(kallsyms_allocated_filename);
-out_try_fixup:
        if (err > 0) {
 out_fixup:
                if (kallsyms_filename != NULL)
@@ -2041,6 +2131,36 @@ int __machine__create_kernel_maps(struct machine *self, struct dso *kernel)
        return 0;
 }
+void machine__destroy_kernel_maps(struct machine *self)
+{
+        enum map_type type;
+        for (type = 0; type < MAP__NR_TYPES; ++type) {
+                struct kmap *kmap;
+                if (self->vmlinux_maps[type] == NULL)
+                        continue;
+                kmap = map__kmap(self->vmlinux_maps[type]);
+                map_groups__remove(&self->kmaps, self->vmlinux_maps[type]);
+                if (kmap->ref_reloc_sym) {
+                        /*
+                         * ref_reloc_sym is shared among all maps, so free just
+                         * on one of them.
+                         */
+                        if (type == MAP__FUNCTION) {
+                                free((char *)kmap->ref_reloc_sym->name);
+                                kmap->ref_reloc_sym->name = NULL;
+                                free(kmap->ref_reloc_sym);
+                        }
+                        kmap->ref_reloc_sym = NULL;
+                }
+                map__delete(self->vmlinux_maps[type]);
+                self->vmlinux_maps[type] = NULL;
+        }
+}
 int machine__create_kernel_maps(struct machine *self)
 {
        struct dso *kernel = machine__create_kernel(self);
@@ -2182,6 +2302,15 @@ out_free_comm_list:
        return -1;
 }
+void symbol__exit(void)
+{
+        strlist__delete(symbol_conf.sym_list);
+        strlist__delete(symbol_conf.dso_list);
+        strlist__delete(symbol_conf.comm_list);
+        vmlinux_path__exit();
+        symbol_conf.sym_list = symbol_conf.dso_list = symbol_conf.comm_list = NULL;
+}
 int machines__create_kernel_maps(struct rb_root *self, pid_t pid)
 {
        struct machine *machine = machines__findnew(self, pid);
@@ -2276,6 +2405,19 @@ failure:
        return ret;
 }
+void machines__destroy_guest_kernel_maps(struct rb_root *self)
+{
+        struct rb_node *next = rb_first(self);
+        while (next) {
+                struct machine *pos = rb_entry(next, struct machine, rb_node);
+                next = rb_next(&pos->rb_node);
+                rb_erase(&pos->rb_node, self);
+                machine__delete(pos);
+        }
+}
 int machine__load_kallsyms(struct machine *self, const char *filename,
                           enum map_type type, symbol_filter_t filter)
 {
diff --git a/tools/perf/util/symbol.h b/tools/perf/util/symbol.h
index 5e02d2c17154..b7a8da4af5a0 100644
--- a/tools/perf/util/symbol.h
+++ b/tools/perf/util/symbol.h
@@ -9,8 +9,6 @@
 #include <linux/rbtree.h>
 #include <stdio.h>
-#define DEBUG_CACHE_DIR ".debug"
 #ifdef HAVE_CPLUS_DEMANGLE
 extern char *cplus_demangle(const char *, int);
@@ -55,6 +53,7 @@ struct symbol {
        u64             start;
        u64             end;
        u16             namelen;
+        u8              binding;
        char            name[0];
 };
@@ -70,9 +69,9 @@ struct symbol_conf {
                        show_nr_samples,
                        use_callchain,
                        exclude_other,
-                        full_paths,
                        show_cpu_utilization;
        const char      *vmlinux_name,
+                        *source_prefix,
                        *field_sep;
        const char      *default_guest_vmlinux_name,
                        *default_guest_kallsyms,
@@ -103,6 +102,8 @@ struct ref_reloc_sym {
 struct map_symbol {
        struct map    *map;
        struct symbol *sym;
+        bool          unfolded;
+        bool          has_children;
 };
 struct addr_location {
@@ -112,7 +113,8 @@ struct addr_location {
        u64           addr;
        char          level;
        bool          filtered;
-        unsigned int  cpumode;
+        u8            cpumode;
+        s32           cpu;
 };
 enum dso_kernel_type {
@@ -125,12 +127,14 @@ struct dso {
        struct list_head node;
        struct rb_root   symbols[MAP__NR_TYPES];
        struct rb_root   symbol_names[MAP__NR_TYPES];
+        enum dso_kernel_type    kernel;
        u8               adjust_symbols:1;
        u8               slen_calculated:1;
        u8               has_build_id:1;
-        enum dso_kernel_type    kernel;
        u8               hit:1;
        u8               annotate_warned:1;
+        u8               sname_alloc:1;
+        u8               lname_alloc:1;
        unsigned char    origin;
        u8               sorted_by_name;
        u8               loaded;
@@ -146,6 +150,8 @@ struct dso *dso__new(const char *name);
 struct dso *dso__new_kernel(const char *name);
 void dso__delete(struct dso *self);
+int dso__name_len(const struct dso *self);
 bool dso__loaded(const struct dso *self, enum map_type type);
 bool dso__sorted_by_name(const struct dso *self, enum map_type type);
@@ -207,13 +213,16 @@ int kallsyms__parse(const char *filename, void *arg,
                    int (*process_symbol)(void *arg, const char *name,
                                          char type, u64 start));
+void machine__destroy_kernel_maps(struct machine *self);
 int __machine__create_kernel_maps(struct machine *self, struct dso *kernel);
 int machine__create_kernel_maps(struct machine *self);
 int machines__create_kernel_maps(struct rb_root *self, pid_t pid);
 int machines__create_guest_kernel_maps(struct rb_root *self);
+void machines__destroy_guest_kernel_maps(struct rb_root *self);
 int symbol__init(void);
+void symbol__exit(void);
 bool symbol_type__is_a(char symbol_type, enum map_type map_type);
 size_t machine__fprintf_vmlinux_path(struct machine *self, FILE *fp);
diff --git a/tools/perf/util/thread.c b/tools/perf/util/thread.c
index 1f7ecd47f499..8c72d888e449 100644
--- a/tools/perf/util/thread.c
+++ b/tools/perf/util/thread.c
@@ -7,6 +7,15 @@
 #include "util.h"
 #include "debug.h"
+/* Skip "." and ".." directories */
+static int filter(const struct dirent *dir)
+{
+        if (dir->d_name[0] == '.')
+                return 0;
+        else
+                return 1;
+}
 int find_all_tid(int pid, pid_t ** all_tid)
 {
        char name[256];
@@ -16,7 +25,7 @@ int find_all_tid(int pid, pid_t ** all_tid)
        int i;
        sprintf(name, "/proc/%d/task", pid);
-        items = scandir(name, &namelist, NULL, NULL);
+        items = scandir(name, &namelist, filter, NULL);
        if (items <= 0)
                return -ENOENT;
        *all_tid = malloc(sizeof(pid_t) * items);
@@ -53,6 +62,13 @@ static struct thread *thread__new(pid_t pid)
        return self;
 }
+void thread__delete(struct thread *self)
+{
+        map_groups__exit(&self->mg);
+        free(self->comm);
+        free(self);
+}
 int thread__set_comm(struct thread *self, const char *comm)
 {
        int err;
diff --git a/tools/perf/util/thread.h b/tools/perf/util/thread.h
index 1dfd9ff8bdcd..688500ff826f 100644
--- a/tools/perf/util/thread.h
+++ b/tools/perf/util/thread.h
@@ -6,7 +6,10 @@
 #include "symbol.h"
 struct thread {
-        struct rb_node          rb_node;
+        union {
+                struct rb_node   rb_node;
+                struct list_head node;
+        };
        struct map_groups       mg;
        pid_t                   pid;
        char                    shortname[3];
@@ -17,6 +20,8 @@ struct thread {
 struct perf_session;
+void thread__delete(struct thread *self);
 int find_all_tid(int pid, pid_t ** all_tid);
 int thread__set_comm(struct thread *self, const char *comm);
 int thread__comm_len(struct thread *self);
diff --git a/tools/perf/util/ui/browser.c b/tools/perf/util/ui/browser.c
new file mode 100644
index 000000000000..66f2d583d8c4
--- /dev/null
+++ b/tools/perf/util/ui/browser.c
@@ -0,0 +1,329 @@
+#define _GNU_SOURCE
+#include <stdio.h>
+#undef _GNU_SOURCE
+/*
+ * slang versions <= 2.0.6 have a "#if HAVE_LONG_LONG" that breaks
+ * the build if it isn't defined. Use the equivalent one that glibc
+ * has on features.h.
+ */
+#include <features.h>
+#ifndef HAVE_LONG_LONG
+#define HAVE_LONG_LONG __GLIBC_HAVE_LONG_LONG
+#endif
+#include <slang.h>
+#include <linux/list.h>
+#include <linux/rbtree.h>
+#include <stdlib.h>
+#include <sys/ttydefaults.h>
+#include "browser.h"
+#include "helpline.h"
+#include "../color.h"
+#include "../util.h"
+#if SLANG_VERSION < 20104
+#define sltt_set_color(obj, name, fg, bg) \
+        SLtt_set_color(obj,(char *)name, (char *)fg, (char *)bg)
+#else
+#define sltt_set_color SLtt_set_color
+#endif
+newtComponent newt_form__new(void);
+int ui_browser__percent_color(double percent, bool current)
+{
+        if (current)
+                return HE_COLORSET_SELECTED;
+        if (percent >= MIN_RED)
+                return HE_COLORSET_TOP;
+        if (percent >= MIN_GREEN)
+                return HE_COLORSET_MEDIUM;
+        return HE_COLORSET_NORMAL;
+}
+void ui_browser__list_head_seek(struct ui_browser *self, off_t offset, int whence)
+{
+        struct list_head *head = self->entries;
+        struct list_head *pos;
+        switch (whence) {
+        case SEEK_SET:
+                pos = head->next;
+                break;
+        case SEEK_CUR:
+                pos = self->top;
+                break;
+        case SEEK_END:
+                pos = head->prev;
+                break;
+        default:
+                return;
+        }
+        if (offset > 0) {
+                while (offset-- != 0)
+                        pos = pos->next;
+        } else {
+                while (offset++ != 0)
+                        pos = pos->prev;
+        }
+        self->top = pos;
+}
+void ui_browser__rb_tree_seek(struct ui_browser *self, off_t offset, int whence)
+{
+        struct rb_root *root = self->entries;
+        struct rb_node *nd;
+        switch (whence) {
+        case SEEK_SET:
+                nd = rb_first(root);
+                break;
+        case SEEK_CUR:
+                nd = self->top;
+                break;
+        case SEEK_END:
+                nd = rb_last(root);
+                break;
+        default:
+                return;
+        }
+        if (offset > 0) {
+                while (offset-- != 0)
+                        nd = rb_next(nd);
+        } else {
+                while (offset++ != 0)
+                        nd = rb_prev(nd);
+        }
+        self->top = nd;
+}
+unsigned int ui_browser__rb_tree_refresh(struct ui_browser *self)
+{
+        struct rb_node *nd;
+        int row = 0;
+        if (self->top == NULL)
+                self->top = rb_first(self->entries);
+        nd = self->top;
+        while (nd != NULL) {
+                SLsmg_gotorc(self->y + row, self->x);
+                self->write(self, nd, row);
+                if (++row == self->height)
+                        break;
+                nd = rb_next(nd);
+        }
+        return row;
+}
+bool ui_browser__is_current_entry(struct ui_browser *self, unsigned row)
+{
+        return self->top_idx + row == self->index;
+}
+void ui_browser__refresh_dimensions(struct ui_browser *self)
+{
+        int cols, rows;
+        newtGetScreenSize(&cols, &rows);
+        if (self->width > cols - 4)
+                self->width = cols - 4;
+        self->height = rows - 5;
+        if (self->height > self->nr_entries)
+                self->height = self->nr_entries;
+        self->y  = (rows - self->height) / 2;
+        self->x = (cols - self->width) / 2;
+}
+void ui_browser__reset_index(struct ui_browser *self)
+{
+        self->index = self->top_idx = 0;
+        self->seek(self, 0, SEEK_SET);
+}
+int ui_browser__show(struct ui_browser *self, const char *title,
+                     const char *helpline, ...)
+{
+        va_list ap;
+        if (self->form != NULL) {
+                newtFormDestroy(self->form);
+                newtPopWindow();
+        }
+        ui_browser__refresh_dimensions(self);
+        newtCenteredWindow(self->width, self->height, title);
+        self->form = newt_form__new();
+        if (self->form == NULL)
+                return -1;
+        self->sb = newtVerticalScrollbar(self->width, 0, self->height,
+                                         HE_COLORSET_NORMAL,
+                                         HE_COLORSET_SELECTED);
+        if (self->sb == NULL)
+                return -1;
+        newtFormAddHotKey(self->form, NEWT_KEY_UP);
+        newtFormAddHotKey(self->form, NEWT_KEY_DOWN);
+        newtFormAddHotKey(self->form, NEWT_KEY_PGUP);
+        newtFormAddHotKey(self->form, NEWT_KEY_PGDN);
+        newtFormAddHotKey(self->form, NEWT_KEY_HOME);
+        newtFormAddHotKey(self->form, NEWT_KEY_END);
+        newtFormAddHotKey(self->form, ' ');
+        newtFormAddComponent(self->form, self->sb);
+        va_start(ap, helpline);
+        ui_helpline__vpush(helpline, ap);
+        va_end(ap);
+        return 0;
+}
+void ui_browser__hide(struct ui_browser *self)
+{
+        newtFormDestroy(self->form);
+        newtPopWindow();
+        self->form = NULL;
+        ui_helpline__pop();
+}
+int ui_browser__refresh(struct ui_browser *self)
+{
+        int row;
+        newtScrollbarSet(self->sb, self->index, self->nr_entries - 1);
+        row = self->refresh(self);
+        SLsmg_set_color(HE_COLORSET_NORMAL);
+        SLsmg_fill_region(self->y + row, self->x,
+                          self->height - row, self->width, ' ');
+        return 0;
+}
+int ui_browser__run(struct ui_browser *self, struct newtExitStruct *es)
+{
+        if (ui_browser__refresh(self) < 0)
+                return -1;
+        while (1) {
+                off_t offset;
+                newtFormRun(self->form, es);
+                if (es->reason != NEWT_EXIT_HOTKEY)
+                        break;
+                if (is_exit_key(es->u.key))
+                        return es->u.key;
+                switch (es->u.key) {
+                case NEWT_KEY_DOWN:
+                        if (self->index == self->nr_entries - 1)
+                                break;
+                        ++self->index;
+                        if (self->index == self->top_idx + self->height) {
+                                ++self->top_idx;
+                                self->seek(self, +1, SEEK_CUR);
+                        }
+                        break;
+                case NEWT_KEY_UP:
+                        if (self->index == 0)
+                                break;
+                        --self->index;
+                        if (self->index < self->top_idx) {
+                                --self->top_idx;
+                                self->seek(self, -1, SEEK_CUR);
+                        }
+                        break;
+                case NEWT_KEY_PGDN:
+                case ' ':
+                        if (self->top_idx + self->height > self->nr_entries - 1)
+                                break;
+                        offset = self->height;
+                        if (self->index + offset > self->nr_entries - 1)
+                                offset = self->nr_entries - 1 - self->index;
+                        self->index += offset;
+                        self->top_idx += offset;
+                        self->seek(self, +offset, SEEK_CUR);
+                        break;
+                case NEWT_KEY_PGUP:
+                        if (self->top_idx == 0)
+                                break;
+                        if (self->top_idx < self->height)
+                                offset = self->top_idx;
+                        else
+                                offset = self->height;
+                        self->index -= offset;
+                        self->top_idx -= offset;
+                        self->seek(self, -offset, SEEK_CUR);
+                        break;
+                case NEWT_KEY_HOME:
+                        ui_browser__reset_index(self);
+                        break;
+                case NEWT_KEY_END:
+                        offset = self->height - 1;
+                        if (offset >= self->nr_entries)
+                                offset = self->nr_entries - 1;
+                        self->index = self->nr_entries - 1;
+                        self->top_idx = self->index - offset;
+                        self->seek(self, -offset, SEEK_END);
+                        break;
+                default:
+                        return es->u.key;
+                }
+                if (ui_browser__refresh(self) < 0)
+                        return -1;
+        }
+        return 0;
+}
+unsigned int ui_browser__list_head_refresh(struct ui_browser *self)
+{
+        struct list_head *pos;
+        struct list_head *head = self->entries;
+        int row = 0;
+        if (self->top == NULL || self->top == self->entries)
+                self->top = head->next;
+        pos = self->top;
+        list_for_each_from(pos, head) {
+                SLsmg_gotorc(self->y + row, self->x);
+                self->write(self, pos, row);
+                if (++row == self->height)
+                        break;
+        }
+        return row;
+}
+static struct newtPercentTreeColors {
+        const char *topColorFg, *topColorBg;
+        const char *mediumColorFg, *mediumColorBg;
+        const char *normalColorFg, *normalColorBg;
+        const char *selColorFg, *selColorBg;
+        const char *codeColorFg, *codeColorBg;
+} defaultPercentTreeColors = {
+        "red",       "lightgray",
+        "green",     "lightgray",
+        "black",     "lightgray",
+        "lightgray", "magenta",
+        "blue",      "lightgray",
+};
+void ui_browser__init(void)
+{
+        struct newtPercentTreeColors *c = &defaultPercentTreeColors;
+        sltt_set_color(HE_COLORSET_TOP, NULL, c->topColorFg, c->topColorBg);
+        sltt_set_color(HE_COLORSET_MEDIUM, NULL, c->mediumColorFg, c->mediumColorBg);
+        sltt_set_color(HE_COLORSET_NORMAL, NULL, c->normalColorFg, c->normalColorBg);
+        sltt_set_color(HE_COLORSET_SELECTED, NULL, c->selColorFg, c->selColorBg);
+        sltt_set_color(HE_COLORSET_CODE, NULL, c->codeColorFg, c->codeColorBg);
+}
diff --git a/tools/perf/util/ui/browser.h b/tools/perf/util/ui/browser.h
new file mode 100644
index 000000000000..0b9f829214f7
--- /dev/null
+++ b/tools/perf/util/ui/browser.h
@@ -0,0 +1,46 @@
+#ifndef _PERF_UI_BROWSER_H_
+#define _PERF_UI_BROWSER_H_ 1
+#include <stdbool.h>
+#include <newt.h>
+#include <sys/types.h>
+#include "../types.h"
+#define HE_COLORSET_TOP         50
+#define HE_COLORSET_MEDIUM      51
+#define HE_COLORSET_NORMAL      52
+#define HE_COLORSET_SELECTED    53
+#define HE_COLORSET_CODE        54
+struct ui_browser {
+        newtComponent form, sb;
+        u64           index, top_idx;
+        void          *top, *entries;
+        u16           y, x, width, height;
+        void          *priv;
+        unsigned int  (*refresh)(struct ui_browser *self);
+        void          (*write)(struct ui_browser *self, void *entry, int row);
+        void          (*seek)(struct ui_browser *self, off_t offset, int whence);
+        u32           nr_entries;
+};
+int ui_browser__percent_color(double percent, bool current);
+bool ui_browser__is_current_entry(struct ui_browser *self, unsigned row);
+void ui_browser__refresh_dimensions(struct ui_browser *self);
+void ui_browser__reset_index(struct ui_browser *self);
+int ui_browser__show(struct ui_browser *self, const char *title,
+                     const char *helpline, ...);
+void ui_browser__hide(struct ui_browser *self);
+int ui_browser__refresh(struct ui_browser *self);
+int ui_browser__run(struct ui_browser *self, struct newtExitStruct *es);
+void ui_browser__rb_tree_seek(struct ui_browser *self, off_t offset, int whence);
+unsigned int ui_browser__rb_tree_refresh(struct ui_browser *self);
+void ui_browser__list_head_seek(struct ui_browser *self, off_t offset, int whence);
+unsigned int ui_browser__list_head_refresh(struct ui_browser *self);
+void ui_browser__init(void);
+#endif /* _PERF_UI_BROWSER_H_ */
diff --git a/tools/perf/util/ui/browsers/annotate.c b/tools/perf/util/ui/browsers/annotate.c
new file mode 100644
index 000000000000..55ff792459ac
--- /dev/null
+++ b/tools/perf/util/ui/browsers/annotate.c
@@ -0,0 +1,240 @@
+#include "../browser.h"
+#include "../helpline.h"
+#include "../libslang.h"
+#include "../../hist.h"
+#include "../../sort.h"
+#include "../../symbol.h"
+static void ui__error_window(const char *fmt, ...)
+{
+        va_list ap;
+        va_start(ap, fmt);
+        newtWinMessagev((char *)"Error", (char *)"Ok", (char *)fmt, ap);
+        va_end(ap);
+}
+struct annotate_browser {
+        struct ui_browser b;
+        struct rb_root    entries;
+        struct rb_node    *curr_hot;
+};
+struct objdump_line_rb_node {
+        struct rb_node  rb_node;
+        double          percent;
+        u32             idx;
+};
+static inline
+struct objdump_line_rb_node *objdump_line__rb(struct objdump_line *self)
+{
+        return (struct objdump_line_rb_node *)(self + 1);
+}
+static void annotate_browser__write(struct ui_browser *self, void *entry, int row)
+{
+        struct objdump_line *ol = rb_entry(entry, struct objdump_line, node);
+        bool current_entry = ui_browser__is_current_entry(self, row);
+        int width = self->width;
+        if (ol->offset != -1) {
+                struct objdump_line_rb_node *olrb = objdump_line__rb(ol);
+                int color = ui_browser__percent_color(olrb->percent, current_entry);
+                SLsmg_set_color(color);
+                slsmg_printf(" %7.2f ", olrb->percent);
+                if (!current_entry)
+                        SLsmg_set_color(HE_COLORSET_CODE);
+        } else {
+                int color = ui_browser__percent_color(0, current_entry);
+                SLsmg_set_color(color);
+                slsmg_write_nstring(" ", 9);
+        }
+        SLsmg_write_char(':');
+        slsmg_write_nstring(" ", 8);
+        if (!*ol->line)
+                slsmg_write_nstring(" ", width - 18);
+        else
+                slsmg_write_nstring(ol->line, width - 18);
+}
+static double objdump_line__calc_percent(struct objdump_line *self,
+                                         struct list_head *head,
+                                         struct symbol *sym)
+{
+        double percent = 0.0;
+        if (self->offset != -1) {
+                int len = sym->end - sym->start;
+                unsigned int hits = 0;
+                struct sym_priv *priv = symbol__priv(sym);
+                struct sym_ext *sym_ext = priv->ext;
+                struct sym_hist *h = priv->hist;
+                s64 offset = self->offset;
+                struct objdump_line *next = objdump__get_next_ip_line(head, self);
+                while (offset < (s64)len &&
+                       (next == NULL || offset < next->offset)) {
+                        if (sym_ext) {
+                                percent += sym_ext[offset].percent;
+                        } else
+                                hits += h->ip[offset];
+                        ++offset;
+                }
+                if (sym_ext == NULL && h->sum)
+                        percent = 100.0 * hits / h->sum;
+        }
+        return percent;
+}
+static void objdump__insert_line(struct rb_root *self,
+                                 struct objdump_line_rb_node *line)
+{
+        struct rb_node **p = &self->rb_node;
+        struct rb_node *parent = NULL;
+        struct objdump_line_rb_node *l;
+        while (*p != NULL) {
+                parent = *p;
+                l = rb_entry(parent, struct objdump_line_rb_node, rb_node);
+                if (line->percent < l->percent)
+                        p = &(*p)->rb_left;
+                else
+                        p = &(*p)->rb_right;
+        }
+        rb_link_node(&line->rb_node, parent, p);
+        rb_insert_color(&line->rb_node, self);
+}
+static void annotate_browser__set_top(struct annotate_browser *self,
+                                      struct rb_node *nd)
+{
+        struct objdump_line_rb_node *rbpos;
+        struct objdump_line *pos;
+        unsigned back;
+        ui_browser__refresh_dimensions(&self->b);
+        back = self->b.height / 2;
+        rbpos = rb_entry(nd, struct objdump_line_rb_node, rb_node);
+        pos = ((struct objdump_line *)rbpos) - 1;
+        self->b.top_idx = self->b.index = rbpos->idx;
+        while (self->b.top_idx != 0 && back != 0) {
+                pos = list_entry(pos->node.prev, struct objdump_line, node);
+                --self->b.top_idx;
+                --back;
+        }
+        self->b.top = pos;
+        self->curr_hot = nd;
+}
+static int annotate_browser__run(struct annotate_browser *self,
+                                 struct newtExitStruct *es)
+{
+        struct rb_node *nd;
+        struct hist_entry *he = self->b.priv;
+        if (ui_browser__show(&self->b, he->ms.sym->name,
+                             "<- or ESC: exit, TAB/shift+TAB: cycle thru samples") < 0)
+                return -1;
+        newtFormAddHotKey(self->b.form, NEWT_KEY_LEFT);
+        nd = self->curr_hot;
+        if (nd) {
+                newtFormAddHotKey(self->b.form, NEWT_KEY_TAB);
+                newtFormAddHotKey(self->b.form, NEWT_KEY_UNTAB);
+        }
+        while (1) {
+                ui_browser__run(&self->b, es);
+                if (es->reason != NEWT_EXIT_HOTKEY)
+                        break;
+                switch (es->u.key) {
+                case NEWT_KEY_TAB:
+                        nd = rb_prev(nd);
+                        if (nd == NULL)
+                                nd = rb_last(&self->entries);
+                        annotate_browser__set_top(self, nd);
+                        break;
+                case NEWT_KEY_UNTAB:
+                        nd = rb_next(nd);
+                        if (nd == NULL)
+                                nd = rb_first(&self->entries);
+                        annotate_browser__set_top(self, nd);
+                        break;
+                default:
+                        goto out;
+                }
+        }
+out:
+        ui_browser__hide(&self->b);
+        return 0;
+}
+int hist_entry__tui_annotate(struct hist_entry *self)
+{
+        struct newtExitStruct es;
+        struct objdump_line *pos, *n;
+        struct objdump_line_rb_node *rbpos;
+        LIST_HEAD(head);
+        struct annotate_browser browser = {
+                .b = {
+                        .entries = &head,
+                        .refresh = ui_browser__list_head_refresh,
+                        .seek    = ui_browser__list_head_seek,
+                        .write   = annotate_browser__write,
+                        .priv    = self,
+                },
+        };
+        int ret;
+        if (self->ms.sym == NULL)
+                return -1;
+        if (self->ms.map->dso->annotate_warned)
+                return -1;
+        if (hist_entry__annotate(self, &head, sizeof(*rbpos)) < 0) {
+                ui__error_window(ui_helpline__last_msg);
+                return -1;
+        }
+        ui_helpline__push("Press <- or ESC to exit");
+        list_for_each_entry(pos, &head, node) {
+                size_t line_len = strlen(pos->line);
+                if (browser.b.width < line_len)
+                        browser.b.width = line_len;
+                rbpos = objdump_line__rb(pos);
+                rbpos->idx = browser.b.nr_entries++;
+                rbpos->percent = objdump_line__calc_percent(pos, &head, self->ms.sym);
+                if (rbpos->percent < 0.01)
+                        continue;
+                objdump__insert_line(&browser.entries, rbpos);
+        }
+        /*
+         * Position the browser at the hottest line.
+         */
+        browser.curr_hot = rb_last(&browser.entries);
+        if (browser.curr_hot)
+                annotate_browser__set_top(&browser, browser.curr_hot);
+        browser.b.width += 18; /* Percentage */
+        ret = annotate_browser__run(&browser, &es);
+        list_for_each_entry_safe(pos, n, &head, node) {
+                list_del(&pos->node);
+                objdump_line__free(pos);
+        }
+        return ret;
+}
diff --git a/tools/perf/util/ui/browsers/hists.c b/tools/perf/util/ui/browsers/hists.c
new file mode 100644
index 000000000000..dafdf6775d77
--- /dev/null
+++ b/tools/perf/util/ui/browsers/hists.c
@@ -0,0 +1,948 @@
+#define _GNU_SOURCE
+#include <stdio.h>
+#undef _GNU_SOURCE
+#include "../libslang.h"
+#include <stdlib.h>
+#include <string.h>
+#include <newt.h>
+#include <linux/rbtree.h>
+#include "../../hist.h"
+#include "../../pstack.h"
+#include "../../sort.h"
+#include "../../util.h"
+#include "../browser.h"
+#include "../helpline.h"
+#include "../util.h"
+#include "map.h"
+struct hist_browser {
+        struct ui_browser   b;
+        struct hists        *hists;
+        struct hist_entry   *he_selection;
+        struct map_symbol   *selection;
+};
+static void hist_browser__refresh_dimensions(struct hist_browser *self)
+{
+        /* 3 == +/- toggle symbol before actual hist_entry rendering */
+        self->b.width = 3 + (hists__sort_list_width(self->hists) +
+                             sizeof("[k]"));
+}
+static void hist_browser__reset(struct hist_browser *self)
+{
+        self->b.nr_entries = self->hists->nr_entries;
+        hist_browser__refresh_dimensions(self);
+        ui_browser__reset_index(&self->b);
+}
+static char tree__folded_sign(bool unfolded)
+{
+        return unfolded ? '-' : '+';
+}
+static char map_symbol__folded(const struct map_symbol *self)
+{
+        return self->has_children ? tree__folded_sign(self->unfolded) : ' ';
+}
+static char hist_entry__folded(const struct hist_entry *self)
+{
+        return map_symbol__folded(&self->ms);
+}
+static char callchain_list__folded(const struct callchain_list *self)
+{
+        return map_symbol__folded(&self->ms);
+}
+static int callchain_node__count_rows_rb_tree(struct callchain_node *self)
+{
+        int n = 0;
+        struct rb_node *nd;
+        for (nd = rb_first(&self->rb_root); nd; nd = rb_next(nd)) {
+                struct callchain_node *child = rb_entry(nd, struct callchain_node, rb_node);
+                struct callchain_list *chain;
+                char folded_sign = ' '; /* No children */
+                list_for_each_entry(chain, &child->val, list) {
+                        ++n;
+                        /* We need this because we may not have children */
+                        folded_sign = callchain_list__folded(chain);
+                        if (folded_sign == '+')
+                                break;
+                }
+                if (folded_sign == '-') /* Have children and they're unfolded */
+                        n += callchain_node__count_rows_rb_tree(child);
+        }
+        return n;
+}
+static int callchain_node__count_rows(struct callchain_node *node)
+{
+        struct callchain_list *chain;
+        bool unfolded = false;
+        int n = 0;
+        list_for_each_entry(chain, &node->val, list) {
+                ++n;
+                unfolded = chain->ms.unfolded;
+        }
+        if (unfolded)
+                n += callchain_node__count_rows_rb_tree(node);
+        return n;
+}
+static int callchain__count_rows(struct rb_root *chain)
+{
+        struct rb_node *nd;
+        int n = 0;
+        for (nd = rb_first(chain); nd; nd = rb_next(nd)) {
+                struct callchain_node *node = rb_entry(nd, struct callchain_node, rb_node);
+                n += callchain_node__count_rows(node);
+        }
+        return n;
+}
+static bool map_symbol__toggle_fold(struct map_symbol *self)
+{
+        if (!self->has_children)
+                return false;
+        self->unfolded = !self->unfolded;
+        return true;
+}
+static void callchain_node__init_have_children_rb_tree(struct callchain_node *self)
+{
+        struct rb_node *nd = rb_first(&self->rb_root);
+        for (nd = rb_first(&self->rb_root); nd; nd = rb_next(nd)) {
+                struct callchain_node *child = rb_entry(nd, struct callchain_node, rb_node);
+                struct callchain_list *chain;
+                int first = true;
+                list_for_each_entry(chain, &child->val, list) {
+                        if (first) {
+                                first = false;
+                                chain->ms.has_children = chain->list.next != &child->val ||
+                                                         rb_first(&child->rb_root) != NULL;
+                        } else
+                                chain->ms.has_children = chain->list.next == &child->val &&
+                                                         rb_first(&child->rb_root) != NULL;
+                }
+                callchain_node__init_have_children_rb_tree(child);
+        }
+}
+static void callchain_node__init_have_children(struct callchain_node *self)
+{
+        struct callchain_list *chain;
+        list_for_each_entry(chain, &self->val, list)
+                chain->ms.has_children = rb_first(&self->rb_root) != NULL;
+        callchain_node__init_have_children_rb_tree(self);
+}
+static void callchain__init_have_children(struct rb_root *self)
+{
+        struct rb_node *nd;
+        for (nd = rb_first(self); nd; nd = rb_next(nd)) {
+                struct callchain_node *node = rb_entry(nd, struct callchain_node, rb_node);
+                callchain_node__init_have_children(node);
+        }
+}
+static void hist_entry__init_have_children(struct hist_entry *self)
+{
+        if (!self->init_have_children) {
+                callchain__init_have_children(&self->sorted_chain);
+                self->init_have_children = true;
+        }
+}
+static bool hist_browser__toggle_fold(struct hist_browser *self)
+{
+        if (map_symbol__toggle_fold(self->selection)) {
+                struct hist_entry *he = self->he_selection;
+                hist_entry__init_have_children(he);
+                self->hists->nr_entries -= he->nr_rows;
+                if (he->ms.unfolded)
+                        he->nr_rows = callchain__count_rows(&he->sorted_chain);
+                else
+                        he->nr_rows = 0;
+                self->hists->nr_entries += he->nr_rows;
+                self->b.nr_entries = self->hists->nr_entries;
+                return true;
+        }
+        /* If it doesn't have children, no toggling performed */
+        return false;
+}
+static int hist_browser__run(struct hist_browser *self, const char *title,
+                             struct newtExitStruct *es)
+{
+        char str[256], unit;
+        unsigned long nr_events = self->hists->stats.nr_events[PERF_RECORD_SAMPLE];
+        self->b.entries = &self->hists->entries;
+        self->b.nr_entries = self->hists->nr_entries;
+        hist_browser__refresh_dimensions(self);
+        nr_events = convert_unit(nr_events, &unit);
+        snprintf(str, sizeof(str), "Events: %lu%c                            ",
+                 nr_events, unit);
+        newtDrawRootText(0, 0, str);
+        if (ui_browser__show(&self->b, title,
+                             "Press '?' for help on key bindings") < 0)
+                return -1;
+        newtFormAddHotKey(self->b.form, 'a');
+        newtFormAddHotKey(self->b.form, '?');
+        newtFormAddHotKey(self->b.form, 'h');
+        newtFormAddHotKey(self->b.form, 'd');
+        newtFormAddHotKey(self->b.form, 'D');
+        newtFormAddHotKey(self->b.form, 't');
+        newtFormAddHotKey(self->b.form, NEWT_KEY_LEFT);
+        newtFormAddHotKey(self->b.form, NEWT_KEY_RIGHT);
+        newtFormAddHotKey(self->b.form, NEWT_KEY_ENTER);
+        while (1) {
+                ui_browser__run(&self->b, es);
+                if (es->reason != NEWT_EXIT_HOTKEY)
+                        break;
+                switch (es->u.key) {
+                case 'D': { /* Debug */
+                        static int seq;
+                        struct hist_entry *h = rb_entry(self->b.top,
+                                                        struct hist_entry, rb_node);
+                        ui_helpline__pop();
+                        ui_helpline__fpush("%d: nr_ent=(%d,%d), height=%d, idx=%d, fve: idx=%d, row_off=%d, nrows=%d",
+                                           seq++, self->b.nr_entries,
+                                           self->hists->nr_entries,
+                                           self->b.height,
+                                           self->b.index,
+                                           self->b.top_idx,
+                                           h->row_offset, h->nr_rows);
+                }
+                        continue;
+                case NEWT_KEY_ENTER:
+                        if (hist_browser__toggle_fold(self))
+                                break;
+                        /* fall thru */
+                default:
+                        return 0;
+                }
+        }
+        ui_browser__hide(&self->b);
+        return 0;
+}
+static char *callchain_list__sym_name(struct callchain_list *self,
+                                      char *bf, size_t bfsize)
+{
+        if (self->ms.sym)
+                return self->ms.sym->name;
+        snprintf(bf, bfsize, "%#Lx", self->ip);
+        return bf;
+}
+#define LEVEL_OFFSET_STEP 3
+static int hist_browser__show_callchain_node_rb_tree(struct hist_browser *self,
+                                                     struct callchain_node *chain_node,
+                                                     u64 total, int level,
+                                                     unsigned short row,
+                                                     off_t *row_offset,
+                                                     bool *is_current_entry)
+{
+        struct rb_node *node;
+        int first_row = row, width, offset = level * LEVEL_OFFSET_STEP;
+        u64 new_total, remaining;
+        if (callchain_param.mode == CHAIN_GRAPH_REL)
+                new_total = chain_node->children_hit;
+        else
+                new_total = total;
+        remaining = new_total;
+        node = rb_first(&chain_node->rb_root);
+        while (node) {
+                struct callchain_node *child = rb_entry(node, struct callchain_node, rb_node);
+                struct rb_node *next = rb_next(node);
+                u64 cumul = cumul_hits(child);
+                struct callchain_list *chain;
+                char folded_sign = ' ';
+                int first = true;
+                int extra_offset = 0;
+                remaining -= cumul;
+                list_for_each_entry(chain, &child->val, list) {
+                        char ipstr[BITS_PER_LONG / 4 + 1], *alloc_str;
+                        const char *str;
+                        int color;
+                        bool was_first = first;
+                        if (first) {
+                                first = false;
+                                chain->ms.has_children = chain->list.next != &child->val ||
+                                                         rb_first(&child->rb_root) != NULL;
+                        } else {
+                                extra_offset = LEVEL_OFFSET_STEP;
+                                chain->ms.has_children = chain->list.next == &child->val &&
+                                                         rb_first(&child->rb_root) != NULL;
+                        }
+                        folded_sign = callchain_list__folded(chain);
+                        if (*row_offset != 0) {
+                                --*row_offset;
+                                goto do_next;
+                        }
+                        alloc_str = NULL;
+                        str = callchain_list__sym_name(chain, ipstr, sizeof(ipstr));
+                        if (was_first) {
+                                double percent = cumul * 100.0 / new_total;
+                                if (asprintf(&alloc_str, "%2.2f%% %s", percent, str) < 0)
+                                        str = "Not enough memory!";
+                                else
+                                        str = alloc_str;
+                        }
+                        color = HE_COLORSET_NORMAL;
+                        width = self->b.width - (offset + extra_offset + 2);
+                        if (ui_browser__is_current_entry(&self->b, row)) {
+                                self->selection = &chain->ms;
+                                color = HE_COLORSET_SELECTED;
+                                *is_current_entry = true;
+                        }
+                        SLsmg_set_color(color);
+                        SLsmg_gotorc(self->b.y + row, self->b.x);
+                        slsmg_write_nstring(" ", offset + extra_offset);
+                        slsmg_printf("%c ", folded_sign);
+                        slsmg_write_nstring(str, width);
+                        free(alloc_str);
+                        if (++row == self->b.height)
+                                goto out;
+do_next:
+                        if (folded_sign == '+')
+                                break;
+                }
+                if (folded_sign == '-') {
+                        const int new_level = level + (extra_offset ? 2 : 1);
+                        row += hist_browser__show_callchain_node_rb_tree(self, child, new_total,
+                                                                         new_level, row, row_offset,
+                                                                         is_current_entry);
+                }
+                if (row == self->b.height)
+                        goto out;
+                node = next;
+        }
+out:
+        return row - first_row;
+}
+static int hist_browser__show_callchain_node(struct hist_browser *self,
+                                             struct callchain_node *node,
+                                             int level, unsigned short row,
+                                             off_t *row_offset,
+                                             bool *is_current_entry)
+{
+        struct callchain_list *chain;
+        int first_row = row,
+             offset = level * LEVEL_OFFSET_STEP,
+             width = self->b.width - offset;
+        char folded_sign = ' ';
+        list_for_each_entry(chain, &node->val, list) {
+                char ipstr[BITS_PER_LONG / 4 + 1], *s;
+                int color;
+                /*
+                 * FIXME: This should be moved to somewhere else,
+                 * probably when the callchain is created, so as not to
+                 * traverse it all over again
+                 */
+                chain->ms.has_children = rb_first(&node->rb_root) != NULL;
+                folded_sign = callchain_list__folded(chain);
+                if (*row_offset != 0) {
+                        --*row_offset;
+                        continue;
+                }
+                color = HE_COLORSET_NORMAL;
+                if (ui_browser__is_current_entry(&self->b, row)) {
+                        self->selection = &chain->ms;
+                        color = HE_COLORSET_SELECTED;
+                        *is_current_entry = true;
+                }
+                s = callchain_list__sym_name(chain, ipstr, sizeof(ipstr));
+                SLsmg_gotorc(self->b.y + row, self->b.x);
+                SLsmg_set_color(color);
+                slsmg_write_nstring(" ", offset);
+                slsmg_printf("%c ", folded_sign);
+                slsmg_write_nstring(s, width - 2);
+                if (++row == self->b.height)
+                        goto out;
+        }
+        if (folded_sign == '-')
+                row += hist_browser__show_callchain_node_rb_tree(self, node,
+                                                                 self->hists->stats.total_period,
+                                                                 level + 1, row,
+                                                                 row_offset,
+                                                                 is_current_entry);
+out:
+        return row - first_row;
+}
+static int hist_browser__show_callchain(struct hist_browser *self,
+                                        struct rb_root *chain,
+                                        int level, unsigned short row,
+                                        off_t *row_offset,
+                                        bool *is_current_entry)
+{
+        struct rb_node *nd;
+        int first_row = row;
+        for (nd = rb_first(chain); nd; nd = rb_next(nd)) {
+                struct callchain_node *node = rb_entry(nd, struct callchain_node, rb_node);
+                row += hist_browser__show_callchain_node(self, node, level,
+                                                         row, row_offset,
+                                                         is_current_entry);
+                if (row == self->b.height)
+                        break;
+        }
+        return row - first_row;
+}
+static int hist_browser__show_entry(struct hist_browser *self,
+                                    struct hist_entry *entry,
+                                    unsigned short row)
+{
+        char s[256];
+        double percent;
+        int printed = 0;
+        int color, width = self->b.width;
+        char folded_sign = ' ';
+        bool current_entry = ui_browser__is_current_entry(&self->b, row);
+        off_t row_offset = entry->row_offset;
+        if (current_entry) {
+                self->he_selection = entry;
+                self->selection = &entry->ms;
+        }
+        if (symbol_conf.use_callchain) {
+                entry->ms.has_children = !RB_EMPTY_ROOT(&entry->sorted_chain);
+                folded_sign = hist_entry__folded(entry);
+        }
+        if (row_offset == 0) {
+                hist_entry__snprintf(entry, s, sizeof(s), self->hists, NULL, false,
+                                     0, false, self->hists->stats.total_period);
+                percent = (entry->period * 100.0) / self->hists->stats.total_period;
+                color = HE_COLORSET_SELECTED;
+                if (!current_entry) {
+                        if (percent >= MIN_RED)
+                                color = HE_COLORSET_TOP;
+                        else if (percent >= MIN_GREEN)
+                                color = HE_COLORSET_MEDIUM;
+                        else
+                                color = HE_COLORSET_NORMAL;
+                }
+                SLsmg_set_color(color);
+                SLsmg_gotorc(self->b.y + row, self->b.x);
+                if (symbol_conf.use_callchain) {
+                        slsmg_printf("%c ", folded_sign);
+                        width -= 2;
+                }
+                slsmg_write_nstring(s, width);
+                ++row;
+                ++printed;
+        } else
+                --row_offset;
+        if (folded_sign == '-' && row != self->b.height) {
+                printed += hist_browser__show_callchain(self, &entry->sorted_chain,
+                                                        1, row, &row_offset,
+                                                        &current_entry);
+                if (current_entry)
+                        self->he_selection = entry;
+        }
+        return printed;
+}
+static unsigned int hist_browser__refresh(struct ui_browser *self)
+{
+        unsigned row = 0;
+        struct rb_node *nd;
+        struct hist_browser *hb = container_of(self, struct hist_browser, b);
+        if (self->top == NULL)
+                self->top = rb_first(&hb->hists->entries);
+        for (nd = self->top; nd; nd = rb_next(nd)) {
+                struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
+                if (h->filtered)
+                        continue;
+                row += hist_browser__show_entry(hb, h, row);
+                if (row == self->height)
+                        break;
+        }
+        return row;
+}
+static struct rb_node *hists__filter_entries(struct rb_node *nd)
+{
+        while (nd != NULL) {
+                struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
+                if (!h->filtered)
+                        return nd;
+                nd = rb_next(nd);
+        }
+        return NULL;
+}
+static struct rb_node *hists__filter_prev_entries(struct rb_node *nd)
+{
+        while (nd != NULL) {
+                struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
+                if (!h->filtered)
+                        return nd;
+                nd = rb_prev(nd);
+        }
+        return NULL;
+}
+static void ui_browser__hists_seek(struct ui_browser *self,
+                                   off_t offset, int whence)
+{
+        struct hist_entry *h;
+        struct rb_node *nd;
+        bool first = true;
+        switch (whence) {
+        case SEEK_SET:
+                nd = hists__filter_entries(rb_first(self->entries));
+                break;
+        case SEEK_CUR:
+                nd = self->top;
+                goto do_offset;
+        case SEEK_END:
+                nd = hists__filter_prev_entries(rb_last(self->entries));
+                first = false;
+                break;
+        default:
+                return;
+        }
+        /*
+         * Moves not relative to the first visible entry invalidates its
+         * row_offset:
+         */
+        h = rb_entry(self->top, struct hist_entry, rb_node);
+        h->row_offset = 0;
+        /*
+         * Here we have to check if nd is expanded (+), if it is we can't go
+         * the next top level hist_entry, instead we must compute an offset of
+         * what _not_ to show and not change the first visible entry.
+         *
+         * This offset increments when we are going from top to bottom and
+         * decreases when we're going from bottom to top.
+         *
+         * As we don't have backpointers to the top level in the callchains
+         * structure, we need to always print the whole hist_entry callchain,
+         * skipping the first ones that are before the first visible entry
+         * and stop when we printed enough lines to fill the screen.
+         */
+do_offset:
+        if (offset > 0) {
+                do {
+                        h = rb_entry(nd, struct hist_entry, rb_node);
+                        if (h->ms.unfolded) {
+                                u16 remaining = h->nr_rows - h->row_offset;
+                                if (offset > remaining) {
+                                        offset -= remaining;
+                                        h->row_offset = 0;
+                                } else {
+                                        h->row_offset += offset;
+                                        offset = 0;
+                                        self->top = nd;
+                                        break;
+                                }
+                        }
+                        nd = hists__filter_entries(rb_next(nd));
+                        if (nd == NULL)
+                                break;
+                        --offset;
+                        self->top = nd;
+                } while (offset != 0);
+        } else if (offset < 0) {
+                while (1) {
+                        h = rb_entry(nd, struct hist_entry, rb_node);
+                        if (h->ms.unfolded) {
+                                if (first) {
+                                        if (-offset > h->row_offset) {
+                                                offset += h->row_offset;
+                                                h->row_offset = 0;
+                                        } else {
+                                                h->row_offset += offset;
+                                                offset = 0;
+                                                self->top = nd;
+                                                break;
+                                        }
+                                } else {
+                                        if (-offset > h->nr_rows) {
+                                                offset += h->nr_rows;
+                                                h->row_offset = 0;
+                                        } else {
+                                                h->row_offset = h->nr_rows + offset;
+                                                offset = 0;
+                                                self->top = nd;
+                                                break;
+                                        }
+                                }
+                        }
+                        nd = hists__filter_prev_entries(rb_prev(nd));
+                        if (nd == NULL)
+                                break;
+                        ++offset;
+                        self->top = nd;
+                        if (offset == 0) {
+                                /*
+                                 * Last unfiltered hist_entry, check if it is
+                                 * unfolded, if it is then we should have
+                                 * row_offset at its last entry.
+                                 */
+                                h = rb_entry(nd, struct hist_entry, rb_node);
+                                if (h->ms.unfolded)
+                                        h->row_offset = h->nr_rows;
+                                break;
+                        }
+                        first = false;
+                }
+        } else {
+                self->top = nd;
+                h = rb_entry(nd, struct hist_entry, rb_node);
+                h->row_offset = 0;
+        }
+}
+static struct hist_browser *hist_browser__new(struct hists *hists)
+{
+        struct hist_browser *self = zalloc(sizeof(*self));
+        if (self) {
+                self->hists = hists;
+                self->b.refresh = hist_browser__refresh;
+                self->b.seek = ui_browser__hists_seek;
+        }
+        return self;
+}
+static void hist_browser__delete(struct hist_browser *self)
+{
+        newtFormDestroy(self->b.form);
+        newtPopWindow();
+        free(self);
+}
+static struct hist_entry *hist_browser__selected_entry(struct hist_browser *self)
+{
+        return self->he_selection;
+}
+static struct thread *hist_browser__selected_thread(struct hist_browser *self)
+{
+        return self->he_selection->thread;
+}
+static int hist_browser__title(char *bf, size_t size, const char *ev_name,
+                               const struct dso *dso, const struct thread *thread)
+{
+        int printed = 0;
+        if (thread)
+                printed += snprintf(bf + printed, size - printed,
+                                    "Thread: %s(%d)",
+                                    (thread->comm_set ?  thread->comm : ""),
+                                    thread->pid);
+        if (dso)
+                printed += snprintf(bf + printed, size - printed,
+                                    "%sDSO: %s", thread ? " " : "",
+                                    dso->short_name);
+        return printed ?: snprintf(bf, size, "Event: %s", ev_name);
+}
+int hists__browse(struct hists *self, const char *helpline, const char *ev_name)
+{
+        struct hist_browser *browser = hist_browser__new(self);
+        struct pstack *fstack;
+        const struct thread *thread_filter = NULL;
+        const struct dso *dso_filter = NULL;
+        struct newtExitStruct es;
+        char msg[160];
+        int key = -1;
+        if (browser == NULL)
+                return -1;
+        fstack = pstack__new(2);
+        if (fstack == NULL)
+                goto out;
+        ui_helpline__push(helpline);
+        hist_browser__title(msg, sizeof(msg), ev_name,
+                            dso_filter, thread_filter);
+        while (1) {
+                const struct thread *thread;
+                const struct dso *dso;
+                char *options[16];
+                int nr_options = 0, choice = 0, i,
+                    annotate = -2, zoom_dso = -2, zoom_thread = -2,
+                    browse_map = -2;
+                if (hist_browser__run(browser, msg, &es))
+                        break;
+                thread = hist_browser__selected_thread(browser);
+                dso = browser->selection->map ? browser->selection->map->dso : NULL;
+                if (es.reason == NEWT_EXIT_HOTKEY) {
+                        key = es.u.key;
+                        switch (key) {
+                        case NEWT_KEY_F1:
+                                goto do_help;
+                        case NEWT_KEY_TAB:
+                        case NEWT_KEY_UNTAB:
+                                /*
+                                 * Exit the browser, let hists__browser_tree
+                                 * go to the next or previous
+                                 */
+                                goto out_free_stack;
+                        default:;
+                        }
+                        switch (key) {
+                        case 'a':
+                                if (browser->selection->map == NULL &&
+                                    browser->selection->map->dso->annotate_warned)
+                                        continue;
+                                goto do_annotate;
+                        case 'd':
+                                goto zoom_dso;
+                        case 't':
+                                goto zoom_thread;
+                        case 'h':
+                        case '?':
+do_help:
+                                ui__help_window("->        Zoom into DSO/Threads & Annotate current symbol\n"
+                                                "<-        Zoom out\n"
+                                                "a         Annotate current symbol\n"
+                                                "h/?/F1    Show this window\n"
+                                                "d         Zoom into current DSO\n"
+                                                "t         Zoom into current Thread\n"
+                                                "q/CTRL+C  Exit browser");
+                                continue;
+                        default:;
+                        }
+                        if (is_exit_key(key)) {
+                                if (key == NEWT_KEY_ESCAPE &&
+                                    !ui__dialog_yesno("Do you really want to exit?"))
+                                        continue;
+                                break;
+                        }
+                        if (es.u.key == NEWT_KEY_LEFT) {
+                                const void *top;
+                                if (pstack__empty(fstack))
+                                        continue;
+                                top = pstack__pop(fstack);
+                                if (top == &dso_filter)
+                                        goto zoom_out_dso;
+                                if (top == &thread_filter)
+                                        goto zoom_out_thread;
+                                continue;
+                        }
+                }
+                if (browser->selection->sym != NULL &&
+                    !browser->selection->map->dso->annotate_warned &&
+                    asprintf(&options[nr_options], "Annotate %s",
+                             browser->selection->sym->name) > 0)
+                        annotate = nr_options++;
+                if (thread != NULL &&
+                    asprintf(&options[nr_options], "Zoom %s %s(%d) thread",
+                             (thread_filter ? "out of" : "into"),
+                             (thread->comm_set ? thread->comm : ""),
+                             thread->pid) > 0)
+                        zoom_thread = nr_options++;
+                if (dso != NULL &&
+                    asprintf(&options[nr_options], "Zoom %s %s DSO",
+                             (dso_filter ? "out of" : "into"),
+                             (dso->kernel ? "the Kernel" : dso->short_name)) > 0)
+                        zoom_dso = nr_options++;
+                if (browser->selection->map != NULL &&
+                    asprintf(&options[nr_options], "Browse map details") > 0)
+                        browse_map = nr_options++;
+                options[nr_options++] = (char *)"Exit";
+                choice = ui__popup_menu(nr_options, options);
+                for (i = 0; i < nr_options - 1; ++i)
+                        free(options[i]);
+                if (choice == nr_options - 1)
+                        break;
+                if (choice == -1)
+                        continue;
+                if (choice == annotate) {
+                        struct hist_entry *he;
+do_annotate:
+                        if (browser->selection->map->dso->origin == DSO__ORIG_KERNEL) {
+                                browser->selection->map->dso->annotate_warned = 1;
+                                ui_helpline__puts("No vmlinux file found, can't "
+                                                 "annotate with just a "
+                                                 "kallsyms file");
+                                continue;
+                        }
+                        he = hist_browser__selected_entry(browser);
+                        if (he == NULL)
+                                continue;
+                        hist_entry__tui_annotate(he);
+                } else if (choice == browse_map)
+                        map__browse(browser->selection->map);
+                else if (choice == zoom_dso) {
+zoom_dso:
+                        if (dso_filter) {
+                                pstack__remove(fstack, &dso_filter);
+zoom_out_dso:
+                                ui_helpline__pop();
+                                dso_filter = NULL;
+                        } else {
+                                if (dso == NULL)
+                                        continue;
+                                ui_helpline__fpush("To zoom out press <- or -> + \"Zoom out of %s DSO\"",
+                                                   dso->kernel ? "the Kernel" : dso->short_name);
+                                dso_filter = dso;
+                                pstack__push(fstack, &dso_filter);
+                        }
+                        hists__filter_by_dso(self, dso_filter);
+                        hist_browser__title(msg, sizeof(msg), ev_name,
+                                            dso_filter, thread_filter);
+                        hist_browser__reset(browser);
+                } else if (choice == zoom_thread) {
+zoom_thread:
+                        if (thread_filter) {
+                                pstack__remove(fstack, &thread_filter);
+zoom_out_thread:
+                                ui_helpline__pop();
+                                thread_filter = NULL;
+                        } else {
+                                ui_helpline__fpush("To zoom out press <- or -> + \"Zoom out of %s(%d) thread\"",
+                                                   thread->comm_set ? thread->comm : "",
+                                                   thread->pid);
+                                thread_filter = thread;
+                                pstack__push(fstack, &thread_filter);
+                        }
+                        hists__filter_by_thread(self, thread_filter);
+                        hist_browser__title(msg, sizeof(msg), ev_name,
+                                            dso_filter, thread_filter);
+                        hist_browser__reset(browser);
+                }
+        }
+out_free_stack:
+        pstack__delete(fstack);
+out:
+        hist_browser__delete(browser);
+        return key;
+}
+int hists__tui_browse_tree(struct rb_root *self, const char *help)
+{
+        struct rb_node *first = rb_first(self), *nd = first, *next;
+        int key = 0;
+        while (nd) {
+                struct hists *hists = rb_entry(nd, struct hists, rb_node);
+                const char *ev_name = __event_name(hists->type, hists->config);
+                key = hists__browse(hists, help, ev_name);
+                if (is_exit_key(key))
+                        break;
+                switch (key) {
+                case NEWT_KEY_TAB:
+                        next = rb_next(nd);
+                        if (next)
+                                nd = next;
+                        break;
+                case NEWT_KEY_UNTAB:
+                        if (nd == first)
+                                continue;
+                        nd = rb_prev(nd);
+                default:
+                        break;
+                }
+        }
+        return key;
+}
diff --git a/tools/perf/util/ui/browsers/map.c b/tools/perf/util/ui/browsers/map.c
new file mode 100644
index 000000000000..142b825b42bf
--- /dev/null
+++ b/tools/perf/util/ui/browsers/map.c
@@ -0,0 +1,161 @@
+#include "../libslang.h"
+#include <elf.h>
+#include <newt.h>
+#include <sys/ttydefaults.h>
+#include <ctype.h>
+#include <string.h>
+#include <linux/bitops.h>
+#include "../../debug.h"
+#include "../../symbol.h"
+#include "../browser.h"
+#include "../helpline.h"
+#include "map.h"
+static int ui_entry__read(const char *title, char *bf, size_t size, int width)
+{
+        struct newtExitStruct es;
+        newtComponent form, entry;
+        const char *result;
+        int err = -1;
+        newtCenteredWindow(width, 1, title);
+        form = newtForm(NULL, NULL, 0);
+        if (form == NULL)
+                return -1;
+        entry = newtEntry(0, 0, "0x", width, &result, NEWT_FLAG_SCROLL);
+        if (entry == NULL)
+                goto out_free_form;
+        newtFormAddComponent(form, entry);
+        newtFormAddHotKey(form, NEWT_KEY_ENTER);
+        newtFormAddHotKey(form, NEWT_KEY_ESCAPE);
+        newtFormAddHotKey(form, NEWT_KEY_LEFT);
+        newtFormAddHotKey(form, CTRL('c'));
+        newtFormRun(form, &es);
+        if (result != NULL) {
+                strncpy(bf, result, size);
+                err = 0;
+        }
+out_free_form:
+        newtPopWindow();
+        newtFormDestroy(form);
+        return 0;
+}
+struct map_browser {
+        struct ui_browser b;
+        struct map        *map;
+        u16               namelen;
+        u8                addrlen;
+};
+static void map_browser__write(struct ui_browser *self, void *nd, int row)
+{
+        struct symbol *sym = rb_entry(nd, struct symbol, rb_node);
+        struct map_browser *mb = container_of(self, struct map_browser, b);
+        bool current_entry = ui_browser__is_current_entry(self, row);
+        int color = ui_browser__percent_color(0, current_entry);
+        SLsmg_set_color(color);
+        slsmg_printf("%*llx %*llx %c ",
+                     mb->addrlen, sym->start, mb->addrlen, sym->end,
+                     sym->binding == STB_GLOBAL ? 'g' :
+                     sym->binding == STB_LOCAL  ? 'l' : 'w');
+        slsmg_write_nstring(sym->name, mb->namelen);
+}
+/* FIXME uber-kludgy, see comment on cmd_report... */
+static u32 *symbol__browser_index(struct symbol *self)
+{
+        return ((void *)self) - sizeof(struct rb_node) - sizeof(u32);
+}
+static int map_browser__search(struct map_browser *self)
+{
+        char target[512];
+        struct symbol *sym;
+        int err = ui_entry__read("Search by name/addr", target, sizeof(target), 40);
+        if (err)
+                return err;
+        if (target[0] == '0' && tolower(target[1]) == 'x') {
+                u64 addr = strtoull(target, NULL, 16);
+                sym = map__find_symbol(self->map, addr, NULL);
+        } else
+                sym = map__find_symbol_by_name(self->map, target, NULL);
+        if (sym != NULL) {
+                u32 *idx = symbol__browser_index(sym);
+                self->b.top = &sym->rb_node;
+                self->b.index = self->b.top_idx = *idx;
+        } else
+                ui_helpline__fpush("%s not found!", target);
+        return 0;
+}
+static int map_browser__run(struct map_browser *self, struct newtExitStruct *es)
+{
+        if (ui_browser__show(&self->b, self->map->dso->long_name,
+                             "Press <- or ESC to exit, %s / to search",
+                             verbose ? "" : "restart with -v to use") < 0)
+                return -1;
+        newtFormAddHotKey(self->b.form, NEWT_KEY_LEFT);
+        newtFormAddHotKey(self->b.form, NEWT_KEY_ENTER);
+        if (verbose)
+                newtFormAddHotKey(self->b.form, '/');
+        while (1) {
+                ui_browser__run(&self->b, es);
+                if (es->reason != NEWT_EXIT_HOTKEY)
+                        break;
+                if (verbose && es->u.key == '/')
+                        map_browser__search(self);
+                else
+                        break;
+        }
+        ui_browser__hide(&self->b);
+        return 0;
+}
+int map__browse(struct map *self)
+{
+        struct map_browser mb = {
+                .b = {
+                        .entries = &self->dso->symbols[self->type],
+                        .refresh = ui_browser__rb_tree_refresh,
+                        .seek    = ui_browser__rb_tree_seek,
+                        .write   = map_browser__write,
+                },
+                .map = self,
+        };
+        struct newtExitStruct es;
+        struct rb_node *nd;
+        char tmp[BITS_PER_LONG / 4];
+        u64 maxaddr = 0;
+        for (nd = rb_first(mb.b.entries); nd; nd = rb_next(nd)) {
+                struct symbol *pos = rb_entry(nd, struct symbol, rb_node);
+                if (mb.namelen < pos->namelen)
+                        mb.namelen = pos->namelen;
+                if (maxaddr < pos->end)
+                        maxaddr = pos->end;
+                if (verbose) {
+                        u32 *idx = symbol__browser_index(pos);
+                        *idx = mb.b.nr_entries;
+                }
+                ++mb.b.nr_entries;
+        }
+        mb.addrlen = snprintf(tmp, sizeof(tmp), "%llx", maxaddr);
+        mb.b.width += mb.addrlen * 2 + 4 + mb.namelen;
+        return map_browser__run(&mb, &es);
+}
diff --git a/tools/perf/util/ui/browsers/map.h b/tools/perf/util/ui/browsers/map.h
new file mode 100644
index 000000000000..df8581a43e17
--- /dev/null
+++ b/tools/perf/util/ui/browsers/map.h
@@ -0,0 +1,6 @@
+#ifndef _PERF_UI_MAP_BROWSER_H_
+#define _PERF_UI_MAP_BROWSER_H_ 1
+struct map;
+int map__browse(struct map *self);
+#endif /* _PERF_UI_MAP_BROWSER_H_ */
diff --git a/tools/perf/util/ui/helpline.c b/tools/perf/util/ui/helpline.c
new file mode 100644
index 000000000000..8d79daa4458a
--- /dev/null
+++ b/tools/perf/util/ui/helpline.c
@@ -0,0 +1,69 @@
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <stdlib.h>
+#include <newt.h>
+#include "../debug.h"
+#include "helpline.h"
+void ui_helpline__pop(void)
+{
+        newtPopHelpLine();
+}
+void ui_helpline__push(const char *msg)
+{
+        newtPushHelpLine(msg);
+}
+void ui_helpline__vpush(const char *fmt, va_list ap)
+{
+        char *s;
+        if (vasprintf(&s, fmt, ap) < 0)
+                vfprintf(stderr, fmt, ap);
+        else {
+                ui_helpline__push(s);
+                free(s);
+        }
+}
+void ui_helpline__fpush(const char *fmt, ...)
+{
+        va_list ap;
+        va_start(ap, fmt);
+        ui_helpline__vpush(fmt, ap);
+        va_end(ap);
+}
+void ui_helpline__puts(const char *msg)
+{
+        ui_helpline__pop();
+        ui_helpline__push(msg);
+}
+void ui_helpline__init(void)
+{
+        ui_helpline__puts(" ");
+}
+char ui_helpline__last_msg[1024];
+int ui_helpline__show_help(const char *format, va_list ap)
+{
+        int ret;
+        static int backlog;
+        ret = vsnprintf(ui_helpline__last_msg + backlog,
+                        sizeof(ui_helpline__last_msg) - backlog, format, ap);
+        backlog += ret;
+        if (ui_helpline__last_msg[backlog - 1] == '\n') {
+                ui_helpline__puts(ui_helpline__last_msg);
+                newtRefresh();
+                backlog = 0;
+        }
+        return ret;
+}
diff --git a/tools/perf/util/ui/helpline.h b/tools/perf/util/ui/helpline.h
new file mode 100644
index 000000000000..ab6028d0c401
--- /dev/null
+++ b/tools/perf/util/ui/helpline.h
@@ -0,0 +1,11 @@
+#ifndef _PERF_UI_HELPLINE_H_
+#define _PERF_UI_HELPLINE_H_ 1
+void ui_helpline__init(void);
+void ui_helpline__pop(void);
+void ui_helpline__push(const char *msg);
+void ui_helpline__vpush(const char *fmt, va_list ap);
+void ui_helpline__fpush(const char *fmt, ...);
+void ui_helpline__puts(const char *msg);
+#endif /* _PERF_UI_HELPLINE_H_ */
diff --git a/tools/perf/util/ui/libslang.h b/tools/perf/util/ui/libslang.h
new file mode 100644
index 000000000000..5623da8e8080
--- /dev/null
+++ b/tools/perf/util/ui/libslang.h
@@ -0,0 +1,27 @@
+#ifndef _PERF_UI_SLANG_H_
+#define _PERF_UI_SLANG_H_ 1
+/*
+ * slang versions <= 2.0.6 have a "#if HAVE_LONG_LONG" that breaks
+ * the build if it isn't defined. Use the equivalent one that glibc
+ * has on features.h.
+ */
+#include <features.h>
+#ifndef HAVE_LONG_LONG
+#define HAVE_LONG_LONG __GLIBC_HAVE_LONG_LONG
+#endif
+#include <slang.h>
+#if SLANG_VERSION < 20104
+#define slsmg_printf(msg, args...) \
+        SLsmg_printf((char *)msg, ##args)
+#define slsmg_write_nstring(msg, len) \
+        SLsmg_write_nstring((char *)msg, len)
+#define sltt_set_color(obj, name, fg, bg) \
+        SLtt_set_color(obj,(char *)name, (char *)fg, (char *)bg)
+#else
+#define slsmg_printf SLsmg_printf
+#define slsmg_write_nstring SLsmg_write_nstring
+#define sltt_set_color SLtt_set_color
+#endif
+#endif /* _PERF_UI_SLANG_H_ */
diff --git a/tools/perf/util/ui/progress.c b/tools/perf/util/ui/progress.c
new file mode 100644
index 000000000000..d7fc399d36b3
--- /dev/null
+++ b/tools/perf/util/ui/progress.c
@@ -0,0 +1,60 @@
+#include <stdlib.h>
+#include <newt.h>
+#include "../cache.h"
+#include "progress.h"
+struct ui_progress {
+        newtComponent form, scale;
+};
+struct ui_progress *ui_progress__new(const char *title, u64 total)
+{
+        struct ui_progress *self = malloc(sizeof(*self));
+        if (self != NULL) {
+                int cols;
+                if (use_browser <= 0)
+                        return self;
+                newtGetScreenSize(&cols, NULL);
+                cols -= 4;
+                newtCenteredWindow(cols, 1, title);
+                self->form  = newtForm(NULL, NULL, 0);
+                if (self->form == NULL)
+                        goto out_free_self;
+                self->scale = newtScale(0, 0, cols, total);
+                if (self->scale == NULL)
+                        goto out_free_form;
+                newtFormAddComponent(self->form, self->scale);
+                newtRefresh();
+        }
+        return self;
+out_free_form:
+        newtFormDestroy(self->form);
+out_free_self:
+        free(self);
+        return NULL;
+}
+void ui_progress__update(struct ui_progress *self, u64 curr)
+{
+        /*
+         * FIXME: We should have a per UI backend way of showing progress,
+         * stdio will just show a percentage as NN%, etc.
+         */
+        if (use_browser <= 0)
+                return;
+        newtScaleSet(self->scale, curr);
+        newtRefresh();
+}
+void ui_progress__delete(struct ui_progress *self)
+{
+        if (use_browser > 0) {
+                newtFormDestroy(self->form);
+                newtPopWindow();
+        }
+        free(self);
+}
diff --git a/tools/perf/util/ui/progress.h b/tools/perf/util/ui/progress.h
new file mode 100644
index 000000000000..a3820a0beb5b
--- /dev/null
+++ b/tools/perf/util/ui/progress.h
@@ -0,0 +1,11 @@
+#ifndef _PERF_UI_PROGRESS_H_
+#define _PERF_UI_PROGRESS_H_ 1
+struct ui_progress;
+struct ui_progress *ui_progress__new(const char *title, u64 total);
+void ui_progress__delete(struct ui_progress *self);
+void ui_progress__update(struct ui_progress *self, u64 curr);
+#endif
diff --git a/tools/perf/util/ui/setup.c b/tools/perf/util/ui/setup.c
new file mode 100644
index 000000000000..662085032eb7
--- /dev/null
+++ b/tools/perf/util/ui/setup.c
@@ -0,0 +1,42 @@
+#include <newt.h>
+#include <signal.h>
+#include <stdbool.h>
+#include "../cache.h"
+#include "../debug.h"
+#include "browser.h"
+#include "helpline.h"
+static void newt_suspend(void *d __used)
+{
+        newtSuspend();
+        raise(SIGTSTP);
+        newtResume();
+}
+void setup_browser(void)
+{
+        if (!isatty(1) || !use_browser || dump_trace) {
+                use_browser = 0;
+                setup_pager();
+                return;
+        }
+        use_browser = 1;
+        newtInit();
+        newtCls();
+        newtSetSuspendCallback(newt_suspend, NULL);
+        ui_helpline__init();
+        ui_browser__init();
+}
+void exit_browser(bool wait_for_ok)
+{
+        if (use_browser > 0) {
+                if (wait_for_ok) {
+                        char title[] = "Fatal Error", ok[] = "Ok";
+                        newtWinMessage(title, ok, ui_helpline__last_msg);
+                }
+                newtFinished();
+        }
+}
diff --git a/tools/perf/util/ui/util.c b/tools/perf/util/ui/util.c
new file mode 100644
index 000000000000..04600e26ceea
--- /dev/null
+++ b/tools/perf/util/ui/util.c
@@ -0,0 +1,114 @@
+#include <newt.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <string.h>
+#include <sys/ttydefaults.h>
+#include "../cache.h"
+#include "../debug.h"
+#include "browser.h"
+#include "helpline.h"
+#include "util.h"
+newtComponent newt_form__new(void);
+static void newt_form__set_exit_keys(newtComponent self)
+{
+        newtFormAddHotKey(self, NEWT_KEY_LEFT);
+        newtFormAddHotKey(self, NEWT_KEY_ESCAPE);
+        newtFormAddHotKey(self, 'Q');
+        newtFormAddHotKey(self, 'q');
+        newtFormAddHotKey(self, CTRL('c'));
+}
+newtComponent newt_form__new(void)
+{
+        newtComponent self = newtForm(NULL, NULL, 0);
+        if (self)
+                newt_form__set_exit_keys(self);
+        return self;
+}
+int ui__popup_menu(int argc, char * const argv[])
+{
+        struct newtExitStruct es;
+        int i, rc = -1, max_len = 5;
+        newtComponent listbox, form = newt_form__new();
+        if (form == NULL)
+                return -1;
+        listbox = newtListbox(0, 0, argc, NEWT_FLAG_RETURNEXIT);
+        if (listbox == NULL)
+                goto out_destroy_form;
+        newtFormAddComponent(form, listbox);
+        for (i = 0; i < argc; ++i) {
+                int len = strlen(argv[i]);
+                if (len > max_len)
+                        max_len = len;
+                if (newtListboxAddEntry(listbox, argv[i], (void *)(long)i))
+                        goto out_destroy_form;
+        }
+        newtCenteredWindow(max_len, argc, NULL);
+        newtFormRun(form, &es);
+        rc = newtListboxGetCurrent(listbox) - NULL;
+        if (es.reason == NEWT_EXIT_HOTKEY)
+                rc = -1;
+        newtPopWindow();
+out_destroy_form:
+        newtFormDestroy(form);
+        return rc;
+}
+int ui__help_window(const char *text)
+{
+        struct newtExitStruct es;
+        newtComponent tb, form = newt_form__new();
+        int rc = -1;
+        int max_len = 0, nr_lines = 0;
+        const char *t;
+        if (form == NULL)
+                return -1;
+        t = text;
+        while (1) {
+                const char *sep = strchr(t, '\n');
+                int len;
+                if (sep == NULL)
+                        sep = strchr(t, '\0');
+                len = sep - t;
+                if (max_len < len)
+                        max_len = len;
+                ++nr_lines;
+                if (*sep == '\0')
+                        break;
+                t = sep + 1;
+        }
+        tb = newtTextbox(0, 0, max_len, nr_lines, 0);
+        if (tb == NULL)
+                goto out_destroy_form;
+        newtTextboxSetText(tb, text);
+        newtFormAddComponent(form, tb);
+        newtCenteredWindow(max_len, nr_lines, NULL);
+        newtFormRun(form, &es);
+        newtPopWindow();
+        rc = 0;
+out_destroy_form:
+        newtFormDestroy(form);
+        return rc;
+}
+bool ui__dialog_yesno(const char *msg)
+{
+        /* newtWinChoice should really be accepting const char pointers... */
+        char yes[] = "Yes", no[] = "No";
+        return newtWinChoice(NULL, yes, no, (char *)msg) == 1;
+}
diff --git a/tools/perf/util/ui/util.h b/tools/perf/util/ui/util.h
new file mode 100644
index 000000000000..afcbc1d99531
--- /dev/null
+++ b/tools/perf/util/ui/util.h
@@ -0,0 +1,10 @@
+#ifndef _PERF_UI_UTIL_H_
+#define _PERF_UI_UTIL_H_ 1
+#include <stdbool.h>
+int ui__popup_menu(int argc, char * const argv[]);
+int ui__help_window(const char *text);
+bool ui__dialog_yesno(const char *msg);
+#endif /* _PERF_UI_UTIL_H_ */
diff --git a/tools/perf/util/util.h b/tools/perf/util/util.h
index 4e8b6b0c551c..f380fed74359 100644
--- a/tools/perf/util/util.h
+++ b/tools/perf/util/util.h
@@ -89,6 +89,7 @@
 extern const char *graph_line;
 extern const char *graph_dotted_line;
+extern char buildid_dir[];
 /* On most systems <limits.h> would have given us this, but
 * not on some systems (e.g. GNU/Hurd).
@@ -152,6 +153,8 @@ extern void warning(const char *err, ...) __attribute__((format (printf, 1, 2)))
 extern void set_die_routine(void (*routine)(const char *err, va_list params) NORETURN);
 extern int prefixcmp(const char *str, const char *prefix);
+extern void set_buildid_dir(void);
+extern void disable_buildid_cache(void);
 static inline const char *skip_prefix(const char *str, const char *prefix)
 {