79 files changed, 4895 insertions, 2494 deletions

diff --git a/tools/perf/util/alias.c b/tools/perf/util/alias.c
index b8144e80bb1e..e6d134773d0a 100644
--- a/tools/perf/util/alias.c
+++ b/tools/perf/util/alias.c
@@ -3,7 +3,8 @@
 static const char *alias_key;
 static char *alias_val;
 
-static int alias_lookup_cb(const char *k, const char *v, void *cb __used)
+static int alias_lookup_cb(const char *k, const char *v,
+                           void *cb __maybe_unused)
 {
         if (!prefixcmp(k, "alias.") && !strcmp(k+6, alias_key)) {
                 if (!v)
diff --git a/tools/perf/util/annotate.c b/tools/perf/util/annotate.c
index 3a282c0057d2..f0a910371377 100644
--- a/tools/perf/util/annotate.c
+++ b/tools/perf/util/annotate.c
@@ -17,6 +17,7 @@
 #include <pthread.h>
 
 const char      *disassembler_style;
+const char      *objdump_path;
 
 static struct ins *ins__find(const char *name);
 static int disasm_line__parse(char *line, char **namep, char **rawp);
@@ -312,8 +313,8 @@ static struct ins_ops dec_ops = {
         .scnprintf = dec__scnprintf,
 };
 
-static int nop__scnprintf(struct ins *ins __used, char *bf, size_t size,
-                          struct ins_operands *ops __used)
+static int nop__scnprintf(struct ins *ins __maybe_unused, char *bf, size_t size,
+                          struct ins_operands *ops __maybe_unused)
 {
         return scnprintf(bf, size, "%-6.6s", "nop");
 }
@@ -415,7 +416,7 @@ static struct ins *ins__find(const char *name)
         return bsearch(name, instructions, nmemb, sizeof(struct ins), ins__cmp);
 }
 
-int symbol__annotate_init(struct map *map __used, struct symbol *sym)
+int symbol__annotate_init(struct map *map __maybe_unused, struct symbol *sym)
 {
         struct annotation *notes = symbol__annotation(sym);
         pthread_mutex_init(&notes->lock, NULL);
@@ -820,9 +821,10 @@ fallback:
                  dso, dso->long_name, sym, sym->name);
 
         snprintf(command, sizeof(command),
-                 "objdump %s%s --start-address=0x%016" PRIx64
+                 "%s %s%s --start-address=0x%016" PRIx64
                  " --stop-address=0x%016" PRIx64
                  " -d %s %s -C %s|grep -v %s|expand",
+                 objdump_path ? objdump_path : "objdump",
                  disassembler_style ? "-M " : "",
                  disassembler_style ? disassembler_style : "",
                  map__rip_2objdump(map, sym->start),
@@ -982,7 +984,8 @@ int symbol__annotate_printf(struct symbol *sym, struct map *map, int evidx,
                             int context)
 {
         struct dso *dso = map->dso;
-        const char *filename = dso->long_name, *d_filename;
+        char *filename;
+        const char *d_filename;
         struct annotation *notes = symbol__annotation(sym);
         struct disasm_line *pos, *queue = NULL;
         u64 start = map__rip_2objdump(map, sym->start);
@@ -990,6 +993,10 @@ int symbol__annotate_printf(struct symbol *sym, struct map *map, int evidx,
         int more = 0;
         u64 len;
 
+        filename = strdup(dso->long_name);
+        if (!filename)
+                return -ENOMEM;
+
         if (full_paths)
                 d_filename = filename;
         else
@@ -1040,6 +1047,8 @@ int symbol__annotate_printf(struct symbol *sym, struct map *map, int evidx,
                 }
         }
 
+        free(filename);
+
         return more;
 }
 
diff --git a/tools/perf/util/annotate.h b/tools/perf/util/annotate.h
index 78a5692dd718..9b5b21e7b032 100644
--- a/tools/perf/util/annotate.h
+++ b/tools/perf/util/annotate.h
@@ -7,6 +7,7 @@
 #include "symbol.h"
 #include <linux/list.h>
 #include <linux/rbtree.h>
+#include <pthread.h>
 
 struct ins;
 
@@ -125,7 +126,7 @@ int symbol__alloc_hist(struct symbol *sym);
 void symbol__annotate_zero_histograms(struct symbol *sym);
 
 int symbol__annotate(struct symbol *sym, struct map *map, size_t privsize);
-int symbol__annotate_init(struct map *map __used, struct symbol *sym);
+int symbol__annotate_init(struct map *map __maybe_unused, struct symbol *sym);
 int symbol__annotate_printf(struct symbol *sym, struct map *map, int evidx,
                             bool full_paths, int min_pcnt, int max_lines,
                             int context);
@@ -138,11 +139,12 @@ int symbol__tty_annotate(struct symbol *sym, struct map *map, int evidx,
                          int max_lines);
 
 #ifdef NO_NEWT_SUPPORT
-static inline int symbol__tui_annotate(struct symbol *sym __used,
-                                       struct map *map __used,
-                                       int evidx __used,
-                                       void(*timer)(void *arg) __used,
-                                       void *arg __used, int delay_secs __used)
+static inline int symbol__tui_annotate(struct symbol *sym __maybe_unused,
+                                       struct map *map __maybe_unused,
+                                       int evidx __maybe_unused,
+                                       void(*timer)(void *arg) __maybe_unused,
+                                       void *arg __maybe_unused,
+                                       int delay_secs __maybe_unused)
 {
         return 0;
 }
@@ -152,5 +154,6 @@ int symbol__tui_annotate(struct symbol *sym, struct map *map, int evidx,
 #endif
 
 extern const char       *disassembler_style;
+extern const char       *objdump_path;
 
 #endif  /* __PERF_ANNOTATE_H */
diff --git a/tools/perf/util/build-id.c b/tools/perf/util/build-id.c
index fd9a5944b627..8e3a740ddbd4 100644
--- a/tools/perf/util/build-id.c
+++ b/tools/perf/util/build-id.c
@@ -16,10 +16,10 @@
 #include "session.h"
 #include "tool.h"
 
-static int build_id__mark_dso_hit(struct perf_tool *tool __used,
+static int build_id__mark_dso_hit(struct perf_tool *tool __maybe_unused,
                                   union perf_event *event,
-                                  struct perf_sample *sample __used,
-                                  struct perf_evsel *evsel __used,
+                                  struct perf_sample *sample __maybe_unused,
+                                  struct perf_evsel *evsel __maybe_unused,
                                   struct machine *machine)
 {
         struct addr_location al;
@@ -41,9 +41,10 @@ static int build_id__mark_dso_hit(struct perf_tool *tool __used,
         return 0;
 }
 
-static int perf_event__exit_del_thread(struct perf_tool *tool __used,
+static int perf_event__exit_del_thread(struct perf_tool *tool __maybe_unused,
                                        union perf_event *event,
-                                       struct perf_sample *sample __used,
+                                       struct perf_sample *sample
+                                       __maybe_unused,
                                        struct machine *machine)
 {
         struct thread *thread = machine__findnew_thread(machine, event->fork.tid);
diff --git a/tools/perf/util/cache.h b/tools/perf/util/cache.h
index cff18c617d13..ab1769426541 100644
--- a/tools/perf/util/cache.h
+++ b/tools/perf/util/cache.h
@@ -39,7 +39,7 @@ static inline void setup_browser(bool fallback_to_pager)
         if (fallback_to_pager)
                 setup_pager();
 }
-static inline void exit_browser(bool wait_for_ok __used) {}
+static inline void exit_browser(bool wait_for_ok __maybe_unused) {}
 #else
 void setup_browser(bool fallback_to_pager);
 void exit_browser(bool wait_for_ok);
@@ -49,7 +49,7 @@ static inline int ui__init(void)
 {
         return -1;
 }
-static inline void ui__exit(bool wait_for_ok __used) {}
+static inline void ui__exit(bool wait_for_ok __maybe_unused) {}
 #else
 int ui__init(void);
 void ui__exit(bool wait_for_ok);
@@ -60,7 +60,7 @@ static inline int perf_gtk__init(void)
 {
         return -1;
 }
-static inline void perf_gtk__exit(bool wait_for_ok __used) {}
+static inline void perf_gtk__exit(bool wait_for_ok __maybe_unused) {}
 #else
 int perf_gtk__init(void);
 void perf_gtk__exit(bool wait_for_ok);
diff --git a/tools/perf/util/callchain.c b/tools/perf/util/callchain.c
index 3a6bff47614f..d3b3f5d82137 100644
--- a/tools/perf/util/callchain.c
+++ b/tools/perf/util/callchain.c
@@ -93,7 +93,7 @@ __sort_chain_flat(struct rb_root *rb_root, struct callchain_node *node,
  */
 static void
 sort_chain_flat(struct rb_root *rb_root, struct callchain_root *root,
-                u64 min_hit, struct callchain_param *param __used)
+                u64 min_hit, struct callchain_param *param __maybe_unused)
 {
         __sort_chain_flat(rb_root, &root->node, min_hit);
 }
@@ -115,7 +115,7 @@ static void __sort_chain_graph_abs(struct callchain_node *node,
 
 static void
 sort_chain_graph_abs(struct rb_root *rb_root, struct callchain_root *chain_root,
-                     u64 min_hit, struct callchain_param *param __used)
+                     u64 min_hit, struct callchain_param *param __maybe_unused)
 {
         __sort_chain_graph_abs(&chain_root->node, min_hit);
         rb_root->rb_node = chain_root->node.rb_root.rb_node;
@@ -140,7 +140,7 @@ static void __sort_chain_graph_rel(struct callchain_node *node,
 
 static void
 sort_chain_graph_rel(struct rb_root *rb_root, struct callchain_root *chain_root,
-                     u64 min_hit __used, struct callchain_param *param)
+                     u64 min_hit __maybe_unused, struct callchain_param *param)
 {
         __sort_chain_graph_rel(&chain_root->node, param->min_percent / 100.0);
         rb_root->rb_node = chain_root->node.rb_root.rb_node;
diff --git a/tools/perf/util/callchain.h b/tools/perf/util/callchain.h
index 3bdb407f9cd9..eb340571e7d6 100644
--- a/tools/perf/util/callchain.h
+++ b/tools/perf/util/callchain.h
@@ -58,7 +58,7 @@ struct callchain_list {
 /*
  * A callchain cursor is a single linked list that
  * let one feed a callchain progressively.
- * It keeps persitent allocated entries to minimize
+ * It keeps persistent allocated entries to minimize
  * allocations.
  */
 struct callchain_cursor_node {
diff --git a/tools/perf/util/cgroup.c b/tools/perf/util/cgroup.c
index dbe2f16b1a1a..96bbda1ddb83 100644
--- a/tools/perf/util/cgroup.c
+++ b/tools/perf/util/cgroup.c
@@ -138,8 +138,8 @@ void close_cgroup(struct cgroup_sel *cgrp)
         }
 }
 
-int parse_cgroups(const struct option *opt __used, const char *str,
-                  int unset __used)
+int parse_cgroups(const struct option *opt __maybe_unused, const char *str,
+                  int unset __maybe_unused)
 {
         struct perf_evlist *evlist = *(struct perf_evlist **)opt->value;
         const char *p, *e, *eos = str + strlen(str);
diff --git a/tools/perf/util/config.c b/tools/perf/util/config.c
index 6faa3a18bfbd..3e0fdd369ccb 100644
--- a/tools/perf/util/config.c
+++ b/tools/perf/util/config.c
@@ -342,13 +342,15 @@ const char *perf_config_dirname(const char *name, const char *value)
         return value;
 }
 
-static int perf_default_core_config(const char *var __used, const char *value __used)
+static int perf_default_core_config(const char *var __maybe_unused,
+                                    const char *value __maybe_unused)
 {
         /* Add other config variables here. */
         return 0;
 }
 
-int perf_default_config(const char *var, const char *value, void *dummy __used)
+int perf_default_config(const char *var, const char *value,
+                        void *dummy __maybe_unused)
 {
         if (!prefixcmp(var, "core."))
                 return perf_default_core_config(var, value);
diff --git a/tools/perf/util/cpumap.c b/tools/perf/util/cpumap.c
index adc72f09914d..2b32ffa9ebdb 100644
--- a/tools/perf/util/cpumap.c
+++ b/tools/perf/util/cpumap.c
@@ -38,24 +38,19 @@ static struct cpu_map *cpu_map__trim_new(int nr_cpus, int *tmp_cpus)
         return cpus;
 }
 
-static struct cpu_map *cpu_map__read_all_cpu_map(void)
+struct cpu_map *cpu_map__read(FILE *file)
 {
         struct cpu_map *cpus = NULL;
-        FILE *onlnf;
         int nr_cpus = 0;
         int *tmp_cpus = NULL, *tmp;
         int max_entries = 0;
         int n, cpu, prev;
         char sep;
 
-        onlnf = fopen("/sys/devices/system/cpu/online", "r");
-        if (!onlnf)
-                return cpu_map__default_new();
-
         sep = 0;
         prev = -1;
         for (;;) {
-                n = fscanf(onlnf, "%u%c", &cpu, &sep);
+                n = fscanf(file, "%u%c", &cpu, &sep);
                 if (n <= 0)
                         break;
                 if (prev >= 0) {
@@ -95,6 +90,19 @@ static struct cpu_map *cpu_map__read_all_cpu_map(void)
                 cpus = cpu_map__default_new();
 out_free_tmp:
         free(tmp_cpus);
+        return cpus;
+}
+
+static struct cpu_map *cpu_map__read_all_cpu_map(void)
+{
+        struct cpu_map *cpus = NULL;
+        FILE *onlnf;
+
+        onlnf = fopen("/sys/devices/system/cpu/online", "r");
+        if (!onlnf)
+                return cpu_map__default_new();
+
+        cpus = cpu_map__read(onlnf);
         fclose(onlnf);
         return cpus;
 }
diff --git a/tools/perf/util/cpumap.h b/tools/perf/util/cpumap.h
index c41518573c6a..2f68a3b8c285 100644
--- a/tools/perf/util/cpumap.h
+++ b/tools/perf/util/cpumap.h
@@ -2,6 +2,7 @@
 #define __PERF_CPUMAP_H
 
 #include <stdio.h>
+#include <stdbool.h>
 
 struct cpu_map {
         int nr;
@@ -11,7 +12,17 @@ struct cpu_map {
 struct cpu_map *cpu_map__new(const char *cpu_list);
 struct cpu_map *cpu_map__dummy_new(void);
 void cpu_map__delete(struct cpu_map *map);
-
+struct cpu_map *cpu_map__read(FILE *file);
 size_t cpu_map__fprintf(struct cpu_map *map, FILE *fp);
 
+static inline int cpu_map__nr(const struct cpu_map *map)
+{
+        return map ? map->nr : 1;
+}
+
+static inline bool cpu_map__all(const struct cpu_map *map)
+{
+        return map ? map->map[0] == -1 : true;
+}
+
 #endif /* __PERF_CPUMAP_H */
diff --git a/tools/perf/util/debug.c b/tools/perf/util/debug.c
index 4dfe0bb3c322..66eb3828ceb5 100644
--- a/tools/perf/util/debug.c
+++ b/tools/perf/util/debug.c
@@ -23,8 +23,10 @@ int eprintf(int level, const char *fmt, ...)
 
         if (verbose >= level) {
                 va_start(args, fmt);
-                if (use_browser > 0)
+                if (use_browser == 1)
                         ret = ui_helpline__show_help(fmt, args);
+                else if (use_browser == 2)
+                        ret = perf_gtk__show_helpline(fmt, args);
                 else
                         ret = vfprintf(stderr, fmt, args);
                 va_end(args);
diff --git a/tools/perf/util/debug.h b/tools/perf/util/debug.h
index 015c91dbc096..bb2e7d1007ab 100644
--- a/tools/perf/util/debug.h
+++ b/tools/perf/util/debug.h
@@ -4,6 +4,7 @@
 
 #include <stdbool.h>
 #include "event.h"
+#include "../ui/helpline.h"
 
 extern int verbose;
 extern bool quiet, dump_trace;
@@ -15,32 +16,26 @@ struct ui_progress;
 struct perf_error_ops;
 
 #if defined(NO_NEWT_SUPPORT) && defined(NO_GTK2_SUPPORT)
-static inline int ui_helpline__show_help(const char *format __used, va_list ap __used)
-{
-        return 0;
-}
-
-static inline void ui_progress__update(u64 curr __used, u64 total __used,
-                                       const char *title __used) {}
+static inline void ui_progress__update(u64 curr __maybe_unused,
+                                       u64 total __maybe_unused,
+                                       const char *title __maybe_unused) {}
 
 #define ui__error(format, arg...) ui__warning(format, ##arg)
 
 static inline int
-perf_error__register(struct perf_error_ops *eops __used)
+perf_error__register(struct perf_error_ops *eops __maybe_unused)
 {
         return 0;
 }
 
 static inline int
-perf_error__unregister(struct perf_error_ops *eops __used)
+perf_error__unregister(struct perf_error_ops *eops __maybe_unused)
 {
         return 0;
 }
 
 #else /* NO_NEWT_SUPPORT && NO_GTK2_SUPPORT */
 
-extern char ui_helpline__last_msg[];
-int ui_helpline__show_help(const char *format, va_list ap);
 #include "../ui/progress.h"
 int ui__error(const char *format, ...) __attribute__((format(printf, 1, 2)));
 #include "../ui/util.h"
diff --git a/tools/perf/util/dso-test-data.c b/tools/perf/util/dso-test-data.c
index 541cdc72c7df..c6caedeb1d6b 100644
--- a/tools/perf/util/dso-test-data.c
+++ b/tools/perf/util/dso-test-data.c
@@ -23,7 +23,7 @@ static char *test_file(int size)
         int fd, i;
         unsigned char *buf;
 
-        fd = mkostemp(templ, O_CREAT|O_WRONLY|O_TRUNC);
+        fd = mkstemp(templ);
 
         buf = malloc(size);
         if (!buf) {
diff --git a/tools/perf/util/dwarf-aux.c b/tools/perf/util/dwarf-aux.c
index ee51e9b4dc09..3e5f5430a28a 100644
--- a/tools/perf/util/dwarf-aux.c
+++ b/tools/perf/util/dwarf-aux.c
@@ -804,6 +804,8 @@ int die_get_typename(Dwarf_Die *vr_die, char *buf, int len)
                         tmp = "union ";
                 else if (tag == DW_TAG_structure_type)
                         tmp = "struct ";
+                else if (tag == DW_TAG_enumeration_type)
+                        tmp = "enum ";
                 /* Write a base name */
                 ret = snprintf(buf, len, "%s%s", tmp, dwarf_diename(&type));
                 return (ret >= len) ? -E2BIG : ret;
diff --git a/tools/perf/util/event.c b/tools/perf/util/event.c
index 2a6f33cd888c..6715b1938725 100644
--- a/tools/perf/util/event.c
+++ b/tools/perf/util/event.c
@@ -112,7 +112,7 @@ static pid_t perf_event__synthesize_comm(struct perf_tool *tool,
         event->comm.header.type = PERF_RECORD_COMM;
 
         size = strlen(event->comm.comm) + 1;
-        size = ALIGN(size, sizeof(u64));
+        size = PERF_ALIGN(size, sizeof(u64));
         memset(event->comm.comm + size, 0, machine->id_hdr_size);
         event->comm.header.size = (sizeof(event->comm) -
                                 (sizeof(event->comm.comm) - size) +
@@ -120,7 +120,9 @@ static pid_t perf_event__synthesize_comm(struct perf_tool *tool,
         if (!full) {
                 event->comm.tid = pid;
 
-                process(tool, event, &synth_sample, machine);
+                if (process(tool, event, &synth_sample, machine) != 0)
+                        return -1;
+
                 goto out;
         }
 
@@ -143,7 +145,7 @@ static pid_t perf_event__synthesize_comm(struct perf_tool *tool,
                                          sizeof(event->comm.comm));
 
                 size = strlen(event->comm.comm) + 1;
-                size = ALIGN(size, sizeof(u64));
+                size = PERF_ALIGN(size, sizeof(u64));
                 memset(event->comm.comm + size, 0, machine->id_hdr_size);
                 event->comm.header.size = (sizeof(event->comm) -
                                           (sizeof(event->comm.comm) - size) +
@@ -151,7 +153,10 @@ static pid_t perf_event__synthesize_comm(struct perf_tool *tool,
 
                 event->comm.tid = pid;
 
-                process(tool, event, &synth_sample, machine);
+                if (process(tool, event, &synth_sample, machine) != 0) {
+                        tgid = -1;
+                        break;
+                }
         }
 
         closedir(tasks);
@@ -167,6 +172,7 @@ static int perf_event__synthesize_mmap_events(struct perf_tool *tool,
 {
         char filename[PATH_MAX];
         FILE *fp;
+        int rc = 0;
 
         snprintf(filename, sizeof(filename), "/proc/%d/maps", pid);
 
@@ -222,7 +228,7 @@ static int perf_event__synthesize_mmap_events(struct perf_tool *tool,
                         size = strlen(execname);
                         execname[size - 1] = '\0'; /* Remove \n */
                         memcpy(event->mmap.filename, execname, size);
-                        size = ALIGN(size, sizeof(u64));
+                        size = PERF_ALIGN(size, sizeof(u64));
                         event->mmap.len -= event->mmap.start;
                         event->mmap.header.size = (sizeof(event->mmap) -
                                                 (sizeof(event->mmap.filename) - size));
@@ -231,18 +237,22 @@ static int perf_event__synthesize_mmap_events(struct perf_tool *tool,
                         event->mmap.pid = tgid;
                         event->mmap.tid = pid;
 
-                        process(tool, event, &synth_sample, machine);
+                        if (process(tool, event, &synth_sample, machine) != 0) {
+                                rc = -1;
+                                break;
+                        }
                 }
         }
 
         fclose(fp);
-        return 0;
+        return rc;
 }
 
 int perf_event__synthesize_modules(struct perf_tool *tool,
                                    perf_event__handler_t process,
                                    struct machine *machine)
 {
+        int rc = 0;
         struct rb_node *nd;
         struct map_groups *kmaps = &machine->kmaps;
         union perf_event *event = zalloc((sizeof(event->mmap) +
@@ -272,7 +282,7 @@ int perf_event__synthesize_modules(struct perf_tool *tool,
                 if (pos->dso->kernel)
                         continue;
 
-                size = ALIGN(pos->dso->long_name_len + 1, sizeof(u64));
+                size = PERF_ALIGN(pos->dso->long_name_len + 1, sizeof(u64));
                 event->mmap.header.type = PERF_RECORD_MMAP;
                 event->mmap.header.size = (sizeof(event->mmap) -
                                         (sizeof(event->mmap.filename) - size));
@@ -284,11 +294,14 @@ int perf_event__synthesize_modules(struct perf_tool *tool,
 
                 memcpy(event->mmap.filename, pos->dso->long_name,
                        pos->dso->long_name_len + 1);
-                process(tool, event, &synth_sample, machine);
+                if (process(tool, event, &synth_sample, machine) != 0) {
+                        rc = -1;
+                        break;
+                }
         }
 
         free(event);
-        return 0;
+        return rc;
 }
 
 static int __event__synthesize_thread(union perf_event *comm_event,
@@ -392,12 +405,16 @@ int perf_event__synthesize_threads(struct perf_tool *tool,
                 if (*end) /* only interested in proper numerical dirents */
                         continue;
 
-                __event__synthesize_thread(comm_event, mmap_event, pid, 1,
-                                           process, tool, machine);
+                if (__event__synthesize_thread(comm_event, mmap_event, pid, 1,
+                                           process, tool, machine) != 0) {
+                        err = -1;
+                        goto out_closedir;
+                }
         }
 
-        closedir(proc);
         err = 0;
+out_closedir:
+        closedir(proc);
 out_free_mmap:
         free(mmap_event);
 out_free_comm:
@@ -412,7 +429,7 @@ struct process_symbol_args {
 };
 
 static int find_symbol_cb(void *arg, const char *name, char type,
-                          u64 start, u64 end __used)
+                          u64 start)
 {
         struct process_symbol_args *args = arg;
 
@@ -477,7 +494,7 @@ int perf_event__synthesize_kernel_mmap(struct perf_tool *tool,
         map = machine->vmlinux_maps[MAP__FUNCTION];
         size = snprintf(event->mmap.filename, sizeof(event->mmap.filename),
                         "%s%s", mmap_name, symbol_name) + 1;
-        size = ALIGN(size, sizeof(u64));
+        size = PERF_ALIGN(size, sizeof(u64));
         event->mmap.header.type = PERF_RECORD_MMAP;
         event->mmap.header.size = (sizeof(event->mmap) -
                         (sizeof(event->mmap.filename) - size) + machine->id_hdr_size);
@@ -497,9 +514,9 @@ size_t perf_event__fprintf_comm(union perf_event *event, FILE *fp)
         return fprintf(fp, ": %s:%d\n", event->comm.comm, event->comm.tid);
 }
 
-int perf_event__process_comm(struct perf_tool *tool __used,
+int perf_event__process_comm(struct perf_tool *tool __maybe_unused,
                              union perf_event *event,
-                             struct perf_sample *sample __used,
+                             struct perf_sample *sample __maybe_unused,
                              struct machine *machine)
 {
         struct thread *thread = machine__findnew_thread(machine, event->comm.tid);
@@ -515,10 +532,10 @@ int perf_event__process_comm(struct perf_tool *tool __used,
         return 0;
 }
 
-int perf_event__process_lost(struct perf_tool *tool __used,
+int perf_event__process_lost(struct perf_tool *tool __maybe_unused,
                              union perf_event *event,
-                             struct perf_sample *sample __used,
-                             struct machine *machine __used)
+                             struct perf_sample *sample __maybe_unused,
+                             struct machine *machine __maybe_unused)
 {
         dump_printf(": id:%" PRIu64 ": lost:%" PRIu64 "\n",
                     event->lost.id, event->lost.lost);
@@ -538,7 +555,8 @@ static void perf_event__set_kernel_mmap_len(union perf_event *event,
                 maps[MAP__FUNCTION]->end = ~0ULL;
 }
 
-static int perf_event__process_kernel_mmap(struct perf_tool *tool __used,
+static int perf_event__process_kernel_mmap(struct perf_tool *tool
+                                           __maybe_unused,
                                            union perf_event *event,
                                            struct machine *machine)
 {
@@ -640,7 +658,7 @@ size_t perf_event__fprintf_mmap(union perf_event *event, FILE *fp)
 
 int perf_event__process_mmap(struct perf_tool *tool,
                              union perf_event *event,
-                             struct perf_sample *sample __used,
+                             struct perf_sample *sample __maybe_unused,
                              struct machine *machine)
 {
         struct thread *thread;
@@ -684,9 +702,9 @@ size_t perf_event__fprintf_task(union perf_event *event, FILE *fp)
                        event->fork.ppid, event->fork.ptid);
 }
 
-int perf_event__process_task(struct perf_tool *tool __used,
+int perf_event__process_task(struct perf_tool *tool __maybe_unused,
                              union perf_event *event,
-                             struct perf_sample *sample __used,
+                             struct perf_sample *sample __maybe_unused,
                               struct machine *machine)
 {
         struct thread *thread = machine__findnew_thread(machine, event->fork.tid);
@@ -886,8 +904,9 @@ int perf_event__preprocess_sample(const union perf_event *event,
                 al->sym = map__find_symbol(al->map, al->addr, filter);
         }
 
-        if (symbol_conf.sym_list && al->sym &&
-            !strlist__has_entry(symbol_conf.sym_list, al->sym->name))
+        if (symbol_conf.sym_list &&
+                (!al->sym || !strlist__has_entry(symbol_conf.sym_list,
+                                                al->sym->name)))
                 goto out_filtered;
 
         return 0;
diff --git a/tools/perf/util/event.h b/tools/perf/util/event.h
index d84870b06426..21b99e741a87 100644
--- a/tools/perf/util/event.h
+++ b/tools/perf/util/event.h
@@ -69,6 +69,16 @@ struct sample_event {
         u64 array[];
 };
 
+struct regs_dump {
+        u64 *regs;
+};
+
+struct stack_dump {
+        u16 offset;
+        u64 size;
+        char *data;
+};
+
 struct perf_sample {
         u64 ip;
         u32 pid, tid;
@@ -82,6 +92,8 @@ struct perf_sample {
         void *raw_data;
         struct ip_callchain *callchain;
         struct branch_stack *branch_stack;
+        struct regs_dump  user_regs;
+        struct stack_dump user_stack;
 };
 
 #define BUILD_ID_SIZE 20
@@ -89,7 +101,7 @@ struct perf_sample {
 struct build_id_event {
         struct perf_event_header header;
         pid_t                    pid;
-        u8                       build_id[ALIGN(BUILD_ID_SIZE, sizeof(u64))];
+        u8                       build_id[PERF_ALIGN(BUILD_ID_SIZE, sizeof(u64))];
         char                     filename[];
 };
 
diff --git a/tools/perf/util/evlist.c b/tools/perf/util/evlist.c
index 9b38681add9e..ae89686102f4 100644
--- a/tools/perf/util/evlist.c
+++ b/tools/perf/util/evlist.c
@@ -57,7 +57,7 @@ void perf_evlist__config_attrs(struct perf_evlist *evlist,
         if (evlist->cpus->map[0] < 0)
                 opts->no_inherit = true;
 
-        first = list_entry(evlist->entries.next, struct perf_evsel, node);
+        first = perf_evlist__first(evlist);
 
         list_for_each_entry(evsel, &evlist->entries, node) {
                 perf_evsel__config(evsel, opts, first);
@@ -108,6 +108,25 @@ void perf_evlist__splice_list_tail(struct perf_evlist *evlist,
         evlist->nr_entries += nr_entries;
 }
 
+void __perf_evlist__set_leader(struct list_head *list)
+{
+        struct perf_evsel *evsel, *leader;
+
+        leader = list_entry(list->next, struct perf_evsel, node);
+        leader->leader = NULL;
+
+        list_for_each_entry(evsel, list, node) {
+                if (evsel != leader)
+                        evsel->leader = leader;
+        }
+}
+
+void perf_evlist__set_leader(struct perf_evlist *evlist)
+{
+        if (evlist->nr_entries)
+                __perf_evlist__set_leader(&evlist->entries);
+}
+
 int perf_evlist__add_default(struct perf_evlist *evlist)
 {
         struct perf_event_attr attr = {
@@ -285,7 +304,7 @@ void perf_evlist__enable(struct perf_evlist *evlist)
         int cpu, thread;
         struct perf_evsel *pos;
 
-        for (cpu = 0; cpu < evlist->cpus->nr; cpu++) {
+        for (cpu = 0; cpu < cpu_map__nr(evlist->cpus); cpu++) {
                 list_for_each_entry(pos, &evlist->entries, node) {
                         for (thread = 0; thread < evlist->threads->nr; thread++)
                                 ioctl(FD(pos, cpu, thread),
@@ -296,7 +315,7 @@ void perf_evlist__enable(struct perf_evlist *evlist)
 
 static int perf_evlist__alloc_pollfd(struct perf_evlist *evlist)
 {
-        int nfds = evlist->cpus->nr * evlist->threads->nr * evlist->nr_entries;
+        int nfds = cpu_map__nr(evlist->cpus) * evlist->threads->nr * evlist->nr_entries;
         evlist->pollfd = malloc(sizeof(struct pollfd) * nfds);
         return evlist->pollfd != NULL ? 0 : -ENOMEM;
 }
@@ -357,7 +376,7 @@ struct perf_evsel *perf_evlist__id2evsel(struct perf_evlist *evlist, u64 id)
         int hash;
 
         if (evlist->nr_entries == 1)
-                return list_entry(evlist->entries.next, struct perf_evsel, node);
+                return perf_evlist__first(evlist);
 
         hash = hash_64(id, PERF_EVLIST__HLIST_BITS);
         head = &evlist->heads[hash];
@@ -367,7 +386,7 @@ struct perf_evsel *perf_evlist__id2evsel(struct perf_evlist *evlist, u64 id)
                         return sid->evsel;
 
         if (!perf_evlist__sample_id_all(evlist))
-                return list_entry(evlist->entries.next, struct perf_evsel, node);
+                return perf_evlist__first(evlist);
 
         return NULL;
 }
@@ -456,8 +475,8 @@ void perf_evlist__munmap(struct perf_evlist *evlist)
 
 static int perf_evlist__alloc_mmap(struct perf_evlist *evlist)
 {
-        evlist->nr_mmaps = evlist->cpus->nr;
-        if (evlist->cpus->map[0] == -1)
+        evlist->nr_mmaps = cpu_map__nr(evlist->cpus);
+        if (cpu_map__all(evlist->cpus))
                 evlist->nr_mmaps = evlist->threads->nr;
         evlist->mmap = zalloc(evlist->nr_mmaps * sizeof(struct perf_mmap));
         return evlist->mmap != NULL ? 0 : -ENOMEM;
@@ -603,11 +622,11 @@ int perf_evlist__mmap(struct perf_evlist *evlist, unsigned int pages,
         list_for_each_entry(evsel, &evlist->entries, node) {
                 if ((evsel->attr.read_format & PERF_FORMAT_ID) &&
                     evsel->sample_id == NULL &&
-                    perf_evsel__alloc_id(evsel, cpus->nr, threads->nr) < 0)
+                    perf_evsel__alloc_id(evsel, cpu_map__nr(cpus), threads->nr) < 0)
                         return -ENOMEM;
         }
 
-        if (evlist->cpus->map[0] == -1)
+        if (cpu_map__all(cpus))
                 return perf_evlist__mmap_per_thread(evlist, prot, mask);
 
         return perf_evlist__mmap_per_cpu(evlist, prot, mask);
@@ -647,39 +666,44 @@ void perf_evlist__delete_maps(struct perf_evlist *evlist)
         evlist->threads = NULL;
 }
 
-int perf_evlist__set_filters(struct perf_evlist *evlist)
+int perf_evlist__apply_filters(struct perf_evlist *evlist)
 {
-        const struct thread_map *threads = evlist->threads;
-        const struct cpu_map *cpus = evlist->cpus;
         struct perf_evsel *evsel;
-        char *filter;
-        int thread;
-        int cpu;
-        int err;
-        int fd;
+        int err = 0;
+        const int ncpus = cpu_map__nr(evlist->cpus),
+                  nthreads = evlist->threads->nr;
 
         list_for_each_entry(evsel, &evlist->entries, node) {
-                filter = evsel->filter;
-                if (!filter)
+                if (evsel->filter == NULL)
                         continue;
-                for (cpu = 0; cpu < cpus->nr; cpu++) {
-                        for (thread = 0; thread < threads->nr; thread++) {
-                                fd = FD(evsel, cpu, thread);
-                                err = ioctl(fd, PERF_EVENT_IOC_SET_FILTER, filter);
-                                if (err)
-                                        return err;
-                        }
-                }
+
+                err = perf_evsel__set_filter(evsel, ncpus, nthreads, evsel->filter);
+                if (err)
+                        break;
         }
 
-        return 0;
+        return err;
 }
 
-bool perf_evlist__valid_sample_type(const struct perf_evlist *evlist)
+int perf_evlist__set_filter(struct perf_evlist *evlist, const char *filter)
 {
-        struct perf_evsel *pos, *first;
+        struct perf_evsel *evsel;
+        int err = 0;
+        const int ncpus = cpu_map__nr(evlist->cpus),
+                  nthreads = evlist->threads->nr;
+
+        list_for_each_entry(evsel, &evlist->entries, node) {
+                err = perf_evsel__set_filter(evsel, ncpus, nthreads, filter);
+                if (err)
+                        break;
+        }
+
+        return err;
+}
 
-        pos = first = list_entry(evlist->entries.next, struct perf_evsel, node);
+bool perf_evlist__valid_sample_type(struct perf_evlist *evlist)
+{
+        struct perf_evsel *first = perf_evlist__first(evlist), *pos = first;
 
         list_for_each_entry_continue(pos, &evlist->entries, node) {
                 if (first->attr.sample_type != pos->attr.sample_type)
@@ -689,23 +713,19 @@ bool perf_evlist__valid_sample_type(const struct perf_evlist *evlist)
         return true;
 }
 
-u64 perf_evlist__sample_type(const struct perf_evlist *evlist)
+u64 perf_evlist__sample_type(struct perf_evlist *evlist)
 {
-        struct perf_evsel *first;
-
-        first = list_entry(evlist->entries.next, struct perf_evsel, node);
+        struct perf_evsel *first = perf_evlist__first(evlist);
         return first->attr.sample_type;
 }
 
-u16 perf_evlist__id_hdr_size(const struct perf_evlist *evlist)
+u16 perf_evlist__id_hdr_size(struct perf_evlist *evlist)
 {
-        struct perf_evsel *first;
+        struct perf_evsel *first = perf_evlist__first(evlist);
         struct perf_sample *data;
         u64 sample_type;
         u16 size = 0;
 
-        first = list_entry(evlist->entries.next, struct perf_evsel, node);
-
         if (!first->attr.sample_id_all)
                 goto out;
 
@@ -729,11 +749,9 @@ out:
         return size;
 }
 
-bool perf_evlist__valid_sample_id_all(const struct perf_evlist *evlist)
+bool perf_evlist__valid_sample_id_all(struct perf_evlist *evlist)
 {
-        struct perf_evsel *pos, *first;
-
-        pos = first = list_entry(evlist->entries.next, struct perf_evsel, node);
+        struct perf_evsel *first = perf_evlist__first(evlist), *pos = first;
 
         list_for_each_entry_continue(pos, &evlist->entries, node) {
                 if (first->attr.sample_id_all != pos->attr.sample_id_all)
@@ -743,11 +761,9 @@ bool perf_evlist__valid_sample_id_all(const struct perf_evlist *evlist)
         return true;
 }
 
-bool perf_evlist__sample_id_all(const struct perf_evlist *evlist)
+bool perf_evlist__sample_id_all(struct perf_evlist *evlist)
 {
-        struct perf_evsel *first;
-
-        first = list_entry(evlist->entries.next, struct perf_evsel, node);
+        struct perf_evsel *first = perf_evlist__first(evlist);
         return first->attr.sample_id_all;
 }
 
@@ -757,21 +773,13 @@ void perf_evlist__set_selected(struct perf_evlist *evlist,
         evlist->selected = evsel;
 }
 
-int perf_evlist__open(struct perf_evlist *evlist, bool group)
+int perf_evlist__open(struct perf_evlist *evlist)
 {
-        struct perf_evsel *evsel, *first;
+        struct perf_evsel *evsel;
         int err, ncpus, nthreads;
 
-        first = list_entry(evlist->entries.next, struct perf_evsel, node);
-
         list_for_each_entry(evsel, &evlist->entries, node) {
-                struct xyarray *group_fd = NULL;
-
-                if (group && evsel != first)
-                        group_fd = first->fd;
-
-                err = perf_evsel__open(evsel, evlist->cpus, evlist->threads,
-                                       group, group_fd);
+                err = perf_evsel__open(evsel, evlist->cpus, evlist->threads);
                 if (err < 0)
                         goto out_err;
         }
@@ -883,8 +891,21 @@ int perf_evlist__start_workload(struct perf_evlist *evlist)
 }
 
 int perf_evlist__parse_sample(struct perf_evlist *evlist, union perf_event *event,
-                              struct perf_sample *sample, bool swapped)
+                              struct perf_sample *sample)
+{
+        struct perf_evsel *evsel = perf_evlist__first(evlist);
+        return perf_evsel__parse_sample(evsel, event, sample);
+}
+
+size_t perf_evlist__fprintf(struct perf_evlist *evlist, FILE *fp)
 {
-        struct perf_evsel *e = list_entry(evlist->entries.next, struct perf_evsel, node);
-        return perf_evsel__parse_sample(e, event, sample, swapped);
+        struct perf_evsel *evsel;
+        size_t printed = 0;
+
+        list_for_each_entry(evsel, &evlist->entries, node) {
+                printed += fprintf(fp, "%s%s", evsel->idx ? ", " : "",
+                                   perf_evsel__name(evsel));
+        }
+
+        return printed + fprintf(fp, "\n");;
 }
diff --git a/tools/perf/util/evlist.h b/tools/perf/util/evlist.h
index 528c1acd9298..3f1fb66be022 100644
--- a/tools/perf/util/evlist.h
+++ b/tools/perf/util/evlist.h
@@ -5,6 +5,7 @@
 #include <stdio.h>
 #include "../perf.h"
 #include "event.h"
+#include "evsel.h"
 #include "util.h"
 #include <unistd.h>
 
@@ -41,8 +42,6 @@ struct perf_evsel_str_handler {
         void       *handler;
 };
 
-struct perf_evsel;
-
 struct perf_evlist *perf_evlist__new(struct cpu_map *cpus,
                                      struct thread_map *threads);
 void perf_evlist__init(struct perf_evlist *evlist, struct cpu_map *cpus,
@@ -73,6 +72,8 @@ int perf_evlist__set_tracepoints_handlers(struct perf_evlist *evlist,
 #define perf_evlist__set_tracepoints_handlers_array(evlist, array) \
         perf_evlist__set_tracepoints_handlers(evlist, array, ARRAY_SIZE(array))
 
+int perf_evlist__set_filter(struct perf_evlist *evlist, const char *filter);
+
 struct perf_evsel *
 perf_evlist__find_tracepoint_by_id(struct perf_evlist *evlist, int id);
 
@@ -85,7 +86,7 @@ struct perf_evsel *perf_evlist__id2evsel(struct perf_evlist *evlist, u64 id);
 
 union perf_event *perf_evlist__mmap_read(struct perf_evlist *self, int idx);
 
-int perf_evlist__open(struct perf_evlist *evlist, bool group);
+int perf_evlist__open(struct perf_evlist *evlist);
 
 void perf_evlist__config_attrs(struct perf_evlist *evlist,
                                struct perf_record_opts *opts);
@@ -116,20 +117,34 @@ static inline void perf_evlist__set_maps(struct perf_evlist *evlist,
 int perf_evlist__create_maps(struct perf_evlist *evlist,
                              struct perf_target *target);
 void perf_evlist__delete_maps(struct perf_evlist *evlist);
-int perf_evlist__set_filters(struct perf_evlist *evlist);
+int perf_evlist__apply_filters(struct perf_evlist *evlist);
+
+void __perf_evlist__set_leader(struct list_head *list);
+void perf_evlist__set_leader(struct perf_evlist *evlist);
 
-u64 perf_evlist__sample_type(const struct perf_evlist *evlist);
-bool perf_evlist__sample_id_all(const const struct perf_evlist *evlist);
-u16 perf_evlist__id_hdr_size(const struct perf_evlist *evlist);
+u64 perf_evlist__sample_type(struct perf_evlist *evlist);
+bool perf_evlist__sample_id_all(struct perf_evlist *evlist);
+u16 perf_evlist__id_hdr_size(struct perf_evlist *evlist);
 
 int perf_evlist__parse_sample(struct perf_evlist *evlist, union perf_event *event,
-                              struct perf_sample *sample, bool swapped);
+                              struct perf_sample *sample);
 
-bool perf_evlist__valid_sample_type(const struct perf_evlist *evlist);
-bool perf_evlist__valid_sample_id_all(const struct perf_evlist *evlist);
+bool perf_evlist__valid_sample_type(struct perf_evlist *evlist);
+bool perf_evlist__valid_sample_id_all(struct perf_evlist *evlist);
 
 void perf_evlist__splice_list_tail(struct perf_evlist *evlist,
                                    struct list_head *list,
                                    int nr_entries);
 
+static inline struct perf_evsel *perf_evlist__first(struct perf_evlist *evlist)
+{
+        return list_entry(evlist->entries.next, struct perf_evsel, node);
+}
+
+static inline struct perf_evsel *perf_evlist__last(struct perf_evlist *evlist)
+{
+        return list_entry(evlist->entries.prev, struct perf_evsel, node);
+}
+
+size_t perf_evlist__fprintf(struct perf_evlist *evlist, FILE *fp);
 #endif /* __PERF_EVLIST_H */
diff --git a/tools/perf/util/evsel.c b/tools/perf/util/evsel.c
index 2eaae140def2..ffdd94e9c9c3 100644
--- a/tools/perf/util/evsel.c
+++ b/tools/perf/util/evsel.c
@@ -8,7 +8,10 @@
  */
 
 #include <byteswap.h>
+#include <linux/bitops.h>
 #include "asm/bug.h"
+#include "debugfs.h"
+#include "event-parse.h"
 #include "evsel.h"
 #include "evlist.h"
 #include "util.h"
@@ -16,9 +19,10 @@
 #include "thread_map.h"
 #include "target.h"
 #include "../../../include/linux/hw_breakpoint.h"
+#include "../../include/linux/perf_event.h"
+#include "perf_regs.h"
 
 #define FD(e, x, y) (*(int *)xyarray__entry(e->fd, x, y))
-#define GROUP_FD(group_fd, cpu) (*(int *)xyarray__entry(group_fd, cpu, 0))
 
 static int __perf_evsel__sample_size(u64 sample_type)
 {
@@ -66,7 +70,80 @@ struct perf_evsel *perf_evsel__new(struct perf_event_attr *attr, int idx)
         return evsel;
 }
 
-static const char *perf_evsel__hw_names[PERF_COUNT_HW_MAX] = {
+struct event_format *event_format__new(const char *sys, const char *name)
+{
+        int fd, n;
+        char *filename;
+        void *bf = NULL, *nbf;
+        size_t size = 0, alloc_size = 0;
+        struct event_format *format = NULL;
+
+        if (asprintf(&filename, "%s/%s/%s/format", tracing_events_path, sys, name) < 0)
+                goto out;
+
+        fd = open(filename, O_RDONLY);
+        if (fd < 0)
+                goto out_free_filename;
+
+        do {
+                if (size == alloc_size) {
+                        alloc_size += BUFSIZ;
+                        nbf = realloc(bf, alloc_size);
+                        if (nbf == NULL)
+                                goto out_free_bf;
+                        bf = nbf;
+                }
+
+                n = read(fd, bf + size, BUFSIZ);
+                if (n < 0)
+                        goto out_free_bf;
+                size += n;
+        } while (n > 0);
+
+        pevent_parse_format(&format, bf, size, sys);
+
+out_free_bf:
+        free(bf);
+        close(fd);
+out_free_filename:
+        free(filename);
+out:
+        return format;
+}
+
+struct perf_evsel *perf_evsel__newtp(const char *sys, const char *name, int idx)
+{
+        struct perf_evsel *evsel = zalloc(sizeof(*evsel));
+
+        if (evsel != NULL) {
+                struct perf_event_attr attr = {
+                        .type          = PERF_TYPE_TRACEPOINT,
+                        .sample_type   = (PERF_SAMPLE_RAW | PERF_SAMPLE_TIME |
+                                          PERF_SAMPLE_CPU | PERF_SAMPLE_PERIOD),
+                };
+
+                if (asprintf(&evsel->name, "%s:%s", sys, name) < 0)
+                        goto out_free;
+
+                evsel->tp_format = event_format__new(sys, name);
+                if (evsel->tp_format == NULL)
+                        goto out_free;
+
+                event_attr_init(&attr);
+                attr.config = evsel->tp_format->id;
+                attr.sample_period = 1;
+                perf_evsel__init(evsel, &attr, idx);
+        }
+
+        return evsel;
+
+out_free:
+        free(evsel->name);
+        free(evsel);
+        return NULL;
+}
+
+const char *perf_evsel__hw_names[PERF_COUNT_HW_MAX] = {
         "cycles",
         "instructions",
         "cache-references",
@@ -129,12 +206,12 @@ static int perf_evsel__hw_name(struct perf_evsel *evsel, char *bf, size_t size)
         return r + perf_evsel__add_modifiers(evsel, bf + r, size - r);
 }
 
-static const char *perf_evsel__sw_names[PERF_COUNT_SW_MAX] = {
+const char *perf_evsel__sw_names[PERF_COUNT_SW_MAX] = {
         "cpu-clock",
         "task-clock",
         "page-faults",
         "context-switches",
-        "CPU-migrations",
+        "cpu-migrations",
         "minor-faults",
         "major-faults",
         "alignment-faults",
@@ -317,7 +394,8 @@ const char *perf_evsel__name(struct perf_evsel *evsel)
                 break;
 
         default:
-                scnprintf(bf, sizeof(bf), "%s", "unknown attr type");
+                scnprintf(bf, sizeof(bf), "unknown attr type: %d",
+                          evsel->attr.type);
                 break;
         }
 
@@ -367,9 +445,18 @@ void perf_evsel__config(struct perf_evsel *evsel, struct perf_record_opts *opts,
                 attr->mmap_data = track;
         }
 
-        if (opts->call_graph)
+        if (opts->call_graph) {
                 attr->sample_type       |= PERF_SAMPLE_CALLCHAIN;
 
+                if (opts->call_graph == CALLCHAIN_DWARF) {
+                        attr->sample_type |= PERF_SAMPLE_REGS_USER |
+                                             PERF_SAMPLE_STACK_USER;
+                        attr->sample_regs_user = PERF_REGS_MASK;
+                        attr->sample_stack_user = opts->stack_dump_size;
+                        attr->exclude_callchain_user = 1;
+                }
+        }
+
         if (perf_target__has_cpu(&opts->target))
                 attr->sample_type       |= PERF_SAMPLE_CPU;
 
@@ -421,6 +508,24 @@ int perf_evsel__alloc_fd(struct perf_evsel *evsel, int ncpus, int nthreads)
         return evsel->fd != NULL ? 0 : -ENOMEM;
 }
 
+int perf_evsel__set_filter(struct perf_evsel *evsel, int ncpus, int nthreads,
+                           const char *filter)
+{
+        int cpu, thread;
+
+        for (cpu = 0; cpu < ncpus; cpu++) {
+                for (thread = 0; thread < nthreads; thread++) {
+                        int fd = FD(evsel, cpu, thread),
+                            err = ioctl(fd, PERF_EVENT_IOC_SET_FILTER, filter);
+
+                        if (err)
+                                return err;
+                }
+        }
+
+        return 0;
+}
+
 int perf_evsel__alloc_id(struct perf_evsel *evsel, int ncpus, int nthreads)
 {
         evsel->sample_id = xyarray__new(ncpus, nthreads, sizeof(struct perf_sample_id));
@@ -481,6 +586,9 @@ void perf_evsel__delete(struct perf_evsel *evsel)
 {
         perf_evsel__exit(evsel);
         close_cgroup(evsel->cgrp);
+        free(evsel->group_name);
+        if (evsel->tp_format)
+                pevent_free_format(evsel->tp_format);
         free(evsel->name);
         free(evsel);
 }
@@ -556,9 +664,28 @@ int __perf_evsel__read(struct perf_evsel *evsel,
         return 0;
 }
 
+static int get_group_fd(struct perf_evsel *evsel, int cpu, int thread)
+{
+        struct perf_evsel *leader = evsel->leader;
+        int fd;
+
+        if (!leader)
+                return -1;
+
+        /*
+         * Leader must be already processed/open,
+         * if not it's a bug.
+         */
+        BUG_ON(!leader->fd);
+
+        fd = FD(leader, cpu, thread);
+        BUG_ON(fd == -1);
+
+        return fd;
+}
+
 static int __perf_evsel__open(struct perf_evsel *evsel, struct cpu_map *cpus,
-                              struct thread_map *threads, bool group,
-                              struct xyarray *group_fds)
+                              struct thread_map *threads)
 {
         int cpu, thread;
         unsigned long flags = 0;
@@ -574,13 +701,15 @@ static int __perf_evsel__open(struct perf_evsel *evsel, struct cpu_map *cpus,
         }
 
         for (cpu = 0; cpu < cpus->nr; cpu++) {
-                int group_fd = group_fds ? GROUP_FD(group_fds, cpu) : -1;
 
                 for (thread = 0; thread < threads->nr; thread++) {
+                        int group_fd;
 
                         if (!evsel->cgrp)
                                 pid = threads->map[thread];
 
+                        group_fd = get_group_fd(evsel, cpu, thread);
+
                         FD(evsel, cpu, thread) = sys_perf_event_open(&evsel->attr,
                                                                      pid,
                                                                      cpus->map[cpu],
@@ -589,9 +718,6 @@ static int __perf_evsel__open(struct perf_evsel *evsel, struct cpu_map *cpus,
                                 err = -errno;
                                 goto out_close;
                         }
-
-                        if (group && group_fd == -1)
-                                group_fd = FD(evsel, cpu, thread);
                 }
         }
 
@@ -635,8 +761,7 @@ static struct {
 };
 
 int perf_evsel__open(struct perf_evsel *evsel, struct cpu_map *cpus,
-                     struct thread_map *threads, bool group,
-                     struct xyarray *group_fd)
+                     struct thread_map *threads)
 {
         if (cpus == NULL) {
                 /* Work around old compiler warnings about strict aliasing */
@@ -646,30 +771,28 @@ int perf_evsel__open(struct perf_evsel *evsel, struct cpu_map *cpus,
         if (threads == NULL)
                 threads = &empty_thread_map.map;
 
-        return __perf_evsel__open(evsel, cpus, threads, group, group_fd);
+        return __perf_evsel__open(evsel, cpus, threads);
 }
 
 int perf_evsel__open_per_cpu(struct perf_evsel *evsel,
-                             struct cpu_map *cpus, bool group,
-                             struct xyarray *group_fd)
+                             struct cpu_map *cpus)
 {
-        return __perf_evsel__open(evsel, cpus, &empty_thread_map.map, group,
-                                  group_fd);
+        return __perf_evsel__open(evsel, cpus, &empty_thread_map.map);
 }
 
 int perf_evsel__open_per_thread(struct perf_evsel *evsel,
-                                struct thread_map *threads, bool group,
-                                struct xyarray *group_fd)
+                                struct thread_map *threads)
 {
-        return __perf_evsel__open(evsel, &empty_cpu_map.map, threads, group,
-                                  group_fd);
+        return __perf_evsel__open(evsel, &empty_cpu_map.map, threads);
 }
 
-static int perf_event__parse_id_sample(const union perf_event *event, u64 type,
-                                       struct perf_sample *sample,
-                                       bool swapped)
+static int perf_evsel__parse_id_sample(const struct perf_evsel *evsel,
+                                       const union perf_event *event,
+                                       struct perf_sample *sample)
 {
+        u64 type = evsel->attr.sample_type;
         const u64 *array = event->sample.array;
+        bool swapped = evsel->needs_swap;
         union u64_swap u;
 
         array += ((event->header.size -
@@ -730,9 +853,11 @@ static bool sample_overlap(const union perf_event *event,
 }
 
 int perf_evsel__parse_sample(struct perf_evsel *evsel, union perf_event *event,
-                             struct perf_sample *data, bool swapped)
+                             struct perf_sample *data)
 {
         u64 type = evsel->attr.sample_type;
+        u64 regs_user = evsel->attr.sample_regs_user;
+        bool swapped = evsel->needs_swap;
         const u64 *array;
 
         /*
@@ -749,7 +874,7 @@ int perf_evsel__parse_sample(struct perf_evsel *evsel, union perf_event *event,
         if (event->header.type != PERF_RECORD_SAMPLE) {
                 if (!evsel->attr.sample_id_all)
                         return 0;
-                return perf_event__parse_id_sample(event, type, data, swapped);
+                return perf_evsel__parse_id_sample(evsel, event, data);
         }
 
         array = event->sample.array;
@@ -869,6 +994,32 @@ int perf_evsel__parse_sample(struct perf_evsel *evsel, union perf_event *event,
                 sz /= sizeof(u64);
                 array += sz;
         }
+
+        if (type & PERF_SAMPLE_REGS_USER) {
+                /* First u64 tells us if we have any regs in sample. */
+                u64 avail = *array++;
+
+                if (avail) {
+                        data->user_regs.regs = (u64 *)array;
+                        array += hweight_long(regs_user);
+                }
+        }
+
+        if (type & PERF_SAMPLE_STACK_USER) {
+                u64 size = *array++;
+
+                data->user_stack.offset = ((char *)(array - 1)
+                                          - (char *) event);
+
+                if (!size) {
+                        data->user_stack.size = 0;
+                } else {
+                        data->user_stack.data = (char *)array;
+                        array += size / sizeof(*array);
+                        data->user_stack.size = *array;
+                }
+        }
+
         return 0;
 }
 
@@ -947,3 +1098,72 @@ int perf_event__synthesize_sample(union perf_event *event, u64 type,
 
         return 0;
 }
+
+struct format_field *perf_evsel__field(struct perf_evsel *evsel, const char *name)
+{
+        return pevent_find_field(evsel->tp_format, name);
+}
+
+void *perf_evsel__rawptr(struct perf_evsel *evsel, struct perf_sample *sample,
+                         const char *name)
+{
+        struct format_field *field = perf_evsel__field(evsel, name);
+        int offset;
+
+        if (!field)
+                return NULL;
+
+        offset = field->offset;
+
+        if (field->flags & FIELD_IS_DYNAMIC) {
+                offset = *(int *)(sample->raw_data + field->offset);
+                offset &= 0xffff;
+        }
+
+        return sample->raw_data + offset;
+}
+
+u64 perf_evsel__intval(struct perf_evsel *evsel, struct perf_sample *sample,
+                       const char *name)
+{
+        struct format_field *field = perf_evsel__field(evsel, name);
+        void *ptr;
+        u64 value;
+
+        if (!field)
+                return 0;
+
+        ptr = sample->raw_data + field->offset;
+
+        switch (field->size) {
+        case 1:
+                return *(u8 *)ptr;
+        case 2:
+                value = *(u16 *)ptr;
+                break;
+        case 4:
+                value = *(u32 *)ptr;
+                break;
+        case 8:
+                value = *(u64 *)ptr;
+                break;
+        default:
+                return 0;
+        }
+
+        if (!evsel->needs_swap)
+                return value;
+
+        switch (field->size) {
+        case 2:
+                return bswap_16(value);
+        case 4:
+                return bswap_32(value);
+        case 8:
+                return bswap_64(value);
+        default:
+                return 0;
+        }
+
+        return 0;
+}
diff --git a/tools/perf/util/evsel.h b/tools/perf/util/evsel.h
index b559929983bb..3ead0d59c03d 100644
--- a/tools/perf/util/evsel.h
+++ b/tools/perf/util/evsel.h
@@ -53,9 +53,10 @@ struct perf_evsel {
         u64                     *id;
         struct perf_counts      *counts;
         int                     idx;
-        int                     ids;
+        u32                     ids;
         struct hists            hists;
         char                    *name;
+        struct event_format     *tp_format;
         union {
                 void            *priv;
                 off_t           id_offset;
@@ -65,8 +66,14 @@ struct perf_evsel {
                 void            *func;
                 void            *data;
         } handler;
+        struct cpu_map          *cpus;
         unsigned int            sample_size;
         bool                    supported;
+        bool                    needs_swap;
+        /* parse modifier helper */
+        int                     exclude_GH;
+        struct perf_evsel       *leader;
+        char                    *group_name;
 };
 
 struct cpu_map;
@@ -75,6 +82,10 @@ struct perf_evlist;
 struct perf_record_opts;
 
 struct perf_evsel *perf_evsel__new(struct perf_event_attr *attr, int idx);
+struct perf_evsel *perf_evsel__newtp(const char *sys, const char *name, int idx);
+
+struct event_format *event_format__new(const char *sys, const char *name);
+
 void perf_evsel__init(struct perf_evsel *evsel,
                       struct perf_event_attr *attr, int idx);
 void perf_evsel__exit(struct perf_evsel *evsel);
@@ -92,8 +103,10 @@ extern const char *perf_evsel__hw_cache[PERF_COUNT_HW_CACHE_MAX]
                                        [PERF_EVSEL__MAX_ALIASES];
 extern const char *perf_evsel__hw_cache_op[PERF_COUNT_HW_CACHE_OP_MAX]
                                           [PERF_EVSEL__MAX_ALIASES];
-const char *perf_evsel__hw_cache_result[PERF_COUNT_HW_CACHE_RESULT_MAX]
-                                       [PERF_EVSEL__MAX_ALIASES];
+extern const char *perf_evsel__hw_cache_result[PERF_COUNT_HW_CACHE_RESULT_MAX]
+                                              [PERF_EVSEL__MAX_ALIASES];
+extern const char *perf_evsel__hw_names[PERF_COUNT_HW_MAX];
+extern const char *perf_evsel__sw_names[PERF_COUNT_SW_MAX];
 int __perf_evsel__hw_cache_type_op_res_name(u8 type, u8 op, u8 result,
                                             char *bf, size_t size);
 const char *perf_evsel__name(struct perf_evsel *evsel);
@@ -105,21 +118,46 @@ void perf_evsel__free_fd(struct perf_evsel *evsel);
 void perf_evsel__free_id(struct perf_evsel *evsel);
 void perf_evsel__close_fd(struct perf_evsel *evsel, int ncpus, int nthreads);
 
+int perf_evsel__set_filter(struct perf_evsel *evsel, int ncpus, int nthreads,
+                           const char *filter);
+
 int perf_evsel__open_per_cpu(struct perf_evsel *evsel,
-                             struct cpu_map *cpus, bool group,
-                             struct xyarray *group_fds);
+                             struct cpu_map *cpus);
 int perf_evsel__open_per_thread(struct perf_evsel *evsel,
-                                struct thread_map *threads, bool group,
-                                struct xyarray *group_fds);
+                                struct thread_map *threads);
 int perf_evsel__open(struct perf_evsel *evsel, struct cpu_map *cpus,
-                     struct thread_map *threads, bool group,
-                     struct xyarray *group_fds);
+                     struct thread_map *threads);
 void perf_evsel__close(struct perf_evsel *evsel, int ncpus, int nthreads);
 
+struct perf_sample;
+
+void *perf_evsel__rawptr(struct perf_evsel *evsel, struct perf_sample *sample,
+                         const char *name);
+u64 perf_evsel__intval(struct perf_evsel *evsel, struct perf_sample *sample,
+                       const char *name);
+
+static inline char *perf_evsel__strval(struct perf_evsel *evsel,
+                                       struct perf_sample *sample,
+                                       const char *name)
+{
+        return perf_evsel__rawptr(evsel, sample, name);
+}
+
+struct format_field;
+
+struct format_field *perf_evsel__field(struct perf_evsel *evsel, const char *name);
+
 #define perf_evsel__match(evsel, t, c)          \
         (evsel->attr.type == PERF_TYPE_##t &&   \
          evsel->attr.config == PERF_COUNT_##c)
 
+static inline bool perf_evsel__match2(struct perf_evsel *e1,
+                                      struct perf_evsel *e2)
+{
+        return (e1->attr.type == e2->attr.type) &&
+               (e1->attr.config == e2->attr.config);
+}
+
 int __perf_evsel__read_on_cpu(struct perf_evsel *evsel,
                               int cpu, int thread, bool scale);
 
@@ -181,5 +219,10 @@ static inline int perf_evsel__read_scaled(struct perf_evsel *evsel,
 void hists__init(struct hists *hists);
 
 int perf_evsel__parse_sample(struct perf_evsel *evsel, union perf_event *event,
-                             struct perf_sample *sample, bool swapped);
+                             struct perf_sample *sample);
+
+static inline struct perf_evsel *perf_evsel__next(struct perf_evsel *evsel)
+{
+        return list_entry(evsel->node.next, struct perf_evsel, node);
+}
 #endif /* __PERF_EVSEL_H */
diff --git a/tools/perf/util/generate-cmdlist.sh b/tools/perf/util/generate-cmdlist.sh
index f06f6fd148f8..389590c1ad21 100755
--- a/tools/perf/util/generate-cmdlist.sh
+++ b/tools/perf/util/generate-cmdlist.sh
@@ -21,4 +21,19 @@ do
             p
      }' "Documentation/perf-$cmd.txt"
 done
+
+echo "#ifndef NO_LIBELF_SUPPORT"
+sed -n -e 's/^perf-\([^         ]*\)[   ].* full.*/\1/p' command-list.txt |
+sort |
+while read cmd
+do
+     sed -n '
+     /^NAME/,/perf-'"$cmd"'/H
+     ${
+            x
+            s/.*perf-'"$cmd"' - \(.*\)/  {"'"$cmd"'", "\1"},/
+            p
+     }' "Documentation/perf-$cmd.txt"
+done
+echo "#endif /* NO_LIBELF_SUPPORT */"
 echo "};"
diff --git a/tools/perf/util/header.c b/tools/perf/util/header.c
index 74ea3c2f8138..7daad237dea5 100644
--- a/tools/perf/util/header.c
+++ b/tools/perf/util/header.c
@@ -20,11 +20,14 @@
 #include "symbol.h"
 #include "debug.h"
 #include "cpumap.h"
+#include "pmu.h"
+#include "vdso.h"
+#include "strbuf.h"
 
 static bool no_buildid_cache = false;
 
-static int event_count;
-static struct perf_trace_event_type *events;
+static int trace_event_count;
+static struct perf_trace_event_type *trace_events;
 
 static u32 header_argc;
 static const char **header_argv;
@@ -36,24 +39,24 @@ int perf_header__push_event(u64 id, const char *name)
         if (strlen(name) > MAX_EVENT_NAME)
                 pr_warning("Event %s will be truncated\n", name);
 
-        nevents = realloc(events, (event_count + 1) * sizeof(*events));
+        nevents = realloc(trace_events, (trace_event_count + 1) * sizeof(*trace_events));
         if (nevents == NULL)
                 return -ENOMEM;
-        events = nevents;
+        trace_events = nevents;
 
-        memset(&events[event_count], 0, sizeof(struct perf_trace_event_type));
-        events[event_count].event_id = id;
-        strncpy(events[event_count].name, name, MAX_EVENT_NAME - 1);
-        event_count++;
+        memset(&trace_events[trace_event_count], 0, sizeof(struct perf_trace_event_type));
+        trace_events[trace_event_count].event_id = id;
+        strncpy(trace_events[trace_event_count].name, name, MAX_EVENT_NAME - 1);
+        trace_event_count++;
         return 0;
 }
 
 char *perf_header__find_event(u64 id)
 {
         int i;
-        for (i = 0 ; i < event_count; i++) {
-                if (events[i].event_id == id)
-                        return events[i].name;
+        for (i = 0 ; i < trace_event_count; i++) {
+                if (trace_events[i].event_id == id)
+                        return trace_events[i].name;
         }
         return NULL;
 }
@@ -128,7 +131,7 @@ static int do_write_string(int fd, const char *str)
         int ret;
 
         olen = strlen(str) + 1;
-        len = ALIGN(olen, NAME_ALIGN);
+        len = PERF_ALIGN(olen, NAME_ALIGN);
 
         /* write len, incl. \0 */
         ret = do_write(fd, &len, sizeof(len));
@@ -206,6 +209,29 @@ perf_header__set_cmdline(int argc, const char **argv)
                         continue;               \
                 else
 
+static int write_buildid(char *name, size_t name_len, u8 *build_id,
+                         pid_t pid, u16 misc, int fd)
+{
+        int err;
+        struct build_id_event b;
+        size_t len;
+
+        len = name_len + 1;
+        len = PERF_ALIGN(len, NAME_ALIGN);
+
+        memset(&b, 0, sizeof(b));
+        memcpy(&b.build_id, build_id, BUILD_ID_SIZE);
+        b.pid = pid;
+        b.header.misc = misc;
+        b.header.size = sizeof(b) + len;
+
+        err = do_write(fd, &b, sizeof(b));
+        if (err < 0)
+                return err;
+
+        return write_padded(fd, name, name_len + 1, len);
+}
+
 static int __dsos__write_buildid_table(struct list_head *head, pid_t pid,
                                 u16 misc, int fd)
 {
@@ -213,24 +239,23 @@ static int __dsos__write_buildid_table(struct list_head *head, pid_t pid,
 
         dsos__for_each_with_build_id(pos, head) {
                 int err;
-                struct build_id_event b;
-                size_t len;
+                char  *name;
+                size_t name_len;
 
                 if (!pos->hit)
                         continue;
-                len = pos->long_name_len + 1;
-                len = ALIGN(len, NAME_ALIGN);
-                memset(&b, 0, sizeof(b));
-                memcpy(&b.build_id, pos->build_id, sizeof(pos->build_id));
-                b.pid = pid;
-                b.header.misc = misc;
-                b.header.size = sizeof(b) + len;
-                err = do_write(fd, &b, sizeof(b));
-                if (err < 0)
-                        return err;
-                err = write_padded(fd, pos->long_name,
-                                   pos->long_name_len + 1, len);
-                if (err < 0)
+
+                if (is_vdso_map(pos->short_name)) {
+                        name = (char *) VDSO__MAP_NAME;
+                        name_len = sizeof(VDSO__MAP_NAME) + 1;
+                } else {
+                        name = pos->long_name;
+                        name_len = pos->long_name_len + 1;
+                }
+
+                err = write_buildid(name, name_len, pos->build_id,
+                                    pid, misc, fd);
+                if (err)
                         return err;
         }
 
@@ -276,19 +301,20 @@ static int dsos__write_buildid_table(struct perf_header *header, int fd)
 }
 
 int build_id_cache__add_s(const char *sbuild_id, const char *debugdir,
-                          const char *name, bool is_kallsyms)
+                          const char *name, bool is_kallsyms, bool is_vdso)
 {
         const size_t size = PATH_MAX;
         char *realname, *filename = zalloc(size),
              *linkname = zalloc(size), *targetname;
         int len, err = -1;
+        bool slash = is_kallsyms || is_vdso;
 
         if (is_kallsyms) {
                 if (symbol_conf.kptr_restrict) {
                         pr_debug("Not caching a kptr_restrict'ed /proc/kallsyms\n");
                         return 0;
                 }
-                realname = (char *)name;
+                realname = (char *) name;
         } else
                 realname = realpath(name, NULL);
 
@@ -296,7 +322,8 @@ int build_id_cache__add_s(const char *sbuild_id, const char *debugdir,
                 goto out_free;
 
         len = scnprintf(filename, size, "%s%s%s",
-                       debugdir, is_kallsyms ? "/" : "", realname);
+                       debugdir, slash ? "/" : "",
+                       is_vdso ? VDSO__MAP_NAME : realname);
         if (mkdir_p(filename, 0755))
                 goto out_free;
 
@@ -332,13 +359,14 @@ out_free:
 
 static int build_id_cache__add_b(const u8 *build_id, size_t build_id_size,
                                  const char *name, const char *debugdir,
-                                 bool is_kallsyms)
+                                 bool is_kallsyms, bool is_vdso)
 {
         char sbuild_id[BUILD_ID_SIZE * 2 + 1];
 
         build_id__sprintf(build_id, build_id_size, sbuild_id);
 
-        return build_id_cache__add_s(sbuild_id, debugdir, name, is_kallsyms);
+        return build_id_cache__add_s(sbuild_id, debugdir, name,
+                                     is_kallsyms, is_vdso);
 }
 
 int build_id_cache__remove_s(const char *sbuild_id, const char *debugdir)
@@ -382,9 +410,11 @@ out_free:
 static int dso__cache_build_id(struct dso *dso, const char *debugdir)
 {
         bool is_kallsyms = dso->kernel && dso->long_name[0] != '/';
+        bool is_vdso = is_vdso_map(dso->short_name);
 
         return build_id_cache__add_b(dso->build_id, sizeof(dso->build_id),
-                                     dso->long_name, debugdir, is_kallsyms);
+                                     dso->long_name, debugdir,
+                                     is_kallsyms, is_vdso);
 }
 
 static int __dsos__cache_build_ids(struct list_head *head, const char *debugdir)
@@ -446,7 +476,7 @@ static bool perf_session__read_build_ids(struct perf_session *session, bool with
         return ret;
 }
 
-static int write_tracing_data(int fd, struct perf_header *h __used,
+static int write_tracing_data(int fd, struct perf_header *h __maybe_unused,
                             struct perf_evlist *evlist)
 {
         return read_tracing_data(fd, &evlist->entries);
@@ -454,7 +484,7 @@ static int write_tracing_data(int fd, struct perf_header *h __used,
 
 
 static int write_build_id(int fd, struct perf_header *h,
-                          struct perf_evlist *evlist __used)
+                          struct perf_evlist *evlist __maybe_unused)
 {
         struct perf_session *session;
         int err;
@@ -475,8 +505,8 @@ static int write_build_id(int fd, struct perf_header *h,
         return 0;
 }
 
-static int write_hostname(int fd, struct perf_header *h __used,
-                          struct perf_evlist *evlist __used)
+static int write_hostname(int fd, struct perf_header *h __maybe_unused,
+                          struct perf_evlist *evlist __maybe_unused)
 {
         struct utsname uts;
         int ret;
@@ -488,8 +518,8 @@ static int write_hostname(int fd, struct perf_header *h __used,
         return do_write_string(fd, uts.nodename);
 }
 
-static int write_osrelease(int fd, struct perf_header *h __used,
-                           struct perf_evlist *evlist __used)
+static int write_osrelease(int fd, struct perf_header *h __maybe_unused,
+                           struct perf_evlist *evlist __maybe_unused)
 {
         struct utsname uts;
         int ret;
@@ -501,8 +531,8 @@ static int write_osrelease(int fd, struct perf_header *h __used,
         return do_write_string(fd, uts.release);
 }
 
-static int write_arch(int fd, struct perf_header *h __used,
-                      struct perf_evlist *evlist __used)
+static int write_arch(int fd, struct perf_header *h __maybe_unused,
+                      struct perf_evlist *evlist __maybe_unused)
 {
         struct utsname uts;
         int ret;
@@ -514,14 +544,14 @@ static int write_arch(int fd, struct perf_header *h __used,
         return do_write_string(fd, uts.machine);
 }
 
-static int write_version(int fd, struct perf_header *h __used,
-                         struct perf_evlist *evlist __used)
+static int write_version(int fd, struct perf_header *h __maybe_unused,
+                         struct perf_evlist *evlist __maybe_unused)
 {
         return do_write_string(fd, perf_version_string);
 }
 
-static int write_cpudesc(int fd, struct perf_header *h __used,
-                       struct perf_evlist *evlist __used)
+static int write_cpudesc(int fd, struct perf_header *h __maybe_unused,
+                       struct perf_evlist *evlist __maybe_unused)
 {
 #ifndef CPUINFO_PROC
 #define CPUINFO_PROC NULL
@@ -579,8 +609,8 @@ done:
         return ret;
 }
 
-static int write_nrcpus(int fd, struct perf_header *h __used,
-                        struct perf_evlist *evlist __used)
+static int write_nrcpus(int fd, struct perf_header *h __maybe_unused,
+                        struct perf_evlist *evlist __maybe_unused)
 {
         long nr;
         u32 nrc, nra;
@@ -605,15 +635,14 @@ static int write_nrcpus(int fd, struct perf_header *h __used,
         return do_write(fd, &nra, sizeof(nra));
 }
 
-static int write_event_desc(int fd, struct perf_header *h __used,
+static int write_event_desc(int fd, struct perf_header *h __maybe_unused,
                             struct perf_evlist *evlist)
 {
-        struct perf_evsel *attr;
-        u32 nre = 0, nri, sz;
+        struct perf_evsel *evsel;
+        u32 nre, nri, sz;
         int ret;
 
-        list_for_each_entry(attr, &evlist->entries, node)
-                nre++;
+        nre = evlist->nr_entries;
 
         /*
          * write number of events
@@ -625,14 +654,14 @@ static int write_event_desc(int fd, struct perf_header *h __used,
         /*
          * size of perf_event_attr struct
          */
-        sz = (u32)sizeof(attr->attr);
+        sz = (u32)sizeof(evsel->attr);
         ret = do_write(fd, &sz, sizeof(sz));
         if (ret < 0)
                 return ret;
 
-        list_for_each_entry(attr, &evlist->entries, node) {
+        list_for_each_entry(evsel, &evlist->entries, node) {
 
-                ret = do_write(fd, &attr->attr, sz);
+                ret = do_write(fd, &evsel->attr, sz);
                 if (ret < 0)
                         return ret;
                 /*
@@ -642,7 +671,7 @@ static int write_event_desc(int fd, struct perf_header *h __used,
                  * copy into an nri to be independent of the
                  * type of ids,
                  */
-                nri = attr->ids;
+                nri = evsel->ids;
                 ret = do_write(fd, &nri, sizeof(nri));
                 if (ret < 0)
                         return ret;
@@ -650,21 +679,21 @@ static int write_event_desc(int fd, struct perf_header *h __used,
                 /*
                  * write event string as passed on cmdline
                  */
-                ret = do_write_string(fd, perf_evsel__name(attr));
+                ret = do_write_string(fd, perf_evsel__name(evsel));
                 if (ret < 0)
                         return ret;
                 /*
                  * write unique ids for this event
                  */
-                ret = do_write(fd, attr->id, attr->ids * sizeof(u64));
+                ret = do_write(fd, evsel->id, evsel->ids * sizeof(u64));
                 if (ret < 0)
                         return ret;
         }
         return 0;
 }
 
-static int write_cmdline(int fd, struct perf_header *h __used,
-                         struct perf_evlist *evlist __used)
+static int write_cmdline(int fd, struct perf_header *h __maybe_unused,
+                         struct perf_evlist *evlist __maybe_unused)
 {
         char buf[MAXPATHLEN];
         char proc[32];
@@ -832,8 +861,8 @@ static struct cpu_topo *build_cpu_topology(void)
         return tp;
 }
 
-static int write_cpu_topology(int fd, struct perf_header *h __used,
-                          struct perf_evlist *evlist __used)
+static int write_cpu_topology(int fd, struct perf_header *h __maybe_unused,
+                          struct perf_evlist *evlist __maybe_unused)
 {
         struct cpu_topo *tp;
         u32 i;
@@ -868,8 +897,8 @@ done:
 
 
 
-static int write_total_mem(int fd, struct perf_header *h __used,
-                          struct perf_evlist *evlist __used)
+static int write_total_mem(int fd, struct perf_header *h __maybe_unused,
+                          struct perf_evlist *evlist __maybe_unused)
 {
         char *buf = NULL;
         FILE *fp;
@@ -954,8 +983,8 @@ done:
         return ret;
 }
 
-static int write_numa_topology(int fd, struct perf_header *h __used,
-                          struct perf_evlist *evlist __used)
+static int write_numa_topology(int fd, struct perf_header *h __maybe_unused,
+                          struct perf_evlist *evlist __maybe_unused)
 {
         char *buf = NULL;
         size_t len = 0;
@@ -1004,16 +1033,56 @@ done:
 }
 
 /*
+ * File format:
+ *
+ * struct pmu_mappings {
+ *      u32     pmu_num;
+ *      struct pmu_map {
+ *              u32     type;
+ *              char    name[];
+ *      }[pmu_num];
+ * };
+ */
+
+static int write_pmu_mappings(int fd, struct perf_header *h __maybe_unused,
+                              struct perf_evlist *evlist __maybe_unused)
+{
+        struct perf_pmu *pmu = NULL;
+        off_t offset = lseek(fd, 0, SEEK_CUR);
+        __u32 pmu_num = 0;
+
+        /* write real pmu_num later */
+        do_write(fd, &pmu_num, sizeof(pmu_num));
+
+        while ((pmu = perf_pmu__scan(pmu))) {
+                if (!pmu->name)
+                        continue;
+                pmu_num++;
+                do_write(fd, &pmu->type, sizeof(pmu->type));
+                do_write_string(fd, pmu->name);
+        }
+
+        if (pwrite(fd, &pmu_num, sizeof(pmu_num), offset) != sizeof(pmu_num)) {
+                /* discard all */
+                lseek(fd, offset, SEEK_SET);
+                return -1;
+        }
+
+        return 0;
+}
+
+/*
  * default get_cpuid(): nothing gets recorded
  * actual implementation must be in arch/$(ARCH)/util/header.c
  */
-int __attribute__((weak)) get_cpuid(char *buffer __used, size_t sz __used)
+int __attribute__ ((weak)) get_cpuid(char *buffer __maybe_unused,
+                                     size_t sz __maybe_unused)
 {
         return -1;
 }
 
-static int write_cpuid(int fd, struct perf_header *h __used,
-                       struct perf_evlist *evlist __used)
+static int write_cpuid(int fd, struct perf_header *h __maybe_unused,
+                       struct perf_evlist *evlist __maybe_unused)
 {
         char buffer[64];
         int ret;
@@ -1027,133 +1096,113 @@ write_it:
         return do_write_string(fd, buffer);
 }
 
-static int write_branch_stack(int fd __used, struct perf_header *h __used,
-                       struct perf_evlist *evlist __used)
+static int write_branch_stack(int fd __maybe_unused,
+                              struct perf_header *h __maybe_unused,
+                       struct perf_evlist *evlist __maybe_unused)
 {
         return 0;
 }
 
-static void print_hostname(struct perf_header *ph, int fd, FILE *fp)
+static void print_hostname(struct perf_header *ph, int fd __maybe_unused,
+                           FILE *fp)
 {
-        char *str = do_read_string(fd, ph);
-        fprintf(fp, "# hostname : %s\n", str);
-        free(str);
+        fprintf(fp, "# hostname : %s\n", ph->env.hostname);
 }
 
-static void print_osrelease(struct perf_header *ph, int fd, FILE *fp)
+static void print_osrelease(struct perf_header *ph, int fd __maybe_unused,
+                            FILE *fp)
 {
-        char *str = do_read_string(fd, ph);
-        fprintf(fp, "# os release : %s\n", str);
-        free(str);
+        fprintf(fp, "# os release : %s\n", ph->env.os_release);
 }
 
-static void print_arch(struct perf_header *ph, int fd, FILE *fp)
+static void print_arch(struct perf_header *ph, int fd __maybe_unused, FILE *fp)
 {
-        char *str = do_read_string(fd, ph);
-        fprintf(fp, "# arch : %s\n", str);
-        free(str);
+        fprintf(fp, "# arch : %s\n", ph->env.arch);
 }
 
-static void print_cpudesc(struct perf_header *ph, int fd, FILE *fp)
+static void print_cpudesc(struct perf_header *ph, int fd __maybe_unused,
+                          FILE *fp)
 {
-        char *str = do_read_string(fd, ph);
-        fprintf(fp, "# cpudesc : %s\n", str);
-        free(str);
+        fprintf(fp, "# cpudesc : %s\n", ph->env.cpu_desc);
 }
 
-static void print_nrcpus(struct perf_header *ph, int fd, FILE *fp)
+static void print_nrcpus(struct perf_header *ph, int fd __maybe_unused,
+                         FILE *fp)
 {
-        ssize_t ret;
-        u32 nr;
-
-        ret = read(fd, &nr, sizeof(nr));
-        if (ret != (ssize_t)sizeof(nr))
-                nr = -1; /* interpreted as error */
-
-        if (ph->needs_swap)
-                nr = bswap_32(nr);
-
-        fprintf(fp, "# nrcpus online : %u\n", nr);
-
-        ret = read(fd, &nr, sizeof(nr));
-        if (ret != (ssize_t)sizeof(nr))
-                nr = -1; /* interpreted as error */
-
-        if (ph->needs_swap)
-                nr = bswap_32(nr);
-
-        fprintf(fp, "# nrcpus avail : %u\n", nr);
+        fprintf(fp, "# nrcpus online : %u\n", ph->env.nr_cpus_online);
+        fprintf(fp, "# nrcpus avail : %u\n", ph->env.nr_cpus_avail);
 }
 
-static void print_version(struct perf_header *ph, int fd, FILE *fp)
+static void print_version(struct perf_header *ph, int fd __maybe_unused,
+                          FILE *fp)
 {
-        char *str = do_read_string(fd, ph);
-        fprintf(fp, "# perf version : %s\n", str);
-        free(str);
+        fprintf(fp, "# perf version : %s\n", ph->env.version);
 }
 
-static void print_cmdline(struct perf_header *ph, int fd, FILE *fp)
+static void print_cmdline(struct perf_header *ph, int fd __maybe_unused,
+                          FILE *fp)
 {
-        ssize_t ret;
+        int nr, i;
         char *str;
-        u32 nr, i;
-
-        ret = read(fd, &nr, sizeof(nr));
-        if (ret != (ssize_t)sizeof(nr))
-                return;
 
-        if (ph->needs_swap)
-                nr = bswap_32(nr);
+        nr = ph->env.nr_cmdline;
+        str = ph->env.cmdline;
 
         fprintf(fp, "# cmdline : ");
 
         for (i = 0; i < nr; i++) {
-                str = do_read_string(fd, ph);
                 fprintf(fp, "%s ", str);
-                free(str);
+                str += strlen(str) + 1;
         }
         fputc('\n', fp);
 }
 
-static void print_cpu_topology(struct perf_header *ph, int fd, FILE *fp)
+static void print_cpu_topology(struct perf_header *ph, int fd __maybe_unused,
+                               FILE *fp)
 {
-        ssize_t ret;
-        u32 nr, i;
+        int nr, i;
         char *str;
 
-        ret = read(fd, &nr, sizeof(nr));
-        if (ret != (ssize_t)sizeof(nr))
-                return;
-
-        if (ph->needs_swap)
-                nr = bswap_32(nr);
+        nr = ph->env.nr_sibling_cores;
+        str = ph->env.sibling_cores;
 
         for (i = 0; i < nr; i++) {
-                str = do_read_string(fd, ph);
                 fprintf(fp, "# sibling cores   : %s\n", str);
-                free(str);
+                str += strlen(str) + 1;
         }
 
-        ret = read(fd, &nr, sizeof(nr));
-        if (ret != (ssize_t)sizeof(nr))
-                return;
-
-        if (ph->needs_swap)
-                nr = bswap_32(nr);
+        nr = ph->env.nr_sibling_threads;
+        str = ph->env.sibling_threads;
 
         for (i = 0; i < nr; i++) {
-                str = do_read_string(fd, ph);
                 fprintf(fp, "# sibling threads : %s\n", str);
-                free(str);
+                str += strlen(str) + 1;
         }
 }
 
-static void print_event_desc(struct perf_header *ph, int fd, FILE *fp)
+static void free_event_desc(struct perf_evsel *events)
+{
+        struct perf_evsel *evsel;
+
+        if (!events)
+                return;
+
+        for (evsel = events; evsel->attr.size; evsel++) {
+                if (evsel->name)
+                        free(evsel->name);
+                if (evsel->id)
+                        free(evsel->id);
+        }
+
+        free(events);
+}
+
+static struct perf_evsel *
+read_event_desc(struct perf_header *ph, int fd)
 {
-        struct perf_event_attr attr;
-        uint64_t id;
+        struct perf_evsel *evsel, *events = NULL;
+        u64 *id;
         void *buf = NULL;
-        char *str;
         u32 nre, sz, nr, i, j;
         ssize_t ret;
         size_t msz;
@@ -1173,18 +1222,22 @@ static void print_event_desc(struct perf_header *ph, int fd, FILE *fp)
         if (ph->needs_swap)
                 sz = bswap_32(sz);
 
-        memset(&attr, 0, sizeof(attr));
-
         /* buffer to hold on file attr struct */
         buf = malloc(sz);
         if (!buf)
                 goto error;
 
-        msz = sizeof(attr);
+        /* the last event terminates with evsel->attr.size == 0: */
+        events = calloc(nre + 1, sizeof(*events));
+        if (!events)
+                goto error;
+
+        msz = sizeof(evsel->attr);
         if (sz < msz)
                 msz = sz;
 
-        for (i = 0 ; i < nre; i++) {
+        for (i = 0, evsel = events; i < nre; evsel++, i++) {
+                evsel->idx = i;
 
                 /*
                  * must read entire on-file attr struct to
@@ -1197,146 +1250,188 @@ static void print_event_desc(struct perf_header *ph, int fd, FILE *fp)
                 if (ph->needs_swap)
                         perf_event__attr_swap(buf);
 
-                memcpy(&attr, buf, msz);
+                memcpy(&evsel->attr, buf, msz);
 
                 ret = read(fd, &nr, sizeof(nr));
                 if (ret != (ssize_t)sizeof(nr))
                         goto error;
 
-                if (ph->needs_swap)
+                if (ph->needs_swap) {
                         nr = bswap_32(nr);
+                        evsel->needs_swap = true;
+                }
 
-                str = do_read_string(fd, ph);
-                fprintf(fp, "# event : name = %s, ", str);
-                free(str);
+                evsel->name = do_read_string(fd, ph);
+
+                if (!nr)
+                        continue;
+
+                id = calloc(nr, sizeof(*id));
+                if (!id)
+                        goto error;
+                evsel->ids = nr;
+                evsel->id = id;
+
+                for (j = 0 ; j < nr; j++) {
+                        ret = read(fd, id, sizeof(*id));
+                        if (ret != (ssize_t)sizeof(*id))
+                                goto error;
+                        if (ph->needs_swap)
+                                *id = bswap_64(*id);
+                        id++;
+                }
+        }
+out:
+        if (buf)
+                free(buf);
+        return events;
+error:
+        if (events)
+                free_event_desc(events);
+        events = NULL;
+        goto out;
+}
+
+static void print_event_desc(struct perf_header *ph, int fd, FILE *fp)
+{
+        struct perf_evsel *evsel, *events = read_event_desc(ph, fd);
+        u32 j;
+        u64 *id;
+
+        if (!events) {
+                fprintf(fp, "# event desc: not available or unable to read\n");
+                return;
+        }
+
+        for (evsel = events; evsel->attr.size; evsel++) {
+                fprintf(fp, "# event : name = %s, ", evsel->name);
 
                 fprintf(fp, "type = %d, config = 0x%"PRIx64
                             ", config1 = 0x%"PRIx64", config2 = 0x%"PRIx64,
-                                attr.type,
-                                (u64)attr.config,
-                                (u64)attr.config1,
-                                (u64)attr.config2);
+                                evsel->attr.type,
+                                (u64)evsel->attr.config,
+                                (u64)evsel->attr.config1,
+                                (u64)evsel->attr.config2);
 
                 fprintf(fp, ", excl_usr = %d, excl_kern = %d",
-                                attr.exclude_user,
-                                attr.exclude_kernel);
+                                evsel->attr.exclude_user,
+                                evsel->attr.exclude_kernel);
 
                 fprintf(fp, ", excl_host = %d, excl_guest = %d",
-                                attr.exclude_host,
-                                attr.exclude_guest);
+                                evsel->attr.exclude_host,
+                                evsel->attr.exclude_guest);
 
-                fprintf(fp, ", precise_ip = %d", attr.precise_ip);
+                fprintf(fp, ", precise_ip = %d", evsel->attr.precise_ip);
 
-                if (nr)
+                if (evsel->ids) {
                         fprintf(fp, ", id = {");
-
-                for (j = 0 ; j < nr; j++) {
-                        ret = read(fd, &id, sizeof(id));
-                        if (ret != (ssize_t)sizeof(id))
-                                goto error;
-
-                        if (ph->needs_swap)
-                                id = bswap_64(id);
-
-                        if (j)
-                                fputc(',', fp);
-
-                        fprintf(fp, " %"PRIu64, id);
-                }
-                if (nr && j == nr)
+                        for (j = 0, id = evsel->id; j < evsel->ids; j++, id++) {
+                                if (j)
+                                        fputc(',', fp);
+                                fprintf(fp, " %"PRIu64, *id);
+                        }
                         fprintf(fp, " }");
+                }
+
                 fputc('\n', fp);
         }
-        free(buf);
-        return;
-error:
-        fprintf(fp, "# event desc: not available or unable to read\n");
+
+        free_event_desc(events);
 }
 
-static void print_total_mem(struct perf_header *h __used, int fd, FILE *fp)
+static void print_total_mem(struct perf_header *ph, int fd __maybe_unused,
+                            FILE *fp)
 {
-        uint64_t mem;
-        ssize_t ret;
-
-        ret = read(fd, &mem, sizeof(mem));
-        if (ret != sizeof(mem))
-                goto error;
-
-        if (h->needs_swap)
-                mem = bswap_64(mem);
-
-        fprintf(fp, "# total memory : %"PRIu64" kB\n", mem);
-        return;
-error:
-        fprintf(fp, "# total memory : unknown\n");
+        fprintf(fp, "# total memory : %Lu kB\n", ph->env.total_mem);
 }
 
-static void print_numa_topology(struct perf_header *h __used, int fd, FILE *fp)
+static void print_numa_topology(struct perf_header *ph, int fd __maybe_unused,
+                                FILE *fp)
 {
-        ssize_t ret;
         u32 nr, c, i;
-        char *str;
+        char *str, *tmp;
         uint64_t mem_total, mem_free;
 
         /* nr nodes */
-        ret = read(fd, &nr, sizeof(nr));
-        if (ret != (ssize_t)sizeof(nr))
-                goto error;
-
-        if (h->needs_swap)
-                nr = bswap_32(nr);
+        nr = ph->env.nr_numa_nodes;
+        str = ph->env.numa_nodes;
 
         for (i = 0; i < nr; i++) {
-
                 /* node number */
-                ret = read(fd, &c, sizeof(c));
-                if (ret != (ssize_t)sizeof(c))
+                c = strtoul(str, &tmp, 0);
+                if (*tmp != ':')
                         goto error;
 
-                if (h->needs_swap)
-                        c = bswap_32(c);
-
-                ret = read(fd, &mem_total, sizeof(u64));
-                if (ret != sizeof(u64))
+                str = tmp + 1;
+                mem_total = strtoull(str, &tmp, 0);
+                if (*tmp != ':')
                         goto error;
 
-                ret = read(fd, &mem_free, sizeof(u64));
-                if (ret != sizeof(u64))
+                str = tmp + 1;
+                mem_free = strtoull(str, &tmp, 0);
+                if (*tmp != ':')
                         goto error;
 
-                if (h->needs_swap) {
-                        mem_total = bswap_64(mem_total);
-                        mem_free = bswap_64(mem_free);
-                }
-
                 fprintf(fp, "# node%u meminfo  : total = %"PRIu64" kB,"
                             " free = %"PRIu64" kB\n",
-                        c,
-                        mem_total,
-                        mem_free);
+                        c, mem_total, mem_free);
 
-                str = do_read_string(fd, h);
+                str = tmp + 1;
                 fprintf(fp, "# node%u cpu list : %s\n", c, str);
-                free(str);
         }
         return;
 error:
         fprintf(fp, "# numa topology : not available\n");
 }
 
-static void print_cpuid(struct perf_header *ph, int fd, FILE *fp)
+static void print_cpuid(struct perf_header *ph, int fd __maybe_unused, FILE *fp)
 {
-        char *str = do_read_string(fd, ph);
-        fprintf(fp, "# cpuid : %s\n", str);
-        free(str);
+        fprintf(fp, "# cpuid : %s\n", ph->env.cpuid);
 }
 
-static void print_branch_stack(struct perf_header *ph __used, int fd __used,
-                               FILE *fp)
+static void print_branch_stack(struct perf_header *ph __maybe_unused,
+                               int fd __maybe_unused, FILE *fp)
 {
         fprintf(fp, "# contains samples with branch stack\n");
 }
 
+static void print_pmu_mappings(struct perf_header *ph, int fd __maybe_unused,
+                               FILE *fp)
+{
+        const char *delimiter = "# pmu mappings: ";
+        char *str, *tmp;
+        u32 pmu_num;
+        u32 type;
+
+        pmu_num = ph->env.nr_pmu_mappings;
+        if (!pmu_num) {
+                fprintf(fp, "# pmu mappings: not available\n");
+                return;
+        }
+
+        str = ph->env.pmu_mappings;
+
+        while (pmu_num) {
+                type = strtoul(str, &tmp, 0);
+                if (*tmp != ':')
+                        goto error;
+
+                str = tmp + 1;
+                fprintf(fp, "%s%s = %" PRIu32, delimiter, str, type);
+
+                delimiter = ", ";
+                str += strlen(str) + 1;
+                pmu_num--;
+        }
+
+        fprintf(fp, "\n");
+
+        if (!pmu_num)
+                return;
+error:
+        fprintf(fp, "# pmu mappings: unable to read\n");
+}
+
 static int __event_process_build_id(struct build_id_event *bev,
                                     char *filename,
                                     struct perf_session *session)
@@ -1398,7 +1493,7 @@ static int perf_header__read_build_ids_abi_quirk(struct perf_header *header,
         struct perf_session *session = container_of(header, struct perf_session, header);
         struct {
                 struct perf_event_header   header;
-                u8                         build_id[ALIGN(BUILD_ID_SIZE, sizeof(u64))];
+                u8                         build_id[PERF_ALIGN(BUILD_ID_SIZE, sizeof(u64))];
                 char                       filename[0];
         } old_bev;
         struct build_id_event bev;
@@ -1487,28 +1582,375 @@ out:
         return err;
 }
 
-static int process_tracing_data(struct perf_file_section *section __unused,
-                              struct perf_header *ph __unused,
-                              int feat __unused, int fd, void *data)
+static int process_tracing_data(struct perf_file_section *section __maybe_unused,
+                                struct perf_header *ph __maybe_unused,
+                                int fd, void *data)
 {
         trace_report(fd, data, false);
         return 0;
 }
 
 static int process_build_id(struct perf_file_section *section,
-                            struct perf_header *ph,
-                            int feat __unused, int fd, void *data __used)
+                            struct perf_header *ph, int fd,
+                            void *data __maybe_unused)
 {
         if (perf_header__read_build_ids(ph, fd, section->offset, section->size))
                 pr_debug("Failed to read buildids, continuing...\n");
         return 0;
 }
 
+static int process_hostname(struct perf_file_section *section __maybe_unused,
+                            struct perf_header *ph, int fd,
+                            void *data __maybe_unused)
+{
+        ph->env.hostname = do_read_string(fd, ph);
+        return ph->env.hostname ? 0 : -ENOMEM;
+}
+
+static int process_osrelease(struct perf_file_section *section __maybe_unused,
+                             struct perf_header *ph, int fd,
+                             void *data __maybe_unused)
+{
+        ph->env.os_release = do_read_string(fd, ph);
+        return ph->env.os_release ? 0 : -ENOMEM;
+}
+
+static int process_version(struct perf_file_section *section __maybe_unused,
+                           struct perf_header *ph, int fd,
+                           void *data __maybe_unused)
+{
+        ph->env.version = do_read_string(fd, ph);
+        return ph->env.version ? 0 : -ENOMEM;
+}
+
+static int process_arch(struct perf_file_section *section __maybe_unused,
+                        struct perf_header *ph, int fd,
+                        void *data __maybe_unused)
+{
+        ph->env.arch = do_read_string(fd, ph);
+        return ph->env.arch ? 0 : -ENOMEM;
+}
+
+static int process_nrcpus(struct perf_file_section *section __maybe_unused,
+                          struct perf_header *ph, int fd,
+                          void *data __maybe_unused)
+{
+        size_t ret;
+        u32 nr;
+
+        ret = read(fd, &nr, sizeof(nr));
+        if (ret != sizeof(nr))
+                return -1;
+
+        if (ph->needs_swap)
+                nr = bswap_32(nr);
+
+        ph->env.nr_cpus_online = nr;
+
+        ret = read(fd, &nr, sizeof(nr));
+        if (ret != sizeof(nr))
+                return -1;
+
+        if (ph->needs_swap)
+                nr = bswap_32(nr);
+
+        ph->env.nr_cpus_avail = nr;
+        return 0;
+}
+
+static int process_cpudesc(struct perf_file_section *section __maybe_unused,
+                           struct perf_header *ph, int fd,
+                           void *data __maybe_unused)
+{
+        ph->env.cpu_desc = do_read_string(fd, ph);
+        return ph->env.cpu_desc ? 0 : -ENOMEM;
+}
+
+static int process_cpuid(struct perf_file_section *section __maybe_unused,
+                         struct perf_header *ph,  int fd,
+                         void *data __maybe_unused)
+{
+        ph->env.cpuid = do_read_string(fd, ph);
+        return ph->env.cpuid ? 0 : -ENOMEM;
+}
+
+static int process_total_mem(struct perf_file_section *section __maybe_unused,
+                             struct perf_header *ph, int fd,
+                             void *data __maybe_unused)
+{
+        uint64_t mem;
+        size_t ret;
+
+        ret = read(fd, &mem, sizeof(mem));
+        if (ret != sizeof(mem))
+                return -1;
+
+        if (ph->needs_swap)
+                mem = bswap_64(mem);
+
+        ph->env.total_mem = mem;
+        return 0;
+}
+
+static struct perf_evsel *
+perf_evlist__find_by_index(struct perf_evlist *evlist, int idx)
+{
+        struct perf_evsel *evsel;
+
+        list_for_each_entry(evsel, &evlist->entries, node) {
+                if (evsel->idx == idx)
+                        return evsel;
+        }
+
+        return NULL;
+}
+
+static void
+perf_evlist__set_event_name(struct perf_evlist *evlist,
+                            struct perf_evsel *event)
+{
+        struct perf_evsel *evsel;
+
+        if (!event->name)
+                return;
+
+        evsel = perf_evlist__find_by_index(evlist, event->idx);
+        if (!evsel)
+                return;
+
+        if (evsel->name)
+                return;
+
+        evsel->name = strdup(event->name);
+}
+
+static int
+process_event_desc(struct perf_file_section *section __maybe_unused,
+                   struct perf_header *header, int fd,
+                   void *data __maybe_unused)
+{
+        struct perf_session *session;
+        struct perf_evsel *evsel, *events = read_event_desc(header, fd);
+
+        if (!events)
+                return 0;
+
+        session = container_of(header, struct perf_session, header);
+        for (evsel = events; evsel->attr.size; evsel++)
+                perf_evlist__set_event_name(session->evlist, evsel);
+
+        free_event_desc(events);
+
+        return 0;
+}
+
+static int process_cmdline(struct perf_file_section *section __maybe_unused,
+                           struct perf_header *ph, int fd,
+                           void *data __maybe_unused)
+{
+        size_t ret;
+        char *str;
+        u32 nr, i;
+        struct strbuf sb;
+
+        ret = read(fd, &nr, sizeof(nr));
+        if (ret != sizeof(nr))
+                return -1;
+
+        if (ph->needs_swap)
+                nr = bswap_32(nr);
+
+        ph->env.nr_cmdline = nr;
+        strbuf_init(&sb, 128);
+
+        for (i = 0; i < nr; i++) {
+                str = do_read_string(fd, ph);
+                if (!str)
+                        goto error;
+
+                /* include a NULL character at the end */
+                strbuf_add(&sb, str, strlen(str) + 1);
+                free(str);
+        }
+        ph->env.cmdline = strbuf_detach(&sb, NULL);
+        return 0;
+
+error:
+        strbuf_release(&sb);
+        return -1;
+}
+
+static int process_cpu_topology(struct perf_file_section *section __maybe_unused,
+                                struct perf_header *ph, int fd,
+                                void *data __maybe_unused)
+{
+        size_t ret;
+        u32 nr, i;
+        char *str;
+        struct strbuf sb;
+
+        ret = read(fd, &nr, sizeof(nr));
+        if (ret != sizeof(nr))
+                return -1;
+
+        if (ph->needs_swap)
+                nr = bswap_32(nr);
+
+        ph->env.nr_sibling_cores = nr;
+        strbuf_init(&sb, 128);
+
+        for (i = 0; i < nr; i++) {
+                str = do_read_string(fd, ph);
+                if (!str)
+                        goto error;
+
+                /* include a NULL character at the end */
+                strbuf_add(&sb, str, strlen(str) + 1);
+                free(str);
+        }
+        ph->env.sibling_cores = strbuf_detach(&sb, NULL);
+
+        ret = read(fd, &nr, sizeof(nr));
+        if (ret != sizeof(nr))
+                return -1;
+
+        if (ph->needs_swap)
+                nr = bswap_32(nr);
+
+        ph->env.nr_sibling_threads = nr;
+
+        for (i = 0; i < nr; i++) {
+                str = do_read_string(fd, ph);
+                if (!str)
+                        goto error;
+
+                /* include a NULL character at the end */
+                strbuf_add(&sb, str, strlen(str) + 1);
+                free(str);
+        }
+        ph->env.sibling_threads = strbuf_detach(&sb, NULL);
+        return 0;
+
+error:
+        strbuf_release(&sb);
+        return -1;
+}
+
+static int process_numa_topology(struct perf_file_section *section __maybe_unused,
+                                 struct perf_header *ph, int fd,
+                                 void *data __maybe_unused)
+{
+        size_t ret;
+        u32 nr, node, i;
+        char *str;
+        uint64_t mem_total, mem_free;
+        struct strbuf sb;
+
+        /* nr nodes */
+        ret = read(fd, &nr, sizeof(nr));
+        if (ret != sizeof(nr))
+                goto error;
+
+        if (ph->needs_swap)
+                nr = bswap_32(nr);
+
+        ph->env.nr_numa_nodes = nr;
+        strbuf_init(&sb, 256);
+
+        for (i = 0; i < nr; i++) {
+                /* node number */
+                ret = read(fd, &node, sizeof(node));
+                if (ret != sizeof(node))
+                        goto error;
+
+                ret = read(fd, &mem_total, sizeof(u64));
+                if (ret != sizeof(u64))
+                        goto error;
+
+                ret = read(fd, &mem_free, sizeof(u64));
+                if (ret != sizeof(u64))
+                        goto error;
+
+                if (ph->needs_swap) {
+                        node = bswap_32(node);
+                        mem_total = bswap_64(mem_total);
+                        mem_free = bswap_64(mem_free);
+                }
+
+                strbuf_addf(&sb, "%u:%"PRIu64":%"PRIu64":",
+                            node, mem_total, mem_free);
+
+                str = do_read_string(fd, ph);
+                if (!str)
+                        goto error;
+
+                /* include a NULL character at the end */
+                strbuf_add(&sb, str, strlen(str) + 1);
+                free(str);
+        }
+        ph->env.numa_nodes = strbuf_detach(&sb, NULL);
+        return 0;
+
+error:
+        strbuf_release(&sb);
+        return -1;
+}
+
+static int process_pmu_mappings(struct perf_file_section *section __maybe_unused,
+                                struct perf_header *ph, int fd,
+                                void *data __maybe_unused)
+{
+        size_t ret;
+        char *name;
+        u32 pmu_num;
+        u32 type;
+        struct strbuf sb;
+
+        ret = read(fd, &pmu_num, sizeof(pmu_num));
+        if (ret != sizeof(pmu_num))
+                return -1;
+
+        if (ph->needs_swap)
+                pmu_num = bswap_32(pmu_num);
+
+        if (!pmu_num) {
+                pr_debug("pmu mappings not available\n");
+                return 0;
+        }
+
+        ph->env.nr_pmu_mappings = pmu_num;
+        strbuf_init(&sb, 128);
+
+        while (pmu_num) {
+                if (read(fd, &type, sizeof(type)) != sizeof(type))
+                        goto error;
+                if (ph->needs_swap)
+                        type = bswap_32(type);
+
+                name = do_read_string(fd, ph);
+                if (!name)
+                        goto error;
+
+                strbuf_addf(&sb, "%u:%s", type, name);
+                /* include a NULL character at the end */
+                strbuf_add(&sb, "", 1);
+
+                free(name);
+                pmu_num--;
+        }
+        ph->env.pmu_mappings = strbuf_detach(&sb, NULL);
+        return 0;
+
+error:
+        strbuf_release(&sb);
+        return -1;
+}
+
 struct feature_ops {
         int (*write)(int fd, struct perf_header *h, struct perf_evlist *evlist);
         void (*print)(struct perf_header *h, int fd, FILE *fp);
         int (*process)(struct perf_file_section *section,
-                       struct perf_header *h, int feat, int fd, void *data);
+                       struct perf_header *h, int fd, void *data);
         const char *name;
         bool full_only;
 };
@@ -1520,7 +1962,7 @@ struct feature_ops {
                 .process = process_##func }
 #define FEAT_OPF(n, func) \
         [n] = { .name = #n, .write = write_##func, .print = print_##func, \
-                .full_only = true }
+                .process = process_##func, .full_only = true }
 
 /* feature_ops not implemented: */
 #define print_tracing_data      NULL
@@ -1529,19 +1971,20 @@ struct feature_ops {
 static const struct feature_ops feat_ops[HEADER_LAST_FEATURE] = {
         FEAT_OPP(HEADER_TRACING_DATA,   tracing_data),
         FEAT_OPP(HEADER_BUILD_ID,       build_id),
-        FEAT_OPA(HEADER_HOSTNAME,       hostname),
-        FEAT_OPA(HEADER_OSRELEASE,      osrelease),
-        FEAT_OPA(HEADER_VERSION,        version),
-        FEAT_OPA(HEADER_ARCH,           arch),
-        FEAT_OPA(HEADER_NRCPUS,         nrcpus),
-        FEAT_OPA(HEADER_CPUDESC,        cpudesc),
-        FEAT_OPA(HEADER_CPUID,          cpuid),
-        FEAT_OPA(HEADER_TOTAL_MEM,      total_mem),
-        FEAT_OPA(HEADER_EVENT_DESC,     event_desc),
-        FEAT_OPA(HEADER_CMDLINE,        cmdline),
+        FEAT_OPP(HEADER_HOSTNAME,       hostname),
+        FEAT_OPP(HEADER_OSRELEASE,      osrelease),
+        FEAT_OPP(HEADER_VERSION,        version),
+        FEAT_OPP(HEADER_ARCH,           arch),
+        FEAT_OPP(HEADER_NRCPUS,         nrcpus),
+        FEAT_OPP(HEADER_CPUDESC,        cpudesc),
+        FEAT_OPP(HEADER_CPUID,          cpuid),
+        FEAT_OPP(HEADER_TOTAL_MEM,      total_mem),
+        FEAT_OPP(HEADER_EVENT_DESC,     event_desc),
+        FEAT_OPP(HEADER_CMDLINE,        cmdline),
         FEAT_OPF(HEADER_CPU_TOPOLOGY,   cpu_topology),
         FEAT_OPF(HEADER_NUMA_TOPOLOGY,  numa_topology),
         FEAT_OPA(HEADER_BRANCH_STACK,   branch_stack),
+        FEAT_OPP(HEADER_PMU_MAPPINGS,   pmu_mappings),
 };
 
 struct header_print_data {
@@ -1683,17 +2126,17 @@ int perf_session__write_header(struct perf_session *session,
         struct perf_file_header f_header;
         struct perf_file_attr   f_attr;
         struct perf_header *header = &session->header;
-        struct perf_evsel *attr, *pair = NULL;
+        struct perf_evsel *evsel, *pair = NULL;
         int err;
 
         lseek(fd, sizeof(f_header), SEEK_SET);
 
         if (session->evlist != evlist)
-                pair = list_entry(session->evlist->entries.next, struct perf_evsel, node);
+                pair = perf_evlist__first(session->evlist);
 
-        list_for_each_entry(attr, &evlist->entries, node) {
-                attr->id_offset = lseek(fd, 0, SEEK_CUR);
-                err = do_write(fd, attr->id, attr->ids * sizeof(u64));
+        list_for_each_entry(evsel, &evlist->entries, node) {
+                evsel->id_offset = lseek(fd, 0, SEEK_CUR);
+                err = do_write(fd, evsel->id, evsel->ids * sizeof(u64));
                 if (err < 0) {
 out_err_write:
                         pr_debug("failed to write perf header\n");
@@ -1703,19 +2146,19 @@ out_err_write:
                         err = do_write(fd, pair->id, pair->ids * sizeof(u64));
                         if (err < 0)
                                 goto out_err_write;
-                        attr->ids += pair->ids;
-                        pair = list_entry(pair->node.next, struct perf_evsel, node);
+                        evsel->ids += pair->ids;
+                        pair = perf_evsel__next(pair);
                 }
         }
 
         header->attr_offset = lseek(fd, 0, SEEK_CUR);
 
-        list_for_each_entry(attr, &evlist->entries, node) {
+        list_for_each_entry(evsel, &evlist->entries, node) {
                 f_attr = (struct perf_file_attr){
-                        .attr = attr->attr,
+                        .attr = evsel->attr,
                         .ids  = {
-                                .offset = attr->id_offset,
-                                .size   = attr->ids * sizeof(u64),
+                                .offset = evsel->id_offset,
+                                .size   = evsel->ids * sizeof(u64),
                         }
                 };
                 err = do_write(fd, &f_attr, sizeof(f_attr));
@@ -1726,9 +2169,9 @@ out_err_write:
         }
 
         header->event_offset = lseek(fd, 0, SEEK_CUR);
-        header->event_size = event_count * sizeof(struct perf_trace_event_type);
-        if (events) {
-                err = do_write(fd, events, header->event_size);
+        header->event_size = trace_event_count * sizeof(struct perf_trace_event_type);
+        if (trace_events) {
+                err = do_write(fd, trace_events, header->event_size);
                 if (err < 0) {
                         pr_debug("failed to write perf header events\n");
                         return err;
@@ -1829,6 +2272,8 @@ out_free:
 static const int attr_file_abi_sizes[] = {
         [0] = PERF_ATTR_SIZE_VER0,
         [1] = PERF_ATTR_SIZE_VER1,
+        [2] = PERF_ATTR_SIZE_VER2,
+        [3] = PERF_ATTR_SIZE_VER3,
         0,
 };
 
@@ -2019,7 +2464,7 @@ static int perf_file_section__process(struct perf_file_section *section,
         if (!feat_ops[feat].process)
                 return 0;
 
-        return feat_ops[feat].process(section, ph, feat, fd, data);
+        return feat_ops[feat].process(section, ph, fd, data);
 }
 
 static int perf_file_header__read_pipe(struct perf_pipe_file_header *header,
@@ -2108,32 +2553,39 @@ static int read_attr(int fd, struct perf_header *ph,
         return ret <= 0 ? -1 : 0;
 }
 
-static int perf_evsel__set_tracepoint_name(struct perf_evsel *evsel,
-                                           struct pevent *pevent)
+static int perf_evsel__prepare_tracepoint_event(struct perf_evsel *evsel,
+                                                struct pevent *pevent)
 {
-        struct event_format *event = pevent_find_event(pevent,
-                                                       evsel->attr.config);
+        struct event_format *event;
         char bf[128];
 
+        /* already prepared */
+        if (evsel->tp_format)
+                return 0;
+
+        event = pevent_find_event(pevent, evsel->attr.config);
         if (event == NULL)
                 return -1;
 
-        snprintf(bf, sizeof(bf), "%s:%s", event->system, event->name);
-        evsel->name = strdup(bf);
-        if (event->name == NULL)
-                return -1;
+        if (!evsel->name) {
+                snprintf(bf, sizeof(bf), "%s:%s", event->system, event->name);
+                evsel->name = strdup(bf);
+                if (evsel->name == NULL)
+                        return -1;
+        }
 
+        evsel->tp_format = event;
         return 0;
 }
 
-static int perf_evlist__set_tracepoint_names(struct perf_evlist *evlist,
-                                             struct pevent *pevent)
+static int perf_evlist__prepare_tracepoint_events(struct perf_evlist *evlist,
+                                                  struct pevent *pevent)
 {
         struct perf_evsel *pos;
 
         list_for_each_entry(pos, &evlist->entries, node) {
                 if (pos->attr.type == PERF_TYPE_TRACEPOINT &&
-                    perf_evsel__set_tracepoint_name(pos, pevent))
+                    perf_evsel__prepare_tracepoint_event(pos, pevent))
                         return -1;
         }
 
@@ -2176,6 +2628,8 @@ int perf_session__read_header(struct perf_session *session, int fd)
 
                 if (evsel == NULL)
                         goto out_delete_evlist;
+
+                evsel->needs_swap = header->needs_swap;
                 /*
                  * Do it before so that if perf_evsel__alloc_id fails, this
                  * entry gets purged too at perf_evlist__delete().
@@ -2207,13 +2661,13 @@ int perf_session__read_header(struct perf_session *session, int fd)
 
         if (f_header.event_types.size) {
                 lseek(fd, f_header.event_types.offset, SEEK_SET);
-                events = malloc(f_header.event_types.size);
-                if (events == NULL)
+                trace_events = malloc(f_header.event_types.size);
+                if (trace_events == NULL)
                         return -ENOMEM;
-                if (perf_header__getbuffer64(header, fd, events,
+                if (perf_header__getbuffer64(header, fd, trace_events,
                                              f_header.event_types.size))
                         goto out_errno;
-                event_count =  f_header.event_types.size / sizeof(struct perf_trace_event_type);
+                trace_event_count =  f_header.event_types.size / sizeof(struct perf_trace_event_type);
         }
 
         perf_header__process_sections(header, fd, &session->pevent,
@@ -2221,7 +2675,8 @@ int perf_session__read_header(struct perf_session *session, int fd)
 
         lseek(fd, header->data_offset, SEEK_SET);
 
-        if (perf_evlist__set_tracepoint_names(session->evlist, session->pevent))
+        if (perf_evlist__prepare_tracepoint_events(session->evlist,
+                                                   session->pevent))
                 goto out_delete_evlist;
 
         header->frozen = 1;
@@ -2236,7 +2691,7 @@ out_delete_evlist:
 }
 
 int perf_event__synthesize_attr(struct perf_tool *tool,
-                                struct perf_event_attr *attr, u16 ids, u64 *id,
+                                struct perf_event_attr *attr, u32 ids, u64 *id,
                                 perf_event__handler_t process)
 {
         union perf_event *ev;
@@ -2244,7 +2699,7 @@ int perf_event__synthesize_attr(struct perf_tool *tool,
         int err;
 
         size = sizeof(struct perf_event_attr);
-        size = ALIGN(size, sizeof(u64));
+        size = PERF_ALIGN(size, sizeof(u64));
         size += sizeof(struct perf_event_header);
         size += ids * sizeof(u64);
 
@@ -2257,9 +2712,12 @@ int perf_event__synthesize_attr(struct perf_tool *tool,
         memcpy(ev->attr.id, id, ids * sizeof(u64));
 
         ev->attr.header.type = PERF_RECORD_HEADER_ATTR;
-        ev->attr.header.size = size;
+        ev->attr.header.size = (u16)size;
 
-        err = process(tool, ev, NULL, NULL);
+        if (ev->attr.header.size == size)
+                err = process(tool, ev, NULL, NULL);
+        else
+                err = -E2BIG;
 
         free(ev);
 
@@ -2270,12 +2728,12 @@ int perf_event__synthesize_attrs(struct perf_tool *tool,
                                    struct perf_session *session,
                                    perf_event__handler_t process)
 {
-        struct perf_evsel *attr;
+        struct perf_evsel *evsel;
         int err = 0;
 
-        list_for_each_entry(attr, &session->evlist->entries, node) {
-                err = perf_event__synthesize_attr(tool, &attr->attr, attr->ids,
-                                                  attr->id, process);
+        list_for_each_entry(evsel, &session->evlist->entries, node) {
+                err = perf_event__synthesize_attr(tool, &evsel->attr, evsel->ids,
+                                                  evsel->id, process);
                 if (err) {
                         pr_debug("failed to create perf header attribute\n");
                         return err;
@@ -2288,7 +2746,7 @@ int perf_event__synthesize_attrs(struct perf_tool *tool,
 int perf_event__process_attr(union perf_event *event,
                              struct perf_evlist **pevlist)
 {
-        unsigned int i, ids, n_ids;
+        u32 i, ids, n_ids;
         struct perf_evsel *evsel;
         struct perf_evlist *evlist = *pevlist;
 
@@ -2339,7 +2797,7 @@ int perf_event__synthesize_event_type(struct perf_tool *tool,
 
         ev.event_type.header.type = PERF_RECORD_HEADER_EVENT_TYPE;
         size = strlen(ev.event_type.event_type.name);
-        size = ALIGN(size, sizeof(u64));
+        size = PERF_ALIGN(size, sizeof(u64));
         ev.event_type.header.size = sizeof(ev.event_type) -
                 (sizeof(ev.event_type.event_type.name) - size);
 
@@ -2355,8 +2813,8 @@ int perf_event__synthesize_event_types(struct perf_tool *tool,
         struct perf_trace_event_type *type;
         int i, err = 0;
 
-        for (i = 0; i < event_count; i++) {
-                type = &events[i];
+        for (i = 0; i < trace_event_count; i++) {
+                type = &trace_events[i];
 
                 err = perf_event__synthesize_event_type(tool, type->event_id,
                                                         type->name, process,
@@ -2370,7 +2828,7 @@ int perf_event__synthesize_event_types(struct perf_tool *tool,
         return err;
 }
 
-int perf_event__process_event_type(struct perf_tool *tool __unused,
+int perf_event__process_event_type(struct perf_tool *tool __maybe_unused,
                                    union perf_event *event)
 {
         if (perf_header__push_event(event->event_type.event_type.event_id,
@@ -2387,7 +2845,7 @@ int perf_event__synthesize_tracing_data(struct perf_tool *tool, int fd,
         union perf_event ev;
         struct tracing_data *tdata;
         ssize_t size = 0, aligned_size = 0, padding;
-        int err __used = 0;
+        int err __maybe_unused = 0;
 
         /*
          * We are going to store the size of the data followed
@@ -2408,7 +2866,7 @@ int perf_event__synthesize_tracing_data(struct perf_tool *tool, int fd,
 
         ev.tracing_data.header.type = PERF_RECORD_HEADER_TRACING_DATA;
         size = tdata->size;
-        aligned_size = ALIGN(size, sizeof(u64));
+        aligned_size = PERF_ALIGN(size, sizeof(u64));
         padding = aligned_size - size;
         ev.tracing_data.header.size = sizeof(ev.tracing_data);
         ev.tracing_data.size = aligned_size;
@@ -2439,7 +2897,7 @@ int perf_event__process_tracing_data(union perf_event *event,
 
         size_read = trace_report(session->fd, &session->pevent,
                                  session->repipe);
-        padding = ALIGN(size_read, sizeof(u64)) - size_read;
+        padding = PERF_ALIGN(size_read, sizeof(u64)) - size_read;
 
         if (read(session->fd, buf, padding) < 0)
                 die("reading input file");
@@ -2452,6 +2910,9 @@ int perf_event__process_tracing_data(union perf_event *event,
         if (size_read + padding != size)
                 die("tracing data size mismatch");
 
+        perf_evlist__prepare_tracepoint_events(session->evlist,
+                                               session->pevent);
+
         return size_read + padding;
 }
 
@@ -2470,7 +2931,7 @@ int perf_event__synthesize_build_id(struct perf_tool *tool,
         memset(&ev, 0, sizeof(ev));
 
         len = pos->long_name_len + 1;
-        len = ALIGN(len, NAME_ALIGN);
+        len = PERF_ALIGN(len, NAME_ALIGN);
         memcpy(&ev.build_id.build_id, pos->build_id, sizeof(pos->build_id));
         ev.build_id.header.type = PERF_RECORD_HEADER_BUILD_ID;
         ev.build_id.header.misc = misc;
@@ -2483,7 +2944,7 @@ int perf_event__synthesize_build_id(struct perf_tool *tool,
         return err;
 }
 
-int perf_event__process_build_id(struct perf_tool *tool __used,
+int perf_event__process_build_id(struct perf_tool *tool __maybe_unused,
                                  union perf_event *event,
                                  struct perf_session *session)
 {
diff --git a/tools/perf/util/header.h b/tools/perf/util/header.h
index 2d42b3e1826f..99bdd3abce59 100644
--- a/tools/perf/util/header.h
+++ b/tools/perf/util/header.h
@@ -28,6 +28,7 @@ enum {
         HEADER_CPU_TOPOLOGY,
         HEADER_NUMA_TOPOLOGY,
         HEADER_BRANCH_STACK,
+        HEADER_PMU_MAPPINGS,
         HEADER_LAST_FEATURE,
         HEADER_FEAT_BITS        = 256,
 };
@@ -57,6 +58,29 @@ struct perf_header;
 int perf_file_header__read(struct perf_file_header *header,
                            struct perf_header *ph, int fd);
 
+struct perf_session_env {
+        char                    *hostname;
+        char                    *os_release;
+        char                    *version;
+        char                    *arch;
+        int                     nr_cpus_online;
+        int                     nr_cpus_avail;
+        char                    *cpu_desc;
+        char                    *cpuid;
+        unsigned long long      total_mem;
+
+        int                     nr_cmdline;
+        char                    *cmdline;
+        int                     nr_sibling_cores;
+        char                    *sibling_cores;
+        int                     nr_sibling_threads;
+        char                    *sibling_threads;
+        int                     nr_numa_nodes;
+        char                    *numa_nodes;
+        int                     nr_pmu_mappings;
+        char                    *pmu_mappings;
+};
+
 struct perf_header {
         int                     frozen;
         bool                    needs_swap;
@@ -66,6 +90,7 @@ struct perf_header {
         u64                     event_offset;
         u64                     event_size;
         DECLARE_BITMAP(adds_features, HEADER_FEAT_BITS);
+        struct perf_session_env env;
 };
 
 struct perf_evlist;
@@ -95,11 +120,11 @@ int perf_header__process_sections(struct perf_header *header, int fd,
 int perf_header__fprintf_info(struct perf_session *s, FILE *fp, bool full);
 
 int build_id_cache__add_s(const char *sbuild_id, const char *debugdir,
-                          const char *name, bool is_kallsyms);
+                          const char *name, bool is_kallsyms, bool is_vdso);
 int build_id_cache__remove_s(const char *sbuild_id, const char *debugdir);
 
 int perf_event__synthesize_attr(struct perf_tool *tool,
-                                struct perf_event_attr *attr, u16 ids, u64 *id,
+                                struct perf_event_attr *attr, u32 ids, u64 *id,
                                 perf_event__handler_t process);
 int perf_event__synthesize_attrs(struct perf_tool *tool,
                                  struct perf_session *session,
diff --git a/tools/perf/util/help.c b/tools/perf/util/help.c
index 6f2975a00358..8b1f6e891b8a 100644
--- a/tools/perf/util/help.c
+++ b/tools/perf/util/help.c
@@ -3,6 +3,7 @@
 #include "exec_cmd.h"
 #include "levenshtein.h"
 #include "help.h"
+#include <termios.h>
 
 void add_cmdname(struct cmdnames *cmds, const char *name, size_t len)
 {
@@ -331,7 +332,8 @@ const char *help_unknown_cmd(const char *cmd)
         exit(1);
 }
 
-int cmd_version(int argc __used, const char **argv __used, const char *prefix __used)
+int cmd_version(int argc __maybe_unused, const char **argv __maybe_unused,
+                const char *prefix __maybe_unused)
 {
         printf("perf version %s\n", perf_version_string);
         return 0;
diff --git a/tools/perf/util/hist.c b/tools/perf/util/hist.c
index f247ef2789a4..236bc9d98ff2 100644
--- a/tools/perf/util/hist.c
+++ b/tools/perf/util/hist.c
@@ -45,7 +45,7 @@ bool hists__new_col_len(struct hists *hists, enum hist_column col, u16 len)
         return false;
 }
 
-static void hists__reset_col_len(struct hists *hists)
+void hists__reset_col_len(struct hists *hists)
 {
         enum hist_column col;
 
@@ -63,7 +63,7 @@ static void hists__set_unres_dso_col_len(struct hists *hists, int dso)
                 hists__set_col_len(hists, dso, unresolved_col_width);
 }
 
-static void hists__calc_col_len(struct hists *hists, struct hist_entry *h)
+void hists__calc_col_len(struct hists *hists, struct hist_entry *h)
 {
         const unsigned int unresolved_col_width = BITS_PER_LONG / 4;
         u16 len;
@@ -114,6 +114,22 @@ static void hists__calc_col_len(struct hists *hists, struct hist_entry *h)
         }
 }
 
+void hists__output_recalc_col_len(struct hists *hists, int max_rows)
+{
+        struct rb_node *next = rb_first(&hists->entries);
+        struct hist_entry *n;
+        int row = 0;
+
+        hists__reset_col_len(hists);
+
+        while (next && row++ < max_rows) {
+                n = rb_entry(next, struct hist_entry, rb_node);
+                if (!n->filtered)
+                        hists__calc_col_len(hists, n);
+                next = rb_next(&n->rb_node);
+        }
+}
+
 static void hist_entry__add_cpumode_period(struct hist_entry *he,
                                            unsigned int cpumode, u64 period)
 {
@@ -378,7 +394,7 @@ void hist_entry__free(struct hist_entry *he)
  * collapse the histogram
  */
 
-static bool hists__collapse_insert_entry(struct hists *hists __used,
+static bool hists__collapse_insert_entry(struct hists *hists __maybe_unused,
                                          struct rb_root *root,
                                          struct hist_entry *he)
 {
@@ -394,8 +410,13 @@ static bool hists__collapse_insert_entry(struct hists *hists __used,
                 cmp = hist_entry__collapse(iter, he);
 
                 if (!cmp) {
-                        iter->period += he->period;
-                        iter->nr_events += he->nr_events;
+                        iter->period            += he->period;
+                        iter->period_sys        += he->period_sys;
+                        iter->period_us         += he->period_us;
+                        iter->period_guest_sys  += he->period_guest_sys;
+                        iter->period_guest_us   += he->period_guest_us;
+                        iter->nr_events         += he->nr_events;
+
                         if (symbol_conf.use_callchain) {
                                 callchain_cursor_reset(&callchain_cursor);
                                 callchain_merge(&callchain_cursor,
@@ -547,674 +568,6 @@ void hists__output_resort_threaded(struct hists *hists)
         return __hists__output_resort(hists, true);
 }
 
-static size_t callchain__fprintf_left_margin(FILE *fp, int left_margin)
-{
-        int i;
-        int ret = fprintf(fp, "            ");
-
-        for (i = 0; i < left_margin; i++)
-                ret += fprintf(fp, " ");
-
-        return ret;
-}
-
-static size_t ipchain__fprintf_graph_line(FILE *fp, int depth, int depth_mask,
-                                          int left_margin)
-{
-        int i;
-        size_t ret = callchain__fprintf_left_margin(fp, left_margin);
-
-        for (i = 0; i < depth; i++)
-                if (depth_mask & (1 << i))
-                        ret += fprintf(fp, "|          ");
-                else
-                        ret += fprintf(fp, "           ");
-
-        ret += fprintf(fp, "\n");
-
-        return ret;
-}
-
-static size_t ipchain__fprintf_graph(FILE *fp, struct callchain_list *chain,
-                                     int depth, int depth_mask, int period,
-                                     u64 total_samples, u64 hits,
-                                     int left_margin)
-{
-        int i;
-        size_t ret = 0;
-
-        ret += callchain__fprintf_left_margin(fp, left_margin);
-        for (i = 0; i < depth; i++) {
-                if (depth_mask & (1 << i))
-                        ret += fprintf(fp, "|");
-                else
-                        ret += fprintf(fp, " ");
-                if (!period && i == depth - 1) {
-                        double percent;
-
-                        percent = hits * 100.0 / total_samples;
-                        ret += percent_color_fprintf(fp, "--%2.2f%%-- ", percent);
-                } else
-                        ret += fprintf(fp, "%s", "          ");
-        }
-        if (chain->ms.sym)
-                ret += fprintf(fp, "%s\n", chain->ms.sym->name);
-        else
-                ret += fprintf(fp, "0x%0" PRIx64 "\n", chain->ip);
-
-        return ret;
-}
-
-static struct symbol *rem_sq_bracket;
-static struct callchain_list rem_hits;
-
-static void init_rem_hits(void)
-{
-        rem_sq_bracket = malloc(sizeof(*rem_sq_bracket) + 6);
-        if (!rem_sq_bracket) {
-                fprintf(stderr, "Not enough memory to display remaining hits\n");
-                return;
-        }
-
-        strcpy(rem_sq_bracket->name, "[...]");
-        rem_hits.ms.sym = rem_sq_bracket;
-}
-
-static size_t __callchain__fprintf_graph(FILE *fp, struct rb_root *root,
-                                         u64 total_samples, int depth,
-                                         int depth_mask, int left_margin)
-{
-        struct rb_node *node, *next;
-        struct callchain_node *child;
-        struct callchain_list *chain;
-        int new_depth_mask = depth_mask;
-        u64 remaining;
-        size_t ret = 0;
-        int i;
-        uint entries_printed = 0;
-
-        remaining = total_samples;
-
-        node = rb_first(root);
-        while (node) {
-                u64 new_total;
-                u64 cumul;
-
-                child = rb_entry(node, struct callchain_node, rb_node);
-                cumul = callchain_cumul_hits(child);
-                remaining -= cumul;
-
-                /*
-                 * The depth mask manages the output of pipes that show
-                 * the depth. We don't want to keep the pipes of the current
-                 * level for the last child of this depth.
-                 * Except if we have remaining filtered hits. They will
-                 * supersede the last child
-                 */
-                next = rb_next(node);
-                if (!next && (callchain_param.mode != CHAIN_GRAPH_REL || !remaining))
-                        new_depth_mask &= ~(1 << (depth - 1));
-
-                /*
-                 * But we keep the older depth mask for the line separator
-                 * to keep the level link until we reach the last child
-                 */
-                ret += ipchain__fprintf_graph_line(fp, depth, depth_mask,
-                                                   left_margin);
-                i = 0;
-                list_for_each_entry(chain, &child->val, list) {
-                        ret += ipchain__fprintf_graph(fp, chain, depth,
-                                                      new_depth_mask, i++,
-                                                      total_samples,
-                                                      cumul,
-                                                      left_margin);
-                }
-
-                if (callchain_param.mode == CHAIN_GRAPH_REL)
-                        new_total = child->children_hit;
-                else
-                        new_total = total_samples;
-
-                ret += __callchain__fprintf_graph(fp, &child->rb_root, new_total,
-                                                  depth + 1,
-                                                  new_depth_mask | (1 << depth),
-                                                  left_margin);
-                node = next;
-                if (++entries_printed == callchain_param.print_limit)
-                        break;
-        }
-
-        if (callchain_param.mode == CHAIN_GRAPH_REL &&
-                remaining && remaining != total_samples) {
-
-                if (!rem_sq_bracket)
-                        return ret;
-
-                new_depth_mask &= ~(1 << (depth - 1));
-                ret += ipchain__fprintf_graph(fp, &rem_hits, depth,
-                                              new_depth_mask, 0, total_samples,
-                                              remaining, left_margin);
-        }
-
-        return ret;
-}
-
-static size_t callchain__fprintf_graph(FILE *fp, struct rb_root *root,
-                                       u64 total_samples, int left_margin)
-{
-        struct callchain_node *cnode;
-        struct callchain_list *chain;
-        u32 entries_printed = 0;
-        bool printed = false;
-        struct rb_node *node;
-        int i = 0;
-        int ret = 0;
-
-        /*
-         * If have one single callchain root, don't bother printing
-         * its percentage (100 % in fractal mode and the same percentage
-         * than the hist in graph mode). This also avoid one level of column.
-         */
-        node = rb_first(root);
-        if (node && !rb_next(node)) {
-                cnode = rb_entry(node, struct callchain_node, rb_node);
-                list_for_each_entry(chain, &cnode->val, list) {
-                        /*
-                         * If we sort by symbol, the first entry is the same than
-                         * the symbol. No need to print it otherwise it appears as
-                         * displayed twice.
-                         */
-                        if (!i++ && sort__first_dimension == SORT_SYM)
-                                continue;
-                        if (!printed) {
-                                ret += callchain__fprintf_left_margin(fp, left_margin);
-                                ret += fprintf(fp, "|\n");
-                                ret += callchain__fprintf_left_margin(fp, left_margin);
-                                ret += fprintf(fp, "---");
-                                left_margin += 3;
-                                printed = true;
-                        } else
-                                ret += callchain__fprintf_left_margin(fp, left_margin);
-
-                        if (chain->ms.sym)
-                                ret += fprintf(fp, " %s\n", chain->ms.sym->name);
-                        else
-                                ret += fprintf(fp, " %p\n", (void *)(long)chain->ip);
-
-                        if (++entries_printed == callchain_param.print_limit)
-                                break;
-                }
-                root = &cnode->rb_root;
-        }
-
-        ret += __callchain__fprintf_graph(fp, root, total_samples,
-                                          1, 1, left_margin);
-        ret += fprintf(fp, "\n");
-
-        return ret;
-}
-
-static size_t __callchain__fprintf_flat(FILE *fp,
-                                        struct callchain_node *self,
-                                        u64 total_samples)
-{
-        struct callchain_list *chain;
-        size_t ret = 0;
-
-        if (!self)
-                return 0;
-
-        ret += __callchain__fprintf_flat(fp, self->parent, total_samples);
-
-
-        list_for_each_entry(chain, &self->val, list) {
-                if (chain->ip >= PERF_CONTEXT_MAX)
-                        continue;
-                if (chain->ms.sym)
-                        ret += fprintf(fp, "                %s\n", chain->ms.sym->name);
-                else
-                        ret += fprintf(fp, "                %p\n",
-                                        (void *)(long)chain->ip);
-        }
-
-        return ret;
-}
-
-static size_t callchain__fprintf_flat(FILE *fp, struct rb_root *self,
-                                      u64 total_samples)
-{
-        size_t ret = 0;
-        u32 entries_printed = 0;
-        struct rb_node *rb_node;
-        struct callchain_node *chain;
-
-        rb_node = rb_first(self);
-        while (rb_node) {
-                double percent;
-
-                chain = rb_entry(rb_node, struct callchain_node, rb_node);
-                percent = chain->hit * 100.0 / total_samples;
-
-                ret = percent_color_fprintf(fp, "           %6.2f%%\n", percent);
-                ret += __callchain__fprintf_flat(fp, chain, total_samples);
-                ret += fprintf(fp, "\n");
-                if (++entries_printed == callchain_param.print_limit)
-                        break;
-
-                rb_node = rb_next(rb_node);
-        }
-
-        return ret;
-}
-
-static size_t hist_entry_callchain__fprintf(struct hist_entry *he,
-                                            u64 total_samples, int left_margin,
-                                            FILE *fp)
-{
-        switch (callchain_param.mode) {
-        case CHAIN_GRAPH_REL:
-                return callchain__fprintf_graph(fp, &he->sorted_chain, he->period,
-                                                left_margin);
-                break;
-        case CHAIN_GRAPH_ABS:
-                return callchain__fprintf_graph(fp, &he->sorted_chain, total_samples,
-                                                left_margin);
-                break;
-        case CHAIN_FLAT:
-                return callchain__fprintf_flat(fp, &he->sorted_chain, total_samples);
-                break;
-        case CHAIN_NONE:
-                break;
-        default:
-                pr_err("Bad callchain mode\n");
-        }
-
-        return 0;
-}
-
-void hists__output_recalc_col_len(struct hists *hists, int max_rows)
-{
-        struct rb_node *next = rb_first(&hists->entries);
-        struct hist_entry *n;
-        int row = 0;
-
-        hists__reset_col_len(hists);
-
-        while (next && row++ < max_rows) {
-                n = rb_entry(next, struct hist_entry, rb_node);
-                if (!n->filtered)
-                        hists__calc_col_len(hists, n);
-                next = rb_next(&n->rb_node);
-        }
-}
-
-static int hist_entry__pcnt_snprintf(struct hist_entry *he, char *s,
-                                     size_t size, struct hists *pair_hists,
-                                     bool show_displacement, long displacement,
-                                     bool color, u64 total_period)
-{
-        u64 period, total, period_sys, period_us, period_guest_sys, period_guest_us;
-        u64 nr_events;
-        const char *sep = symbol_conf.field_sep;
-        int ret;
-
-        if (symbol_conf.exclude_other && !he->parent)
-                return 0;
-
-        if (pair_hists) {
-                period = he->pair ? he->pair->period : 0;
-                nr_events = he->pair ? he->pair->nr_events : 0;
-                total = pair_hists->stats.total_period;
-                period_sys = he->pair ? he->pair->period_sys : 0;
-                period_us = he->pair ? he->pair->period_us : 0;
-                period_guest_sys = he->pair ? he->pair->period_guest_sys : 0;
-                period_guest_us = he->pair ? he->pair->period_guest_us : 0;
-        } else {
-                period = he->period;
-                nr_events = he->nr_events;
-                total = total_period;
-                period_sys = he->period_sys;
-                period_us = he->period_us;
-                period_guest_sys = he->period_guest_sys;
-                period_guest_us = he->period_guest_us;
-        }
-
-        if (total) {
-                if (color)
-                        ret = percent_color_snprintf(s, size,
-                                                     sep ? "%.2f" : "   %6.2f%%",
-                                                     (period * 100.0) / total);
-                else
-                        ret = scnprintf(s, size, sep ? "%.2f" : "   %6.2f%%",
-                                       (period * 100.0) / total);
-                if (symbol_conf.show_cpu_utilization) {
-                        ret += percent_color_snprintf(s + ret, size - ret,
-                                        sep ? "%.2f" : "   %6.2f%%",
-                                        (period_sys * 100.0) / total);
-                        ret += percent_color_snprintf(s + ret, size - ret,
-                                        sep ? "%.2f" : "   %6.2f%%",
-                                        (period_us * 100.0) / total);
-                        if (perf_guest) {
-                                ret += percent_color_snprintf(s + ret,
-                                                size - ret,
-                                                sep ? "%.2f" : "   %6.2f%%",
-                                                (period_guest_sys * 100.0) /
-                                                                total);
-                                ret += percent_color_snprintf(s + ret,
-                                                size - ret,
-                                                sep ? "%.2f" : "   %6.2f%%",
-                                                (period_guest_us * 100.0) /
-                                                                total);
-                        }
-                }
-        } else
-                ret = scnprintf(s, size, sep ? "%" PRIu64 : "%12" PRIu64 " ", period);
-
-        if (symbol_conf.show_nr_samples) {
-                if (sep)
-                        ret += scnprintf(s + ret, size - ret, "%c%" PRIu64, *sep, nr_events);
-                else
-                        ret += scnprintf(s + ret, size - ret, "%11" PRIu64, nr_events);
-        }
-
-        if (symbol_conf.show_total_period) {
-                if (sep)
-                        ret += scnprintf(s + ret, size - ret, "%c%" PRIu64, *sep, period);
-                else
-                        ret += scnprintf(s + ret, size - ret, " %12" PRIu64, period);
-        }
-
-        if (pair_hists) {
-                char bf[32];
-                double old_percent = 0, new_percent = 0, diff;
-
-                if (total > 0)
-                        old_percent = (period * 100.0) / total;
-                if (total_period > 0)
-                        new_percent = (he->period * 100.0) / total_period;
-
-                diff = new_percent - old_percent;
-
-                if (fabs(diff) >= 0.01)
-                        scnprintf(bf, sizeof(bf), "%+4.2F%%", diff);
-                else
-                        scnprintf(bf, sizeof(bf), " ");
-
-                if (sep)
-                        ret += scnprintf(s + ret, size - ret, "%c%s", *sep, bf);
-                else
-                        ret += scnprintf(s + ret, size - ret, "%11.11s", bf);
-
-                if (show_displacement) {
-                        if (displacement)
-                                scnprintf(bf, sizeof(bf), "%+4ld", displacement);
-                        else
-                                scnprintf(bf, sizeof(bf), " ");
-
-                        if (sep)
-                                ret += scnprintf(s + ret, size - ret, "%c%s", *sep, bf);
-                        else
-                                ret += scnprintf(s + ret, size - ret, "%6.6s", bf);
-                }
-        }
-
-        return ret;
-}
-
-int hist_entry__snprintf(struct hist_entry *he, char *s, size_t size,
-                         struct hists *hists)
-{
-        const char *sep = symbol_conf.field_sep;
-        struct sort_entry *se;
-        int ret = 0;
-
-        list_for_each_entry(se, &hist_entry__sort_list, list) {
-                if (se->elide)
-                        continue;
-
-                ret += scnprintf(s + ret, size - ret, "%s", sep ?: "  ");
-                ret += se->se_snprintf(he, s + ret, size - ret,
-                                       hists__col_len(hists, se->se_width_idx));
-        }
-
-        return ret;
-}
-
-static int hist_entry__fprintf(struct hist_entry *he, size_t size,
-                               struct hists *hists, struct hists *pair_hists,
-                               bool show_displacement, long displacement,
-                               u64 total_period, FILE *fp)
-{
-        char bf[512];
-        int ret;
-
-        if (size == 0 || size > sizeof(bf))
-                size = sizeof(bf);
-
-        ret = hist_entry__pcnt_snprintf(he, bf, size, pair_hists,
-                                        show_displacement, displacement,
-                                        true, total_period);
-        hist_entry__snprintf(he, bf + ret, size - ret, hists);
-        return fprintf(fp, "%s\n", bf);
-}
-
-static size_t hist_entry__fprintf_callchain(struct hist_entry *he,
-                                            struct hists *hists,
-                                            u64 total_period, FILE *fp)
-{
-        int left_margin = 0;
-
-        if (sort__first_dimension == SORT_COMM) {
-                struct sort_entry *se = list_first_entry(&hist_entry__sort_list,
-                                                         typeof(*se), list);
-                left_margin = hists__col_len(hists, se->se_width_idx);
-                left_margin -= thread__comm_len(he->thread);
-        }
-
-        return hist_entry_callchain__fprintf(he, total_period, left_margin, fp);
-}
-
-size_t hists__fprintf(struct hists *hists, struct hists *pair,
-                      bool show_displacement, bool show_header, int max_rows,
-                      int max_cols, FILE *fp)
-{
-        struct sort_entry *se;
-        struct rb_node *nd;
-        size_t ret = 0;
-        u64 total_period;
-        unsigned long position = 1;
-        long displacement = 0;
-        unsigned int width;
-        const char *sep = symbol_conf.field_sep;
-        const char *col_width = symbol_conf.col_width_list_str;
-        int nr_rows = 0;
-
-        init_rem_hits();
-
-        if (!show_header)
-                goto print_entries;
-
-        fprintf(fp, "# %s", pair ? "Baseline" : "Overhead");
-
-        if (symbol_conf.show_cpu_utilization) {
-                if (sep) {
-                        ret += fprintf(fp, "%csys", *sep);
-                        ret += fprintf(fp, "%cus", *sep);
-                        if (perf_guest) {
-                                ret += fprintf(fp, "%cguest sys", *sep);
-                                ret += fprintf(fp, "%cguest us", *sep);
-                        }
-                } else {
-                        ret += fprintf(fp, "     sys  ");
-                        ret += fprintf(fp, "      us  ");
-                        if (perf_guest) {
-                                ret += fprintf(fp, "  guest sys  ");
-                                ret += fprintf(fp, "  guest us  ");
-                        }
-                }
-        }
-
-        if (symbol_conf.show_nr_samples) {
-                if (sep)
-                        fprintf(fp, "%cSamples", *sep);
-                else
-                        fputs("  Samples  ", fp);
-        }
-
-        if (symbol_conf.show_total_period) {
-                if (sep)
-                        ret += fprintf(fp, "%cPeriod", *sep);
-                else
-                        ret += fprintf(fp, "   Period    ");
-        }
-
-        if (pair) {
-                if (sep)
-                        ret += fprintf(fp, "%cDelta", *sep);
-                else
-                        ret += fprintf(fp, "  Delta    ");
-
-                if (show_displacement) {
-                        if (sep)
-                                ret += fprintf(fp, "%cDisplacement", *sep);
-                        else
-                                ret += fprintf(fp, " Displ");
-                }
-        }
-
-        list_for_each_entry(se, &hist_entry__sort_list, list) {
-                if (se->elide)
-                        continue;
-                if (sep) {
-                        fprintf(fp, "%c%s", *sep, se->se_header);
-                        continue;
-                }
-                width = strlen(se->se_header);
-                if (symbol_conf.col_width_list_str) {
-                        if (col_width) {
-                                hists__set_col_len(hists, se->se_width_idx,
-                                                   atoi(col_width));
-                                col_width = strchr(col_width, ',');
-                                if (col_width)
-                                        ++col_width;
-                        }
-                }
-                if (!hists__new_col_len(hists, se->se_width_idx, width))
-                        width = hists__col_len(hists, se->se_width_idx);
-                fprintf(fp, "  %*s", width, se->se_header);
-        }
-
-        fprintf(fp, "\n");
-        if (max_rows && ++nr_rows >= max_rows)
-                goto out;
-
-        if (sep)
-                goto print_entries;
-
-        fprintf(fp, "# ........");
-        if (symbol_conf.show_cpu_utilization)
-                fprintf(fp, "   .......   .......");
-        if (symbol_conf.show_nr_samples)
-                fprintf(fp, " ..........");
-        if (symbol_conf.show_total_period)
-                fprintf(fp, " ............");
-        if (pair) {
-                fprintf(fp, " ..........");
-                if (show_displacement)
-                        fprintf(fp, " .....");
-        }
-        list_for_each_entry(se, &hist_entry__sort_list, list) {
-                unsigned int i;
-
-                if (se->elide)
-                        continue;
-
-                fprintf(fp, "  ");
-                width = hists__col_len(hists, se->se_width_idx);
-                if (width == 0)
-                        width = strlen(se->se_header);
-                for (i = 0; i < width; i++)
-                        fprintf(fp, ".");
-        }
-
-        fprintf(fp, "\n");
-        if (max_rows && ++nr_rows >= max_rows)
-                goto out;
-
-        fprintf(fp, "#\n");
-        if (max_rows && ++nr_rows >= max_rows)
-                goto out;
-
-print_entries:
-        total_period = hists->stats.total_period;
-
-        for (nd = rb_first(&hists->entries); nd; nd = rb_next(nd)) {
-                struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
-
-                if (h->filtered)
-                        continue;
-
-                if (show_displacement) {
-                        if (h->pair != NULL)
-                                displacement = ((long)h->pair->position -
-                                                (long)position);
-                        else
-                                displacement = 0;
-                        ++position;
-                }
-                ret += hist_entry__fprintf(h, max_cols, hists, pair, show_displacement,
-                                           displacement, total_period, fp);
-
-                if (symbol_conf.use_callchain)
-                        ret += hist_entry__fprintf_callchain(h, hists, total_period, fp);
-                if (max_rows && ++nr_rows >= max_rows)
-                        goto out;
-
-                if (h->ms.map == NULL && verbose > 1) {
-                        __map_groups__fprintf_maps(&h->thread->mg,
-                                                   MAP__FUNCTION, verbose, fp);
-                        fprintf(fp, "%.10s end\n", graph_dotted_line);
-                }
-        }
-out:
-        free(rem_sq_bracket);
-
-        return ret;
-}
-
-/*
- * See hists__fprintf to match the column widths
- */
-unsigned int hists__sort_list_width(struct hists *hists)
-{
-        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;
-
-        if (symbol_conf.show_total_period)
-                ret += 13;
-
-        list_for_each_entry(se, &hist_entry__sort_list, list)
-                if (!se->elide)
-                        ret += 2 + hists__col_len(hists, se->se_width_idx);
-
-        if (verbose) /* Addr + origin */
-                ret += 3 + BITS_PER_LONG / 4;
-
-        return ret;
-}
-
 static void hists__remove_entry_filter(struct hists *hists, struct hist_entry *h,
                                        enum hist_filter filter)
 {
@@ -1342,25 +695,3 @@ void hists__inc_nr_events(struct hists *hists, u32 type)
         ++hists->stats.nr_events[0];
         ++hists->stats.nr_events[type];
 }
-
-size_t hists__fprintf_nr_events(struct hists *hists, FILE *fp)
-{
-        int i;
-        size_t ret = 0;
-
-        for (i = 0; i < PERF_RECORD_HEADER_MAX; ++i) {
-                const char *name;
-
-                if (hists->stats.nr_events[i] == 0)
-                        continue;
-
-                name = perf_event__name(i);
-                if (!strcmp(name, "UNKNOWN"))
-                        continue;
-
-                ret += fprintf(fp, "%16s events: %10d\n", name,
-                               hists->stats.nr_events[i]);
-        }
-
-        return ret;
-}
diff --git a/tools/perf/util/hist.h b/tools/perf/util/hist.h
index 0b096c27a419..f011ad4756e8 100644
--- a/tools/perf/util/hist.h
+++ b/tools/perf/util/hist.h
@@ -75,8 +75,8 @@ struct hist_entry *__hists__add_entry(struct hists *self,
                                       struct symbol *parent, u64 period);
 int64_t hist_entry__cmp(struct hist_entry *left, struct hist_entry *right);
 int64_t hist_entry__collapse(struct hist_entry *left, struct hist_entry *right);
-int hist_entry__snprintf(struct hist_entry *self, char *bf, size_t size,
-                         struct hists *hists);
+int hist_entry__sort_snprintf(struct hist_entry *self, char *bf, size_t size,
+                              struct hists *hists);
 void hist_entry__free(struct hist_entry *);
 
 struct hist_entry *__hists__add_branch_entry(struct hists *self,
@@ -112,25 +112,66 @@ void hists__filter_by_symbol(struct hists *hists);
 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);
+void hists__reset_col_len(struct hists *hists);
+void hists__calc_col_len(struct hists *hists, struct hist_entry *he);
+
+struct perf_hpp {
+        char *buf;
+        size_t size;
+        u64 total_period;
+        const char *sep;
+        long displacement;
+        void *ptr;
+};
+
+struct perf_hpp_fmt {
+        bool cond;
+        int (*header)(struct perf_hpp *hpp);
+        int (*width)(struct perf_hpp *hpp);
+        int (*color)(struct perf_hpp *hpp, struct hist_entry *he);
+        int (*entry)(struct perf_hpp *hpp, struct hist_entry *he);
+};
+
+extern struct perf_hpp_fmt perf_hpp__format[];
+
+enum {
+        PERF_HPP__OVERHEAD,
+        PERF_HPP__OVERHEAD_SYS,
+        PERF_HPP__OVERHEAD_US,
+        PERF_HPP__OVERHEAD_GUEST_SYS,
+        PERF_HPP__OVERHEAD_GUEST_US,
+        PERF_HPP__SAMPLES,
+        PERF_HPP__PERIOD,
+        PERF_HPP__DELTA,
+        PERF_HPP__DISPL,
+
+        PERF_HPP__MAX_INDEX
+};
+
+void perf_hpp__init(bool need_pair, bool show_displacement);
+int hist_entry__period_snprintf(struct perf_hpp *hpp, struct hist_entry *he,
+                                bool color);
 
 struct perf_evlist;
 
 #ifdef NO_NEWT_SUPPORT
 static inline
-int perf_evlist__tui_browse_hists(struct perf_evlist *evlist __used,
-                                  const char *help __used,
-                                  void(*timer)(void *arg) __used,
-                                  void *arg __used,
-                                  int refresh __used)
+int perf_evlist__tui_browse_hists(struct perf_evlist *evlist __maybe_unused,
+                                  const char *help __maybe_unused,
+                                  void(*timer)(void *arg) __maybe_unused,
+                                  void *arg __maybe_unused,
+                                  int refresh __maybe_unused)
 {
         return 0;
 }
 
-static inline int hist_entry__tui_annotate(struct hist_entry *self __used,
-                                           int evidx __used,
-                                           void(*timer)(void *arg) __used,
-                                           void *arg __used,
-                                           int delay_secs __used)
+static inline int hist_entry__tui_annotate(struct hist_entry *self
+                                           __maybe_unused,
+                                           int evidx __maybe_unused,
+                                           void(*timer)(void *arg)
+                                           __maybe_unused,
+                                           void *arg __maybe_unused,
+                                           int delay_secs __maybe_unused)
 {
         return 0;
 }
@@ -148,11 +189,11 @@ int perf_evlist__tui_browse_hists(struct perf_evlist *evlist, const char *help,
 
 #ifdef NO_GTK2_SUPPORT
 static inline
-int perf_evlist__gtk_browse_hists(struct perf_evlist *evlist __used,
-                                  const char *help __used,
-                                  void(*timer)(void *arg) __used,
-                                  void *arg __used,
-                                  int refresh __used)
+int perf_evlist__gtk_browse_hists(struct perf_evlist *evlist __maybe_unused,
+                                  const char *help __maybe_unused,
+                                  void(*timer)(void *arg) __maybe_unused,
+                                  void *arg __maybe_unused,
+                                  int refresh __maybe_unused)
 {
         return 0;
 }
diff --git a/tools/perf/util/include/linux/bitops.h b/tools/perf/util/include/linux/bitops.h
index 587a230d2075..a55d8cf083c9 100644
--- a/tools/perf/util/include/linux/bitops.h
+++ b/tools/perf/util/include/linux/bitops.h
@@ -5,6 +5,10 @@
 #include <linux/compiler.h>
 #include <asm/hweight.h>
 
+#ifndef __WORDSIZE
+#define __WORDSIZE (__SIZEOF_LONG__ * 8)
+#endif
+
 #define BITS_PER_LONG __WORDSIZE
 #define BITS_PER_BYTE           8
 #define BITS_TO_LONGS(nr)       DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(long))
diff --git a/tools/perf/util/include/linux/compiler.h b/tools/perf/util/include/linux/compiler.h
index 547628e97f3d..96b919dae11c 100644
--- a/tools/perf/util/include/linux/compiler.h
+++ b/tools/perf/util/include/linux/compiler.h
@@ -9,6 +9,13 @@
 #define __attribute_const__
 #endif
 
-#define __used          __attribute__((__unused__))
+#ifndef __maybe_unused
+#define __maybe_unused          __attribute__((unused))
+#endif
+#define __packed        __attribute__((__packed__))
+
+#ifndef __force
+#define __force
+#endif
 
 #endif
diff --git a/tools/perf/util/include/linux/kernel.h b/tools/perf/util/include/linux/kernel.h
index b6842c1d02a8..d8c927c868ee 100644
--- a/tools/perf/util/include/linux/kernel.h
+++ b/tools/perf/util/include/linux/kernel.h
@@ -8,8 +8,8 @@
 
 #define DIV_ROUND_UP(n,d) (((n) + (d) - 1) / (d))
 
-#define ALIGN(x,a)              __ALIGN_MASK(x,(typeof(x))(a)-1)
-#define __ALIGN_MASK(x,mask)    (((x)+(mask))&~(mask))
+#define PERF_ALIGN(x, a)        __PERF_ALIGN_MASK(x, (typeof(x))(a)-1)
+#define __PERF_ALIGN_MASK(x, mask)      (((x)+(mask))&~(mask))
 
 #ifndef offsetof
 #define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
@@ -46,9 +46,22 @@
         _min1 < _min2 ? _min1 : _min2; })
 #endif
 
+#ifndef roundup
+#define roundup(x, y) (                                \
+{                                                      \
+        const typeof(y) __y = y;                       \
+        (((x) + (__y - 1)) / __y) * __y;               \
+}                                                      \
+)
+#endif
+
 #ifndef BUG_ON
+#ifdef NDEBUG
+#define BUG_ON(cond) do { if (cond) {} } while (0)
+#else
 #define BUG_ON(cond) assert(!(cond))
 #endif
+#endif
 
 /*
  * Both need more care to handle endianness
diff --git a/tools/perf/util/include/linux/magic.h b/tools/perf/util/include/linux/magic.h
new file mode 100644
index 000000000000..58b64ed4da12
--- /dev/null
+++ b/tools/perf/util/include/linux/magic.h
@@ -0,0 +1,12 @@
+#ifndef _PERF_LINUX_MAGIC_H_
+#define _PERF_LINUX_MAGIC_H_
+
+#ifndef DEBUGFS_MAGIC
+#define DEBUGFS_MAGIC          0x64626720
+#endif
+
+#ifndef SYSFS_MAGIC
+#define SYSFS_MAGIC            0x62656572
+#endif
+
+#endif
diff --git a/tools/perf/util/include/linux/rbtree.h b/tools/perf/util/include/linux/rbtree.h
index 7a243a143037..2a030c5af3aa 100644
--- a/tools/perf/util/include/linux/rbtree.h
+++ b/tools/perf/util/include/linux/rbtree.h
@@ -1 +1,2 @@
+#include <stdbool.h>
 #include "../../../../include/linux/rbtree.h"
diff --git a/tools/perf/util/include/linux/string.h b/tools/perf/util/include/linux/string.h
index 3b2f5900276f..6f19c548ecc0 100644
--- a/tools/perf/util/include/linux/string.h
+++ b/tools/perf/util/include/linux/string.h
@@ -1 +1,3 @@
 #include <string.h>
+
+void *memdup(const void *src, size_t len);
diff --git a/tools/perf/util/include/linux/types.h b/tools/perf/util/include/linux/types.h
index 12de3b8112f9..eb464786c084 100644
--- a/tools/perf/util/include/linux/types.h
+++ b/tools/perf/util/include/linux/types.h
@@ -3,6 +3,14 @@
 
 #include <asm/types.h>
 
+#ifndef __bitwise
+#define __bitwise
+#endif
+
+#ifndef __le32
+typedef __u32 __bitwise __le32;
+#endif
+
 #define DECLARE_BITMAP(name,bits) \
         unsigned long name[BITS_TO_LONGS(bits)]
 
diff --git a/tools/perf/util/intlist.c b/tools/perf/util/intlist.c
index fd530dced9cb..9d0740024ba8 100644
--- a/tools/perf/util/intlist.c
+++ b/tools/perf/util/intlist.c
@@ -11,7 +11,7 @@
 
 #include "intlist.h"
 
-static struct rb_node *intlist__node_new(struct rblist *rblist __used,
+static struct rb_node *intlist__node_new(struct rblist *rblist __maybe_unused,
                                          const void *entry)
 {
         int i = (int)((long)entry);
@@ -31,7 +31,7 @@ static void int_node__delete(struct int_node *ilist)
         free(ilist);
 }
 
-static void intlist__node_delete(struct rblist *rblist __used,
+static void intlist__node_delete(struct rblist *rblist __maybe_unused,
                                  struct rb_node *rb_node)
 {
         struct int_node *node = container_of(rb_node, struct int_node, rb_node);
@@ -52,9 +52,9 @@ int intlist__add(struct intlist *ilist, int i)
         return rblist__add_node(&ilist->rblist, (void *)((long)i));
 }
 
-void intlist__remove(struct intlist *ilist __used, struct int_node *node)
+void intlist__remove(struct intlist *ilist, struct int_node *node)
 {
-        int_node__delete(node);
+        rblist__remove_node(&ilist->rblist, &node->rb_node);
 }
 
 struct int_node *intlist__find(struct intlist *ilist, int i)
diff --git a/tools/perf/util/map.c b/tools/perf/util/map.c
index cc33486ad9e2..ead5316b3f89 100644
--- a/tools/perf/util/map.c
+++ b/tools/perf/util/map.c
@@ -9,6 +9,7 @@
 #include "map.h"
 #include "thread.h"
 #include "strlist.h"
+#include "vdso.h"
 
 const char *map_type__name[MAP__NR_TYPES] = {
         [MAP__FUNCTION] = "Functions",
@@ -23,7 +24,6 @@ static inline int is_anon_memory(const char *filename)
 static inline int is_no_dso_memory(const char *filename)
 {
         return !strcmp(filename, "[stack]") ||
-               !strcmp(filename, "[vdso]")  ||
                !strcmp(filename, "[heap]");
 }
 
@@ -52,9 +52,10 @@ struct map *map__new(struct list_head *dsos__list, u64 start, u64 len,
         if (self != NULL) {
                 char newfilename[PATH_MAX];
                 struct dso *dso;
-                int anon, no_dso;
+                int anon, no_dso, vdso;
 
                 anon = is_anon_memory(filename);
+                vdso = is_vdso_map(filename);
                 no_dso = is_no_dso_memory(filename);
 
                 if (anon) {
@@ -62,7 +63,12 @@ struct map *map__new(struct list_head *dsos__list, u64 start, u64 len,
                         filename = newfilename;
                 }
 
-                dso = __dsos__findnew(dsos__list, filename);
+                if (vdso) {
+                        pgoff = 0;
+                        dso = vdso__dso_findnew(dsos__list);
+                } else
+                        dso = __dsos__findnew(dsos__list, filename);
+
                 if (dso == NULL)
                         goto out_delete;
 
@@ -86,6 +92,25 @@ out_delete:
         return NULL;
 }
 
+/*
+ * Constructor variant for modules (where we know from /proc/modules where
+ * they are loaded) and for vmlinux, where only after we load all the
+ * symbols we'll know where it starts and ends.
+ */
+struct map *map__new2(u64 start, struct dso *dso, enum map_type type)
+{
+        struct map *map = calloc(1, (sizeof(*map) +
+                                     (dso->kernel ? sizeof(struct kmap) : 0)));
+        if (map != NULL) {
+                /*
+                 * ->end will be filled after we load all the symbols
+                 */
+                map__init(map, type, start, 0, 0, dso);
+        }
+
+        return map;
+}
+
 void map__delete(struct map *self)
 {
         free(self);
@@ -137,6 +162,7 @@ int map__load(struct map *self, symbol_filter_t filter)
                 pr_warning(", continuing without symbols\n");
                 return -1;
         } else if (nr == 0) {
+#ifndef NO_LIBELF_SUPPORT
                 const size_t len = strlen(name);
                 const size_t real_len = len - sizeof(DSO__DELETED);
 
@@ -149,7 +175,7 @@ int map__load(struct map *self, symbol_filter_t filter)
                         pr_warning("no symbols found in %s, maybe install "
                                    "a debug package?\n", name);
                 }
-
+#endif
                 return -1;
         }
         /*
@@ -217,15 +243,14 @@ size_t map__fprintf(struct map *self, FILE *fp)
 
 size_t map__fprintf_dsoname(struct map *map, FILE *fp)
 {
-        const char *dsoname;
+        const char *dsoname = "[unknown]";
 
         if (map && map->dso && (map->dso->name || map->dso->long_name)) {
                 if (symbol_conf.show_kernel_path && map->dso->long_name)
                         dsoname = map->dso->long_name;
                 else if (map->dso->name)
                         dsoname = map->dso->name;
-        } else
-                dsoname = "[unknown]";
+        }
 
         return fprintf(fp, "%s", dsoname);
 }
@@ -242,14 +267,6 @@ u64 map__rip_2objdump(struct map *map, u64 rip)
         return addr;
 }
 
-u64 map__objdump_2ip(struct map *map, u64 addr)
-{
-        u64 ip = map->dso->adjust_symbols ?
-                        addr :
-                        map->unmap_ip(map, addr);       /* RIP -> IP */
-        return ip;
-}
-
 void map_groups__init(struct map_groups *mg)
 {
         int i;
diff --git a/tools/perf/util/map.h b/tools/perf/util/map.h
index 03a1e9b08b21..d2250fc97e25 100644
--- a/tools/perf/util/map.h
+++ b/tools/perf/util/map.h
@@ -96,7 +96,7 @@ static inline u64 map__unmap_ip(struct map *map, u64 ip)
         return ip + map->start - map->pgoff;
 }
 
-static inline u64 identity__map_ip(struct map *map __used, u64 ip)
+static inline u64 identity__map_ip(struct map *map __maybe_unused, u64 ip)
 {
         return ip;
 }
@@ -104,7 +104,6 @@ static inline u64 identity__map_ip(struct map *map __used, u64 ip)
 
 /* rip/ip <-> addr suitable for passing to `objdump --start-address=` */
 u64 map__rip_2objdump(struct map *map, u64 rip);
-u64 map__objdump_2ip(struct map *map, u64 addr);
 
 struct symbol;
 
@@ -115,6 +114,7 @@ void map__init(struct map *self, enum map_type type,
 struct map *map__new(struct list_head *dsos__list, u64 start, u64 len,
                      u64 pgoff, u32 pid, char *filename,
                      enum map_type type);
+struct map *map__new2(u64 start, struct dso *dso, 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);
@@ -157,9 +157,12 @@ 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);
 
+struct perf_evsel;
+struct perf_sample;
 int machine__resolve_callchain(struct machine *machine,
+                               struct perf_evsel *evsel,
                                struct thread *thread,
-                               struct ip_callchain *chain,
+                               struct perf_sample *sample,
                                struct symbol **parent);
 int maps__set_kallsyms_ref_reloc_sym(struct map **maps, const char *symbol_name,
                                      u64 addr);
diff --git a/tools/perf/util/parse-events-test.c b/tools/perf/util/parse-events-test.c
index 127d648cc548..28c18d1d52c3 100644
--- a/tools/perf/util/parse-events-test.c
+++ b/tools/perf/util/parse-events-test.c
@@ -18,8 +18,7 @@ do { \
 
 static int test__checkevent_tracepoint(struct perf_evlist *evlist)
 {
-        struct perf_evsel *evsel = list_entry(evlist->entries.next,
-                                              struct perf_evsel, node);
+        struct perf_evsel *evsel = perf_evlist__first(evlist);
 
         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->nr_entries);
         TEST_ASSERT_VAL("wrong type", PERF_TYPE_TRACEPOINT == evsel->attr.type);
@@ -48,8 +47,7 @@ static int test__checkevent_tracepoint_multi(struct perf_evlist *evlist)
 
 static int test__checkevent_raw(struct perf_evlist *evlist)
 {
-        struct perf_evsel *evsel = list_entry(evlist->entries.next,
-                                              struct perf_evsel, node);
+        struct perf_evsel *evsel = perf_evlist__first(evlist);
 
         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->nr_entries);
         TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->attr.type);
@@ -59,8 +57,7 @@ static int test__checkevent_raw(struct perf_evlist *evlist)
 
 static int test__checkevent_numeric(struct perf_evlist *evlist)
 {
-        struct perf_evsel *evsel = list_entry(evlist->entries.next,
-                                              struct perf_evsel, node);
+        struct perf_evsel *evsel = perf_evlist__first(evlist);
 
         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->nr_entries);
         TEST_ASSERT_VAL("wrong type", 1 == evsel->attr.type);
@@ -70,8 +67,7 @@ static int test__checkevent_numeric(struct perf_evlist *evlist)
 
 static int test__checkevent_symbolic_name(struct perf_evlist *evlist)
 {
-        struct perf_evsel *evsel = list_entry(evlist->entries.next,
-                                              struct perf_evsel, node);
+        struct perf_evsel *evsel = perf_evlist__first(evlist);
 
         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->nr_entries);
         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->attr.type);
@@ -82,8 +78,7 @@ static int test__checkevent_symbolic_name(struct perf_evlist *evlist)
 
 static int test__checkevent_symbolic_name_config(struct perf_evlist *evlist)
 {
-        struct perf_evsel *evsel = list_entry(evlist->entries.next,
-                                              struct perf_evsel, node);
+        struct perf_evsel *evsel = perf_evlist__first(evlist);
 
         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->nr_entries);
         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->attr.type);
@@ -100,8 +95,7 @@ static int test__checkevent_symbolic_name_config(struct perf_evlist *evlist)
 
 static int test__checkevent_symbolic_alias(struct perf_evlist *evlist)
 {
-        struct perf_evsel *evsel = list_entry(evlist->entries.next,
-                                              struct perf_evsel, node);
+        struct perf_evsel *evsel = perf_evlist__first(evlist);
 
         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->nr_entries);
         TEST_ASSERT_VAL("wrong type", PERF_TYPE_SOFTWARE == evsel->attr.type);
@@ -112,8 +106,7 @@ static int test__checkevent_symbolic_alias(struct perf_evlist *evlist)
 
 static int test__checkevent_genhw(struct perf_evlist *evlist)
 {
-        struct perf_evsel *evsel = list_entry(evlist->entries.next,
-                                              struct perf_evsel, node);
+        struct perf_evsel *evsel = perf_evlist__first(evlist);
 
         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->nr_entries);
         TEST_ASSERT_VAL("wrong type", PERF_TYPE_HW_CACHE == evsel->attr.type);
@@ -123,8 +116,7 @@ static int test__checkevent_genhw(struct perf_evlist *evlist)
 
 static int test__checkevent_breakpoint(struct perf_evlist *evlist)
 {
-        struct perf_evsel *evsel = list_entry(evlist->entries.next,
-                                              struct perf_evsel, node);
+        struct perf_evsel *evsel = perf_evlist__first(evlist);
 
         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->nr_entries);
         TEST_ASSERT_VAL("wrong type", PERF_TYPE_BREAKPOINT == evsel->attr.type);
@@ -138,8 +130,7 @@ static int test__checkevent_breakpoint(struct perf_evlist *evlist)
 
 static int test__checkevent_breakpoint_x(struct perf_evlist *evlist)
 {
-        struct perf_evsel *evsel = list_entry(evlist->entries.next,
-                                              struct perf_evsel, node);
+        struct perf_evsel *evsel = perf_evlist__first(evlist);
 
         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->nr_entries);
         TEST_ASSERT_VAL("wrong type", PERF_TYPE_BREAKPOINT == evsel->attr.type);
@@ -152,8 +143,7 @@ static int test__checkevent_breakpoint_x(struct perf_evlist *evlist)
 
 static int test__checkevent_breakpoint_r(struct perf_evlist *evlist)
 {
-        struct perf_evsel *evsel = list_entry(evlist->entries.next,
-                                              struct perf_evsel, node);
+        struct perf_evsel *evsel = perf_evlist__first(evlist);
 
         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->nr_entries);
         TEST_ASSERT_VAL("wrong type",
@@ -168,8 +158,7 @@ static int test__checkevent_breakpoint_r(struct perf_evlist *evlist)
 
 static int test__checkevent_breakpoint_w(struct perf_evlist *evlist)
 {
-        struct perf_evsel *evsel = list_entry(evlist->entries.next,
-                                              struct perf_evsel, node);
+        struct perf_evsel *evsel = perf_evlist__first(evlist);
 
         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->nr_entries);
         TEST_ASSERT_VAL("wrong type",
@@ -184,8 +173,7 @@ static int test__checkevent_breakpoint_w(struct perf_evlist *evlist)
 
 static int test__checkevent_breakpoint_rw(struct perf_evlist *evlist)
 {
-        struct perf_evsel *evsel = list_entry(evlist->entries.next,
-                                              struct perf_evsel, node);
+        struct perf_evsel *evsel = perf_evlist__first(evlist);
 
         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->nr_entries);
         TEST_ASSERT_VAL("wrong type",
@@ -200,8 +188,7 @@ static int test__checkevent_breakpoint_rw(struct perf_evlist *evlist)
 
 static int test__checkevent_tracepoint_modifier(struct perf_evlist *evlist)
 {
-        struct perf_evsel *evsel = list_entry(evlist->entries.next,
-                                              struct perf_evsel, node);
+        struct perf_evsel *evsel = perf_evlist__first(evlist);
 
         TEST_ASSERT_VAL("wrong exclude_user", evsel->attr.exclude_user);
         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->attr.exclude_kernel);
@@ -232,8 +219,7 @@ test__checkevent_tracepoint_multi_modifier(struct perf_evlist *evlist)
 
 static int test__checkevent_raw_modifier(struct perf_evlist *evlist)
 {
-        struct perf_evsel *evsel = list_entry(evlist->entries.next,
-                                              struct perf_evsel, node);
+        struct perf_evsel *evsel = perf_evlist__first(evlist);
 
         TEST_ASSERT_VAL("wrong exclude_user", evsel->attr.exclude_user);
         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->attr.exclude_kernel);
@@ -245,8 +231,7 @@ static int test__checkevent_raw_modifier(struct perf_evlist *evlist)
 
 static int test__checkevent_numeric_modifier(struct perf_evlist *evlist)
 {
-        struct perf_evsel *evsel = list_entry(evlist->entries.next,
-                                              struct perf_evsel, node);
+        struct perf_evsel *evsel = perf_evlist__first(evlist);
 
         TEST_ASSERT_VAL("wrong exclude_user", evsel->attr.exclude_user);
         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->attr.exclude_kernel);
@@ -258,8 +243,7 @@ static int test__checkevent_numeric_modifier(struct perf_evlist *evlist)
 
 static int test__checkevent_symbolic_name_modifier(struct perf_evlist *evlist)
 {
-        struct perf_evsel *evsel = list_entry(evlist->entries.next,
-                                              struct perf_evsel, node);
+        struct perf_evsel *evsel = perf_evlist__first(evlist);
 
         TEST_ASSERT_VAL("wrong exclude_user", evsel->attr.exclude_user);
         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->attr.exclude_kernel);
@@ -271,8 +255,7 @@ static int test__checkevent_symbolic_name_modifier(struct perf_evlist *evlist)
 
 static int test__checkevent_exclude_host_modifier(struct perf_evlist *evlist)
 {
-        struct perf_evsel *evsel = list_entry(evlist->entries.next,
-                                              struct perf_evsel, node);
+        struct perf_evsel *evsel = perf_evlist__first(evlist);
 
         TEST_ASSERT_VAL("wrong exclude guest", !evsel->attr.exclude_guest);
         TEST_ASSERT_VAL("wrong exclude host", evsel->attr.exclude_host);
@@ -282,8 +265,7 @@ static int test__checkevent_exclude_host_modifier(struct perf_evlist *evlist)
 
 static int test__checkevent_exclude_guest_modifier(struct perf_evlist *evlist)
 {
-        struct perf_evsel *evsel = list_entry(evlist->entries.next,
-                                              struct perf_evsel, node);
+        struct perf_evsel *evsel = perf_evlist__first(evlist);
 
         TEST_ASSERT_VAL("wrong exclude guest", evsel->attr.exclude_guest);
         TEST_ASSERT_VAL("wrong exclude host", !evsel->attr.exclude_host);
@@ -293,8 +275,7 @@ static int test__checkevent_exclude_guest_modifier(struct perf_evlist *evlist)
 
 static int test__checkevent_symbolic_alias_modifier(struct perf_evlist *evlist)
 {
-        struct perf_evsel *evsel = list_entry(evlist->entries.next,
-                                              struct perf_evsel, node);
+        struct perf_evsel *evsel = perf_evlist__first(evlist);
 
         TEST_ASSERT_VAL("wrong exclude_user", !evsel->attr.exclude_user);
         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->attr.exclude_kernel);
@@ -306,8 +287,7 @@ static int test__checkevent_symbolic_alias_modifier(struct perf_evlist *evlist)
 
 static int test__checkevent_genhw_modifier(struct perf_evlist *evlist)
 {
-        struct perf_evsel *evsel = list_entry(evlist->entries.next,
-                                              struct perf_evsel, node);
+        struct perf_evsel *evsel = perf_evlist__first(evlist);
 
         TEST_ASSERT_VAL("wrong exclude_user", evsel->attr.exclude_user);
         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->attr.exclude_kernel);
@@ -319,75 +299,71 @@ static int test__checkevent_genhw_modifier(struct perf_evlist *evlist)
 
 static int test__checkevent_breakpoint_modifier(struct perf_evlist *evlist)
 {
-        struct perf_evsel *evsel = list_entry(evlist->entries.next,
-                                              struct perf_evsel, node);
+        struct perf_evsel *evsel = perf_evlist__first(evlist);
+
 
         TEST_ASSERT_VAL("wrong exclude_user", !evsel->attr.exclude_user);
         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->attr.exclude_kernel);
         TEST_ASSERT_VAL("wrong exclude_hv", evsel->attr.exclude_hv);
         TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
         TEST_ASSERT_VAL("wrong name",
-                        !strcmp(perf_evsel__name(evsel), "mem:0x0:rw:u"));
+                        !strcmp(perf_evsel__name(evsel), "mem:0:u"));
 
         return test__checkevent_breakpoint(evlist);
 }
 
 static int test__checkevent_breakpoint_x_modifier(struct perf_evlist *evlist)
 {
-        struct perf_evsel *evsel = list_entry(evlist->entries.next,
-                                              struct perf_evsel, node);
+        struct perf_evsel *evsel = perf_evlist__first(evlist);
 
         TEST_ASSERT_VAL("wrong exclude_user", evsel->attr.exclude_user);
         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->attr.exclude_kernel);
         TEST_ASSERT_VAL("wrong exclude_hv", evsel->attr.exclude_hv);
         TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
         TEST_ASSERT_VAL("wrong name",
-                        !strcmp(perf_evsel__name(evsel), "mem:0x0:x:k"));
+                        !strcmp(perf_evsel__name(evsel), "mem:0:x:k"));
 
         return test__checkevent_breakpoint_x(evlist);
 }
 
 static int test__checkevent_breakpoint_r_modifier(struct perf_evlist *evlist)
 {
-        struct perf_evsel *evsel = list_entry(evlist->entries.next,
-                                              struct perf_evsel, node);
+        struct perf_evsel *evsel = perf_evlist__first(evlist);
 
         TEST_ASSERT_VAL("wrong exclude_user", evsel->attr.exclude_user);
         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->attr.exclude_kernel);
         TEST_ASSERT_VAL("wrong exclude_hv", !evsel->attr.exclude_hv);
         TEST_ASSERT_VAL("wrong precise_ip", evsel->attr.precise_ip);
         TEST_ASSERT_VAL("wrong name",
-                        !strcmp(perf_evsel__name(evsel), "mem:0x0:r:hp"));
+                        !strcmp(perf_evsel__name(evsel), "mem:0:r:hp"));
 
         return test__checkevent_breakpoint_r(evlist);
 }
 
 static int test__checkevent_breakpoint_w_modifier(struct perf_evlist *evlist)
 {
-        struct perf_evsel *evsel = list_entry(evlist->entries.next,
-                                              struct perf_evsel, node);
+        struct perf_evsel *evsel = perf_evlist__first(evlist);
 
         TEST_ASSERT_VAL("wrong exclude_user", !evsel->attr.exclude_user);
         TEST_ASSERT_VAL("wrong exclude_kernel", evsel->attr.exclude_kernel);
         TEST_ASSERT_VAL("wrong exclude_hv", evsel->attr.exclude_hv);
         TEST_ASSERT_VAL("wrong precise_ip", evsel->attr.precise_ip);
         TEST_ASSERT_VAL("wrong name",
-                        !strcmp(perf_evsel__name(evsel), "mem:0x0:w:up"));
+                        !strcmp(perf_evsel__name(evsel), "mem:0:w:up"));
 
         return test__checkevent_breakpoint_w(evlist);
 }
 
 static int test__checkevent_breakpoint_rw_modifier(struct perf_evlist *evlist)
 {
-        struct perf_evsel *evsel = list_entry(evlist->entries.next,
-                                              struct perf_evsel, node);
+        struct perf_evsel *evsel = perf_evlist__first(evlist);
 
         TEST_ASSERT_VAL("wrong exclude_user", evsel->attr.exclude_user);
         TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->attr.exclude_kernel);
         TEST_ASSERT_VAL("wrong exclude_hv", evsel->attr.exclude_hv);
         TEST_ASSERT_VAL("wrong precise_ip", evsel->attr.precise_ip);
         TEST_ASSERT_VAL("wrong name",
-                        !strcmp(perf_evsel__name(evsel), "mem:0x0:rw:kp"));
+                        !strcmp(perf_evsel__name(evsel), "mem:0:rw:kp"));
 
         return test__checkevent_breakpoint_rw(evlist);
 }
@@ -395,8 +371,7 @@ static int test__checkevent_breakpoint_rw_modifier(struct perf_evlist *evlist)
 static int test__checkevent_pmu(struct perf_evlist *evlist)
 {
 
-        struct perf_evsel *evsel = list_entry(evlist->entries.next,
-                                              struct perf_evsel, node);
+        struct perf_evsel *evsel = perf_evlist__first(evlist);
 
         TEST_ASSERT_VAL("wrong number of entries", 1 == evlist->nr_entries);
         TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->attr.type);
@@ -410,12 +385,11 @@ static int test__checkevent_pmu(struct perf_evlist *evlist)
 
 static int test__checkevent_list(struct perf_evlist *evlist)
 {
-        struct perf_evsel *evsel;
+        struct perf_evsel *evsel = perf_evlist__first(evlist);
 
         TEST_ASSERT_VAL("wrong number of entries", 3 == evlist->nr_entries);
 
         /* r1 */
-        evsel = list_entry(evlist->entries.next, struct perf_evsel, node);
         TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->attr.type);
         TEST_ASSERT_VAL("wrong config", 1 == evsel->attr.config);
         TEST_ASSERT_VAL("wrong config1", 0 == evsel->attr.config1);
@@ -426,7 +400,7 @@ static int test__checkevent_list(struct perf_evlist *evlist)
         TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
 
         /* syscalls:sys_enter_open:k */
-        evsel = list_entry(evsel->node.next, struct perf_evsel, node);
+        evsel = perf_evsel__next(evsel);
         TEST_ASSERT_VAL("wrong type", PERF_TYPE_TRACEPOINT == evsel->attr.type);
         TEST_ASSERT_VAL("wrong sample_type",
                 PERF_TP_SAMPLE_TYPE == evsel->attr.sample_type);
@@ -437,7 +411,7 @@ static int test__checkevent_list(struct perf_evlist *evlist)
         TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
 
         /* 1:1:hp */
-        evsel = list_entry(evsel->node.next, struct perf_evsel, node);
+        evsel = perf_evsel__next(evsel);
         TEST_ASSERT_VAL("wrong type", 1 == evsel->attr.type);
         TEST_ASSERT_VAL("wrong config", 1 == evsel->attr.config);
         TEST_ASSERT_VAL("wrong exclude_user", evsel->attr.exclude_user);
@@ -450,22 +424,21 @@ static int test__checkevent_list(struct perf_evlist *evlist)
 
 static int test__checkevent_pmu_name(struct perf_evlist *evlist)
 {
-        struct perf_evsel *evsel;
+        struct perf_evsel *evsel = perf_evlist__first(evlist);
 
         /* cpu/config=1,name=krava/u */
-        evsel = list_entry(evlist->entries.next, struct perf_evsel, node);
         TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->nr_entries);
         TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->attr.type);
         TEST_ASSERT_VAL("wrong config",  1 == evsel->attr.config);
         TEST_ASSERT_VAL("wrong name", !strcmp(perf_evsel__name(evsel), "krava"));
 
         /* cpu/config=2/u" */
-        evsel = list_entry(evsel->node.next, struct perf_evsel, node);
+        evsel = perf_evsel__next(evsel);
         TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->nr_entries);
         TEST_ASSERT_VAL("wrong type", PERF_TYPE_RAW == evsel->attr.type);
         TEST_ASSERT_VAL("wrong config",  2 == evsel->attr.config);
         TEST_ASSERT_VAL("wrong name",
-                        !strcmp(perf_evsel__name(evsel), "raw 0x2:u"));
+                        !strcmp(perf_evsel__name(evsel), "cpu/config=2/u"));
 
         return 0;
 }
@@ -513,6 +486,280 @@ static int test__checkterms_simple(struct list_head *terms)
         return 0;
 }
 
+static int test__group1(struct perf_evlist *evlist)
+{
+        struct perf_evsel *evsel, *leader;
+
+        TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->nr_entries);
+
+        /* instructions:k */
+        evsel = leader = perf_evlist__first(evlist);
+        TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->attr.type);
+        TEST_ASSERT_VAL("wrong config",
+                        PERF_COUNT_HW_INSTRUCTIONS == evsel->attr.config);
+        TEST_ASSERT_VAL("wrong exclude_user", evsel->attr.exclude_user);
+        TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->attr.exclude_kernel);
+        TEST_ASSERT_VAL("wrong exclude_hv", evsel->attr.exclude_hv);
+        TEST_ASSERT_VAL("wrong exclude guest", !evsel->attr.exclude_guest);
+        TEST_ASSERT_VAL("wrong exclude host", !evsel->attr.exclude_host);
+        TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
+        TEST_ASSERT_VAL("wrong leader", evsel->leader == NULL);
+
+        /* cycles:upp */
+        evsel = perf_evsel__next(evsel);
+        TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->attr.type);
+        TEST_ASSERT_VAL("wrong config",
+                        PERF_COUNT_HW_CPU_CYCLES == evsel->attr.config);
+        TEST_ASSERT_VAL("wrong exclude_user", !evsel->attr.exclude_user);
+        TEST_ASSERT_VAL("wrong exclude_kernel", evsel->attr.exclude_kernel);
+        TEST_ASSERT_VAL("wrong exclude_hv", evsel->attr.exclude_hv);
+        TEST_ASSERT_VAL("wrong exclude guest", !evsel->attr.exclude_guest);
+        TEST_ASSERT_VAL("wrong exclude host", !evsel->attr.exclude_host);
+        TEST_ASSERT_VAL("wrong precise_ip", evsel->attr.precise_ip == 2);
+        TEST_ASSERT_VAL("wrong leader", evsel->leader == leader);
+
+        return 0;
+}
+
+static int test__group2(struct perf_evlist *evlist)
+{
+        struct perf_evsel *evsel, *leader;
+
+        TEST_ASSERT_VAL("wrong number of entries", 3 == evlist->nr_entries);
+
+        /* faults + :ku modifier */
+        evsel = leader = perf_evlist__first(evlist);
+        TEST_ASSERT_VAL("wrong type", PERF_TYPE_SOFTWARE == evsel->attr.type);
+        TEST_ASSERT_VAL("wrong config",
+                        PERF_COUNT_SW_PAGE_FAULTS == evsel->attr.config);
+        TEST_ASSERT_VAL("wrong exclude_user", !evsel->attr.exclude_user);
+        TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->attr.exclude_kernel);
+        TEST_ASSERT_VAL("wrong exclude_hv", evsel->attr.exclude_hv);
+        TEST_ASSERT_VAL("wrong exclude guest", !evsel->attr.exclude_guest);
+        TEST_ASSERT_VAL("wrong exclude host", !evsel->attr.exclude_host);
+        TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
+        TEST_ASSERT_VAL("wrong leader", evsel->leader == NULL);
+
+        /* cache-references + :u modifier */
+        evsel = perf_evsel__next(evsel);
+        TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->attr.type);
+        TEST_ASSERT_VAL("wrong config",
+                        PERF_COUNT_HW_CACHE_REFERENCES == evsel->attr.config);
+        TEST_ASSERT_VAL("wrong exclude_user", !evsel->attr.exclude_user);
+        TEST_ASSERT_VAL("wrong exclude_kernel", evsel->attr.exclude_kernel);
+        TEST_ASSERT_VAL("wrong exclude_hv", evsel->attr.exclude_hv);
+        TEST_ASSERT_VAL("wrong exclude guest", !evsel->attr.exclude_guest);
+        TEST_ASSERT_VAL("wrong exclude host", !evsel->attr.exclude_host);
+        TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
+        TEST_ASSERT_VAL("wrong leader", evsel->leader == leader);
+
+        /* cycles:k */
+        evsel = perf_evsel__next(evsel);
+        TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->attr.type);
+        TEST_ASSERT_VAL("wrong config",
+                        PERF_COUNT_HW_CPU_CYCLES == evsel->attr.config);
+        TEST_ASSERT_VAL("wrong exclude_user", evsel->attr.exclude_user);
+        TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->attr.exclude_kernel);
+        TEST_ASSERT_VAL("wrong exclude_hv", evsel->attr.exclude_hv);
+        TEST_ASSERT_VAL("wrong exclude guest", !evsel->attr.exclude_guest);
+        TEST_ASSERT_VAL("wrong exclude host", !evsel->attr.exclude_host);
+        TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
+        TEST_ASSERT_VAL("wrong leader", evsel->leader == NULL);
+
+        return 0;
+}
+
+static int test__group3(struct perf_evlist *evlist __maybe_unused)
+{
+        struct perf_evsel *evsel, *leader;
+
+        TEST_ASSERT_VAL("wrong number of entries", 5 == evlist->nr_entries);
+
+        /* group1 syscalls:sys_enter_open:H */
+        evsel = leader = perf_evlist__first(evlist);
+        TEST_ASSERT_VAL("wrong type", PERF_TYPE_TRACEPOINT == evsel->attr.type);
+        TEST_ASSERT_VAL("wrong sample_type",
+                PERF_TP_SAMPLE_TYPE == evsel->attr.sample_type);
+        TEST_ASSERT_VAL("wrong sample_period", 1 == evsel->attr.sample_period);
+        TEST_ASSERT_VAL("wrong exclude_user", !evsel->attr.exclude_user);
+        TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->attr.exclude_kernel);
+        TEST_ASSERT_VAL("wrong exclude_hv", !evsel->attr.exclude_hv);
+        TEST_ASSERT_VAL("wrong exclude guest", evsel->attr.exclude_guest);
+        TEST_ASSERT_VAL("wrong exclude host", !evsel->attr.exclude_host);
+        TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
+        TEST_ASSERT_VAL("wrong leader", evsel->leader == NULL);
+        TEST_ASSERT_VAL("wrong group name",
+                !strcmp(leader->group_name, "group1"));
+
+        /* group1 cycles:kppp */
+        evsel = perf_evsel__next(evsel);
+        TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->attr.type);
+        TEST_ASSERT_VAL("wrong config",
+                        PERF_COUNT_HW_CPU_CYCLES == evsel->attr.config);
+        TEST_ASSERT_VAL("wrong exclude_user", evsel->attr.exclude_user);
+        TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->attr.exclude_kernel);
+        TEST_ASSERT_VAL("wrong exclude_hv", evsel->attr.exclude_hv);
+        TEST_ASSERT_VAL("wrong exclude guest", !evsel->attr.exclude_guest);
+        TEST_ASSERT_VAL("wrong exclude host", !evsel->attr.exclude_host);
+        TEST_ASSERT_VAL("wrong precise_ip", evsel->attr.precise_ip == 3);
+        TEST_ASSERT_VAL("wrong leader", evsel->leader == leader);
+        TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
+
+        /* group2 cycles + G modifier */
+        evsel = leader = perf_evsel__next(evsel);
+        TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->attr.type);
+        TEST_ASSERT_VAL("wrong config",
+                        PERF_COUNT_HW_CPU_CYCLES == evsel->attr.config);
+        TEST_ASSERT_VAL("wrong exclude_user", !evsel->attr.exclude_user);
+        TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->attr.exclude_kernel);
+        TEST_ASSERT_VAL("wrong exclude_hv", !evsel->attr.exclude_hv);
+        TEST_ASSERT_VAL("wrong exclude guest", !evsel->attr.exclude_guest);
+        TEST_ASSERT_VAL("wrong exclude host", evsel->attr.exclude_host);
+        TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
+        TEST_ASSERT_VAL("wrong leader", evsel->leader == NULL);
+        TEST_ASSERT_VAL("wrong group name",
+                !strcmp(leader->group_name, "group2"));
+
+        /* group2 1:3 + G modifier */
+        evsel = perf_evsel__next(evsel);
+        TEST_ASSERT_VAL("wrong type", 1 == evsel->attr.type);
+        TEST_ASSERT_VAL("wrong config", 3 == evsel->attr.config);
+        TEST_ASSERT_VAL("wrong exclude_user", !evsel->attr.exclude_user);
+        TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->attr.exclude_kernel);
+        TEST_ASSERT_VAL("wrong exclude_hv", !evsel->attr.exclude_hv);
+        TEST_ASSERT_VAL("wrong exclude guest", !evsel->attr.exclude_guest);
+        TEST_ASSERT_VAL("wrong exclude host", evsel->attr.exclude_host);
+        TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
+        TEST_ASSERT_VAL("wrong leader", evsel->leader == leader);
+
+        /* instructions:u */
+        evsel = perf_evsel__next(evsel);
+        TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->attr.type);
+        TEST_ASSERT_VAL("wrong config",
+                        PERF_COUNT_HW_INSTRUCTIONS == evsel->attr.config);
+        TEST_ASSERT_VAL("wrong exclude_user", !evsel->attr.exclude_user);
+        TEST_ASSERT_VAL("wrong exclude_kernel", evsel->attr.exclude_kernel);
+        TEST_ASSERT_VAL("wrong exclude_hv", evsel->attr.exclude_hv);
+        TEST_ASSERT_VAL("wrong exclude guest", !evsel->attr.exclude_guest);
+        TEST_ASSERT_VAL("wrong exclude host", !evsel->attr.exclude_host);
+        TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
+        TEST_ASSERT_VAL("wrong leader", evsel->leader == NULL);
+
+        return 0;
+}
+
+static int test__group4(struct perf_evlist *evlist __maybe_unused)
+{
+        struct perf_evsel *evsel, *leader;
+
+        TEST_ASSERT_VAL("wrong number of entries", 2 == evlist->nr_entries);
+
+        /* cycles:u + p */
+        evsel = leader = perf_evlist__first(evlist);
+        TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->attr.type);
+        TEST_ASSERT_VAL("wrong config",
+                        PERF_COUNT_HW_CPU_CYCLES == evsel->attr.config);
+        TEST_ASSERT_VAL("wrong exclude_user", !evsel->attr.exclude_user);
+        TEST_ASSERT_VAL("wrong exclude_kernel", evsel->attr.exclude_kernel);
+        TEST_ASSERT_VAL("wrong exclude_hv", evsel->attr.exclude_hv);
+        TEST_ASSERT_VAL("wrong exclude guest", !evsel->attr.exclude_guest);
+        TEST_ASSERT_VAL("wrong exclude host", !evsel->attr.exclude_host);
+        TEST_ASSERT_VAL("wrong precise_ip", evsel->attr.precise_ip == 1);
+        TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
+        TEST_ASSERT_VAL("wrong leader", evsel->leader == NULL);
+
+        /* instructions:kp + p */
+        evsel = perf_evsel__next(evsel);
+        TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->attr.type);
+        TEST_ASSERT_VAL("wrong config",
+                        PERF_COUNT_HW_INSTRUCTIONS == evsel->attr.config);
+        TEST_ASSERT_VAL("wrong exclude_user", evsel->attr.exclude_user);
+        TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->attr.exclude_kernel);
+        TEST_ASSERT_VAL("wrong exclude_hv", evsel->attr.exclude_hv);
+        TEST_ASSERT_VAL("wrong exclude guest", !evsel->attr.exclude_guest);
+        TEST_ASSERT_VAL("wrong exclude host", !evsel->attr.exclude_host);
+        TEST_ASSERT_VAL("wrong precise_ip", evsel->attr.precise_ip == 2);
+        TEST_ASSERT_VAL("wrong leader", evsel->leader == leader);
+
+        return 0;
+}
+
+static int test__group5(struct perf_evlist *evlist __maybe_unused)
+{
+        struct perf_evsel *evsel, *leader;
+
+        TEST_ASSERT_VAL("wrong number of entries", 5 == evlist->nr_entries);
+
+        /* cycles + G */
+        evsel = leader = perf_evlist__first(evlist);
+        TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->attr.type);
+        TEST_ASSERT_VAL("wrong config",
+                        PERF_COUNT_HW_CPU_CYCLES == evsel->attr.config);
+        TEST_ASSERT_VAL("wrong exclude_user", !evsel->attr.exclude_user);
+        TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->attr.exclude_kernel);
+        TEST_ASSERT_VAL("wrong exclude_hv", !evsel->attr.exclude_hv);
+        TEST_ASSERT_VAL("wrong exclude guest", !evsel->attr.exclude_guest);
+        TEST_ASSERT_VAL("wrong exclude host", evsel->attr.exclude_host);
+        TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
+        TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
+        TEST_ASSERT_VAL("wrong leader", evsel->leader == NULL);
+
+        /* instructions + G */
+        evsel = perf_evsel__next(evsel);
+        TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->attr.type);
+        TEST_ASSERT_VAL("wrong config",
+                        PERF_COUNT_HW_INSTRUCTIONS == evsel->attr.config);
+        TEST_ASSERT_VAL("wrong exclude_user", !evsel->attr.exclude_user);
+        TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->attr.exclude_kernel);
+        TEST_ASSERT_VAL("wrong exclude_hv", !evsel->attr.exclude_hv);
+        TEST_ASSERT_VAL("wrong exclude guest", !evsel->attr.exclude_guest);
+        TEST_ASSERT_VAL("wrong exclude host", evsel->attr.exclude_host);
+        TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
+        TEST_ASSERT_VAL("wrong leader", evsel->leader == leader);
+
+        /* cycles:G */
+        evsel = leader = perf_evsel__next(evsel);
+        TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->attr.type);
+        TEST_ASSERT_VAL("wrong config",
+                        PERF_COUNT_HW_CPU_CYCLES == evsel->attr.config);
+        TEST_ASSERT_VAL("wrong exclude_user", !evsel->attr.exclude_user);
+        TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->attr.exclude_kernel);
+        TEST_ASSERT_VAL("wrong exclude_hv", !evsel->attr.exclude_hv);
+        TEST_ASSERT_VAL("wrong exclude guest", !evsel->attr.exclude_guest);
+        TEST_ASSERT_VAL("wrong exclude host", evsel->attr.exclude_host);
+        TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
+        TEST_ASSERT_VAL("wrong group name", !evsel->group_name);
+        TEST_ASSERT_VAL("wrong leader", evsel->leader == NULL);
+
+        /* instructions:G */
+        evsel = perf_evsel__next(evsel);
+        TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->attr.type);
+        TEST_ASSERT_VAL("wrong config",
+                        PERF_COUNT_HW_INSTRUCTIONS == evsel->attr.config);
+        TEST_ASSERT_VAL("wrong exclude_user", !evsel->attr.exclude_user);
+        TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->attr.exclude_kernel);
+        TEST_ASSERT_VAL("wrong exclude_hv", !evsel->attr.exclude_hv);
+        TEST_ASSERT_VAL("wrong exclude guest", !evsel->attr.exclude_guest);
+        TEST_ASSERT_VAL("wrong exclude host", evsel->attr.exclude_host);
+        TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
+        TEST_ASSERT_VAL("wrong leader", evsel->leader == leader);
+
+        /* cycles */
+        evsel = perf_evsel__next(evsel);
+        TEST_ASSERT_VAL("wrong type", PERF_TYPE_HARDWARE == evsel->attr.type);
+        TEST_ASSERT_VAL("wrong config",
+                        PERF_COUNT_HW_CPU_CYCLES == evsel->attr.config);
+        TEST_ASSERT_VAL("wrong exclude_user", !evsel->attr.exclude_user);
+        TEST_ASSERT_VAL("wrong exclude_kernel", !evsel->attr.exclude_kernel);
+        TEST_ASSERT_VAL("wrong exclude_hv", !evsel->attr.exclude_hv);
+        TEST_ASSERT_VAL("wrong exclude guest", evsel->attr.exclude_guest);
+        TEST_ASSERT_VAL("wrong exclude host", !evsel->attr.exclude_host);
+        TEST_ASSERT_VAL("wrong precise_ip", !evsel->attr.precise_ip);
+        TEST_ASSERT_VAL("wrong leader", evsel->leader == NULL);
+
+        return 0;
+}
+
 struct test__event_st {
         const char *name;
         __u32 type;
@@ -632,6 +879,26 @@ static struct test__event_st test__events[] = {
                 .name  = "mem:0:rw:kp",
                 .check = test__checkevent_breakpoint_rw_modifier,
         },
+        [28] = {
+                .name  = "{instructions:k,cycles:upp}",
+                .check = test__group1,
+        },
+        [29] = {
+                .name  = "{faults:k,cache-references}:u,cycles:k",
+                .check = test__group2,
+        },
+        [30] = {
+                .name  = "group1{syscalls:sys_enter_open:H,cycles:kppp},group2{cycles,1:3}:G,instructions:u",
+                .check = test__group3,
+        },
+        [31] = {
+                .name  = "{cycles:u,instructions:kp}:p",
+                .check = test__group4,
+        },
+        [32] = {
+                .name  = "{cycles,instructions}:G,{cycles:G,instructions:G},cycles",
+                .check = test__group5,
+        },
 };
 
 static struct test__event_st test__events_pmu[] = {
@@ -658,9 +925,6 @@ static struct test__term test__terms[] = {
         },
 };
 
-#define TEST__TERMS_CNT (sizeof(test__terms) / \
-                         sizeof(struct test__term))
-
 static int test_event(struct test__event_st *e)
 {
         struct perf_evlist *evlist;
@@ -685,19 +949,19 @@ static int test_event(struct test__event_st *e)
 
 static int test_events(struct test__event_st *events, unsigned cnt)
 {
-        int ret = 0;
+        int ret1, ret2 = 0;
         unsigned i;
 
         for (i = 0; i < cnt; i++) {
                 struct test__event_st *e = &events[i];
 
                 pr_debug("running test %d '%s'\n", i, e->name);
-                ret = test_event(e);
-                if (ret)
-                        break;
+                ret1 = test_event(e);
+                if (ret1)
+                        ret2 = ret1;
         }
 
-        return ret;
+        return ret2;
 }
 
 static int test_term(struct test__term *t)
@@ -752,19 +1016,19 @@ static int test_pmu(void)
 
         ret = stat(path, &st);
         if (ret)
-                pr_debug("ommiting PMU cpu tests\n");
+                pr_debug("omitting PMU cpu tests\n");
         return !ret;
 }
 
 int parse_events__test(void)
 {
-        int ret;
+        int ret1, ret2 = 0;
 
 #define TEST_EVENTS(tests)                              \
 do {                                                    \
-        ret = test_events(tests, ARRAY_SIZE(tests));    \
-        if (ret)                                        \
-                return ret;                             \
+        ret1 = test_events(tests, ARRAY_SIZE(tests));   \
+        if (!ret2)                                      \
+                ret2 = ret1;                            \
 } while (0)
 
         TEST_EVENTS(test__events);
@@ -772,5 +1036,9 @@ do {							\
         if (test_pmu())
                 TEST_EVENTS(test__events_pmu);
 
-        return test_terms(test__terms, ARRAY_SIZE(test__terms));
+        ret1 = test_terms(test__terms, ARRAY_SIZE(test__terms));
+        if (!ret2)
+                ret2 = ret1;
+
+        return ret2;
 }
diff --git a/tools/perf/util/parse-events.c b/tools/perf/util/parse-events.c
index 74a5af4d33ec..aed38e4b9dfa 100644
--- a/tools/perf/util/parse-events.c
+++ b/tools/perf/util/parse-events.c
@@ -239,8 +239,11 @@ const char *event_type(int type)
         return "unknown";
 }
 
-static int add_event(struct list_head **_list, int *idx,
-                     struct perf_event_attr *attr, char *name)
+
+
+static int __add_event(struct list_head **_list, int *idx,
+                       struct perf_event_attr *attr,
+                       char *name, struct cpu_map *cpus)
 {
         struct perf_evsel *evsel;
         struct list_head *list = *_list;
@@ -260,6 +263,7 @@ static int add_event(struct list_head **_list, int *idx,
                 return -ENOMEM;
         }
 
+        evsel->cpus = cpus;
         if (name)
                 evsel->name = strdup(name);
         list_add_tail(&evsel->node, list);
@@ -267,6 +271,12 @@ static int add_event(struct list_head **_list, int *idx,
         return 0;
 }
 
+static int add_event(struct list_head **_list, int *idx,
+                     struct perf_event_attr *attr, char *name)
+{
+        return __add_event(_list, idx, attr, name, NULL);
+}
+
 static int parse_aliases(char *str, const char *names[][PERF_EVSEL__MAX_ALIASES], int size)
 {
         int i, j;
@@ -308,7 +318,7 @@ int parse_events_add_cache(struct list_head **list, int *idx,
         for (i = 0; (i < 2) && (op_result[i]); i++) {
                 char *str = op_result[i];
 
-                snprintf(name + n, MAX_NAME_LEN - n, "-%s\n", str);
+                n += snprintf(name + n, MAX_NAME_LEN - n, "-%s", str);
 
                 if (cache_op == -1) {
                         cache_op = parse_aliases(str, perf_evsel__hw_cache_op,
@@ -346,42 +356,28 @@ int parse_events_add_cache(struct list_head **list, int *idx,
         return add_event(list, idx, &attr, name);
 }
 
-static int add_tracepoint(struct list_head **list, int *idx,
+static int add_tracepoint(struct list_head **listp, int *idx,
                           char *sys_name, char *evt_name)
 {
-        struct perf_event_attr attr;
-        char name[MAX_NAME_LEN];
-        char evt_path[MAXPATHLEN];
-        char id_buf[4];
-        u64 id;
-        int fd;
-
-        snprintf(evt_path, MAXPATHLEN, "%s/%s/%s/id", tracing_events_path,
-                 sys_name, evt_name);
-
-        fd = open(evt_path, O_RDONLY);
-        if (fd < 0)
-                return -1;
+        struct perf_evsel *evsel;
+        struct list_head *list = *listp;
 
-        if (read(fd, id_buf, sizeof(id_buf)) < 0) {
-                close(fd);
-                return -1;
+        if (!list) {
+                list = malloc(sizeof(*list));
+                if (!list)
+                        return -ENOMEM;
+                INIT_LIST_HEAD(list);
         }
 
-        close(fd);
-        id = atoll(id_buf);
-
-        memset(&attr, 0, sizeof(attr));
-        attr.config = id;
-        attr.type = PERF_TYPE_TRACEPOINT;
-        attr.sample_type |= PERF_SAMPLE_RAW;
-        attr.sample_type |= PERF_SAMPLE_TIME;
-        attr.sample_type |= PERF_SAMPLE_CPU;
-        attr.sample_type |= PERF_SAMPLE_PERIOD;
-        attr.sample_period = 1;
+        evsel = perf_evsel__newtp(sys_name, evt_name, (*idx)++);
+        if (!evsel) {
+                free(list);
+                return -ENOMEM;
+        }
 
-        snprintf(name, MAX_NAME_LEN, "%s:%s", sys_name, evt_name);
-        return add_event(list, idx, &attr, name);
+        list_add_tail(&evsel->node, list);
+        *listp = list;
+        return 0;
 }
 
 static int add_tracepoint_multi(struct list_head **list, int *idx,
@@ -551,7 +547,7 @@ static int config_attr(struct perf_event_attr *attr,
 }
 
 int parse_events_add_numeric(struct list_head **list, int *idx,
-                             unsigned long type, unsigned long config,
+                             u32 type, u64 config,
                              struct list_head *head_config)
 {
         struct perf_event_attr attr;
@@ -607,8 +603,23 @@ int parse_events_add_pmu(struct list_head **list, int *idx,
         if (perf_pmu__config(pmu, &attr, head_config))
                 return -EINVAL;
 
-        return add_event(list, idx, &attr,
-                         pmu_event_name(head_config));
+        return __add_event(list, idx, &attr, pmu_event_name(head_config),
+                           pmu->cpus);
+}
+
+int parse_events__modifier_group(struct list_head *list,
+                                 char *event_mod)
+{
+        return parse_events__modifier_event(list, event_mod, true);
+}
+
+void parse_events__set_leader(char *name, struct list_head *list)
+{
+        struct perf_evsel *leader;
+
+        __perf_evlist__set_leader(list);
+        leader = list_entry(list->next, struct perf_evsel, node);
+        leader->group_name = name ? strdup(name) : NULL;
 }
 
 void parse_events_update_lists(struct list_head *list_event,
@@ -616,21 +627,45 @@ void parse_events_update_lists(struct list_head *list_event,
 {
         /*
          * Called for single event definition. Update the
-         * 'all event' list, and reinit the 'signle event'
+         * 'all event' list, and reinit the 'single event'
          * list, for next event definition.
          */
         list_splice_tail(list_event, list_all);
         free(list_event);
 }
 
-int parse_events_modifier(struct list_head *list, char *str)
+struct event_modifier {
+        int eu;
+        int ek;
+        int eh;
+        int eH;
+        int eG;
+        int precise;
+        int exclude_GH;
+};
+
+static int get_event_modifier(struct event_modifier *mod, char *str,
+                               struct perf_evsel *evsel)
 {
-        struct perf_evsel *evsel;
-        int exclude = 0, exclude_GH = 0;
-        int eu = 0, ek = 0, eh = 0, eH = 0, eG = 0, precise = 0;
+        int eu = evsel ? evsel->attr.exclude_user : 0;
+        int ek = evsel ? evsel->attr.exclude_kernel : 0;
+        int eh = evsel ? evsel->attr.exclude_hv : 0;
+        int eH = evsel ? evsel->attr.exclude_host : 0;
+        int eG = evsel ? evsel->attr.exclude_guest : 0;
+        int precise = evsel ? evsel->attr.precise_ip : 0;
 
-        if (str == NULL)
-                return 0;
+        int exclude = eu | ek | eh;
+        int exclude_GH = evsel ? evsel->exclude_GH : 0;
+
+        /*
+         * We are here for group and 'GH' was not set as event
+         * modifier and whatever event/group modifier override
+         * default 'GH' setup.
+         */
+        if (evsel && !exclude_GH)
+                eH = eG = 0;
+
+        memset(mod, 0, sizeof(*mod));
 
         while (*str) {
                 if (*str == 'u') {
@@ -674,13 +709,51 @@ int parse_events_modifier(struct list_head *list, char *str)
         if (precise > 3)
                 return -EINVAL;
 
+        mod->eu = eu;
+        mod->ek = ek;
+        mod->eh = eh;
+        mod->eH = eH;
+        mod->eG = eG;
+        mod->precise = precise;
+        mod->exclude_GH = exclude_GH;
+        return 0;
+}
+
+int parse_events__modifier_event(struct list_head *list, char *str, bool add)
+{
+        struct perf_evsel *evsel;
+        struct event_modifier mod;
+
+        if (str == NULL)
+                return 0;
+
+        if (!add && get_event_modifier(&mod, str, NULL))
+                return -EINVAL;
+
         list_for_each_entry(evsel, list, node) {
-                evsel->attr.exclude_user   = eu;
-                evsel->attr.exclude_kernel = ek;
-                evsel->attr.exclude_hv     = eh;
-                evsel->attr.precise_ip     = precise;
-                evsel->attr.exclude_host   = eH;
-                evsel->attr.exclude_guest  = eG;
+
+                if (add && get_event_modifier(&mod, str, evsel))
+                        return -EINVAL;
+
+                evsel->attr.exclude_user   = mod.eu;
+                evsel->attr.exclude_kernel = mod.ek;
+                evsel->attr.exclude_hv     = mod.eh;
+                evsel->attr.precise_ip     = mod.precise;
+                evsel->attr.exclude_host   = mod.eH;
+                evsel->attr.exclude_guest  = mod.eG;
+                evsel->exclude_GH          = mod.exclude_GH;
+        }
+
+        return 0;
+}
+
+int parse_events_name(struct list_head *list, char *name)
+{
+        struct perf_evsel *evsel;
+
+        list_for_each_entry(evsel, list, node) {
+                if (!evsel->name)
+                        evsel->name = strdup(name);
         }
 
         return 0;
@@ -730,7 +803,8 @@ int parse_events_terms(struct list_head *terms, const char *str)
         return ret;
 }
 
-int parse_events(struct perf_evlist *evlist, const char *str, int unset __used)
+int parse_events(struct perf_evlist *evlist, const char *str,
+                 int unset __maybe_unused)
 {
         struct parse_events_data__events data = {
                 .list = LIST_HEAD_INIT(data.list),
@@ -756,20 +830,20 @@ int parse_events(struct perf_evlist *evlist, const char *str, int unset __used)
 }
 
 int parse_events_option(const struct option *opt, const char *str,
-                        int unset __used)
+                        int unset __maybe_unused)
 {
         struct perf_evlist *evlist = *(struct perf_evlist **)opt->value;
         return parse_events(evlist, str, unset);
 }
 
 int parse_filter(const struct option *opt, const char *str,
-                 int unset __used)
+                 int unset __maybe_unused)
 {
         struct perf_evlist *evlist = *(struct perf_evlist **)opt->value;
         struct perf_evsel *last = NULL;
 
         if (evlist->nr_entries > 0)
-                last = list_entry(evlist->entries.prev, struct perf_evsel, node);
+                last = perf_evlist__last(evlist);
 
         if (last == NULL || last->attr.type != PERF_TYPE_TRACEPOINT) {
                 fprintf(stderr,
@@ -799,7 +873,8 @@ static const char * const event_type_descriptors[] = {
  * Print the events from <debugfs_mount_point>/tracing/events
  */
 
-void print_tracepoint_events(const char *subsys_glob, const char *event_glob)
+void print_tracepoint_events(const char *subsys_glob, const char *event_glob,
+                             bool name_only)
 {
         DIR *sys_dir, *evt_dir;
         struct dirent *sys_next, *evt_next, sys_dirent, evt_dirent;
@@ -829,6 +904,11 @@ void print_tracepoint_events(const char *subsys_glob, const char *event_glob)
                             !strglobmatch(evt_dirent.d_name, event_glob))
                                 continue;
 
+                        if (name_only) {
+                                printf("%s:%s ", sys_dirent.d_name, evt_dirent.d_name);
+                                continue;
+                        }
+
                         snprintf(evt_path, MAXPATHLEN, "%s:%s",
                                  sys_dirent.d_name, evt_dirent.d_name);
                         printf("  %-50s [%s]\n", evt_path,
@@ -906,7 +986,7 @@ void print_events_type(u8 type)
                 __print_events_type(type, event_symbols_hw, PERF_COUNT_HW_MAX);
 }
 
-int print_hwcache_events(const char *event_glob)
+int print_hwcache_events(const char *event_glob, bool name_only)
 {
         unsigned int type, op, i, printed = 0;
         char name[64];
@@ -923,8 +1003,11 @@ int print_hwcache_events(const char *event_glob)
                                 if (event_glob != NULL && !strglobmatch(name, event_glob))
                                         continue;
 
-                                printf("  %-50s [%s]\n", name,
-                                        event_type_descriptors[PERF_TYPE_HW_CACHE]);
+                                if (name_only)
+                                        printf("%s ", name);
+                                else
+                                        printf("  %-50s [%s]\n", name,
+                                               event_type_descriptors[PERF_TYPE_HW_CACHE]);
                                 ++printed;
                         }
                 }
@@ -934,7 +1017,8 @@ int print_hwcache_events(const char *event_glob)
 }
 
 static void print_symbol_events(const char *event_glob, unsigned type,
-                                struct event_symbol *syms, unsigned max)
+                                struct event_symbol *syms, unsigned max,
+                                bool name_only)
 {
         unsigned i, printed = 0;
         char name[MAX_NAME_LEN];
@@ -946,6 +1030,11 @@ static void print_symbol_events(const char *event_glob, unsigned type,
                       (syms->alias && strglobmatch(syms->alias, event_glob))))
                         continue;
 
+                if (name_only) {
+                        printf("%s ", syms->symbol);
+                        continue;
+                }
+
                 if (strlen(syms->alias))
                         snprintf(name, MAX_NAME_LEN, "%s OR %s", syms->symbol, syms->alias);
                 else
@@ -963,39 +1052,42 @@ static void print_symbol_events(const char *event_glob, unsigned type,
 /*
  * Print the help text for the event symbols:
  */
-void print_events(const char *event_glob)
+void print_events(const char *event_glob, bool name_only)
 {
-
-        printf("\n");
-        printf("List of pre-defined events (to be used in -e):\n");
+        if (!name_only) {
+                printf("\n");
+                printf("List of pre-defined events (to be used in -e):\n");
+        }
 
         print_symbol_events(event_glob, PERF_TYPE_HARDWARE,
-                            event_symbols_hw, PERF_COUNT_HW_MAX);
+                            event_symbols_hw, PERF_COUNT_HW_MAX, name_only);
 
         print_symbol_events(event_glob, PERF_TYPE_SOFTWARE,
-                            event_symbols_sw, PERF_COUNT_SW_MAX);
+                            event_symbols_sw, PERF_COUNT_SW_MAX, name_only);
 
-        print_hwcache_events(event_glob);
+        print_hwcache_events(event_glob, name_only);
 
         if (event_glob != NULL)
                 return;
 
-        printf("\n");
-        printf("  %-50s [%s]\n",
-               "rNNN",
-               event_type_descriptors[PERF_TYPE_RAW]);
-        printf("  %-50s [%s]\n",
-               "cpu/t1=v1[,t2=v2,t3 ...]/modifier",
-               event_type_descriptors[PERF_TYPE_RAW]);
-        printf("   (see 'perf list --help' on how to encode it)\n");
-        printf("\n");
-
-        printf("  %-50s [%s]\n",
-                        "mem:<addr>[:access]",
+        if (!name_only) {
+                printf("\n");
+                printf("  %-50s [%s]\n",
+                       "rNNN",
+                       event_type_descriptors[PERF_TYPE_RAW]);
+                printf("  %-50s [%s]\n",
+                       "cpu/t1=v1[,t2=v2,t3 ...]/modifier",
+                       event_type_descriptors[PERF_TYPE_RAW]);
+                printf("   (see 'perf list --help' on how to encode it)\n");
+                printf("\n");
+
+                printf("  %-50s [%s]\n",
+                       "mem:<addr>[:access]",
                         event_type_descriptors[PERF_TYPE_BREAKPOINT]);
-        printf("\n");
+                printf("\n");
+        }
 
-        print_tracepoint_events(NULL, NULL);
+        print_tracepoint_events(NULL, NULL, name_only);
 }
 
 int parse_events__is_hardcoded_term(struct parse_events__term *term)
@@ -1005,7 +1097,7 @@ int parse_events__is_hardcoded_term(struct parse_events__term *term)
 
 static int new_term(struct parse_events__term **_term, int type_val,
                     int type_term, char *config,
-                    char *str, long num)
+                    char *str, u64 num)
 {
         struct parse_events__term *term;
 
@@ -1034,7 +1126,7 @@ static int new_term(struct parse_events__term **_term, int type_val,
 }
 
 int parse_events__term_num(struct parse_events__term **term,
-                           int type_term, char *config, long num)
+                           int type_term, char *config, u64 num)
 {
         return new_term(term, PARSE_EVENTS__TERM_TYPE_NUM, type_term,
                         config, NULL, num);
diff --git a/tools/perf/util/parse-events.h b/tools/perf/util/parse-events.h
index ee9c218a193c..c356e443448d 100644
--- a/tools/perf/util/parse-events.h
+++ b/tools/perf/util/parse-events.h
@@ -55,7 +55,7 @@ struct parse_events__term {
         char *config;
         union {
                 char *str;
-                long  num;
+                u64  num;
         } val;
         int type_val;
         int type_term;
@@ -73,17 +73,19 @@ struct parse_events_data__terms {
 
 int parse_events__is_hardcoded_term(struct parse_events__term *term);
 int parse_events__term_num(struct parse_events__term **_term,
-                           int type_term, char *config, long num);
+                           int type_term, char *config, u64 num);
 int parse_events__term_str(struct parse_events__term **_term,
                            int type_term, char *config, char *str);
 int parse_events__term_clone(struct parse_events__term **new,
                              struct parse_events__term *term);
 void parse_events__free_terms(struct list_head *terms);
-int parse_events_modifier(struct list_head *list, char *str);
+int parse_events__modifier_event(struct list_head *list, char *str, bool add);
+int parse_events__modifier_group(struct list_head *list, char *event_mod);
+int parse_events_name(struct list_head *list, char *name);
 int parse_events_add_tracepoint(struct list_head **list, int *idx,
                                 char *sys, char *event);
 int parse_events_add_numeric(struct list_head **list, int *idx,
-                             unsigned long type, unsigned long config,
+                             u32 type, u64 config,
                              struct list_head *head_config);
 int parse_events_add_cache(struct list_head **list, int *idx,
                            char *type, char *op_result1, char *op_result2);
@@ -91,15 +93,17 @@ int parse_events_add_breakpoint(struct list_head **list, int *idx,
                                 void *ptr, char *type);
 int parse_events_add_pmu(struct list_head **list, int *idx,
                          char *pmu , struct list_head *head_config);
+void parse_events__set_leader(char *name, struct list_head *list);
 void parse_events_update_lists(struct list_head *list_event,
                                struct list_head *list_all);
 void parse_events_error(void *data, void *scanner, char const *msg);
 int parse_events__test(void);
 
-void print_events(const char *event_glob);
+void print_events(const char *event_glob, bool name_only);
 void print_events_type(u8 type);
-void print_tracepoint_events(const char *subsys_glob, const char *event_glob);
-int print_hwcache_events(const char *event_glob);
+void print_tracepoint_events(const char *subsys_glob, const char *event_glob,
+                             bool name_only);
+int print_hwcache_events(const char *event_glob, bool name_only);
 extern int is_valid_tracepoint(const char *event_string);
 
 extern int valid_debugfs_mount(const char *debugfs);
diff --git a/tools/perf/util/parse-events.l b/tools/perf/util/parse-events.l
index 384ca74c6b22..c87efc12579d 100644
--- a/tools/perf/util/parse-events.l
+++ b/tools/perf/util/parse-events.l
@@ -15,10 +15,10 @@ YYSTYPE *parse_events_get_lval(yyscan_t yyscanner);
 
 static int __value(YYSTYPE *yylval, char *str, int base, int token)
 {
-        long num;
+        u64 num;
 
         errno = 0;
-        num = strtoul(str, NULL, base);
+        num = strtoull(str, NULL, base);
         if (errno)
                 return PE_ERROR;
 
@@ -70,6 +70,12 @@ static int term(yyscan_t scanner, int type)
 %}
 
 %x mem
+%s config
+%x event
+
+group           [^,{}/]*[{][^}]*[}][^,{}/]*
+event_pmu       [^,{}/]+[/][^/]*[/][^,{}/]*
+event           [^,{}/]+
 
 num_dec         [0-9]+
 num_hex         0x[a-fA-F0-9]+
@@ -84,7 +90,13 @@ modifier_bp	[rwx]{1,3}
         {
                 int start_token;
 
-                start_token = (int) parse_events_get_extra(yyscanner);
+                start_token = parse_events_get_extra(yyscanner);
+
+                if (start_token == PE_START_TERMS)
+                        BEGIN(config);
+                else if (start_token == PE_START_EVENTS)
+                        BEGIN(event);
+
                 if (start_token) {
                         parse_events_set_extra(NULL, yyscanner);
                         return start_token;
@@ -92,6 +104,26 @@ modifier_bp	[rwx]{1,3}
          }
 %}
 
+<event>{
+
+{group}         {
+                        BEGIN(INITIAL); yyless(0);
+                }
+
+{event_pmu}     |
+{event}         {
+                        str(yyscanner, PE_EVENT_NAME);
+                        BEGIN(INITIAL); yyless(0);
+                        return PE_EVENT_NAME;
+                }
+
+.               |
+<<EOF>>         {
+                        BEGIN(INITIAL); yyless(0);
+                }
+
+}
+
 cpu-cycles|cycles                               { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_CPU_CYCLES); }
 stalled-cycles-frontend|idle-cycles-frontend    { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_STALLED_CYCLES_FRONTEND); }
 stalled-cycles-backend|idle-cycles-backend      { return sym(yyscanner, PERF_TYPE_HARDWARE, PERF_COUNT_HW_STALLED_CYCLES_BACKEND); }
@@ -127,18 +159,16 @@ speculative-read|speculative-load	|
 refs|Reference|ops|access               |
 misses|miss                             { return str(yyscanner, PE_NAME_CACHE_OP_RESULT); }
 
-        /*
-         * These are event config hardcoded term names to be specified
-         * within xxx/.../ syntax. So far we dont clash with other names,
-         * so we can put them here directly. In case the we have a conflict
-         * in future, this needs to go into '//' condition block.
-         */
+<config>{
 config                  { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_CONFIG); }
 config1                 { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_CONFIG1); }
 config2                 { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_CONFIG2); }
 name                    { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_NAME); }
 period                  { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_SAMPLE_PERIOD); }
 branch_type             { return term(yyscanner, PARSE_EVENTS__TERM_TYPE_BRANCH_SAMPLE_TYPE); }
+,                       { return ','; }
+"/"                     { BEGIN(INITIAL); return '/'; }
+}
 
 mem:                    { BEGIN(mem); return PE_PREFIX_MEM; }
 r{num_raw_hex}          { return raw(yyscanner); }
@@ -147,10 +177,12 @@ r{num_raw_hex}		{ return raw(yyscanner); }
 
 {modifier_event}        { return str(yyscanner, PE_MODIFIER_EVENT); }
 {name}                  { return str(yyscanner, PE_NAME); }
-"/"                     { return '/'; }
+"/"                     { BEGIN(config); return '/'; }
 -                       { return '-'; }
-,                       { return ','; }
+,                       { BEGIN(event); return ','; }
 :                       { return ':'; }
+"{"                     { BEGIN(event); return '{'; }
+"}"                     { return '}'; }
 =                       { return '='; }
 \n                      { }
 
@@ -175,7 +207,7 @@ r{num_raw_hex}		{ return raw(yyscanner); }
 
 %%
 
-int parse_events_wrap(void *scanner __used)
+int parse_events_wrap(void *scanner __maybe_unused)
 {
         return 1;
 }
diff --git a/tools/perf/util/parse-events.y b/tools/perf/util/parse-events.y
index 2bc5fbff2b5d..cd88209e3c58 100644
--- a/tools/perf/util/parse-events.y
+++ b/tools/perf/util/parse-events.y
@@ -27,10 +27,11 @@ do { \
 
 %token PE_START_EVENTS PE_START_TERMS
 %token PE_VALUE PE_VALUE_SYM_HW PE_VALUE_SYM_SW PE_RAW PE_TERM
+%token PE_EVENT_NAME
 %token PE_NAME
 %token PE_MODIFIER_EVENT PE_MODIFIER_BP
 %token PE_NAME_CACHE_TYPE PE_NAME_CACHE_OP_RESULT
-%token PE_PREFIX_MEM PE_PREFIX_RAW
+%token PE_PREFIX_MEM PE_PREFIX_RAW PE_PREFIX_GROUP
 %token PE_ERROR
 %type <num> PE_VALUE
 %type <num> PE_VALUE_SYM_HW
@@ -42,6 +43,7 @@ do { \
 %type <str> PE_NAME_CACHE_OP_RESULT
 %type <str> PE_MODIFIER_EVENT
 %type <str> PE_MODIFIER_BP
+%type <str> PE_EVENT_NAME
 %type <num> value_sym
 %type <head> event_config
 %type <term> event_term
@@ -53,44 +55,125 @@ do { \
 %type <head> event_legacy_numeric
 %type <head> event_legacy_raw
 %type <head> event_def
+%type <head> event_mod
+%type <head> event_name
+%type <head> event
+%type <head> events
+%type <head> group_def
+%type <head> group
+%type <head> groups
 
 %union
 {
         char *str;
-        unsigned long num;
+        u64 num;
         struct list_head *head;
         struct parse_events__term *term;
 }
 %%
 
 start:
-PE_START_EVENTS events
+PE_START_EVENTS start_events
 |
-PE_START_TERMS  terms
+PE_START_TERMS  start_terms
+
+start_events: groups
+{
+        struct parse_events_data__events *data = _data;
+
+        parse_events_update_lists($1, &data->list);
+}
+
+groups:
+groups ',' group
+{
+        struct list_head *list  = $1;
+        struct list_head *group = $3;
+
+        parse_events_update_lists(group, list);
+        $$ = list;
+}
+|
+groups ',' event
+{
+        struct list_head *list  = $1;
+        struct list_head *event = $3;
+
+        parse_events_update_lists(event, list);
+        $$ = list;
+}
+|
+group
+|
+event
+
+group:
+group_def ':' PE_MODIFIER_EVENT
+{
+        struct list_head *list = $1;
+
+        ABORT_ON(parse_events__modifier_group(list, $3));
+        $$ = list;
+}
+|
+group_def
+
+group_def:
+PE_NAME '{' events '}'
+{
+        struct list_head *list = $3;
+
+        parse_events__set_leader($1, list);
+        $$ = list;
+}
+|
+'{' events '}'
+{
+        struct list_head *list = $2;
+
+        parse_events__set_leader(NULL, list);
+        $$ = list;
+}
 
 events:
-events ',' event | event
+events ',' event
+{
+        struct list_head *event = $3;
+        struct list_head *list  = $1;
 
-event:
-event_def PE_MODIFIER_EVENT
+        parse_events_update_lists(event, list);
+        $$ = list;
+}
+|
+event
+
+event: event_mod
+
+event_mod:
+event_name PE_MODIFIER_EVENT
 {
-        struct parse_events_data__events *data = _data;
+        struct list_head *list = $1;
 
         /*
          * Apply modifier on all events added by single event definition
          * (there could be more events added for multiple tracepoint
          * definitions via '*?'.
          */
-        ABORT_ON(parse_events_modifier($1, $2));
-        parse_events_update_lists($1, &data->list);
+        ABORT_ON(parse_events__modifier_event(list, $2, false));
+        $$ = list;
 }
 |
-event_def
-{
-        struct parse_events_data__events *data = _data;
+event_name
 
-        parse_events_update_lists($1, &data->list);
+event_name:
+PE_EVENT_NAME event_def
+{
+        ABORT_ON(parse_events_name($2, $1));
+        free($1);
+        $$ = $2;
 }
+|
+event_def
 
 event_def: event_pmu |
            event_legacy_symbol |
@@ -207,7 +290,7 @@ PE_VALUE ':' PE_VALUE
         struct parse_events_data__events *data = _data;
         struct list_head *list = NULL;
 
-        ABORT_ON(parse_events_add_numeric(&list, &data->idx, $1, $3, NULL));
+        ABORT_ON(parse_events_add_numeric(&list, &data->idx, (u32)$1, $3, NULL));
         $$ = list;
 }
 
@@ -222,7 +305,7 @@ PE_RAW
         $$ = list;
 }
 
-terms: event_config
+start_terms: event_config
 {
         struct parse_events_data__terms *data = _data;
         data->terms = $1;
@@ -282,7 +365,7 @@ PE_TERM '=' PE_NAME
 {
         struct parse_events__term *term;
 
-        ABORT_ON(parse_events__term_str(&term, $1, NULL, $3));
+        ABORT_ON(parse_events__term_str(&term, (int)$1, NULL, $3));
         $$ = term;
 }
 |
@@ -290,7 +373,7 @@ PE_TERM '=' PE_VALUE
 {
         struct parse_events__term *term;
 
-        ABORT_ON(parse_events__term_num(&term, $1, NULL, $3));
+        ABORT_ON(parse_events__term_num(&term, (int)$1, NULL, $3));
         $$ = term;
 }
 |
@@ -298,7 +381,7 @@ PE_TERM
 {
         struct parse_events__term *term;
 
-        ABORT_ON(parse_events__term_num(&term, $1, NULL, 1));
+        ABORT_ON(parse_events__term_num(&term, (int)$1, NULL, 1));
         $$ = term;
 }
 
@@ -308,7 +391,7 @@ sep_slash_dc: '/' | ':' |
 
 %%
 
-void parse_events_error(void *data __used, void *scanner __used,
-                        char const *msg __used)
+void parse_events_error(void *data __maybe_unused, void *scanner __maybe_unused,
+                        char const *msg __maybe_unused)
 {
 }
diff --git a/tools/perf/util/parse-options.c b/tools/perf/util/parse-options.c
index 594f8fad5ecd..443fc116512b 100644
--- a/tools/perf/util/parse-options.c
+++ b/tools/perf/util/parse-options.c
@@ -557,7 +557,8 @@ int parse_options_usage(const char * const *usagestr,
 }
 
 
-int parse_opt_verbosity_cb(const struct option *opt, const char *arg __used,
+int parse_opt_verbosity_cb(const struct option *opt,
+                           const char *arg __maybe_unused,
                            int unset)
 {
         int *target = opt->value;
diff --git a/tools/perf/util/perf_regs.h b/tools/perf/util/perf_regs.h
new file mode 100644
index 000000000000..316dbe7f86ed
--- /dev/null
+++ b/tools/perf/util/perf_regs.h
@@ -0,0 +1,14 @@
+#ifndef __PERF_REGS_H
+#define __PERF_REGS_H
+
+#ifndef NO_PERF_REGS
+#include <perf_regs.h>
+#else
+#define PERF_REGS_MASK  0
+
+static inline const char *perf_reg_name(int id __maybe_unused)
+{
+        return NULL;
+}
+#endif /* NO_PERF_REGS */
+#endif /* __PERF_REGS_H */
diff --git a/tools/perf/util/pmu.c b/tools/perf/util/pmu.c
index 67715a42cd6d..8a2229da594f 100644
--- a/tools/perf/util/pmu.c
+++ b/tools/perf/util/pmu.c
@@ -9,6 +9,9 @@
 #include "util.h"
 #include "pmu.h"
 #include "parse-events.h"
+#include "cpumap.h"
+
+#define EVENT_SOURCE_DEVICE_PATH "/bus/event_source/devices/"
 
 int perf_pmu_parse(struct list_head *list, char *name);
 extern FILE *perf_pmu_in;
@@ -69,7 +72,7 @@ static int pmu_format(char *name, struct list_head *format)
                 return -1;
 
         snprintf(path, PATH_MAX,
-                 "%s/bus/event_source/devices/%s/format", sysfs, name);
+                 "%s" EVENT_SOURCE_DEVICE_PATH "%s/format", sysfs, name);
 
         if (stat(path, &st) < 0)
                 return 0;       /* no error if format does not exist */
@@ -206,7 +209,7 @@ static int pmu_type(char *name, __u32 *type)
                 return -1;
 
         snprintf(path, PATH_MAX,
-                 "%s/bus/event_source/devices/%s/type", sysfs, name);
+                 "%s" EVENT_SOURCE_DEVICE_PATH "%s/type", sysfs, name);
 
         if (stat(path, &st) < 0)
                 return -1;
@@ -222,6 +225,62 @@ static int pmu_type(char *name, __u32 *type)
         return ret;
 }
 
+/* Add all pmus in sysfs to pmu list: */
+static void pmu_read_sysfs(void)
+{
+        char path[PATH_MAX];
+        const char *sysfs;
+        DIR *dir;
+        struct dirent *dent;
+
+        sysfs = sysfs_find_mountpoint();
+        if (!sysfs)
+                return;
+
+        snprintf(path, PATH_MAX,
+                 "%s" EVENT_SOURCE_DEVICE_PATH, sysfs);
+
+        dir = opendir(path);
+        if (!dir)
+                return;
+
+        while ((dent = readdir(dir))) {
+                if (!strcmp(dent->d_name, ".") || !strcmp(dent->d_name, ".."))
+                        continue;
+                /* add to static LIST_HEAD(pmus): */
+                perf_pmu__find(dent->d_name);
+        }
+
+        closedir(dir);
+}
+
+static struct cpu_map *pmu_cpumask(char *name)
+{
+        struct stat st;
+        char path[PATH_MAX];
+        const char *sysfs;
+        FILE *file;
+        struct cpu_map *cpus;
+
+        sysfs = sysfs_find_mountpoint();
+        if (!sysfs)
+                return NULL;
+
+        snprintf(path, PATH_MAX,
+                 "%s/bus/event_source/devices/%s/cpumask", sysfs, name);
+
+        if (stat(path, &st) < 0)
+                return NULL;
+
+        file = fopen(path, "r");
+        if (!file)
+                return NULL;
+
+        cpus = cpu_map__read(file);
+        fclose(file);
+        return cpus;
+}
+
 static struct perf_pmu *pmu_lookup(char *name)
 {
         struct perf_pmu *pmu;
@@ -244,6 +303,8 @@ static struct perf_pmu *pmu_lookup(char *name)
         if (!pmu)
                 return NULL;
 
+        pmu->cpus = pmu_cpumask(name);
+
         pmu_aliases(name, &aliases);
 
         INIT_LIST_HEAD(&pmu->format);
@@ -267,6 +328,21 @@ static struct perf_pmu *pmu_find(char *name)
         return NULL;
 }
 
+struct perf_pmu *perf_pmu__scan(struct perf_pmu *pmu)
+{
+        /*
+         * pmu iterator: If pmu is NULL, we start at the begin,
+         * otherwise return the next pmu. Returns NULL on end.
+         */
+        if (!pmu) {
+                pmu_read_sysfs();
+                pmu = list_prepare_entry(pmu, &pmus, list);
+        }
+        list_for_each_entry_continue(pmu, &pmus, list)
+                return pmu;
+        return NULL;
+}
+
 struct perf_pmu *perf_pmu__find(char *name)
 {
         struct perf_pmu *pmu;
diff --git a/tools/perf/util/pmu.h b/tools/perf/util/pmu.h
index 535f2c5258ab..53c7794fc4be 100644
--- a/tools/perf/util/pmu.h
+++ b/tools/perf/util/pmu.h
@@ -28,6 +28,7 @@ struct perf_pmu__alias {
 struct perf_pmu {
         char *name;
         __u32 type;
+        struct cpu_map *cpus;
         struct list_head format;
         struct list_head aliases;
         struct list_head list;
@@ -46,5 +47,7 @@ int perf_pmu__new_format(struct list_head *list, char *name,
                          int config, unsigned long *bits);
 void perf_pmu__set_format(unsigned long *bits, long from, long to);
 
+struct perf_pmu *perf_pmu__scan(struct perf_pmu *pmu);
+
 int perf_pmu__test(void);
 #endif /* __PMU_H */
diff --git a/tools/perf/util/pmu.y b/tools/perf/util/pmu.y
index 20ea77e93169..ec898047ebb9 100644
--- a/tools/perf/util/pmu.y
+++ b/tools/perf/util/pmu.y
@@ -86,8 +86,8 @@ PP_VALUE
 
 %%
 
-void perf_pmu_error(struct list_head *list __used,
-                    char *name __used,
-                    char const *msg __used)
+void perf_pmu_error(struct list_head *list __maybe_unused,
+                    char *name __maybe_unused,
+                    char const *msg __maybe_unused)
 {
 }
diff --git a/tools/perf/util/probe-event.c b/tools/perf/util/probe-event.c
index 0dda25d82d06..49a256e6e0a2 100644
--- a/tools/perf/util/probe-event.c
+++ b/tools/perf/util/probe-event.c
@@ -41,7 +41,7 @@
 #include "symbol.h"
 #include "thread.h"
 #include "debugfs.h"
-#include "trace-event.h"        /* For __unused */
+#include "trace-event.h"        /* For __maybe_unused */
 #include "probe-event.h"
 #include "probe-finder.h"
 #include "session.h"
@@ -647,8 +647,8 @@ static int kprobe_convert_to_perf_probe(struct probe_trace_point *tp,
 }
 
 static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
-                                struct probe_trace_event **tevs __unused,
-                                int max_tevs __unused, const char *target)
+                                struct probe_trace_event **tevs __maybe_unused,
+                                int max_tevs __maybe_unused, const char *target)
 {
         if (perf_probe_event_need_dwarf(pev)) {
                 pr_warning("Debuginfo-analysis is not supported.\n");
@@ -661,17 +661,18 @@ static int try_to_find_probe_trace_events(struct perf_probe_event *pev,
         return 0;
 }
 
-int show_line_range(struct line_range *lr __unused, const char *module __unused)
+int show_line_range(struct line_range *lr __maybe_unused,
+                    const char *module __maybe_unused)
 {
         pr_warning("Debuginfo-analysis is not supported.\n");
         return -ENOSYS;
 }
 
-int show_available_vars(struct perf_probe_event *pevs __unused,
-                        int npevs __unused, int max_vls __unused,
-                        const char *module __unused,
-                        struct strfilter *filter __unused,
-                        bool externs __unused)
+int show_available_vars(struct perf_probe_event *pevs __maybe_unused,
+                        int npevs __maybe_unused, int max_vls __maybe_unused,
+                        const char *module __maybe_unused,
+                        struct strfilter *filter __maybe_unused,
+                        bool externs __maybe_unused)
 {
         pr_warning("Debuginfo-analysis is not supported.\n");
         return -ENOSYS;
@@ -1099,6 +1100,7 @@ static int parse_probe_trace_command(const char *cmd,
         struct probe_trace_point *tp = &tev->point;
         char pr;
         char *p;
+        char *argv0_str = NULL, *fmt, *fmt1_str, *fmt2_str, *fmt3_str;
         int ret, i, argc;
         char **argv;
 
@@ -1115,14 +1117,27 @@ static int parse_probe_trace_command(const char *cmd,
         }
 
         /* Scan event and group name. */
-        ret = sscanf(argv[0], "%c:%a[^/ \t]/%a[^ \t]",
-                     &pr, (float *)(void *)&tev->group,
-                     (float *)(void *)&tev->event);
-        if (ret != 3) {
+        argv0_str = strdup(argv[0]);
+        if (argv0_str == NULL) {
+                ret = -ENOMEM;
+                goto out;
+        }
+        fmt1_str = strtok_r(argv0_str, ":", &fmt);
+        fmt2_str = strtok_r(NULL, "/", &fmt);
+        fmt3_str = strtok_r(NULL, " \t", &fmt);
+        if (fmt1_str == NULL || strlen(fmt1_str) != 1 || fmt2_str == NULL
+            || fmt3_str == NULL) {
                 semantic_error("Failed to parse event name: %s\n", argv[0]);
                 ret = -EINVAL;
                 goto out;
         }
+        pr = fmt1_str[0];
+        tev->group = strdup(fmt2_str);
+        tev->event = strdup(fmt3_str);
+        if (tev->group == NULL || tev->event == NULL) {
+                ret = -ENOMEM;
+                goto out;
+        }
         pr_debug("Group:%s Event:%s probe:%c\n", tev->group, tev->event, pr);
 
         tp->retprobe = (pr == 'r');
@@ -1134,10 +1149,17 @@ static int parse_probe_trace_command(const char *cmd,
                 p++;
         } else
                 p = argv[1];
-        ret = sscanf(p, "%a[^+]+%lu", (float *)(void *)&tp->symbol,
-                     &tp->offset);
-        if (ret == 1)
+        fmt1_str = strtok_r(p, "+", &fmt);
+        tp->symbol = strdup(fmt1_str);
+        if (tp->symbol == NULL) {
+                ret = -ENOMEM;
+                goto out;
+        }
+        fmt2_str = strtok_r(NULL, "", &fmt);
+        if (fmt2_str == NULL)
                 tp->offset = 0;
+        else
+                tp->offset = strtoul(fmt2_str, NULL, 10);
 
         tev->nargs = argc - 2;
         tev->args = zalloc(sizeof(struct probe_trace_arg) * tev->nargs);
@@ -1161,6 +1183,7 @@ static int parse_probe_trace_command(const char *cmd,
         }
         ret = 0;
 out:
+        free(argv0_str);
         argv_free(argv);
         return ret;
 }
@@ -2183,7 +2206,7 @@ static struct strfilter *available_func_filter;
  * If a symbol corresponds to a function with global binding and
  * matches filter return 0. For all others return 1.
  */
-static int filter_available_functions(struct map *map __unused,
+static int filter_available_functions(struct map *map __maybe_unused,
                                       struct symbol *sym)
 {
         if (sym->binding == STB_GLOBAL &&
@@ -2307,10 +2330,17 @@ static int convert_name_to_addr(struct perf_probe_event *pev, const char *exec)
                 function = NULL;
         }
         if (!pev->group) {
-                char *ptr1, *ptr2;
+                char *ptr1, *ptr2, *exec_copy;
 
                 pev->group = zalloc(sizeof(char *) * 64);
-                ptr1 = strdup(basename(exec));
+                exec_copy = strdup(exec);
+                if (!exec_copy) {
+                        ret = -ENOMEM;
+                        pr_warning("Failed to copy exec string.\n");
+                        goto out;
+                }
+
+                ptr1 = strdup(basename(exec_copy));
                 if (ptr1) {
                         ptr2 = strpbrk(ptr1, "-._");
                         if (ptr2)
@@ -2319,6 +2349,7 @@ static int convert_name_to_addr(struct perf_probe_event *pev, const char *exec)
                                         ptr1);
                         free(ptr1);
                 }
+                free(exec_copy);
         }
         free(pp->function);
         pp->function = zalloc(sizeof(char *) * MAX_PROBE_ARGS);
diff --git a/tools/perf/util/probe-finder.c b/tools/perf/util/probe-finder.c
index d448984ed789..1daf5c14e751 100644
--- a/tools/perf/util/probe-finder.c
+++ b/tools/perf/util/probe-finder.c
@@ -207,7 +207,7 @@ static int debuginfo__init_online_kernel_dwarf(struct debuginfo *self,
 #else
 /* With older elfutils, this just support kernel module... */
 static int debuginfo__init_online_kernel_dwarf(struct debuginfo *self,
-                                               Dwarf_Addr addr __used)
+                                               Dwarf_Addr addr __maybe_unused)
 {
         const char *path = kernel_get_module_path("kernel");
 
@@ -525,8 +525,10 @@ static int convert_variable_fields(Dwarf_Die *vr_die, const char *varname,
                         return -ENOENT;
                 }
                 /* Verify it is a data structure  */
-                if (dwarf_tag(&type) != DW_TAG_structure_type) {
-                        pr_warning("%s is not a data structure.\n", varname);
+                tag = dwarf_tag(&type);
+                if (tag != DW_TAG_structure_type && tag != DW_TAG_union_type) {
+                        pr_warning("%s is not a data structure nor an union.\n",
+                                   varname);
                         return -EINVAL;
                 }
 
@@ -539,8 +541,9 @@ static int convert_variable_fields(Dwarf_Die *vr_die, const char *varname,
                         *ref_ptr = ref;
         } else {
                 /* Verify it is a data structure  */
-                if (tag != DW_TAG_structure_type) {
-                        pr_warning("%s is not a data structure.\n", varname);
+                if (tag != DW_TAG_structure_type && tag != DW_TAG_union_type) {
+                        pr_warning("%s is not a data structure nor an union.\n",
+                                   varname);
                         return -EINVAL;
                 }
                 if (field->name[0] == '[') {
@@ -567,10 +570,15 @@ static int convert_variable_fields(Dwarf_Die *vr_die, const char *varname,
         }
 
         /* Get the offset of the field */
-        ret = die_get_data_member_location(die_mem, &offs);
-        if (ret < 0) {
-                pr_warning("Failed to get the offset of %s.\n", field->name);
-                return ret;
+        if (tag == DW_TAG_union_type) {
+                offs = 0;
+        } else {
+                ret = die_get_data_member_location(die_mem, &offs);
+                if (ret < 0) {
+                        pr_warning("Failed to get the offset of %s.\n",
+                                   field->name);
+                        return ret;
+                }
         }
         ref->offset += (long)offs;
 
@@ -1419,7 +1427,7 @@ static int line_range_add_line(const char *src, unsigned int lineno,
 }
 
 static int line_range_walk_cb(const char *fname, int lineno,
-                              Dwarf_Addr addr __used,
+                              Dwarf_Addr addr __maybe_unused,
                               void *data)
 {
         struct line_finder *lf = data;
diff --git a/tools/perf/util/python-ext-sources b/tools/perf/util/python-ext-sources
index 213362850abd..c40c2d33199e 100644
--- a/tools/perf/util/python-ext-sources
+++ b/tools/perf/util/python-ext-sources
@@ -1,5 +1,5 @@
 #
-# List of files needed by perf python extention
+# List of files needed by perf python extension
 #
 # Each source file must be placed on its own line so that it can be
 # processed by Makefile and util/setup.py accordingly.
diff --git a/tools/perf/util/python.c b/tools/perf/util/python.c
index 0688bfb6d280..9181bf212fb9 100644
--- a/tools/perf/util/python.c
+++ b/tools/perf/util/python.c
@@ -627,7 +627,7 @@ static PyObject *pyrf_evsel__open(struct pyrf_evsel *pevsel,
          * This will group just the fds for this single evsel, to group
          * multiple events, use evlist.open().
          */
-        if (perf_evsel__open(evsel, cpus, threads, group, NULL) < 0) {
+        if (perf_evsel__open(evsel, cpus, threads) < 0) {
                 PyErr_SetFromErrno(PyExc_OSError);
                 return NULL;
         }
@@ -672,7 +672,7 @@ struct pyrf_evlist {
 };
 
 static int pyrf_evlist__init(struct pyrf_evlist *pevlist,
-                             PyObject *args, PyObject *kwargs __used)
+                             PyObject *args, PyObject *kwargs __maybe_unused)
 {
         PyObject *pcpus = NULL, *pthreads = NULL;
         struct cpu_map *cpus;
@@ -733,7 +733,8 @@ static PyObject *pyrf_evlist__poll(struct pyrf_evlist *pevlist,
 }
 
 static PyObject *pyrf_evlist__get_pollfd(struct pyrf_evlist *pevlist,
-                                         PyObject *args __used, PyObject *kwargs __used)
+                                         PyObject *args __maybe_unused,
+                                         PyObject *kwargs __maybe_unused)
 {
         struct perf_evlist *evlist = &pevlist->evlist;
         PyObject *list = PyList_New(0);
@@ -765,7 +766,8 @@ free_list:
 
 
 static PyObject *pyrf_evlist__add(struct pyrf_evlist *pevlist,
-                                  PyObject *args, PyObject *kwargs __used)
+                                  PyObject *args,
+                                  PyObject *kwargs __maybe_unused)
 {
         struct perf_evlist *evlist = &pevlist->evlist;
         PyObject *pevsel;
@@ -803,7 +805,7 @@ static PyObject *pyrf_evlist__read_on_cpu(struct pyrf_evlist *pevlist,
                 if (pyevent == NULL)
                         return PyErr_NoMemory();
 
-                err = perf_evlist__parse_sample(evlist, event, &pevent->sample, false);
+                err = perf_evlist__parse_sample(evlist, event, &pevent->sample);
                 if (err)
                         return PyErr_Format(PyExc_OSError,
                                             "perf: can't parse sample, err=%d", err);
@@ -824,7 +826,10 @@ static PyObject *pyrf_evlist__open(struct pyrf_evlist *pevlist,
         if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OOii", kwlist, &group))
                 return NULL;
 
-        if (perf_evlist__open(evlist, group) < 0) {
+        if (group)
+                perf_evlist__set_leader(evlist);
+
+        if (perf_evlist__open(evlist) < 0) {
                 PyErr_SetFromErrno(PyExc_OSError);
                 return NULL;
         }
diff --git a/tools/perf/util/scripting-engines/trace-event-perl.c b/tools/perf/util/scripting-engines/trace-event-perl.c
index 02dfa19a467f..f80605eb1855 100644
--- a/tools/perf/util/scripting-engines/trace-event-perl.c
+++ b/tools/perf/util/scripting-engines/trace-event-perl.c
@@ -25,16 +25,16 @@
 #include <ctype.h>
 #include <errno.h>
 
-#include "../../perf.h"
 #include "../util.h"
+#include <EXTERN.h>
+#include <perl.h>
+
+#include "../../perf.h"
 #include "../thread.h"
 #include "../event.h"
 #include "../trace-event.h"
 #include "../evsel.h"
 
-#include <EXTERN.h>
-#include <perl.h>
-
 void boot_Perf__Trace__Context(pTHX_ CV *cv);
 void boot_DynaLoader(pTHX_ CV *cv);
 typedef PerlInterpreter * INTERP;
@@ -237,16 +237,16 @@ static void define_event_symbols(struct event_format *event,
                 define_event_symbols(event, ev_name, args->next);
 }
 
-static inline
-struct event_format *find_cache_event(struct pevent *pevent, int type)
+static inline struct event_format *find_cache_event(struct perf_evsel *evsel)
 {
         static char ev_name[256];
         struct event_format *event;
+        int type = evsel->attr.config;
 
         if (events[type])
                 return events[type];
 
-        events[type] = event = pevent_find_event(pevent, type);
+        events[type] = event = evsel->tp_format;
         if (!event)
                 return NULL;
 
@@ -257,23 +257,22 @@ struct event_format *find_cache_event(struct pevent *pevent, int type)
         return event;
 }
 
-static void perl_process_tracepoint(union perf_event *perf_event __unused,
-                                    struct pevent *pevent,
+static void perl_process_tracepoint(union perf_event *perf_event __maybe_unused,
                                     struct perf_sample *sample,
                                     struct perf_evsel *evsel,
-                                    struct machine *machine __unused,
-                                    struct thread *thread)
+                                    struct machine *machine __maybe_unused,
+                                    struct addr_location *al)
 {
         struct format_field *field;
         static char handler[256];
         unsigned long long val;
         unsigned long s, ns;
         struct event_format *event;
-        int type;
         int pid;
         int cpu = sample->cpu;
         void *data = sample->raw_data;
         unsigned long long nsecs = sample->time;
+        struct thread *thread = al->thread;
         char *comm = thread->comm;
 
         dSP;
@@ -281,13 +280,11 @@ static void perl_process_tracepoint(union perf_event *perf_event __unused,
         if (evsel->attr.type != PERF_TYPE_TRACEPOINT)
                 return;
 
-        type = trace_parse_common_type(pevent, data);
-
-        event = find_cache_event(pevent, type);
+        event = find_cache_event(evsel);
         if (!event)
-                die("ug! no event found for type %d", type);
+                die("ug! no event found for type %" PRIu64, evsel->attr.config);
 
-        pid = trace_parse_common_pid(pevent, data);
+        pid = raw_field_value(event, "common_pid", data);
 
         sprintf(handler, "%s::%s", event->system, event->name);
 
@@ -320,7 +317,7 @@ static void perl_process_tracepoint(union perf_event *perf_event __unused,
                                 offset = field->offset;
                         XPUSHs(sv_2mortal(newSVpv((char *)data + offset, 0)));
                 } else { /* FIELD_IS_NUMERIC */
-                        val = read_size(pevent, data + field->offset,
+                        val = read_size(event, data + field->offset,
                                         field->size);
                         if (field->flags & FIELD_IS_SIGNED) {
                                 XPUSHs(sv_2mortal(newSViv(val)));
@@ -349,11 +346,11 @@ static void perl_process_tracepoint(union perf_event *perf_event __unused,
         LEAVE;
 }
 
-static void perl_process_event_generic(union perf_event *pevent __unused,
+static void perl_process_event_generic(union perf_event *event,
                                        struct perf_sample *sample,
-                                       struct perf_evsel *evsel __unused,
-                                       struct machine *machine __unused,
-                                       struct thread *thread __unused)
+                                       struct perf_evsel *evsel,
+                                       struct machine *machine __maybe_unused,
+                                       struct addr_location *al __maybe_unused)
 {
         dSP;
 
@@ -363,7 +360,7 @@ static void perl_process_event_generic(union perf_event *pevent __unused,
         ENTER;
         SAVETMPS;
         PUSHMARK(SP);
-        XPUSHs(sv_2mortal(newSVpvn((const char *)pevent, pevent->header.size)));
+        XPUSHs(sv_2mortal(newSVpvn((const char *)event, event->header.size)));
         XPUSHs(sv_2mortal(newSVpvn((const char *)&evsel->attr, sizeof(evsel->attr))));
         XPUSHs(sv_2mortal(newSVpvn((const char *)sample, sizeof(*sample))));
         XPUSHs(sv_2mortal(newSVpvn((const char *)sample->raw_data, sample->raw_size)));
@@ -376,14 +373,13 @@ static void perl_process_event_generic(union perf_event *pevent __unused,
 }
 
 static void perl_process_event(union perf_event *event,
-                               struct pevent *pevent,
                                struct perf_sample *sample,
                                struct perf_evsel *evsel,
                                struct machine *machine,
-                               struct thread *thread)
+                               struct addr_location *al)
 {
-        perl_process_tracepoint(event, pevent, sample, evsel, machine, thread);
-        perl_process_event_generic(event, sample, evsel, machine, thread);
+        perl_process_tracepoint(event, sample, evsel, machine, al);
+        perl_process_event_generic(event, sample, evsel, machine, al);
 }
 
 static void run_start_sub(void)
diff --git a/tools/perf/util/scripting-engines/trace-event-python.c b/tools/perf/util/scripting-engines/trace-event-python.c
index ce4d1b0c3862..730c6630cba5 100644
--- a/tools/perf/util/scripting-engines/trace-event-python.c
+++ b/tools/perf/util/scripting-engines/trace-event-python.c
@@ -27,10 +27,12 @@
 #include <errno.h>
 
 #include "../../perf.h"
+#include "../evsel.h"
 #include "../util.h"
 #include "../event.h"
 #include "../thread.h"
 #include "../trace-event.h"
+#include "../evsel.h"
 
 PyMODINIT_FUNC initperf_trace_context(void);
 
@@ -194,16 +196,21 @@ static void define_event_symbols(struct event_format *event,
                 define_event_symbols(event, ev_name, args->next);
 }
 
-static inline
-struct event_format *find_cache_event(struct pevent *pevent, int type)
+static inline struct event_format *find_cache_event(struct perf_evsel *evsel)
 {
         static char ev_name[256];
         struct event_format *event;
+        int type = evsel->attr.config;
 
+        /*
+         * XXX: Do we really need to cache this since now we have evsel->tp_format
+         * cached already? Need to re-read this "cache" routine that as well calls
+         * define_event_symbols() :-\
+         */
         if (events[type])
                 return events[type];
 
-        events[type] = event = pevent_find_event(pevent, type);
+        events[type] = event = evsel->tp_format;
         if (!event)
                 return NULL;
 
@@ -214,12 +221,12 @@ struct event_format *find_cache_event(struct pevent *pevent, int type)
         return event;
 }
 
-static void python_process_event(union perf_event *perf_event __unused,
-                                 struct pevent *pevent,
+static void python_process_tracepoint(union perf_event *perf_event
+                                      __maybe_unused,
                                  struct perf_sample *sample,
-                                 struct perf_evsel *evsel __unused,
-                                 struct machine *machine __unused,
-                                 struct thread *thread)
+                                 struct perf_evsel *evsel,
+                                 struct machine *machine __maybe_unused,
+                                 struct addr_location *al)
 {
         PyObject *handler, *retval, *context, *t, *obj, *dict = NULL;
         static char handler_name[256];
@@ -228,24 +235,22 @@ static void python_process_event(union perf_event *perf_event __unused,
         unsigned long s, ns;
         struct event_format *event;
         unsigned n = 0;
-        int type;
         int pid;
         int cpu = sample->cpu;
         void *data = sample->raw_data;
         unsigned long long nsecs = sample->time;
+        struct thread *thread = al->thread;
         char *comm = thread->comm;
 
         t = PyTuple_New(MAX_FIELDS);
         if (!t)
                 Py_FatalError("couldn't create Python tuple");
 
-        type = trace_parse_common_type(pevent, data);
-
-        event = find_cache_event(pevent, type);
+        event = find_cache_event(evsel);
         if (!event)
-                die("ug! no event found for type %d", type);
+                die("ug! no event found for type %d", (int)evsel->attr.config);
 
-        pid = trace_parse_common_pid(pevent, data);
+        pid = raw_field_value(event, "common_pid", data);
 
         sprintf(handler_name, "%s__%s", event->system, event->name);
 
@@ -290,7 +295,7 @@ static void python_process_event(union perf_event *perf_event __unused,
                                 offset = field->offset;
                         obj = PyString_FromString((char *)data + offset);
                 } else { /* FIELD_IS_NUMERIC */
-                        val = read_size(pevent, data + field->offset,
+                        val = read_size(event, data + field->offset,
                                         field->size);
                         if (field->flags & FIELD_IS_SIGNED) {
                                 if ((long long)val >= LONG_MIN &&
@@ -335,6 +340,84 @@ static void python_process_event(union perf_event *perf_event __unused,
         Py_DECREF(t);
 }
 
+static void python_process_general_event(union perf_event *perf_event
+                                         __maybe_unused,
+                                         struct perf_sample *sample,
+                                         struct perf_evsel *evsel,
+                                         struct machine *machine __maybe_unused,
+                                         struct addr_location *al)
+{
+        PyObject *handler, *retval, *t, *dict;
+        static char handler_name[64];
+        unsigned n = 0;
+        struct thread *thread = al->thread;
+
+        /*
+         * Use the MAX_FIELDS to make the function expandable, though
+         * currently there is only one item for the tuple.
+         */
+        t = PyTuple_New(MAX_FIELDS);
+        if (!t)
+                Py_FatalError("couldn't create Python tuple");
+
+        dict = PyDict_New();
+        if (!dict)
+                Py_FatalError("couldn't create Python dictionary");
+
+        snprintf(handler_name, sizeof(handler_name), "%s", "process_event");
+
+        handler = PyDict_GetItemString(main_dict, handler_name);
+        if (!handler || !PyCallable_Check(handler))
+                goto exit;
+
+        PyDict_SetItemString(dict, "ev_name", PyString_FromString(perf_evsel__name(evsel)));
+        PyDict_SetItemString(dict, "attr", PyString_FromStringAndSize(
+                        (const char *)&evsel->attr, sizeof(evsel->attr)));
+        PyDict_SetItemString(dict, "sample", PyString_FromStringAndSize(
+                        (const char *)sample, sizeof(*sample)));
+        PyDict_SetItemString(dict, "raw_buf", PyString_FromStringAndSize(
+                        (const char *)sample->raw_data, sample->raw_size));
+        PyDict_SetItemString(dict, "comm",
+                        PyString_FromString(thread->comm));
+        if (al->map) {
+                PyDict_SetItemString(dict, "dso",
+                        PyString_FromString(al->map->dso->name));
+        }
+        if (al->sym) {
+                PyDict_SetItemString(dict, "symbol",
+                        PyString_FromString(al->sym->name));
+        }
+
+        PyTuple_SetItem(t, n++, dict);
+        if (_PyTuple_Resize(&t, n) == -1)
+                Py_FatalError("error resizing Python tuple");
+
+        retval = PyObject_CallObject(handler, t);
+        if (retval == NULL)
+                handler_call_die(handler_name);
+exit:
+        Py_DECREF(dict);
+        Py_DECREF(t);
+}
+
+static void python_process_event(union perf_event *perf_event,
+                                 struct perf_sample *sample,
+                                 struct perf_evsel *evsel,
+                                 struct machine *machine,
+                                 struct addr_location *al)
+{
+        switch (evsel->attr.type) {
+        case PERF_TYPE_TRACEPOINT:
+                python_process_tracepoint(perf_event, sample, evsel,
+                                          machine, al);
+                break;
+        /* Reserve for future process_hw/sw/raw APIs */
+        default:
+                python_process_general_event(perf_event, sample, evsel,
+                                             machine, al);
+        }
+}
+
 static int run_start_sub(void)
 {
         PyObject *handler, *retval;
diff --git a/tools/perf/util/session.c b/tools/perf/util/session.c
index 2437fb0b463a..8cdd23239c90 100644
--- a/tools/perf/util/session.c
+++ b/tools/perf/util/session.c
@@ -15,6 +15,9 @@
 #include "util.h"
 #include "cpumap.h"
 #include "event-parse.h"
+#include "perf_regs.h"
+#include "unwind.h"
+#include "vdso.h"
 
 static int perf_session__open(struct perf_session *self, bool force)
 {
@@ -209,6 +212,7 @@ void perf_session__delete(struct perf_session *self)
         machine__exit(&self->host_machine);
         close(self->fd);
         free(self);
+        vdso__exit();
 }
 
 void machine__remove_thread(struct machine *self, struct thread *th)
@@ -288,10 +292,11 @@ struct branch_info *machine__resolve_bstack(struct machine *self,
         return bi;
 }
 
-int machine__resolve_callchain(struct machine *self,
-                               struct thread *thread,
-                               struct ip_callchain *chain,
-                               struct symbol **parent)
+static int machine__resolve_callchain_sample(struct machine *machine,
+                                             struct thread *thread,
+                                             struct ip_callchain *chain,
+                                             struct symbol **parent)
+
 {
         u8 cpumode = PERF_RECORD_MISC_USER;
         unsigned int i;
@@ -316,11 +321,14 @@ int machine__resolve_callchain(struct machine *self,
                 if (ip >= PERF_CONTEXT_MAX) {
                         switch (ip) {
                         case PERF_CONTEXT_HV:
-                                cpumode = PERF_RECORD_MISC_HYPERVISOR;  break;
+                                cpumode = PERF_RECORD_MISC_HYPERVISOR;
+                                break;
                         case PERF_CONTEXT_KERNEL:
-                                cpumode = PERF_RECORD_MISC_KERNEL;      break;
+                                cpumode = PERF_RECORD_MISC_KERNEL;
+                                break;
                         case PERF_CONTEXT_USER:
-                                cpumode = PERF_RECORD_MISC_USER;        break;
+                                cpumode = PERF_RECORD_MISC_USER;
+                                break;
                         default:
                                 pr_debug("invalid callchain context: "
                                          "%"PRId64"\n", (s64) ip);
@@ -335,7 +343,7 @@ int machine__resolve_callchain(struct machine *self,
                 }
 
                 al.filtered = false;
-                thread__find_addr_location(thread, self, cpumode,
+                thread__find_addr_location(thread, machine, cpumode,
                                            MAP__FUNCTION, ip, &al, NULL);
                 if (al.sym != NULL) {
                         if (sort__has_parent && !*parent &&
@@ -354,49 +362,92 @@ int machine__resolve_callchain(struct machine *self,
         return 0;
 }
 
-static int process_event_synth_tracing_data_stub(union perf_event *event __used,
-                                                 struct perf_session *session __used)
+static int unwind_entry(struct unwind_entry *entry, void *arg)
+{
+        struct callchain_cursor *cursor = arg;
+        return callchain_cursor_append(cursor, entry->ip,
+                                       entry->map, entry->sym);
+}
+
+int machine__resolve_callchain(struct machine *machine,
+                               struct perf_evsel *evsel,
+                               struct thread *thread,
+                               struct perf_sample *sample,
+                               struct symbol **parent)
+
+{
+        int ret;
+
+        callchain_cursor_reset(&callchain_cursor);
+
+        ret = machine__resolve_callchain_sample(machine, thread,
+                                                sample->callchain, parent);
+        if (ret)
+                return ret;
+
+        /* Can we do dwarf post unwind? */
+        if (!((evsel->attr.sample_type & PERF_SAMPLE_REGS_USER) &&
+              (evsel->attr.sample_type & PERF_SAMPLE_STACK_USER)))
+                return 0;
+
+        /* Bail out if nothing was captured. */
+        if ((!sample->user_regs.regs) ||
+            (!sample->user_stack.size))
+                return 0;
+
+        return unwind__get_entries(unwind_entry, &callchain_cursor, machine,
+                                   thread, evsel->attr.sample_regs_user,
+                                   sample);
+
+}
+
+static int process_event_synth_tracing_data_stub(union perf_event *event
+                                                 __maybe_unused,
+                                                 struct perf_session *session
+                                                __maybe_unused)
 {
         dump_printf(": unhandled!\n");
         return 0;
 }
 
-static int process_event_synth_attr_stub(union perf_event *event __used,
-                                         struct perf_evlist **pevlist __used)
+static int process_event_synth_attr_stub(union perf_event *event __maybe_unused,
+                                         struct perf_evlist **pevlist
+                                         __maybe_unused)
 {
         dump_printf(": unhandled!\n");
         return 0;
 }
 
-static int process_event_sample_stub(struct perf_tool *tool __used,
-                                     union perf_event *event __used,
-                                     struct perf_sample *sample __used,
-                                     struct perf_evsel *evsel __used,
-                                     struct machine *machine __used)
+static int process_event_sample_stub(struct perf_tool *tool __maybe_unused,
+                                     union perf_event *event __maybe_unused,
+                                     struct perf_sample *sample __maybe_unused,
+                                     struct perf_evsel *evsel __maybe_unused,
+                                     struct machine *machine __maybe_unused)
 {
         dump_printf(": unhandled!\n");
         return 0;
 }
 
-static int process_event_stub(struct perf_tool *tool __used,
-                              union perf_event *event __used,
-                              struct perf_sample *sample __used,
-                              struct machine *machine __used)
+static int process_event_stub(struct perf_tool *tool __maybe_unused,
+                              union perf_event *event __maybe_unused,
+                              struct perf_sample *sample __maybe_unused,
+                              struct machine *machine __maybe_unused)
 {
         dump_printf(": unhandled!\n");
         return 0;
 }
 
-static int process_finished_round_stub(struct perf_tool *tool __used,
-                                       union perf_event *event __used,
-                                       struct perf_session *perf_session __used)
+static int process_finished_round_stub(struct perf_tool *tool __maybe_unused,
+                                       union perf_event *event __maybe_unused,
+                                       struct perf_session *perf_session
+                                       __maybe_unused)
 {
         dump_printf(": unhandled!\n");
         return 0;
 }
 
-static int process_event_type_stub(struct perf_tool *tool __used,
-                                   union perf_event *event __used)
+static int process_event_type_stub(struct perf_tool *tool __maybe_unused,
+                                   union perf_event *event __maybe_unused)
 {
         dump_printf(": unhandled!\n");
         return 0;
@@ -473,7 +524,7 @@ static void swap_sample_id_all(union perf_event *event, void *data)
 }
 
 static void perf_event__all64_swap(union perf_event *event,
-                                   bool sample_id_all __used)
+                                   bool sample_id_all __maybe_unused)
 {
         struct perf_event_header *hdr = &event->header;
         mem_bswap_64(hdr + 1, event->header.size - sizeof(*hdr));
@@ -487,7 +538,7 @@ static void perf_event__comm_swap(union perf_event *event, bool sample_id_all)
         if (sample_id_all) {
                 void *data = &event->comm.comm;
 
-                data += ALIGN(strlen(data) + 1, sizeof(u64));
+                data += PERF_ALIGN(strlen(data) + 1, sizeof(u64));
                 swap_sample_id_all(event, data);
         }
 }
@@ -504,7 +555,7 @@ static void perf_event__mmap_swap(union perf_event *event,
         if (sample_id_all) {
                 void *data = &event->mmap.filename;
 
-                data += ALIGN(strlen(data) + 1, sizeof(u64));
+                data += PERF_ALIGN(strlen(data) + 1, sizeof(u64));
                 swap_sample_id_all(event, data);
         }
 }
@@ -584,7 +635,7 @@ void perf_event__attr_swap(struct perf_event_attr *attr)
 }
 
 static void perf_event__hdr_attr_swap(union perf_event *event,
-                                      bool sample_id_all __used)
+                                      bool sample_id_all __maybe_unused)
 {
         size_t size;
 
@@ -596,14 +647,14 @@ static void perf_event__hdr_attr_swap(union perf_event *event,
 }
 
 static void perf_event__event_type_swap(union perf_event *event,
-                                        bool sample_id_all __used)
+                                        bool sample_id_all __maybe_unused)
 {
         event->event_type.event_type.event_id =
                 bswap_64(event->event_type.event_type.event_id);
 }
 
 static void perf_event__tracing_data_swap(union perf_event *event,
-                                          bool sample_id_all __used)
+                                          bool sample_id_all __maybe_unused)
 {
         event->tracing_data.size = bswap_32(event->tracing_data.size);
 }
@@ -652,7 +703,7 @@ static int perf_session_deliver_event(struct perf_session *session,
                                       struct perf_tool *tool,
                                       u64 file_offset);
 
-static void flush_sample_queue(struct perf_session *s,
+static int flush_sample_queue(struct perf_session *s,
                                struct perf_tool *tool)
 {
         struct ordered_samples *os = &s->ordered_samples;
@@ -665,19 +716,21 @@ static void flush_sample_queue(struct perf_session *s,
         int ret;
 
         if (!tool->ordered_samples || !limit)
-                return;
+                return 0;
 
         list_for_each_entry_safe(iter, tmp, head, list) {
                 if (iter->timestamp > limit)
                         break;
 
-                ret = perf_evlist__parse_sample(s->evlist, iter->event, &sample,
-                                                s->header.needs_swap);
+                ret = perf_evlist__parse_sample(s->evlist, iter->event, &sample);
                 if (ret)
                         pr_err("Can't parse sample, err = %d\n", ret);
-                else
-                        perf_session_deliver_event(s, iter->event, &sample, tool,
-                                                   iter->file_offset);
+                else {
+                        ret = perf_session_deliver_event(s, iter->event, &sample, tool,
+                                                         iter->file_offset);
+                        if (ret)
+                                return ret;
+                }
 
                 os->last_flush = iter->timestamp;
                 list_del(&iter->list);
@@ -697,6 +750,8 @@ static void flush_sample_queue(struct perf_session *s,
         }
 
         os->nr_samples = 0;
+
+        return 0;
 }
 
 /*
@@ -739,13 +794,14 @@ static void flush_sample_queue(struct perf_session *s,
  *      etc...
  */
 static int process_finished_round(struct perf_tool *tool,
-                                  union perf_event *event __used,
+                                  union perf_event *event __maybe_unused,
                                   struct perf_session *session)
 {
-        flush_sample_queue(session, tool);
-        session->ordered_samples.next_flush = session->ordered_samples.max_timestamp;
+        int ret = flush_sample_queue(session, tool);
+        if (!ret)
+                session->ordered_samples.next_flush = session->ordered_samples.max_timestamp;
 
-        return 0;
+        return ret;
 }
 
 /* The queue is ordered by time */
@@ -860,6 +916,34 @@ static void branch_stack__printf(struct perf_sample *sample)
                         sample->branch_stack->entries[i].to);
 }
 
+static void regs_dump__printf(u64 mask, u64 *regs)
+{
+        unsigned rid, i = 0;
+
+        for_each_set_bit(rid, (unsigned long *) &mask, sizeof(mask) * 8) {
+                u64 val = regs[i++];
+
+                printf(".... %-5s 0x%" PRIx64 "\n",
+                       perf_reg_name(rid), val);
+        }
+}
+
+static void regs_user__printf(struct perf_sample *sample, u64 mask)
+{
+        struct regs_dump *user_regs = &sample->user_regs;
+
+        if (user_regs->regs) {
+                printf("... user regs: mask 0x%" PRIx64 "\n", mask);
+                regs_dump__printf(mask, user_regs->regs);
+        }
+}
+
+static void stack_user__printf(struct stack_dump *dump)
+{
+        printf("... ustack: size %" PRIu64 ", offset 0x%x\n",
+               dump->size, dump->offset);
+}
+
 static void perf_session__print_tstamp(struct perf_session *session,
                                        union perf_event *event,
                                        struct perf_sample *sample)
@@ -897,7 +981,7 @@ static void dump_event(struct perf_session *session, union perf_event *event,
                event->header.size, perf_event__name(event->header.type));
 }
 
-static void dump_sample(struct perf_session *session, union perf_event *event,
+static void dump_sample(struct perf_evsel *evsel, union perf_event *event,
                         struct perf_sample *sample)
 {
         u64 sample_type;
@@ -909,13 +993,19 @@ static void dump_sample(struct perf_session *session, union perf_event *event,
                event->header.misc, sample->pid, sample->tid, sample->ip,
                sample->period, sample->addr);
 
-        sample_type = perf_evlist__sample_type(session->evlist);
+        sample_type = evsel->attr.sample_type;
 
         if (sample_type & PERF_SAMPLE_CALLCHAIN)
                 callchain__printf(sample);
 
         if (sample_type & PERF_SAMPLE_BRANCH_STACK)
                 branch_stack__printf(sample);
+
+        if (sample_type & PERF_SAMPLE_REGS_USER)
+                regs_user__printf(sample, evsel->attr.sample_regs_user);
+
+        if (sample_type & PERF_SAMPLE_STACK_USER)
+                stack_user__printf(&sample->user_stack);
 }
 
 static struct machine *
@@ -973,7 +1063,7 @@ static int perf_session_deliver_event(struct perf_session *session,
 
         switch (event->header.type) {
         case PERF_RECORD_SAMPLE:
-                dump_sample(session, event, sample);
+                dump_sample(evsel, event, sample);
                 if (evsel == NULL) {
                         ++session->hists.stats.nr_unknown_id;
                         return 0;
@@ -1083,8 +1173,7 @@ static int perf_session__process_event(struct perf_session *session,
         /*
          * For all kernel events we get the sample data
          */
-        ret = perf_evlist__parse_sample(session->evlist, event, &sample,
-                                        session->header.needs_swap);
+        ret = perf_evlist__parse_sample(session->evlist, event, &sample);
         if (ret)
                 return ret;
 
@@ -1369,7 +1458,7 @@ more:
         err = 0;
         /* do the final flush for ordered samples */
         session->ordered_samples.next_flush = ULLONG_MAX;
-        flush_sample_queue(session, tool);
+        err = flush_sample_queue(session, tool);
 out_err:
         perf_session__warn_about_errors(session, tool);
         perf_session_free_sample_buffers(session);
@@ -1498,9 +1587,9 @@ struct perf_evsel *perf_session__find_first_evtype(struct perf_session *session,
         return NULL;
 }
 
-void perf_event__print_ip(union perf_event *event, struct perf_sample *sample,
-                          struct machine *machine, int print_sym,
-                          int print_dso, int print_symoffset)
+void perf_evsel__print_ip(struct perf_evsel *evsel, union perf_event *event,
+                          struct perf_sample *sample, struct machine *machine,
+                          int print_sym, int print_dso, int print_symoffset)
 {
         struct addr_location al;
         struct callchain_cursor_node *node;
@@ -1514,8 +1603,9 @@ void perf_event__print_ip(union perf_event *event, struct perf_sample *sample,
 
         if (symbol_conf.use_callchain && sample->callchain) {
 
-                if (machine__resolve_callchain(machine, al.thread,
-                                                sample->callchain, NULL) != 0) {
+
+                if (machine__resolve_callchain(machine, evsel, al.thread,
+                                               sample, NULL) != 0) {
                         if (verbose)
                                 error("Failed to resolve callchain. Skipping\n");
                         return;
diff --git a/tools/perf/util/session.h b/tools/perf/util/session.h
index 1f7ec87db7d7..aab414fbb64b 100644
--- a/tools/perf/util/session.h
+++ b/tools/perf/util/session.h
@@ -36,9 +36,7 @@ struct perf_session {
         struct pevent           *pevent;
         /*
          * FIXME: Need to split this up further, we need global
-         *        stats + per event stats. 'perf diff' also needs
-         *        to properly support multiple events in a single
-         *        perf.data file.
+         *        stats + per event stats.
          */
         struct hists            hists;
         int                     fd;
@@ -129,9 +127,9 @@ size_t perf_session__fprintf_nr_events(struct perf_session *session, FILE *fp);
 struct perf_evsel *perf_session__find_first_evtype(struct perf_session *session,
                                             unsigned int type);
 
-void perf_event__print_ip(union perf_event *event, struct perf_sample *sample,
-                          struct machine *machine, int print_sym,
-                          int print_dso, int print_symoffset);
+void perf_evsel__print_ip(struct perf_evsel *evsel, union perf_event *event,
+                          struct perf_sample *sample, struct machine *machine,
+                          int print_sym, int print_dso, int print_symoffset);
 
 int perf_session__cpu_bitmap(struct perf_session *session,
                              const char *cpu_list, unsigned long *cpu_bitmap);
diff --git a/tools/perf/util/sort.c b/tools/perf/util/sort.c
index 0f5a0a496bc4..b5b1b9211960 100644
--- a/tools/perf/util/sort.c
+++ b/tools/perf/util/sort.c
@@ -8,12 +8,11 @@ const char	default_sort_order[] = "comm,dso,symbol";
 const char      *sort_order = default_sort_order;
 int             sort__need_collapse = 0;
 int             sort__has_parent = 0;
+int             sort__has_sym = 0;
 int             sort__branch_mode = -1; /* -1 = means not set */
 
 enum sort_type  sort__first_dimension;
 
-char * field_sep;
-
 LIST_HEAD(hist_entry__sort_list);
 
 static int repsep_snprintf(char *bf, size_t size, const char *fmt, ...)
@@ -23,11 +22,11 @@ static int repsep_snprintf(char *bf, size_t size, const char *fmt, ...)
 
         va_start(ap, fmt);
         n = vsnprintf(bf, size, fmt, ap);
-        if (field_sep && n > 0) {
+        if (symbol_conf.field_sep && n > 0) {
                 char *sep = bf;
 
                 while (1) {
-                        sep = strchr(sep, *field_sep);
+                        sep = strchr(sep, *symbol_conf.field_sep);
                         if (sep == NULL)
                                 break;
                         *sep = '.';
@@ -172,7 +171,7 @@ static int hist_entry__dso_snprintf(struct hist_entry *self, char *bf,
 
 static int _hist_entry__sym_snprintf(struct map *map, struct symbol *sym,
                                      u64 ip, char level, char *bf, size_t size,
-                                     unsigned int width __used)
+                                     unsigned int width __maybe_unused)
 {
         size_t ret = 0;
 
@@ -207,7 +206,8 @@ struct sort_entry sort_dso = {
 };
 
 static int hist_entry__sym_snprintf(struct hist_entry *self, char *bf,
-                                    size_t size, unsigned int width __used)
+                                    size_t size,
+                                    unsigned int width __maybe_unused)
 {
         return _hist_entry__sym_snprintf(self->ms.map, self->ms.sym, self->ip,
                                          self->level, bf, size, width);
@@ -250,7 +250,8 @@ sort__srcline_cmp(struct hist_entry *left, struct hist_entry *right)
 }
 
 static int hist_entry__srcline_snprintf(struct hist_entry *self, char *bf,
-                                   size_t size, unsigned int width __used)
+                                        size_t size,
+                                        unsigned int width __maybe_unused)
 {
         FILE *fp;
         char cmd[PATH_MAX + 2], *path = self->srcline, *nl;
@@ -399,7 +400,8 @@ sort__sym_to_cmp(struct hist_entry *left, struct hist_entry *right)
 }
 
 static int hist_entry__sym_from_snprintf(struct hist_entry *self, char *bf,
-                                    size_t size, unsigned int width __used)
+                                        size_t size,
+                                        unsigned int width __maybe_unused)
 {
         struct addr_map_symbol *from = &self->branch_info->from;
         return _hist_entry__sym_snprintf(from->map, from->sym, from->addr,
@@ -408,7 +410,8 @@ static int hist_entry__sym_from_snprintf(struct hist_entry *self, char *bf,
 }
 
 static int hist_entry__sym_to_snprintf(struct hist_entry *self, char *bf,
-                                    size_t size, unsigned int width __used)
+                                       size_t size,
+                                       unsigned int width __maybe_unused)
 {
         struct addr_map_symbol *to = &self->branch_info->to;
         return _hist_entry__sym_snprintf(to->map, to->sym, to->addr,
@@ -509,6 +512,10 @@ int sort_dimension__add(const char *tok)
                                 return -EINVAL;
                         }
                         sort__has_parent = 1;
+                } else if (sd->entry == &sort_sym ||
+                           sd->entry == &sort_sym_from ||
+                           sd->entry == &sort_sym_to) {
+                        sort__has_sym = 1;
                 }
 
                 if (sd->taken)
diff --git a/tools/perf/util/sort.h b/tools/perf/util/sort.h
index e724b26acd51..12d634792de5 100644
--- a/tools/perf/util/sort.h
+++ b/tools/perf/util/sort.h
@@ -31,8 +31,8 @@ extern const char *parent_pattern;
 extern const char default_sort_order[];
 extern int sort__need_collapse;
 extern int sort__has_parent;
+extern int sort__has_sym;
 extern int sort__branch_mode;
-extern char *field_sep;
 extern struct sort_entry sort_comm;
 extern struct sort_entry sort_dso;
 extern struct sort_entry sort_sym;
diff --git a/tools/perf/util/stat.c b/tools/perf/util/stat.c
new file mode 100644
index 000000000000..23742126f47c
--- /dev/null
+++ b/tools/perf/util/stat.c
@@ -0,0 +1,57 @@
+#include <math.h>
+
+#include "stat.h"
+
+void update_stats(struct stats *stats, u64 val)
+{
+        double delta;
+
+        stats->n++;
+        delta = val - stats->mean;
+        stats->mean += delta / stats->n;
+        stats->M2 += delta*(val - stats->mean);
+}
+
+double avg_stats(struct stats *stats)
+{
+        return stats->mean;
+}
+
+/*
+ * http://en.wikipedia.org/wiki/Algorithms_for_calculating_variance
+ *
+ *       (\Sum n_i^2) - ((\Sum n_i)^2)/n
+ * s^2 = -------------------------------
+ *                  n - 1
+ *
+ * http://en.wikipedia.org/wiki/Stddev
+ *
+ * The std dev of the mean is related to the std dev by:
+ *
+ *             s
+ * s_mean = -------
+ *          sqrt(n)
+ *
+ */
+double stddev_stats(struct stats *stats)
+{
+        double variance, variance_mean;
+
+        if (!stats->n)
+                return 0.0;
+
+        variance = stats->M2 / (stats->n - 1);
+        variance_mean = variance / stats->n;
+
+        return sqrt(variance_mean);
+}
+
+double rel_stddev_stats(double stddev, double avg)
+{
+        double pct = 0.0;
+
+        if (avg)
+                pct = 100.0 * stddev/avg;
+
+        return pct;
+}
diff --git a/tools/perf/util/stat.h b/tools/perf/util/stat.h
new file mode 100644
index 000000000000..588367c3c767
--- /dev/null
+++ b/tools/perf/util/stat.h
@@ -0,0 +1,16 @@
+#ifndef __PERF_STATS_H
+#define __PERF_STATS_H
+
+#include "types.h"
+
+struct stats
+{
+        double n, mean, M2;
+};
+
+void update_stats(struct stats *stats, u64 val);
+double avg_stats(struct stats *stats);
+double stddev_stats(struct stats *stats);
+double rel_stddev_stats(double stddev, double avg);
+
+#endif
diff --git a/tools/perf/util/string.c b/tools/perf/util/string.c
index 199bc4d8905d..32170590892d 100644
--- a/tools/perf/util/string.c
+++ b/tools/perf/util/string.c
@@ -1,5 +1,5 @@
 #include "util.h"
-#include "string.h"
+#include "linux/string.h"
 
 #define K 1024LL
 /*
@@ -335,3 +335,19 @@ char *rtrim(char *s)
 
         return s;
 }
+
+/**
+ * memdup - duplicate region of memory
+ * @src: memory region to duplicate
+ * @len: memory region length
+ */
+void *memdup(const void *src, size_t len)
+{
+        void *p;
+
+        p = malloc(len);
+        if (p)
+                memcpy(p, src, len);
+
+        return p;
+}
diff --git a/tools/perf/util/strlist.c b/tools/perf/util/strlist.c
index 95856ff3dda4..155d8b7078a7 100644
--- a/tools/perf/util/strlist.c
+++ b/tools/perf/util/strlist.c
@@ -93,7 +93,7 @@ out:
 
 void strlist__remove(struct strlist *slist, struct str_node *snode)
 {
-        str_node__delete(snode, slist->dupstr);
+        rblist__remove_node(&slist->rblist, &snode->rb_node);
 }
 
 struct str_node *strlist__find(struct strlist *slist, const char *entry)
diff --git a/tools/perf/util/symbol-elf.c b/tools/perf/util/symbol-elf.c
new file mode 100644
index 000000000000..db0cc92cf2ea
--- /dev/null
+++ b/tools/perf/util/symbol-elf.c
@@ -0,0 +1,841 @@
+#include <libelf.h>
+#include <gelf.h>
+#include <elf.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+#include <unistd.h>
+#include <inttypes.h>
+
+#include "symbol.h"
+#include "debug.h"
+
+#ifndef NT_GNU_BUILD_ID
+#define NT_GNU_BUILD_ID 3
+#endif
+
+/**
+ * elf_symtab__for_each_symbol - iterate thru all the symbols
+ *
+ * @syms: struct elf_symtab instance to iterate
+ * @idx: uint32_t idx
+ * @sym: GElf_Sym iterator
+ */
+#define elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) \
+        for (idx = 0, gelf_getsym(syms, idx, &sym);\
+             idx < nr_syms; \
+             idx++, gelf_getsym(syms, idx, &sym))
+
+static inline uint8_t elf_sym__type(const GElf_Sym *sym)
+{
+        return GELF_ST_TYPE(sym->st_info);
+}
+
+static inline int elf_sym__is_function(const GElf_Sym *sym)
+{
+        return elf_sym__type(sym) == STT_FUNC &&
+               sym->st_name != 0 &&
+               sym->st_shndx != SHN_UNDEF;
+}
+
+static inline bool elf_sym__is_object(const GElf_Sym *sym)
+{
+        return elf_sym__type(sym) == STT_OBJECT &&
+                sym->st_name != 0 &&
+                sym->st_shndx != SHN_UNDEF;
+}
+
+static inline int elf_sym__is_label(const GElf_Sym *sym)
+{
+        return elf_sym__type(sym) == STT_NOTYPE &&
+                sym->st_name != 0 &&
+                sym->st_shndx != SHN_UNDEF &&
+                sym->st_shndx != SHN_ABS;
+}
+
+static bool elf_sym__is_a(GElf_Sym *sym, enum map_type type)
+{
+        switch (type) {
+        case MAP__FUNCTION:
+                return elf_sym__is_function(sym);
+        case MAP__VARIABLE:
+                return elf_sym__is_object(sym);
+        default:
+                return false;
+        }
+}
+
+static inline const char *elf_sym__name(const GElf_Sym *sym,
+                                        const Elf_Data *symstrs)
+{
+        return symstrs->d_buf + sym->st_name;
+}
+
+static inline const char *elf_sec__name(const GElf_Shdr *shdr,
+                                        const Elf_Data *secstrs)
+{
+        return secstrs->d_buf + shdr->sh_name;
+}
+
+static inline int elf_sec__is_text(const GElf_Shdr *shdr,
+                                        const Elf_Data *secstrs)
+{
+        return strstr(elf_sec__name(shdr, secstrs), "text") != NULL;
+}
+
+static inline bool elf_sec__is_data(const GElf_Shdr *shdr,
+                                    const Elf_Data *secstrs)
+{
+        return strstr(elf_sec__name(shdr, secstrs), "data") != NULL;
+}
+
+static bool elf_sec__is_a(GElf_Shdr *shdr, Elf_Data *secstrs,
+                          enum map_type type)
+{
+        switch (type) {
+        case MAP__FUNCTION:
+                return elf_sec__is_text(shdr, secstrs);
+        case MAP__VARIABLE:
+                return elf_sec__is_data(shdr, secstrs);
+        default:
+                return false;
+        }
+}
+
+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 Elf_Scn *elf_section_by_name(Elf *elf, GElf_Ehdr *ep,
+                                    GElf_Shdr *shp, const char *name,
+                                    size_t *idx)
+{
+        Elf_Scn *sec = NULL;
+        size_t cnt = 1;
+
+        /* Elf is corrupted/truncated, avoid calling elf_strptr. */
+        if (!elf_rawdata(elf_getscn(elf, ep->e_shstrndx), NULL))
+                return NULL;
+
+        while ((sec = elf_nextscn(elf, sec)) != NULL) {
+                char *str;
+
+                gelf_getshdr(sec, shp);
+                str = elf_strptr(elf, ep->e_shstrndx, shp->sh_name);
+                if (!strcmp(name, str)) {
+                        if (idx)
+                                *idx = cnt;
+                        break;
+                }
+                ++cnt;
+        }
+
+        return sec;
+}
+
+#define elf_section__for_each_rel(reldata, pos, pos_mem, idx, nr_entries) \
+        for (idx = 0, pos = gelf_getrel(reldata, 0, &pos_mem); \
+             idx < nr_entries; \
+             ++idx, pos = gelf_getrel(reldata, idx, &pos_mem))
+
+#define elf_section__for_each_rela(reldata, pos, pos_mem, idx, nr_entries) \
+        for (idx = 0, pos = gelf_getrela(reldata, 0, &pos_mem); \
+             idx < nr_entries; \
+             ++idx, pos = gelf_getrela(reldata, idx, &pos_mem))
+
+/*
+ * We need to check if we have a .dynsym, so that we can handle the
+ * .plt, synthesizing its symbols, that aren't on the symtabs (be it
+ * .dynsym or .symtab).
+ * And always look at the original dso, not at debuginfo packages, that
+ * have the PLT data stripped out (shdr_rel_plt.sh_type == SHT_NOBITS).
+ */
+int dso__synthesize_plt_symbols(struct dso *dso, struct symsrc *ss, struct map *map,
+                                symbol_filter_t filter)
+{
+        uint32_t nr_rel_entries, idx;
+        GElf_Sym sym;
+        u64 plt_offset;
+        GElf_Shdr shdr_plt;
+        struct symbol *f;
+        GElf_Shdr shdr_rel_plt, shdr_dynsym;
+        Elf_Data *reldata, *syms, *symstrs;
+        Elf_Scn *scn_plt_rel, *scn_symstrs, *scn_dynsym;
+        size_t dynsym_idx;
+        GElf_Ehdr ehdr;
+        char sympltname[1024];
+        Elf *elf;
+        int nr = 0, symidx, err = 0;
+
+        if (!ss->dynsym)
+                return 0;
+
+        elf = ss->elf;
+        ehdr = ss->ehdr;
+
+        scn_dynsym = ss->dynsym;
+        shdr_dynsym = ss->dynshdr;
+        dynsym_idx = ss->dynsym_idx;
+
+        if (scn_dynsym == NULL)
+                goto out_elf_end;
+
+        scn_plt_rel = elf_section_by_name(elf, &ehdr, &shdr_rel_plt,
+                                          ".rela.plt", NULL);
+        if (scn_plt_rel == NULL) {
+                scn_plt_rel = elf_section_by_name(elf, &ehdr, &shdr_rel_plt,
+                                                  ".rel.plt", NULL);
+                if (scn_plt_rel == NULL)
+                        goto out_elf_end;
+        }
+
+        err = -1;
+
+        if (shdr_rel_plt.sh_link != dynsym_idx)
+                goto out_elf_end;
+
+        if (elf_section_by_name(elf, &ehdr, &shdr_plt, ".plt", NULL) == NULL)
+                goto out_elf_end;
+
+        /*
+         * Fetch the relocation section to find the idxes to the GOT
+         * and the symbols in the .dynsym they refer to.
+         */
+        reldata = elf_getdata(scn_plt_rel, NULL);
+        if (reldata == NULL)
+                goto out_elf_end;
+
+        syms = elf_getdata(scn_dynsym, NULL);
+        if (syms == NULL)
+                goto out_elf_end;
+
+        scn_symstrs = elf_getscn(elf, shdr_dynsym.sh_link);
+        if (scn_symstrs == NULL)
+                goto out_elf_end;
+
+        symstrs = elf_getdata(scn_symstrs, NULL);
+        if (symstrs == NULL)
+                goto out_elf_end;
+
+        if (symstrs->d_size == 0)
+                goto out_elf_end;
+
+        nr_rel_entries = shdr_rel_plt.sh_size / shdr_rel_plt.sh_entsize;
+        plt_offset = shdr_plt.sh_offset;
+
+        if (shdr_rel_plt.sh_type == SHT_RELA) {
+                GElf_Rela pos_mem, *pos;
+
+                elf_section__for_each_rela(reldata, pos, pos_mem, idx,
+                                           nr_rel_entries) {
+                        symidx = GELF_R_SYM(pos->r_info);
+                        plt_offset += shdr_plt.sh_entsize;
+                        gelf_getsym(syms, symidx, &sym);
+                        snprintf(sympltname, sizeof(sympltname),
+                                 "%s@plt", elf_sym__name(&sym, symstrs));
+
+                        f = symbol__new(plt_offset, shdr_plt.sh_entsize,
+                                        STB_GLOBAL, sympltname);
+                        if (!f)
+                                goto out_elf_end;
+
+                        if (filter && filter(map, f))
+                                symbol__delete(f);
+                        else {
+                                symbols__insert(&dso->symbols[map->type], f);
+                                ++nr;
+                        }
+                }
+        } else if (shdr_rel_plt.sh_type == SHT_REL) {
+                GElf_Rel pos_mem, *pos;
+                elf_section__for_each_rel(reldata, pos, pos_mem, idx,
+                                          nr_rel_entries) {
+                        symidx = GELF_R_SYM(pos->r_info);
+                        plt_offset += shdr_plt.sh_entsize;
+                        gelf_getsym(syms, symidx, &sym);
+                        snprintf(sympltname, sizeof(sympltname),
+                                 "%s@plt", elf_sym__name(&sym, symstrs));
+
+                        f = symbol__new(plt_offset, shdr_plt.sh_entsize,
+                                        STB_GLOBAL, sympltname);
+                        if (!f)
+                                goto out_elf_end;
+
+                        if (filter && filter(map, f))
+                                symbol__delete(f);
+                        else {
+                                symbols__insert(&dso->symbols[map->type], f);
+                                ++nr;
+                        }
+                }
+        }
+
+        err = 0;
+out_elf_end:
+        if (err == 0)
+                return nr;
+        pr_debug("%s: problems reading %s PLT info.\n",
+                 __func__, dso->long_name);
+        return 0;
+}
+
+/*
+ * Align offset to 4 bytes as needed for note name and descriptor data.
+ */
+#define NOTE_ALIGN(n) (((n) + 3) & -4U)
+
+static int elf_read_build_id(Elf *elf, void *bf, size_t size)
+{
+        int err = -1;
+        GElf_Ehdr ehdr;
+        GElf_Shdr shdr;
+        Elf_Data *data;
+        Elf_Scn *sec;
+        Elf_Kind ek;
+        void *ptr;
+
+        if (size < BUILD_ID_SIZE)
+                goto out;
+
+        ek = elf_kind(elf);
+        if (ek != ELF_K_ELF)
+                goto out;
+
+        if (gelf_getehdr(elf, &ehdr) == NULL) {
+                pr_err("%s: cannot get elf header.\n", __func__);
+                goto out;
+        }
+
+        /*
+         * Check following sections for notes:
+         *   '.note.gnu.build-id'
+         *   '.notes'
+         *   '.note' (VDSO specific)
+         */
+        do {
+                sec = elf_section_by_name(elf, &ehdr, &shdr,
+                                          ".note.gnu.build-id", NULL);
+                if (sec)
+                        break;
+
+                sec = elf_section_by_name(elf, &ehdr, &shdr,
+                                          ".notes", NULL);
+                if (sec)
+                        break;
+
+                sec = elf_section_by_name(elf, &ehdr, &shdr,
+                                          ".note", NULL);
+                if (sec)
+                        break;
+
+                return err;
+
+        } while (0);
+
+        data = elf_getdata(sec, NULL);
+        if (data == NULL)
+                goto out;
+
+        ptr = data->d_buf;
+        while (ptr < (data->d_buf + data->d_size)) {
+                GElf_Nhdr *nhdr = ptr;
+                size_t namesz = NOTE_ALIGN(nhdr->n_namesz),
+                       descsz = NOTE_ALIGN(nhdr->n_descsz);
+                const char *name;
+
+                ptr += sizeof(*nhdr);
+                name = ptr;
+                ptr += namesz;
+                if (nhdr->n_type == NT_GNU_BUILD_ID &&
+                    nhdr->n_namesz == sizeof("GNU")) {
+                        if (memcmp(name, "GNU", sizeof("GNU")) == 0) {
+                                size_t sz = min(size, descsz);
+                                memcpy(bf, ptr, sz);
+                                memset(bf + sz, 0, size - sz);
+                                err = descsz;
+                                break;
+                        }
+                }
+                ptr += descsz;
+        }
+
+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);
+out:
+        return err;
+}
+
+int sysfs__read_build_id(const char *filename, void *build_id, size_t size)
+{
+        int fd, err = -1;
+
+        if (size < BUILD_ID_SIZE)
+                goto out;
+
+        fd = open(filename, O_RDONLY);
+        if (fd < 0)
+                goto out;
+
+        while (1) {
+                char bf[BUFSIZ];
+                GElf_Nhdr nhdr;
+                size_t namesz, descsz;
+
+                if (read(fd, &nhdr, sizeof(nhdr)) != sizeof(nhdr))
+                        break;
+
+                namesz = NOTE_ALIGN(nhdr.n_namesz);
+                descsz = NOTE_ALIGN(nhdr.n_descsz);
+                if (nhdr.n_type == NT_GNU_BUILD_ID &&
+                    nhdr.n_namesz == sizeof("GNU")) {
+                        if (read(fd, bf, namesz) != (ssize_t)namesz)
+                                break;
+                        if (memcmp(bf, "GNU", sizeof("GNU")) == 0) {
+                                size_t sz = min(descsz, size);
+                                if (read(fd, build_id, sz) == (ssize_t)sz) {
+                                        memset(build_id + sz, 0, size - sz);
+                                        err = 0;
+                                        break;
+                                }
+                        } else if (read(fd, bf, descsz) != (ssize_t)descsz)
+                                break;
+                } else {
+                        int n = namesz + descsz;
+                        if (read(fd, bf, n) != n)
+                                break;
+                }
+        }
+        close(fd);
+out:
+        return err;
+}
+
+int filename__read_debuglink(const char *filename, char *debuglink,
+                             size_t size)
+{
+        int fd, err = -1;
+        Elf *elf;
+        GElf_Ehdr ehdr;
+        GElf_Shdr shdr;
+        Elf_Data *data;
+        Elf_Scn *sec;
+        Elf_Kind ek;
+
+        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_close;
+
+        if (gelf_getehdr(elf, &ehdr) == NULL) {
+                pr_err("%s: cannot get elf header.\n", __func__);
+                goto out_close;
+        }
+
+        sec = elf_section_by_name(elf, &ehdr, &shdr,
+                                  ".gnu_debuglink", NULL);
+        if (sec == NULL)
+                goto out_close;
+
+        data = elf_getdata(sec, NULL);
+        if (data == NULL)
+                goto out_close;
+
+        /* the start of this section is a zero-terminated string */
+        strncpy(debuglink, data->d_buf, size);
+
+        elf_end(elf);
+
+out_close:
+        close(fd);
+out:
+        return err;
+}
+
+static int dso__swap_init(struct dso *dso, unsigned char eidata)
+{
+        static unsigned int const endian = 1;
+
+        dso->needs_swap = DSO_SWAP__NO;
+
+        switch (eidata) {
+        case ELFDATA2LSB:
+                /* We are big endian, DSO is little endian. */
+                if (*(unsigned char const *)&endian != 1)
+                        dso->needs_swap = DSO_SWAP__YES;
+                break;
+
+        case ELFDATA2MSB:
+                /* We are little endian, DSO is big endian. */
+                if (*(unsigned char const *)&endian != 0)
+                        dso->needs_swap = DSO_SWAP__YES;
+                break;
+
+        default:
+                pr_err("unrecognized DSO data encoding %d\n", eidata);
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
+bool symsrc__possibly_runtime(struct symsrc *ss)
+{
+        return ss->dynsym || ss->opdsec;
+}
+
+bool symsrc__has_symtab(struct symsrc *ss)
+{
+        return ss->symtab != NULL;
+}
+
+void symsrc__destroy(struct symsrc *ss)
+{
+        free(ss->name);
+        elf_end(ss->elf);
+        close(ss->fd);
+}
+
+int symsrc__init(struct symsrc *ss, struct dso *dso, const char *name,
+                 enum dso_binary_type type)
+{
+        int err = -1;
+        GElf_Ehdr ehdr;
+        Elf *elf;
+        int fd;
+
+        fd = open(name, O_RDONLY);
+        if (fd < 0)
+                return -1;
+
+        elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
+        if (elf == NULL) {
+                pr_debug("%s: cannot read %s ELF file.\n", __func__, name);
+                goto out_close;
+        }
+
+        if (gelf_getehdr(elf, &ehdr) == NULL) {
+                pr_debug("%s: cannot get elf header.\n", __func__);
+                goto out_elf_end;
+        }
+
+        if (dso__swap_init(dso, ehdr.e_ident[EI_DATA]))
+                goto out_elf_end;
+
+        /* Always reject images with a mismatched build-id: */
+        if (dso->has_build_id) {
+                u8 build_id[BUILD_ID_SIZE];
+
+                if (elf_read_build_id(elf, build_id, BUILD_ID_SIZE) < 0)
+                        goto out_elf_end;
+
+                if (!dso__build_id_equal(dso, build_id))
+                        goto out_elf_end;
+        }
+
+        ss->symtab = elf_section_by_name(elf, &ehdr, &ss->symshdr, ".symtab",
+                        NULL);
+        if (ss->symshdr.sh_type != SHT_SYMTAB)
+                ss->symtab = NULL;
+
+        ss->dynsym_idx = 0;
+        ss->dynsym = elf_section_by_name(elf, &ehdr, &ss->dynshdr, ".dynsym",
+                        &ss->dynsym_idx);
+        if (ss->dynshdr.sh_type != SHT_DYNSYM)
+                ss->dynsym = NULL;
+
+        ss->opdidx = 0;
+        ss->opdsec = elf_section_by_name(elf, &ehdr, &ss->opdshdr, ".opd",
+                        &ss->opdidx);
+        if (ss->opdshdr.sh_type != SHT_PROGBITS)
+                ss->opdsec = NULL;
+
+        if (dso->kernel == DSO_TYPE_USER) {
+                GElf_Shdr shdr;
+                ss->adjust_symbols = (ehdr.e_type == ET_EXEC ||
+                                elf_section_by_name(elf, &ehdr, &shdr,
+                                                     ".gnu.prelink_undo",
+                                                     NULL) != NULL);
+        } else {
+                ss->adjust_symbols = 0;
+        }
+
+        ss->name   = strdup(name);
+        if (!ss->name)
+                goto out_elf_end;
+
+        ss->elf    = elf;
+        ss->fd     = fd;
+        ss->ehdr   = ehdr;
+        ss->type   = type;
+
+        return 0;
+
+out_elf_end:
+        elf_end(elf);
+out_close:
+        close(fd);
+        return err;
+}
+
+int dso__load_sym(struct dso *dso, struct map *map,
+                  struct symsrc *syms_ss, struct symsrc *runtime_ss,
+                  symbol_filter_t filter, int kmodule)
+{
+        struct kmap *kmap = dso->kernel ? map__kmap(map) : NULL;
+        struct map *curr_map = map;
+        struct dso *curr_dso = dso;
+        Elf_Data *symstrs, *secstrs;
+        uint32_t nr_syms;
+        int err = -1;
+        uint32_t idx;
+        GElf_Ehdr ehdr;
+        GElf_Shdr shdr;
+        Elf_Data *syms, *opddata = NULL;
+        GElf_Sym sym;
+        Elf_Scn *sec, *sec_strndx;
+        Elf *elf;
+        int nr = 0;
+
+        dso->symtab_type = syms_ss->type;
+
+        if (!syms_ss->symtab) {
+                syms_ss->symtab  = syms_ss->dynsym;
+                syms_ss->symshdr = syms_ss->dynshdr;
+        }
+
+        elf = syms_ss->elf;
+        ehdr = syms_ss->ehdr;
+        sec = syms_ss->symtab;
+        shdr = syms_ss->symshdr;
+
+        if (runtime_ss->opdsec)
+                opddata = elf_rawdata(runtime_ss->opdsec, NULL);
+
+        syms = elf_getdata(sec, NULL);
+        if (syms == NULL)
+                goto out_elf_end;
+
+        sec = elf_getscn(elf, shdr.sh_link);
+        if (sec == NULL)
+                goto out_elf_end;
+
+        symstrs = elf_getdata(sec, NULL);
+        if (symstrs == NULL)
+                goto out_elf_end;
+
+        sec_strndx = elf_getscn(elf, ehdr.e_shstrndx);
+        if (sec_strndx == NULL)
+                goto out_elf_end;
+
+        secstrs = elf_getdata(sec_strndx, NULL);
+        if (secstrs == NULL)
+                goto out_elf_end;
+
+        nr_syms = shdr.sh_size / shdr.sh_entsize;
+
+        memset(&sym, 0, sizeof(sym));
+        dso->adjust_symbols = runtime_ss->adjust_symbols;
+        elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) {
+                struct symbol *f;
+                const char *elf_name = elf_sym__name(&sym, symstrs);
+                char *demangled = NULL;
+                int is_label = elf_sym__is_label(&sym);
+                const char *section_name;
+                bool used_opd = false;
+
+                if (kmap && kmap->ref_reloc_sym && kmap->ref_reloc_sym->name &&
+                    strcmp(elf_name, kmap->ref_reloc_sym->name) == 0)
+                        kmap->ref_reloc_sym->unrelocated_addr = sym.st_value;
+
+                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 (runtime_ss->opdsec && sym.st_shndx == runtime_ss->opdidx) {
+                        u32 offset = sym.st_value - syms_ss->opdshdr.sh_addr;
+                        u64 *opd = opddata->d_buf + offset;
+                        sym.st_value = DSO__SWAP(dso, u64, *opd);
+                        sym.st_shndx = elf_addr_to_index(runtime_ss->elf,
+                                        sym.st_value);
+                        used_opd = true;
+                }
+
+                sec = elf_getscn(runtime_ss->elf, sym.st_shndx);
+                if (!sec)
+                        goto out_elf_end;
+
+                gelf_getshdr(sec, &shdr);
+
+                if (is_label && !elf_sec__is_a(&shdr, secstrs, map->type))
+                        continue;
+
+                section_name = elf_sec__name(&shdr, secstrs);
+
+                /* On ARM, symbols for thumb functions have 1 added to
+                 * the symbol address as a flag - remove it */
+                if ((ehdr.e_machine == EM_ARM) &&
+                    (map->type == MAP__FUNCTION) &&
+                    (sym.st_value & 1))
+                        --sym.st_value;
+
+                if (dso->kernel != DSO_TYPE_USER || kmodule) {
+                        char dso_name[PATH_MAX];
+
+                        if (strcmp(section_name,
+                                   (curr_dso->short_name +
+                                    dso->short_name_len)) == 0)
+                                goto new_symbol;
+
+                        if (strcmp(section_name, ".text") == 0) {
+                                curr_map = map;
+                                curr_dso = dso;
+                                goto new_symbol;
+                        }
+
+                        snprintf(dso_name, sizeof(dso_name),
+                                 "%s%s", dso->short_name, section_name);
+
+                        curr_map = map_groups__find_by_name(kmap->kmaps, map->type, dso_name);
+                        if (curr_map == NULL) {
+                                u64 start = sym.st_value;
+
+                                if (kmodule)
+                                        start += map->start + shdr.sh_offset;
+
+                                curr_dso = dso__new(dso_name);
+                                if (curr_dso == NULL)
+                                        goto out_elf_end;
+                                curr_dso->kernel = dso->kernel;
+                                curr_dso->long_name = dso->long_name;
+                                curr_dso->long_name_len = dso->long_name_len;
+                                curr_map = map__new2(start, curr_dso,
+                                                     map->type);
+                                if (curr_map == NULL) {
+                                        dso__delete(curr_dso);
+                                        goto out_elf_end;
+                                }
+                                curr_map->map_ip = identity__map_ip;
+                                curr_map->unmap_ip = identity__map_ip;
+                                curr_dso->symtab_type = dso->symtab_type;
+                                map_groups__insert(kmap->kmaps, curr_map);
+                                dsos__add(&dso->node, curr_dso);
+                                dso__set_loaded(curr_dso, map->type);
+                        } else
+                                curr_dso = curr_map->dso;
+
+                        goto new_symbol;
+                }
+
+                if ((used_opd && runtime_ss->adjust_symbols)
+                                || (!used_opd && syms_ss->adjust_symbols)) {
+                        pr_debug4("%s: adjusting symbol: st_value: %#" PRIx64 " "
+                                  "sh_addr: %#" PRIx64 " sh_offset: %#" PRIx64 "\n", __func__,
+                                  (u64)sym.st_value, (u64)shdr.sh_addr,
+                                  (u64)shdr.sh_offset);
+                        sym.st_value -= shdr.sh_addr - shdr.sh_offset;
+                }
+                /*
+                 * We need to figure out if the object was created from C++ sources
+                 * DWARF DW_compile_unit has this, but we don't always have access
+                 * to it...
+                 */
+                demangled = bfd_demangle(NULL, elf_name, DMGL_PARAMS | DMGL_ANSI);
+                if (demangled != NULL)
+                        elf_name = demangled;
+new_symbol:
+                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;
+
+                if (filter && filter(curr_map, f))
+                        symbol__delete(f);
+                else {
+                        symbols__insert(&curr_dso->symbols[curr_map->type], f);
+                        nr++;
+                }
+        }
+
+        /*
+         * For misannotated, zeroed, ASM function sizes.
+         */
+        if (nr > 0) {
+                symbols__fixup_duplicate(&dso->symbols[map->type]);
+                symbols__fixup_end(&dso->symbols[map->type]);
+                if (kmap) {
+                        /*
+                         * We need to fixup this here too because we create new
+                         * maps here, for things like vsyscall sections.
+                         */
+                        __map_groups__fixup_end(kmap->kmaps, map->type);
+                }
+        }
+        err = nr;
+out_elf_end:
+        return err;
+}
+
+void symbol__elf_init(void)
+{
+        elf_version(EV_CURRENT);
+}
diff --git a/tools/perf/util/symbol-minimal.c b/tools/perf/util/symbol-minimal.c
new file mode 100644
index 000000000000..259f8f2ea9c9
--- /dev/null
+++ b/tools/perf/util/symbol-minimal.c
@@ -0,0 +1,307 @@
+#include "symbol.h"
+
+#include <elf.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <string.h>
+#include <byteswap.h>
+#include <sys/stat.h>
+
+
+static bool check_need_swap(int file_endian)
+{
+        const int data = 1;
+        u8 *check = (u8 *)&data;
+        int host_endian;
+
+        if (check[0] == 1)
+                host_endian = ELFDATA2LSB;
+        else
+                host_endian = ELFDATA2MSB;
+
+        return host_endian != file_endian;
+}
+
+#define NOTE_ALIGN(sz) (((sz) + 3) & ~3)
+
+#define NT_GNU_BUILD_ID 3
+
+static int read_build_id(void *note_data, size_t note_len, void *bf,
+                         size_t size, bool need_swap)
+{
+        struct {
+                u32 n_namesz;
+                u32 n_descsz;
+                u32 n_type;
+        } *nhdr;
+        void *ptr;
+
+        ptr = note_data;
+        while (ptr < (note_data + note_len)) {
+                const char *name;
+                size_t namesz, descsz;
+
+                nhdr = ptr;
+                if (need_swap) {
+                        nhdr->n_namesz = bswap_32(nhdr->n_namesz);
+                        nhdr->n_descsz = bswap_32(nhdr->n_descsz);
+                        nhdr->n_type = bswap_32(nhdr->n_type);
+                }
+
+                namesz = NOTE_ALIGN(nhdr->n_namesz);
+                descsz = NOTE_ALIGN(nhdr->n_descsz);
+
+                ptr += sizeof(*nhdr);
+                name = ptr;
+                ptr += namesz;
+                if (nhdr->n_type == NT_GNU_BUILD_ID &&
+                    nhdr->n_namesz == sizeof("GNU")) {
+                        if (memcmp(name, "GNU", sizeof("GNU")) == 0) {
+                                size_t sz = min(size, descsz);
+                                memcpy(bf, ptr, sz);
+                                memset(bf + sz, 0, size - sz);
+                                return 0;
+                        }
+                }
+                ptr += descsz;
+        }
+
+        return -1;
+}
+
+int filename__read_debuglink(const char *filename __maybe_unused,
+                             char *debuglink __maybe_unused,
+                             size_t size __maybe_unused)
+{
+        return -1;
+}
+
+/*
+ * Just try PT_NOTE header otherwise fails
+ */
+int filename__read_build_id(const char *filename, void *bf, size_t size)
+{
+        FILE *fp;
+        int ret = -1;
+        bool need_swap = false;
+        u8 e_ident[EI_NIDENT];
+        size_t buf_size;
+        void *buf;
+        int i;
+
+        fp = fopen(filename, "r");
+        if (fp == NULL)
+                return -1;
+
+        if (fread(e_ident, sizeof(e_ident), 1, fp) != 1)
+                goto out;
+
+        if (memcmp(e_ident, ELFMAG, SELFMAG) ||
+            e_ident[EI_VERSION] != EV_CURRENT)
+                goto out;
+
+        need_swap = check_need_swap(e_ident[EI_DATA]);
+
+        /* for simplicity */
+        fseek(fp, 0, SEEK_SET);
+
+        if (e_ident[EI_CLASS] == ELFCLASS32) {
+                Elf32_Ehdr ehdr;
+                Elf32_Phdr *phdr;
+
+                if (fread(&ehdr, sizeof(ehdr), 1, fp) != 1)
+                        goto out;
+
+                if (need_swap) {
+                        ehdr.e_phoff = bswap_32(ehdr.e_phoff);
+                        ehdr.e_phentsize = bswap_16(ehdr.e_phentsize);
+                        ehdr.e_phnum = bswap_16(ehdr.e_phnum);
+                }
+
+                buf_size = ehdr.e_phentsize * ehdr.e_phnum;
+                buf = malloc(buf_size);
+                if (buf == NULL)
+                        goto out;
+
+                fseek(fp, ehdr.e_phoff, SEEK_SET);
+                if (fread(buf, buf_size, 1, fp) != 1)
+                        goto out_free;
+
+                for (i = 0, phdr = buf; i < ehdr.e_phnum; i++, phdr++) {
+                        void *tmp;
+
+                        if (need_swap) {
+                                phdr->p_type = bswap_32(phdr->p_type);
+                                phdr->p_offset = bswap_32(phdr->p_offset);
+                                phdr->p_filesz = bswap_32(phdr->p_filesz);
+                        }
+
+                        if (phdr->p_type != PT_NOTE)
+                                continue;
+
+                        buf_size = phdr->p_filesz;
+                        tmp = realloc(buf, buf_size);
+                        if (tmp == NULL)
+                                goto out_free;
+
+                        buf = tmp;
+                        fseek(fp, phdr->p_offset, SEEK_SET);
+                        if (fread(buf, buf_size, 1, fp) != 1)
+                                goto out_free;
+
+                        ret = read_build_id(buf, buf_size, bf, size, need_swap);
+                        if (ret == 0)
+                                ret = size;
+                        break;
+                }
+        } else {
+                Elf64_Ehdr ehdr;
+                Elf64_Phdr *phdr;
+
+                if (fread(&ehdr, sizeof(ehdr), 1, fp) != 1)
+                        goto out;
+
+                if (need_swap) {
+                        ehdr.e_phoff = bswap_64(ehdr.e_phoff);
+                        ehdr.e_phentsize = bswap_16(ehdr.e_phentsize);
+                        ehdr.e_phnum = bswap_16(ehdr.e_phnum);
+                }
+
+                buf_size = ehdr.e_phentsize * ehdr.e_phnum;
+                buf = malloc(buf_size);
+                if (buf == NULL)
+                        goto out;
+
+                fseek(fp, ehdr.e_phoff, SEEK_SET);
+                if (fread(buf, buf_size, 1, fp) != 1)
+                        goto out_free;
+
+                for (i = 0, phdr = buf; i < ehdr.e_phnum; i++, phdr++) {
+                        void *tmp;
+
+                        if (need_swap) {
+                                phdr->p_type = bswap_32(phdr->p_type);
+                                phdr->p_offset = bswap_64(phdr->p_offset);
+                                phdr->p_filesz = bswap_64(phdr->p_filesz);
+                        }
+
+                        if (phdr->p_type != PT_NOTE)
+                                continue;
+
+                        buf_size = phdr->p_filesz;
+                        tmp = realloc(buf, buf_size);
+                        if (tmp == NULL)
+                                goto out_free;
+
+                        buf = tmp;
+                        fseek(fp, phdr->p_offset, SEEK_SET);
+                        if (fread(buf, buf_size, 1, fp) != 1)
+                                goto out_free;
+
+                        ret = read_build_id(buf, buf_size, bf, size, need_swap);
+                        if (ret == 0)
+                                ret = size;
+                        break;
+                }
+        }
+out_free:
+        free(buf);
+out:
+        fclose(fp);
+        return ret;
+}
+
+int sysfs__read_build_id(const char *filename, void *build_id, size_t size)
+{
+        int fd;
+        int ret = -1;
+        struct stat stbuf;
+        size_t buf_size;
+        void *buf;
+
+        fd = open(filename, O_RDONLY);
+        if (fd < 0)
+                return -1;
+
+        if (fstat(fd, &stbuf) < 0)
+                goto out;
+
+        buf_size = stbuf.st_size;
+        buf = malloc(buf_size);
+        if (buf == NULL)
+                goto out;
+
+        if (read(fd, buf, buf_size) != (ssize_t) buf_size)
+                goto out_free;
+
+        ret = read_build_id(buf, buf_size, build_id, size, false);
+out_free:
+        free(buf);
+out:
+        close(fd);
+        return ret;
+}
+
+int symsrc__init(struct symsrc *ss, struct dso *dso __maybe_unused,
+                 const char *name,
+                 enum dso_binary_type type)
+{
+        int fd = open(name, O_RDONLY);
+        if (fd < 0)
+                return -1;
+
+        ss->name = strdup(name);
+        if (!ss->name)
+                goto out_close;
+
+        ss->type = type;
+
+        return 0;
+out_close:
+        close(fd);
+        return -1;
+}
+
+bool symsrc__possibly_runtime(struct symsrc *ss __maybe_unused)
+{
+        /* Assume all sym sources could be a runtime image. */
+        return true;
+}
+
+bool symsrc__has_symtab(struct symsrc *ss __maybe_unused)
+{
+        return false;
+}
+
+void symsrc__destroy(struct symsrc *ss)
+{
+        free(ss->name);
+        close(ss->fd);
+}
+
+int dso__synthesize_plt_symbols(struct dso *dso __maybe_unused,
+                                struct symsrc *ss __maybe_unused,
+                                struct map *map __maybe_unused,
+                                symbol_filter_t filter __maybe_unused)
+{
+        return 0;
+}
+
+int dso__load_sym(struct dso *dso, struct map *map __maybe_unused,
+                  struct symsrc *ss,
+                  struct symsrc *runtime_ss __maybe_unused,
+                  symbol_filter_t filter __maybe_unused,
+                  int kmodule __maybe_unused)
+{
+        unsigned char *build_id[BUILD_ID_SIZE];
+
+        if (filename__read_build_id(ss->name, build_id, BUILD_ID_SIZE) > 0) {
+                dso__set_build_id(dso, build_id);
+                return 1;
+        }
+        return 0;
+}
+
+void symbol__elf_init(void)
+{
+}
diff --git a/tools/perf/util/symbol.c b/tools/perf/util/symbol.c
index 8b63b678e127..e2e8c697cffe 100644
--- a/tools/perf/util/symbol.c
+++ b/tools/perf/util/symbol.c
@@ -15,8 +15,6 @@
 #include "symbol.h"
 #include "strlist.h"
 
-#include <libelf.h>
-#include <gelf.h>
 #include <elf.h>
 #include <limits.h>
 #include <sys/utsname.h>
@@ -25,15 +23,7 @@
 #define KSYM_NAME_LEN 256
 #endif
 
-#ifndef NT_GNU_BUILD_ID
-#define NT_GNU_BUILD_ID 3
-#endif
-
 static void dso_cache__free(struct rb_root *root);
-static bool dso__build_id_equal(const struct dso *dso, 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 *dso, struct map *map,
                                 symbol_filter_t filter);
 static int dso__load_guest_kernel_sym(struct dso *dso, struct map *map,
@@ -170,7 +160,7 @@ static int choose_best_symbol(struct symbol *syma, struct symbol *symb)
                 return SYMBOL_B;
 }
 
-static void symbols__fixup_duplicate(struct rb_root *symbols)
+void symbols__fixup_duplicate(struct rb_root *symbols)
 {
         struct rb_node *nd;
         struct symbol *curr, *next;
@@ -199,7 +189,7 @@ again:
         }
 }
 
-static void symbols__fixup_end(struct rb_root *symbols)
+void symbols__fixup_end(struct rb_root *symbols)
 {
         struct rb_node *nd, *prevnd = rb_first(symbols);
         struct symbol *curr, *prev;
@@ -222,7 +212,7 @@ static void symbols__fixup_end(struct rb_root *symbols)
                 curr->end = roundup(curr->start, 4096);
 }
 
-static void __map_groups__fixup_end(struct map_groups *mg, enum map_type type)
+void __map_groups__fixup_end(struct map_groups *mg, enum map_type type)
 {
         struct map *prev, *curr;
         struct rb_node *nd, *prevnd = rb_first(&mg->maps[type]);
@@ -252,8 +242,7 @@ static void map_groups__fixup_end(struct map_groups *mg)
                 __map_groups__fixup_end(mg, i);
 }
 
-static struct symbol *symbol__new(u64 start, u64 len, u8 binding,
-                                  const char *name)
+struct symbol *symbol__new(u64 start, u64 len, u8 binding, const char *name)
 {
         size_t namelen = strlen(name) + 1;
         struct symbol *sym = calloc(1, (symbol_conf.priv_size +
@@ -390,7 +379,7 @@ void dso__set_build_id(struct dso *dso, void *build_id)
         dso->has_build_id = 1;
 }
 
-static void symbols__insert(struct rb_root *symbols, struct symbol *sym)
+void symbols__insert(struct rb_root *symbols, struct symbol *sym)
 {
         struct rb_node **p = &symbols->rb_node;
         struct rb_node *parent = NULL;
@@ -574,7 +563,7 @@ size_t dso__fprintf(struct dso *dso, enum map_type type, FILE *fp)
 
 int kallsyms__parse(const char *filename, void *arg,
                     int (*process_symbol)(void *arg, const char *name,
-                                          char type, u64 start, u64 end))
+                                          char type, u64 start))
 {
         char *line = NULL;
         size_t n;
@@ -614,13 +603,8 @@ int kallsyms__parse(const char *filename, void *arg,
                         break;
                 }
 
-                /*
-                 * module symbols are not sorted so we add all
-                 * symbols with zero length and rely on
-                 * symbols__fixup_end() to fix it up.
-                 */
                 err = process_symbol(arg, symbol_name,
-                                     symbol_type, start, start);
+                                     symbol_type, start);
                 if (err)
                         break;
         }
@@ -647,7 +631,7 @@ static u8 kallsyms2elf_type(char type)
 }
 
 static int map__process_kallsym_symbol(void *arg, const char *name,
-                                       char type, u64 start, u64 end)
+                                       char type, u64 start)
 {
         struct symbol *sym;
         struct process_kallsyms_args *a = arg;
@@ -656,8 +640,12 @@ static int map__process_kallsym_symbol(void *arg, const char *name,
         if (!symbol_type__is_a(type, a->map->type))
                 return 0;
 
-        sym = symbol__new(start, end - start + 1,
-                          kallsyms2elf_type(type), name);
+        /*
+         * module symbols are not sorted so we add all
+         * symbols, setting length to 0, and rely on
+         * symbols__fixup_end() to fix it up.
+         */
+        sym = symbol__new(start, 0, kallsyms2elf_type(type), name);
         if (sym == NULL)
                 return -ENOMEM;
         /*
@@ -904,556 +892,7 @@ out_failure:
         return -1;
 }
 
-/**
- * elf_symtab__for_each_symbol - iterate thru all the symbols
- *
- * @syms: struct elf_symtab instance to iterate
- * @idx: uint32_t idx
- * @sym: GElf_Sym iterator
- */
-#define elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) \
-        for (idx = 0, gelf_getsym(syms, idx, &sym);\
-             idx < nr_syms; \
-             idx++, gelf_getsym(syms, idx, &sym))
-
-static inline uint8_t elf_sym__type(const GElf_Sym *sym)
-{
-        return GELF_ST_TYPE(sym->st_info);
-}
-
-static inline int elf_sym__is_function(const GElf_Sym *sym)
-{
-        return elf_sym__type(sym) == STT_FUNC &&
-               sym->st_name != 0 &&
-               sym->st_shndx != SHN_UNDEF;
-}
-
-static inline bool elf_sym__is_object(const GElf_Sym *sym)
-{
-        return elf_sym__type(sym) == STT_OBJECT &&
-                sym->st_name != 0 &&
-                sym->st_shndx != SHN_UNDEF;
-}
-
-static inline int elf_sym__is_label(const GElf_Sym *sym)
-{
-        return elf_sym__type(sym) == STT_NOTYPE &&
-                sym->st_name != 0 &&
-                sym->st_shndx != SHN_UNDEF &&
-                sym->st_shndx != SHN_ABS;
-}
-
-static inline const char *elf_sec__name(const GElf_Shdr *shdr,
-                                        const Elf_Data *secstrs)
-{
-        return secstrs->d_buf + shdr->sh_name;
-}
-
-static inline int elf_sec__is_text(const GElf_Shdr *shdr,
-                                        const Elf_Data *secstrs)
-{
-        return strstr(elf_sec__name(shdr, secstrs), "text") != NULL;
-}
-
-static inline bool elf_sec__is_data(const GElf_Shdr *shdr,
-                                    const Elf_Data *secstrs)
-{
-        return strstr(elf_sec__name(shdr, secstrs), "data") != NULL;
-}
-
-static inline const char *elf_sym__name(const GElf_Sym *sym,
-                                        const Elf_Data *symstrs)
-{
-        return symstrs->d_buf + sym->st_name;
-}
-
-static Elf_Scn *elf_section_by_name(Elf *elf, GElf_Ehdr *ep,
-                                    GElf_Shdr *shp, const char *name,
-                                    size_t *idx)
-{
-        Elf_Scn *sec = NULL;
-        size_t cnt = 1;
-
-        while ((sec = elf_nextscn(elf, sec)) != NULL) {
-                char *str;
-
-                gelf_getshdr(sec, shp);
-                str = elf_strptr(elf, ep->e_shstrndx, shp->sh_name);
-                if (!strcmp(name, str)) {
-                        if (idx)
-                                *idx = cnt;
-                        break;
-                }
-                ++cnt;
-        }
-
-        return sec;
-}
-
-#define elf_section__for_each_rel(reldata, pos, pos_mem, idx, nr_entries) \
-        for (idx = 0, pos = gelf_getrel(reldata, 0, &pos_mem); \
-             idx < nr_entries; \
-             ++idx, pos = gelf_getrel(reldata, idx, &pos_mem))
-
-#define elf_section__for_each_rela(reldata, pos, pos_mem, idx, nr_entries) \
-        for (idx = 0, pos = gelf_getrela(reldata, 0, &pos_mem); \
-             idx < nr_entries; \
-             ++idx, pos = gelf_getrela(reldata, idx, &pos_mem))
-
-/*
- * We need to check if we have a .dynsym, so that we can handle the
- * .plt, synthesizing its symbols, that aren't on the symtabs (be it
- * .dynsym or .symtab).
- * And always look at the original dso, not at debuginfo packages, that
- * have the PLT data stripped out (shdr_rel_plt.sh_type == SHT_NOBITS).
- */
-static int
-dso__synthesize_plt_symbols(struct dso *dso, char *name, struct map *map,
-                            symbol_filter_t filter)
-{
-        uint32_t nr_rel_entries, idx;
-        GElf_Sym sym;
-        u64 plt_offset;
-        GElf_Shdr shdr_plt;
-        struct symbol *f;
-        GElf_Shdr shdr_rel_plt, shdr_dynsym;
-        Elf_Data *reldata, *syms, *symstrs;
-        Elf_Scn *scn_plt_rel, *scn_symstrs, *scn_dynsym;
-        size_t dynsym_idx;
-        GElf_Ehdr ehdr;
-        char sympltname[1024];
-        Elf *elf;
-        int nr = 0, symidx, fd, err = 0;
-
-        fd = open(name, O_RDONLY);
-        if (fd < 0)
-                goto out;
-
-        elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
-        if (elf == NULL)
-                goto out_close;
-
-        if (gelf_getehdr(elf, &ehdr) == NULL)
-                goto out_elf_end;
-
-        scn_dynsym = elf_section_by_name(elf, &ehdr, &shdr_dynsym,
-                                         ".dynsym", &dynsym_idx);
-        if (scn_dynsym == NULL)
-                goto out_elf_end;
-
-        scn_plt_rel = elf_section_by_name(elf, &ehdr, &shdr_rel_plt,
-                                          ".rela.plt", NULL);
-        if (scn_plt_rel == NULL) {
-                scn_plt_rel = elf_section_by_name(elf, &ehdr, &shdr_rel_plt,
-                                                  ".rel.plt", NULL);
-                if (scn_plt_rel == NULL)
-                        goto out_elf_end;
-        }
-
-        err = -1;
-
-        if (shdr_rel_plt.sh_link != dynsym_idx)
-                goto out_elf_end;
-
-        if (elf_section_by_name(elf, &ehdr, &shdr_plt, ".plt", NULL) == NULL)
-                goto out_elf_end;
-
-        /*
-         * Fetch the relocation section to find the idxes to the GOT
-         * and the symbols in the .dynsym they refer to.
-         */
-        reldata = elf_getdata(scn_plt_rel, NULL);
-        if (reldata == NULL)
-                goto out_elf_end;
-
-        syms = elf_getdata(scn_dynsym, NULL);
-        if (syms == NULL)
-                goto out_elf_end;
-
-        scn_symstrs = elf_getscn(elf, shdr_dynsym.sh_link);
-        if (scn_symstrs == NULL)
-                goto out_elf_end;
-
-        symstrs = elf_getdata(scn_symstrs, NULL);
-        if (symstrs == NULL)
-                goto out_elf_end;
-
-        nr_rel_entries = shdr_rel_plt.sh_size / shdr_rel_plt.sh_entsize;
-        plt_offset = shdr_plt.sh_offset;
-
-        if (shdr_rel_plt.sh_type == SHT_RELA) {
-                GElf_Rela pos_mem, *pos;
-
-                elf_section__for_each_rela(reldata, pos, pos_mem, idx,
-                                           nr_rel_entries) {
-                        symidx = GELF_R_SYM(pos->r_info);
-                        plt_offset += shdr_plt.sh_entsize;
-                        gelf_getsym(syms, symidx, &sym);
-                        snprintf(sympltname, sizeof(sympltname),
-                                 "%s@plt", elf_sym__name(&sym, symstrs));
-
-                        f = symbol__new(plt_offset, shdr_plt.sh_entsize,
-                                        STB_GLOBAL, sympltname);
-                        if (!f)
-                                goto out_elf_end;
-
-                        if (filter && filter(map, f))
-                                symbol__delete(f);
-                        else {
-                                symbols__insert(&dso->symbols[map->type], f);
-                                ++nr;
-                        }
-                }
-        } else if (shdr_rel_plt.sh_type == SHT_REL) {
-                GElf_Rel pos_mem, *pos;
-                elf_section__for_each_rel(reldata, pos, pos_mem, idx,
-                                          nr_rel_entries) {
-                        symidx = GELF_R_SYM(pos->r_info);
-                        plt_offset += shdr_plt.sh_entsize;
-                        gelf_getsym(syms, symidx, &sym);
-                        snprintf(sympltname, sizeof(sympltname),
-                                 "%s@plt", elf_sym__name(&sym, symstrs));
-
-                        f = symbol__new(plt_offset, shdr_plt.sh_entsize,
-                                        STB_GLOBAL, sympltname);
-                        if (!f)
-                                goto out_elf_end;
-
-                        if (filter && filter(map, f))
-                                symbol__delete(f);
-                        else {
-                                symbols__insert(&dso->symbols[map->type], f);
-                                ++nr;
-                        }
-                }
-        }
-
-        err = 0;
-out_elf_end:
-        elf_end(elf);
-out_close:
-        close(fd);
-
-        if (err == 0)
-                return nr;
-out:
-        pr_debug("%s: problems reading %s PLT info.\n",
-                 __func__, dso->long_name);
-        return 0;
-}
-
-static bool elf_sym__is_a(GElf_Sym *sym, enum map_type type)
-{
-        switch (type) {
-        case MAP__FUNCTION:
-                return elf_sym__is_function(sym);
-        case MAP__VARIABLE:
-                return elf_sym__is_object(sym);
-        default:
-                return false;
-        }
-}
-
-static bool elf_sec__is_a(GElf_Shdr *shdr, Elf_Data *secstrs,
-                          enum map_type type)
-{
-        switch (type) {
-        case MAP__FUNCTION:
-                return elf_sec__is_text(shdr, secstrs);
-        case MAP__VARIABLE:
-                return elf_sec__is_data(shdr, secstrs);
-        default:
-                return false;
-        }
-}
-
-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__swap_init(struct dso *dso, unsigned char eidata)
-{
-        static unsigned int const endian = 1;
-
-        dso->needs_swap = DSO_SWAP__NO;
-
-        switch (eidata) {
-        case ELFDATA2LSB:
-                /* We are big endian, DSO is little endian. */
-                if (*(unsigned char const *)&endian != 1)
-                        dso->needs_swap = DSO_SWAP__YES;
-                break;
-
-        case ELFDATA2MSB:
-                /* We are little endian, DSO is big endian. */
-                if (*(unsigned char const *)&endian != 0)
-                        dso->needs_swap = DSO_SWAP__YES;
-                break;
-
-        default:
-                pr_err("unrecognized DSO data encoding %d\n", eidata);
-                return -EINVAL;
-        }
-
-        return 0;
-}
-
-static int dso__load_sym(struct dso *dso, struct map *map, const char *name,
-                         int fd, symbol_filter_t filter, int kmodule,
-                         int want_symtab)
-{
-        struct kmap *kmap = dso->kernel ? map__kmap(map) : NULL;
-        struct map *curr_map = map;
-        struct dso *curr_dso = dso;
-        Elf_Data *symstrs, *secstrs;
-        uint32_t nr_syms;
-        int err = -1;
-        uint32_t idx;
-        GElf_Ehdr ehdr;
-        GElf_Shdr shdr, opdshdr;
-        Elf_Data *syms, *opddata = NULL;
-        GElf_Sym sym;
-        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_debug("%s: cannot read %s ELF file.\n", __func__, name);
-                goto out_close;
-        }
-
-        if (gelf_getehdr(elf, &ehdr) == NULL) {
-                pr_debug("%s: cannot get elf header.\n", __func__);
-                goto out_elf_end;
-        }
-
-        if (dso__swap_init(dso, ehdr.e_ident[EI_DATA]))
-                goto out_elf_end;
-
-        /* Always reject images with a mismatched build-id: */
-        if (dso->has_build_id) {
-                u8 build_id[BUILD_ID_SIZE];
-
-                if (elf_read_build_id(elf, build_id, BUILD_ID_SIZE) < 0)
-                        goto out_elf_end;
-
-                if (!dso__build_id_equal(dso, 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 (opdshdr.sh_type != SHT_PROGBITS)
-                opdsec = NULL;
-        if (opdsec)
-                opddata = elf_rawdata(opdsec, NULL);
-
-        syms = elf_getdata(sec, NULL);
-        if (syms == NULL)
-                goto out_elf_end;
-
-        sec = elf_getscn(elf, shdr.sh_link);
-        if (sec == NULL)
-                goto out_elf_end;
-
-        symstrs = elf_getdata(sec, NULL);
-        if (symstrs == NULL)
-                goto out_elf_end;
-
-        sec_strndx = elf_getscn(elf, ehdr.e_shstrndx);
-        if (sec_strndx == NULL)
-                goto out_elf_end;
-
-        secstrs = elf_getdata(sec_strndx, NULL);
-        if (secstrs == NULL)
-                goto out_elf_end;
-
-        nr_syms = shdr.sh_size / shdr.sh_entsize;
-
-        memset(&sym, 0, sizeof(sym));
-        if (dso->kernel == DSO_TYPE_USER) {
-                dso->adjust_symbols = (ehdr.e_type == ET_EXEC ||
-                                elf_section_by_name(elf, &ehdr, &shdr,
-                                                     ".gnu.prelink_undo",
-                                                     NULL) != NULL);
-        } else {
-                dso->adjust_symbols = 0;
-        }
-        elf_symtab__for_each_symbol(syms, nr_syms, idx, sym) {
-                struct symbol *f;
-                const char *elf_name = elf_sym__name(&sym, symstrs);
-                char *demangled = NULL;
-                int is_label = elf_sym__is_label(&sym);
-                const char *section_name;
-
-                if (kmap && kmap->ref_reloc_sym && kmap->ref_reloc_sym->name &&
-                    strcmp(elf_name, kmap->ref_reloc_sym->name) == 0)
-                        kmap->ref_reloc_sym->unrelocated_addr = sym.st_value;
-
-                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 = DSO__SWAP(dso, u64, *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;
-
-                gelf_getshdr(sec, &shdr);
-
-                if (is_label && !elf_sec__is_a(&shdr, secstrs, map->type))
-                        continue;
-
-                section_name = elf_sec__name(&shdr, secstrs);
-
-                /* On ARM, symbols for thumb functions have 1 added to
-                 * the symbol address as a flag - remove it */
-                if ((ehdr.e_machine == EM_ARM) &&
-                    (map->type == MAP__FUNCTION) &&
-                    (sym.st_value & 1))
-                        --sym.st_value;
-
-                if (dso->kernel != DSO_TYPE_USER || kmodule) {
-                        char dso_name[PATH_MAX];
-
-                        if (strcmp(section_name,
-                                   (curr_dso->short_name +
-                                    dso->short_name_len)) == 0)
-                                goto new_symbol;
-
-                        if (strcmp(section_name, ".text") == 0) {
-                                curr_map = map;
-                                curr_dso = dso;
-                                goto new_symbol;
-                        }
-
-                        snprintf(dso_name, sizeof(dso_name),
-                                 "%s%s", dso->short_name, section_name);
-
-                        curr_map = map_groups__find_by_name(kmap->kmaps, map->type, dso_name);
-                        if (curr_map == NULL) {
-                                u64 start = sym.st_value;
-
-                                if (kmodule)
-                                        start += map->start + shdr.sh_offset;
-
-                                curr_dso = dso__new(dso_name);
-                                if (curr_dso == NULL)
-                                        goto out_elf_end;
-                                curr_dso->kernel = dso->kernel;
-                                curr_dso->long_name = dso->long_name;
-                                curr_dso->long_name_len = dso->long_name_len;
-                                curr_map = map__new2(start, curr_dso,
-                                                     map->type);
-                                if (curr_map == NULL) {
-                                        dso__delete(curr_dso);
-                                        goto out_elf_end;
-                                }
-                                curr_map->map_ip = identity__map_ip;
-                                curr_map->unmap_ip = identity__map_ip;
-                                curr_dso->symtab_type = dso->symtab_type;
-                                map_groups__insert(kmap->kmaps, curr_map);
-                                dsos__add(&dso->node, curr_dso);
-                                dso__set_loaded(curr_dso, map->type);
-                        } else
-                                curr_dso = curr_map->dso;
-
-                        goto new_symbol;
-                }
-
-                if (curr_dso->adjust_symbols) {
-                        pr_debug4("%s: adjusting symbol: st_value: %#" PRIx64 " "
-                                  "sh_addr: %#" PRIx64 " sh_offset: %#" PRIx64 "\n", __func__,
-                                  (u64)sym.st_value, (u64)shdr.sh_addr,
-                                  (u64)shdr.sh_offset);
-                        sym.st_value -= shdr.sh_addr - shdr.sh_offset;
-                }
-                /*
-                 * We need to figure out if the object was created from C++ sources
-                 * DWARF DW_compile_unit has this, but we don't always have access
-                 * to it...
-                 */
-                demangled = bfd_demangle(NULL, elf_name, DMGL_PARAMS | DMGL_ANSI);
-                if (demangled != NULL)
-                        elf_name = demangled;
-new_symbol:
-                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;
-
-                if (filter && filter(curr_map, f))
-                        symbol__delete(f);
-                else {
-                        symbols__insert(&curr_dso->symbols[curr_map->type], f);
-                        nr++;
-                }
-        }
-
-        /*
-         * For misannotated, zeroed, ASM function sizes.
-         */
-        if (nr > 0) {
-                symbols__fixup_duplicate(&dso->symbols[map->type]);
-                symbols__fixup_end(&dso->symbols[map->type]);
-                if (kmap) {
-                        /*
-                         * We need to fixup this here too because we create new
-                         * maps here, for things like vsyscall sections.
-                         */
-                        __map_groups__fixup_end(kmap->kmaps, map->type);
-                }
-        }
-        err = nr;
-out_elf_end:
-        elf_end(elf);
-out_close:
-        return err;
-}
-
-static bool dso__build_id_equal(const struct dso *dso, u8 *build_id)
+bool dso__build_id_equal(const struct dso *dso, u8 *build_id)
 {
         return memcmp(dso->build_id, build_id, sizeof(dso->build_id)) == 0;
 }
@@ -1480,216 +919,11 @@ bool __dsos__read_build_ids(struct list_head *head, bool with_hits)
         return have_build_id;
 }
 
-/*
- * Align offset to 4 bytes as needed for note name and descriptor data.
- */
-#define NOTE_ALIGN(n) (((n) + 3) & -4U)
-
-static int elf_read_build_id(Elf *elf, void *bf, size_t size)
-{
-        int err = -1;
-        GElf_Ehdr ehdr;
-        GElf_Shdr shdr;
-        Elf_Data *data;
-        Elf_Scn *sec;
-        Elf_Kind ek;
-        void *ptr;
-
-        if (size < BUILD_ID_SIZE)
-                goto out;
-
-        ek = elf_kind(elf);
-        if (ek != ELF_K_ELF)
-                goto out;
-
-        if (gelf_getehdr(elf, &ehdr) == NULL) {
-                pr_err("%s: cannot get elf header.\n", __func__);
-                goto out;
-        }
-
-        /*
-         * Check following sections for notes:
-         *   '.note.gnu.build-id'
-         *   '.notes'
-         *   '.note' (VDSO specific)
-         */
-        do {
-                sec = elf_section_by_name(elf, &ehdr, &shdr,
-                                          ".note.gnu.build-id", NULL);
-                if (sec)
-                        break;
-
-                sec = elf_section_by_name(elf, &ehdr, &shdr,
-                                          ".notes", NULL);
-                if (sec)
-                        break;
-
-                sec = elf_section_by_name(elf, &ehdr, &shdr,
-                                          ".note", NULL);
-                if (sec)
-                        break;
-
-                return err;
-
-        } while (0);
-
-        data = elf_getdata(sec, NULL);
-        if (data == NULL)
-                goto out;
-
-        ptr = data->d_buf;
-        while (ptr < (data->d_buf + data->d_size)) {
-                GElf_Nhdr *nhdr = ptr;
-                size_t namesz = NOTE_ALIGN(nhdr->n_namesz),
-                       descsz = NOTE_ALIGN(nhdr->n_descsz);
-                const char *name;
-
-                ptr += sizeof(*nhdr);
-                name = ptr;
-                ptr += namesz;
-                if (nhdr->n_type == NT_GNU_BUILD_ID &&
-                    nhdr->n_namesz == sizeof("GNU")) {
-                        if (memcmp(name, "GNU", sizeof("GNU")) == 0) {
-                                size_t sz = min(size, descsz);
-                                memcpy(bf, ptr, sz);
-                                memset(bf + sz, 0, size - sz);
-                                err = descsz;
-                                break;
-                        }
-                }
-                ptr += descsz;
-        }
-
-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);
-out:
-        return err;
-}
-
-int sysfs__read_build_id(const char *filename, void *build_id, size_t size)
-{
-        int fd, err = -1;
-
-        if (size < BUILD_ID_SIZE)
-                goto out;
-
-        fd = open(filename, O_RDONLY);
-        if (fd < 0)
-                goto out;
-
-        while (1) {
-                char bf[BUFSIZ];
-                GElf_Nhdr nhdr;
-                size_t namesz, descsz;
-
-                if (read(fd, &nhdr, sizeof(nhdr)) != sizeof(nhdr))
-                        break;
-
-                namesz = NOTE_ALIGN(nhdr.n_namesz);
-                descsz = NOTE_ALIGN(nhdr.n_descsz);
-                if (nhdr.n_type == NT_GNU_BUILD_ID &&
-                    nhdr.n_namesz == sizeof("GNU")) {
-                        if (read(fd, bf, namesz) != (ssize_t)namesz)
-                                break;
-                        if (memcmp(bf, "GNU", sizeof("GNU")) == 0) {
-                                size_t sz = min(descsz, size);
-                                if (read(fd, build_id, sz) == (ssize_t)sz) {
-                                        memset(build_id + sz, 0, size - sz);
-                                        err = 0;
-                                        break;
-                                }
-                        } else if (read(fd, bf, descsz) != (ssize_t)descsz)
-                                break;
-                } else {
-                        int n = namesz + descsz;
-                        if (read(fd, bf, n) != n)
-                                break;
-                }
-        }
-        close(fd);
-out:
-        return err;
-}
-
-static int filename__read_debuglink(const char *filename,
-                                    char *debuglink, size_t size)
-{
-        int fd, err = -1;
-        Elf *elf;
-        GElf_Ehdr ehdr;
-        GElf_Shdr shdr;
-        Elf_Data *data;
-        Elf_Scn *sec;
-        Elf_Kind ek;
-
-        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_close;
-
-        if (gelf_getehdr(elf, &ehdr) == NULL) {
-                pr_err("%s: cannot get elf header.\n", __func__);
-                goto out_close;
-        }
-
-        sec = elf_section_by_name(elf, &ehdr, &shdr,
-                                  ".gnu_debuglink", NULL);
-        if (sec == NULL)
-                goto out_close;
-
-        data = elf_getdata(sec, NULL);
-        if (data == NULL)
-                goto out_close;
-
-        /* the start of this section is a zero-terminated string */
-        strncpy(debuglink, data->d_buf, size);
-
-        elf_end(elf);
-
-out_close:
-        close(fd);
-out:
-        return err;
-}
-
 char dso__symtab_origin(const struct dso *dso)
 {
         static const char origin[] = {
                 [DSO_BINARY_TYPE__KALLSYMS]             = 'k',
+                [DSO_BINARY_TYPE__VMLINUX]              = 'v',
                 [DSO_BINARY_TYPE__JAVA_JIT]             = 'j',
                 [DSO_BINARY_TYPE__DEBUGLINK]            = 'l',
                 [DSO_BINARY_TYPE__BUILD_ID_CACHE]       = 'B',
@@ -1700,6 +934,7 @@ char dso__symtab_origin(const struct dso *dso)
                 [DSO_BINARY_TYPE__SYSTEM_PATH_KMODULE]  = 'K',
                 [DSO_BINARY_TYPE__GUEST_KALLSYMS]       = 'g',
                 [DSO_BINARY_TYPE__GUEST_KMODULE]        = 'G',
+                [DSO_BINARY_TYPE__GUEST_VMLINUX]        = 'V',
         };
 
         if (dso == NULL || dso->symtab_type == DSO_BINARY_TYPE__NOT_FOUND)
@@ -1775,7 +1010,9 @@ int dso__binary_type_file(struct dso *dso, enum dso_binary_type type,
 
         default:
         case DSO_BINARY_TYPE__KALLSYMS:
+        case DSO_BINARY_TYPE__VMLINUX:
         case DSO_BINARY_TYPE__GUEST_KALLSYMS:
+        case DSO_BINARY_TYPE__GUEST_VMLINUX:
         case DSO_BINARY_TYPE__JAVA_JIT:
         case DSO_BINARY_TYPE__NOT_FOUND:
                 ret = -1;
@@ -1789,11 +1026,12 @@ int dso__load(struct dso *dso, struct map *map, symbol_filter_t filter)
 {
         char *name;
         int ret = -1;
-        int fd;
         u_int i;
         struct machine *machine;
         char *root_dir = (char *) "";
-        int want_symtab;
+        int ss_pos = 0;
+        struct symsrc ss_[2];
+        struct symsrc *syms_ss = NULL, *runtime_ss = NULL;
 
         dso__set_loaded(dso, map->type);
 
@@ -1835,54 +1073,69 @@ int dso__load(struct dso *dso, struct map *map, symbol_filter_t filter)
                 root_dir = machine->root_dir;
 
         /* Iterate over candidate debug images.
-         * On the first pass, only load images if they have a full symtab.
-         * Failing that, do a second pass where we accept .dynsym also
+         * Keep track of "interesting" ones (those which have a symtab, dynsym,
+         * and/or opd section) for processing.
          */
-        want_symtab = 1;
-restart:
         for (i = 0; i < DSO_BINARY_TYPE__SYMTAB_CNT; i++) {
+                struct symsrc *ss = &ss_[ss_pos];
+                bool next_slot = false;
 
-                dso->symtab_type = binary_type_symtab[i];
+                enum dso_binary_type symtab_type = binary_type_symtab[i];
 
-                if (dso__binary_type_file(dso, dso->symtab_type,
+                if (dso__binary_type_file(dso, symtab_type,
                                           root_dir, name, PATH_MAX))
                         continue;
 
                 /* Name is now the name of the next image to try */
-                fd = open(name, O_RDONLY);
-                if (fd < 0)
+                if (symsrc__init(ss, dso, name, symtab_type) < 0)
                         continue;
 
-                ret = dso__load_sym(dso, map, name, fd, filter, 0,
-                                    want_symtab);
-                close(fd);
+                if (!syms_ss && symsrc__has_symtab(ss)) {
+                        syms_ss = ss;
+                        next_slot = true;
+                }
 
-                /*
-                 * Some people seem to have debuginfo files _WITHOUT_ debug
-                 * info!?!?
-                 */
-                if (!ret)
-                        continue;
+                if (!runtime_ss && symsrc__possibly_runtime(ss)) {
+                        runtime_ss = ss;
+                        next_slot = true;
+                }
 
-                if (ret > 0) {
-                        int nr_plt;
+                if (next_slot) {
+                        ss_pos++;
 
-                        nr_plt = dso__synthesize_plt_symbols(dso, name, map, filter);
-                        if (nr_plt > 0)
-                                ret += nr_plt;
-                        break;
+                        if (syms_ss && runtime_ss)
+                                break;
                 }
+
         }
 
-        /*
-         * If we wanted a full symtab but no image had one,
-         * relax our requirements and repeat the search.
-         */
-        if (ret <= 0 && want_symtab) {
-                want_symtab = 0;
-                goto restart;
+        if (!runtime_ss && !syms_ss)
+                goto out_free;
+
+        if (runtime_ss && !syms_ss) {
+                syms_ss = runtime_ss;
+        }
+
+        /* We'll have to hope for the best */
+        if (!runtime_ss && syms_ss)
+                runtime_ss = syms_ss;
+
+        if (syms_ss)
+                ret = dso__load_sym(dso, map, syms_ss, runtime_ss, filter, 0);
+        else
+                ret = -1;
+
+        if (ret > 0) {
+                int nr_plt;
+
+                nr_plt = dso__synthesize_plt_symbols(dso, runtime_ss, map, filter);
+                if (nr_plt > 0)
+                        ret += nr_plt;
         }
 
+        for (; ss_pos > 0; ss_pos--)
+                symsrc__destroy(&ss_[ss_pos - 1]);
+out_free:
         free(name);
         if (ret < 0 && strstr(dso->name, " (deleted)") != NULL)
                 return 0;
@@ -2030,25 +1283,6 @@ static int machine__set_modules_path(struct machine *machine)
         return map_groups__set_modules_path_dir(&machine->kmaps, modules_path);
 }
 
-/*
- * Constructor variant for modules (where we know from /proc/modules where
- * they are loaded) and for vmlinux, where only after we load all the
- * symbols we'll know where it starts and ends.
- */
-static struct map *map__new2(u64 start, struct dso *dso, enum map_type type)
-{
-        struct map *map = calloc(1, (sizeof(*map) +
-                                     (dso->kernel ? sizeof(struct kmap) : 0)));
-        if (map != NULL) {
-                /*
-                 * ->end will be filled after we load all the symbols
-                 */
-                map__init(map, type, start, 0, 0, dso);
-        }
-
-        return map;
-}
-
 struct map *machine__new_module(struct machine *machine, u64 start,
                                 const char *filename)
 {
@@ -2141,22 +1375,30 @@ out_failure:
 int dso__load_vmlinux(struct dso *dso, struct map *map,
                       const char *vmlinux, symbol_filter_t filter)
 {
-        int err = -1, fd;
+        int err = -1;
+        struct symsrc ss;
         char symfs_vmlinux[PATH_MAX];
+        enum dso_binary_type symtab_type;
 
         snprintf(symfs_vmlinux, sizeof(symfs_vmlinux), "%s%s",
                  symbol_conf.symfs, vmlinux);
-        fd = open(symfs_vmlinux, O_RDONLY);
-        if (fd < 0)
+
+        if (dso->kernel == DSO_TYPE_GUEST_KERNEL)
+                symtab_type = DSO_BINARY_TYPE__GUEST_VMLINUX;
+        else
+                symtab_type = DSO_BINARY_TYPE__VMLINUX;
+
+        if (symsrc__init(&ss, dso, symfs_vmlinux, symtab_type))
                 return -1;
 
-        dso__set_long_name(dso, (char *)vmlinux);
-        dso__set_loaded(dso, map->type);
-        err = dso__load_sym(dso, map, symfs_vmlinux, fd, filter, 0, 0);
-        close(fd);
+        err = dso__load_sym(dso, map, &ss, &ss, filter, 0);
+        symsrc__destroy(&ss);
 
-        if (err > 0)
+        if (err > 0) {
+                dso__set_long_name(dso, (char *)vmlinux);
+                dso__set_loaded(dso, map->type);
                 pr_debug("Using %s for symbols\n", symfs_vmlinux);
+        }
 
         return err;
 }
@@ -2173,10 +1415,8 @@ int dso__load_vmlinux_path(struct dso *dso, struct map *map,
         filename = dso__build_id_filename(dso, NULL, 0);
         if (filename != NULL) {
                 err = dso__load_vmlinux(dso, map, filename, filter);
-                if (err > 0) {
-                        dso__set_long_name(dso, filename);
+                if (err > 0)
                         goto out;
-                }
                 free(filename);
         }
 
@@ -2291,9 +1531,8 @@ do_kallsyms:
         free(kallsyms_allocated_filename);
 
         if (err > 0) {
+                dso__set_long_name(dso, strdup("[kernel.kallsyms]"));
 out_fixup:
-                if (kallsyms_filename != NULL)
-                        dso__set_long_name(dso, strdup("[kernel.kallsyms]"));
                 map__fixup_start(map);
                 map__fixup_end(map);
         }
@@ -2352,12 +1591,12 @@ out_try_fixup:
         return err;
 }
 
-static void dsos__add(struct list_head *head, struct dso *dso)
+void dsos__add(struct list_head *head, struct dso *dso)
 {
         list_add_tail(&dso->node, head);
 }
 
-static struct dso *dsos__find(struct list_head *head, const char *name)
+struct dso *dsos__find(struct list_head *head, const char *name)
 {
         struct dso *pos;
 
@@ -2516,7 +1755,7 @@ struct process_args {
 };
 
 static int symbol__in_kernel(void *arg, const char *name,
-                             char type __used, u64 start, u64 end __used)
+                             char type __maybe_unused, u64 start)
 {
         struct process_args *args = arg;
 
@@ -2752,9 +1991,10 @@ int symbol__init(void)
         if (symbol_conf.initialized)
                 return 0;
 
-        symbol_conf.priv_size = ALIGN(symbol_conf.priv_size, sizeof(u64));
+        symbol_conf.priv_size = PERF_ALIGN(symbol_conf.priv_size, sizeof(u64));
+
+        symbol__elf_init();
 
-        elf_version(EV_CURRENT);
         if (symbol_conf.sort_by_name)
                 symbol_conf.priv_size += (sizeof(struct symbol_name_rb_node) -
                                           sizeof(struct symbol));
diff --git a/tools/perf/util/symbol.h b/tools/perf/util/symbol.h
index 1fe733a1e21f..b441b07172b7 100644
--- a/tools/perf/util/symbol.h
+++ b/tools/perf/util/symbol.h
@@ -10,22 +10,31 @@
 #include <linux/rbtree.h>
 #include <stdio.h>
 #include <byteswap.h>
+#include <libgen.h>
+
+#ifndef NO_LIBELF_SUPPORT
+#include <libelf.h>
+#include <gelf.h>
+#include <elf.h>
+#endif
 
 #ifdef HAVE_CPLUS_DEMANGLE
 extern char *cplus_demangle(const char *, int);
 
-static inline char *bfd_demangle(void __used *v, const char *c, int i)
+static inline char *bfd_demangle(void __maybe_unused *v, const char *c, int i)
 {
         return cplus_demangle(c, i);
 }
 #else
 #ifdef NO_DEMANGLE
-static inline char *bfd_demangle(void __used *v, const char __used *c,
-                                 int __used i)
+static inline char *bfd_demangle(void __maybe_unused *v,
+                                 const char __maybe_unused *c,
+                                 int __maybe_unused i)
 {
         return NULL;
 }
 #else
+#define PACKAGE 'perf'
 #include <bfd.h>
 #endif
 #endif
@@ -158,6 +167,8 @@ struct addr_location {
 enum dso_binary_type {
         DSO_BINARY_TYPE__KALLSYMS = 0,
         DSO_BINARY_TYPE__GUEST_KALLSYMS,
+        DSO_BINARY_TYPE__VMLINUX,
+        DSO_BINARY_TYPE__GUEST_VMLINUX,
         DSO_BINARY_TYPE__JAVA_JIT,
         DSO_BINARY_TYPE__DEBUGLINK,
         DSO_BINARY_TYPE__BUILD_ID_CACHE,
@@ -217,6 +228,36 @@ struct dso {
         char             name[0];
 };
 
+struct symsrc {
+        char *name;
+        int fd;
+        enum dso_binary_type type;
+
+#ifndef NO_LIBELF_SUPPORT
+        Elf *elf;
+        GElf_Ehdr ehdr;
+
+        Elf_Scn *opdsec;
+        size_t opdidx;
+        GElf_Shdr opdshdr;
+
+        Elf_Scn *symtab;
+        GElf_Shdr symshdr;
+
+        Elf_Scn *dynsym;
+        size_t dynsym_idx;
+        GElf_Shdr dynshdr;
+
+        bool adjust_symbols;
+#endif
+};
+
+void symsrc__destroy(struct symsrc *ss);
+int symsrc__init(struct symsrc *ss, struct dso *dso, const char *name,
+                 enum dso_binary_type type);
+bool symsrc__has_symtab(struct symsrc *ss);
+bool symsrc__possibly_runtime(struct symsrc *ss);
+
 #define DSO__SWAP(dso, type, val)                       \
 ({                                                      \
         type ____r = val;                               \
@@ -254,6 +295,8 @@ static inline void dso__set_loaded(struct dso *dso, enum map_type type)
 
 void dso__sort_by_name(struct dso *dso, enum map_type type);
 
+void dsos__add(struct list_head *head, struct dso *dso);
+struct dso *dsos__find(struct list_head *head, const char *name);
 struct dso *__dsos__findnew(struct list_head *head, const char *name);
 
 int dso__load(struct dso *dso, struct map *map, symbol_filter_t filter);
@@ -283,6 +326,7 @@ size_t dso__fprintf(struct dso *dso, enum map_type type, FILE *fp);
 char dso__symtab_origin(const struct dso *dso);
 void dso__set_long_name(struct dso *dso, char *name);
 void dso__set_build_id(struct dso *dso, void *build_id);
+bool dso__build_id_equal(const struct dso *dso, u8 *build_id);
 void dso__read_running_kernel_build_id(struct dso *dso,
                                        struct machine *machine);
 struct map *dso__new_map(const char *name);
@@ -297,7 +341,9 @@ bool __dsos__read_build_ids(struct list_head *head, bool with_hits);
 int build_id__sprintf(const u8 *build_id, int len, char *bf);
 int kallsyms__parse(const char *filename, void *arg,
                     int (*process_symbol)(void *arg, const char *name,
-                                          char type, u64 start, u64 end));
+                                          char type, u64 start));
+int filename__read_debuglink(const char *filename, char *debuglink,
+                             size_t size);
 
 void machine__destroy_kernel_maps(struct machine *machine);
 int __machine__create_kernel_maps(struct machine *machine, struct dso *kernel);
@@ -309,6 +355,8 @@ void machines__destroy_guest_kernel_maps(struct rb_root *machines);
 
 int symbol__init(void);
 void symbol__exit(void);
+void symbol__elf_init(void);
+struct symbol *symbol__new(u64 start, u64 len, u8 binding, const char *name);
 size_t symbol__fprintf_symname_offs(const struct symbol *sym,
                                     const struct addr_location *al, FILE *fp);
 size_t symbol__fprintf_symname(const struct symbol *sym, FILE *fp);
@@ -326,4 +374,15 @@ ssize_t dso__data_read_addr(struct dso *dso, struct map *map,
                             struct machine *machine, u64 addr,
                             u8 *data, ssize_t size);
 int dso__test_data(void);
+int dso__load_sym(struct dso *dso, struct map *map, struct symsrc *syms_ss,
+                  struct symsrc *runtime_ss, symbol_filter_t filter,
+                  int kmodule);
+int dso__synthesize_plt_symbols(struct dso *dso, struct symsrc *ss,
+                                struct map *map, symbol_filter_t filter);
+
+void symbols__insert(struct rb_root *symbols, struct symbol *sym);
+void symbols__fixup_duplicate(struct rb_root *symbols);
+void symbols__fixup_end(struct rb_root *symbols);
+void __map_groups__fixup_end(struct map_groups *mg, enum map_type type);
+
 #endif /* __PERF_SYMBOL */
diff --git a/tools/perf/util/target.c b/tools/perf/util/target.c
index 051eaa68095e..065528b7563e 100644
--- a/tools/perf/util/target.c
+++ b/tools/perf/util/target.c
@@ -117,8 +117,8 @@ int perf_target__strerror(struct perf_target *target, int errnum,
 
                 if (err != buf) {
                         size_t len = strlen(err);
-                        char *c = mempcpy(buf, err, min(buflen - 1, len));
-                        *c = '\0';
+                        memcpy(buf, err, min(buflen - 1, len));
+                        *(buf + min(buflen - 1, len)) = '\0';
                 }
 
                 return 0;
diff --git a/tools/perf/util/thread.h b/tools/perf/util/thread.h
index 70c2c13ff679..f66610b7bacf 100644
--- a/tools/perf/util/thread.h
+++ b/tools/perf/util/thread.h
@@ -16,6 +16,8 @@ struct thread {
         bool                    comm_set;
         char                    *comm;
         int                     comm_len;
+
+        void                    *priv;
 };
 
 struct machine;
diff --git a/tools/perf/util/top.c b/tools/perf/util/top.c
index 7eeebcee291c..884dde9b9bc1 100644
--- a/tools/perf/util/top.c
+++ b/tools/perf/util/top.c
@@ -58,8 +58,7 @@ size_t perf_top__header_snprintf(struct perf_top *top, char *bf, size_t size)
         }
 
         if (top->evlist->nr_entries == 1) {
-                struct perf_evsel *first;
-                first = list_entry(top->evlist->entries.next, struct perf_evsel, node);
+                struct perf_evsel *first = perf_evlist__first(top->evlist);
                 ret += SNPRINTF(bf + ret, size - ret, "%" PRIu64 "%s ",
                                 (uint64_t)first->attr.sample_period,
                                 top->freq ? "Hz" : "");
diff --git a/tools/perf/util/top.h b/tools/perf/util/top.h
index 33347ca89ee4..86ff1b15059b 100644
--- a/tools/perf/util/top.h
+++ b/tools/perf/util/top.h
@@ -5,6 +5,7 @@
 #include "types.h"
 #include <stddef.h>
 #include <stdbool.h>
+#include <termios.h>
 
 struct perf_evlist;
 struct perf_evsel;
diff --git a/tools/perf/util/trace-event-parse.c b/tools/perf/util/trace-event-parse.c
index 0715c843c2e7..3aabcd687cd5 100644
--- a/tools/perf/util/trace-event-parse.c
+++ b/tools/perf/util/trace-event-parse.c
@@ -162,25 +162,16 @@ int trace_parse_common_pid(struct pevent *pevent, void *data)
         return pevent_data_pid(pevent, &record);
 }
 
-unsigned long long read_size(struct pevent *pevent, void *ptr, int size)
+unsigned long long read_size(struct event_format *event, void *ptr, int size)
 {
-        return pevent_read_number(pevent, ptr, size);
+        return pevent_read_number(event->pevent, ptr, size);
 }
 
-void print_trace_event(struct pevent *pevent, int cpu, void *data, int size)
+void event_format__print(struct event_format *event,
+                         int cpu, void *data, int size)
 {
-        struct event_format *event;
         struct pevent_record record;
         struct trace_seq s;
-        int type;
-
-        type = trace_parse_common_type(pevent, data);
-
-        event = pevent_find_event(pevent, type);
-        if (!event) {
-                warning("ug! no event found for type %d", type);
-                return;
-        }
 
         memset(&record, 0, sizeof(record));
         record.cpu = cpu;
@@ -192,6 +183,19 @@ void print_trace_event(struct pevent *pevent, int cpu, void *data, int size)
         trace_seq_do_printf(&s);
 }
 
+void print_trace_event(struct pevent *pevent, int cpu, void *data, int size)
+{
+        int type = trace_parse_common_type(pevent, data);
+        struct event_format *event = pevent_find_event(pevent, type);
+
+        if (!event) {
+                warning("ug! no event found for type %d", type);
+                return;
+        }
+
+        event_format__print(event, cpu, data, size);
+}
+
 void print_event(struct pevent *pevent, int cpu, void *data, int size,
                  unsigned long long nsecs, char *comm)
 {
@@ -217,7 +221,7 @@ void print_event(struct pevent *pevent, int cpu, void *data, int size,
 }
 
 void parse_proc_kallsyms(struct pevent *pevent,
-                         char *file, unsigned int size __unused)
+                         char *file, unsigned int size __maybe_unused)
 {
         unsigned long long addr;
         char *func;
@@ -225,31 +229,29 @@ void parse_proc_kallsyms(struct pevent *pevent,
         char *next = NULL;
         char *addr_str;
         char *mod;
-        char ch;
+        char *fmt;
 
         line = strtok_r(file, "\n", &next);
         while (line) {
                 mod = NULL;
-                sscanf(line, "%as %c %as\t[%as",
-                       (float *)(void *)&addr_str, /* workaround gcc warning */
-                       &ch, (float *)(void *)&func, (float *)(void *)&mod);
+                addr_str = strtok_r(line, " ", &fmt);
                 addr = strtoull(addr_str, NULL, 16);
-                free(addr_str);
-
-                /* truncate the extra ']' */
+                /* skip character */
+                strtok_r(NULL, " ", &fmt);
+                func = strtok_r(NULL, "\t", &fmt);
+                mod = strtok_r(NULL, "]", &fmt);
+                /* truncate the extra '[' */
                 if (mod)
-                        mod[strlen(mod) - 1] = 0;
+                        mod = mod + 1;
 
                 pevent_register_function(pevent, func, addr, mod);
-                free(func);
-                free(mod);
 
                 line = strtok_r(NULL, "\n", &next);
         }
 }
 
 void parse_ftrace_printk(struct pevent *pevent,
-                         char *file, unsigned int size __unused)
+                         char *file, unsigned int size __maybe_unused)
 {
         unsigned long long addr;
         char *printk;
@@ -289,7 +291,7 @@ struct event_format *trace_find_next_event(struct pevent *pevent,
 {
         static int idx;
 
-        if (!pevent->events)
+        if (!pevent || !pevent->events)
                 return NULL;
 
         if (!event) {
diff --git a/tools/perf/util/trace-event-scripting.c b/tools/perf/util/trace-event-scripting.c
index 474aa7a7df43..8715a1006d00 100644
--- a/tools/perf/util/trace-event-scripting.c
+++ b/tools/perf/util/trace-event-scripting.c
@@ -35,12 +35,11 @@ static int stop_script_unsupported(void)
         return 0;
 }
 
-static void process_event_unsupported(union perf_event *event __unused,
-                                      struct pevent *pevent __unused,
-                                      struct perf_sample *sample __unused,
-                                      struct perf_evsel *evsel __unused,
-                                      struct machine *machine __unused,
-                                      struct thread *thread __unused)
+static void process_event_unsupported(union perf_event *event __maybe_unused,
+                                      struct perf_sample *sample __maybe_unused,
+                                      struct perf_evsel *evsel __maybe_unused,
+                                      struct machine *machine __maybe_unused,
+                                      struct addr_location *al __maybe_unused)
 {
 }
 
@@ -53,17 +52,19 @@ static void print_python_unsupported_msg(void)
                 "\n  etc.\n");
 }
 
-static int python_start_script_unsupported(const char *script __unused,
-                                           int argc __unused,
-                                           const char **argv __unused)
+static int python_start_script_unsupported(const char *script __maybe_unused,
+                                           int argc __maybe_unused,
+                                           const char **argv __maybe_unused)
 {
         print_python_unsupported_msg();
 
         return -1;
 }
 
-static int python_generate_script_unsupported(struct pevent *pevent __unused,
-                                              const char *outfile __unused)
+static int python_generate_script_unsupported(struct pevent *pevent
+                                              __maybe_unused,
+                                              const char *outfile
+                                              __maybe_unused)
 {
         print_python_unsupported_msg();
 
@@ -115,17 +116,18 @@ static void print_perl_unsupported_msg(void)
                 "\n  etc.\n");
 }
 
-static int perl_start_script_unsupported(const char *script __unused,
-                                         int argc __unused,
-                                         const char **argv __unused)
+static int perl_start_script_unsupported(const char *script __maybe_unused,
+                                         int argc __maybe_unused,
+                                         const char **argv __maybe_unused)
 {
         print_perl_unsupported_msg();
 
         return -1;
 }
 
-static int perl_generate_script_unsupported(struct pevent *pevent __unused,
-                                            const char *outfile __unused)
+static int perl_generate_script_unsupported(struct pevent *pevent
+                                            __maybe_unused,
+                                            const char *outfile __maybe_unused)
 {
         print_perl_unsupported_msg();
 
diff --git a/tools/perf/util/trace-event.h b/tools/perf/util/trace-event.h
index 8fef1d6687b7..a55fd37ffea1 100644
--- a/tools/perf/util/trace-event.h
+++ b/tools/perf/util/trace-event.h
@@ -9,7 +9,6 @@ struct machine;
 struct perf_sample;
 union perf_event;
 struct perf_tool;
-struct thread;
 
 extern int header_page_size_size;
 extern int header_page_ts_size;
@@ -32,6 +31,8 @@ int bigendian(void);
 
 struct pevent *read_trace_init(int file_bigendian, int host_bigendian);
 void print_trace_event(struct pevent *pevent, int cpu, void *data, int size);
+void event_format__print(struct event_format *event,
+                         int cpu, void *data, int size);
 
 void print_event(struct pevent *pevent, int cpu, void *data, int size,
                  unsigned long long nsecs, char *comm);
@@ -56,7 +57,7 @@ int trace_parse_common_pid(struct pevent *pevent, void *data);
 
 struct event_format *trace_find_next_event(struct pevent *pevent,
                                            struct event_format *event);
-unsigned long long read_size(struct pevent *pevent, void *ptr, int size);
+unsigned long long read_size(struct event_format *event, void *ptr, int size);
 unsigned long long eval_flag(const char *flag);
 
 struct pevent_record *trace_read_data(struct pevent *pevent, int cpu);
@@ -74,16 +75,19 @@ struct tracing_data *tracing_data_get(struct list_head *pattrs,
 void tracing_data_put(struct tracing_data *tdata);
 
 
+struct addr_location;
+
+struct perf_session;
+
 struct scripting_ops {
         const char *name;
         int (*start_script) (const char *script, int argc, const char **argv);
         int (*stop_script) (void);
         void (*process_event) (union perf_event *event,
-                               struct pevent *pevent,
                                struct perf_sample *sample,
                                struct perf_evsel *evsel,
                                struct machine *machine,
-                               struct thread *thread);
+                               struct addr_location *al);
         int (*generate_script) (struct pevent *pevent, const char *outfile);
 };
 
diff --git a/tools/perf/util/unwind.c b/tools/perf/util/unwind.c
new file mode 100644
index 000000000000..958723ba3d2e
--- /dev/null
+++ b/tools/perf/util/unwind.c
@@ -0,0 +1,571 @@
+/*
+ * Post mortem Dwarf CFI based unwinding on top of regs and stack dumps.
+ *
+ * Lots of this code have been borrowed or heavily inspired from parts of
+ * the libunwind 0.99 code which are (amongst other contributors I may have
+ * forgotten):
+ *
+ * Copyright (C) 2002-2007 Hewlett-Packard Co
+ *      Contributed by David Mosberger-Tang <davidm@hpl.hp.com>
+ *
+ * And the bugs have been added by:
+ *
+ * Copyright (C) 2010, Frederic Weisbecker <fweisbec@gmail.com>
+ * Copyright (C) 2012, Jiri Olsa <jolsa@redhat.com>
+ *
+ */
+
+#include <elf.h>
+#include <gelf.h>
+#include <fcntl.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <linux/list.h>
+#include <libunwind.h>
+#include <libunwind-ptrace.h>
+#include "thread.h"
+#include "session.h"
+#include "perf_regs.h"
+#include "unwind.h"
+#include "util.h"
+
+extern int
+UNW_OBJ(dwarf_search_unwind_table) (unw_addr_space_t as,
+                                    unw_word_t ip,
+                                    unw_dyn_info_t *di,
+                                    unw_proc_info_t *pi,
+                                    int need_unwind_info, void *arg);
+
+#define dwarf_search_unwind_table UNW_OBJ(dwarf_search_unwind_table)
+
+#define DW_EH_PE_FORMAT_MASK    0x0f    /* format of the encoded value */
+#define DW_EH_PE_APPL_MASK      0x70    /* how the value is to be applied */
+
+/* Pointer-encoding formats: */
+#define DW_EH_PE_omit           0xff
+#define DW_EH_PE_ptr            0x00    /* pointer-sized unsigned value */
+#define DW_EH_PE_udata4         0x03    /* unsigned 32-bit value */
+#define DW_EH_PE_udata8         0x04    /* unsigned 64-bit value */
+#define DW_EH_PE_sdata4         0x0b    /* signed 32-bit value */
+#define DW_EH_PE_sdata8         0x0c    /* signed 64-bit value */
+
+/* Pointer-encoding application: */
+#define DW_EH_PE_absptr         0x00    /* absolute value */
+#define DW_EH_PE_pcrel          0x10    /* rel. to addr. of encoded value */
+
+/*
+ * The following are not documented by LSB v1.3, yet they are used by
+ * GCC, presumably they aren't documented by LSB since they aren't
+ * used on Linux:
+ */
+#define DW_EH_PE_funcrel        0x40    /* start-of-procedure-relative */
+#define DW_EH_PE_aligned        0x50    /* aligned pointer */
+
+/* Flags intentionaly not handled, since they're not needed:
+ * #define DW_EH_PE_indirect      0x80
+ * #define DW_EH_PE_uleb128       0x01
+ * #define DW_EH_PE_udata2        0x02
+ * #define DW_EH_PE_sleb128       0x09
+ * #define DW_EH_PE_sdata2        0x0a
+ * #define DW_EH_PE_textrel       0x20
+ * #define DW_EH_PE_datarel       0x30
+ */
+
+struct unwind_info {
+        struct perf_sample      *sample;
+        struct machine          *machine;
+        struct thread           *thread;
+        u64                     sample_uregs;
+};
+
+#define dw_read(ptr, type, end) ({      \
+        type *__p = (type *) ptr;       \
+        type  __v;                      \
+        if ((__p + 1) > (type *) end)   \
+                return -EINVAL;         \
+        __v = *__p++;                   \
+        ptr = (typeof(ptr)) __p;        \
+        __v;                            \
+        })
+
+static int __dw_read_encoded_value(u8 **p, u8 *end, u64 *val,
+                                   u8 encoding)
+{
+        u8 *cur = *p;
+        *val = 0;
+
+        switch (encoding) {
+        case DW_EH_PE_omit:
+                *val = 0;
+                goto out;
+        case DW_EH_PE_ptr:
+                *val = dw_read(cur, unsigned long, end);
+                goto out;
+        default:
+                break;
+        }
+
+        switch (encoding & DW_EH_PE_APPL_MASK) {
+        case DW_EH_PE_absptr:
+                break;
+        case DW_EH_PE_pcrel:
+                *val = (unsigned long) cur;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        if ((encoding & 0x07) == 0x00)
+                encoding |= DW_EH_PE_udata4;
+
+        switch (encoding & DW_EH_PE_FORMAT_MASK) {
+        case DW_EH_PE_sdata4:
+                *val += dw_read(cur, s32, end);
+                break;
+        case DW_EH_PE_udata4:
+                *val += dw_read(cur, u32, end);
+                break;
+        case DW_EH_PE_sdata8:
+                *val += dw_read(cur, s64, end);
+                break;
+        case DW_EH_PE_udata8:
+                *val += dw_read(cur, u64, end);
+                break;
+        default:
+                return -EINVAL;
+        }
+
+ out:
+        *p = cur;
+        return 0;
+}
+
+#define dw_read_encoded_value(ptr, end, enc) ({                 \
+        u64 __v;                                                \
+        if (__dw_read_encoded_value(&ptr, end, &__v, enc)) {    \
+                return -EINVAL;                                 \
+        }                                                       \
+        __v;                                                    \
+        })
+
+static Elf_Scn *elf_section_by_name(Elf *elf, GElf_Ehdr *ep,
+                                    GElf_Shdr *shp, const char *name)
+{
+        Elf_Scn *sec = NULL;
+
+        while ((sec = elf_nextscn(elf, sec)) != NULL) {
+                char *str;
+
+                gelf_getshdr(sec, shp);
+                str = elf_strptr(elf, ep->e_shstrndx, shp->sh_name);
+                if (!strcmp(name, str))
+                        break;
+        }
+
+        return sec;
+}
+
+static u64 elf_section_offset(int fd, const char *name)
+{
+        Elf *elf;
+        GElf_Ehdr ehdr;
+        GElf_Shdr shdr;
+        u64 offset = 0;
+
+        elf = elf_begin(fd, PERF_ELF_C_READ_MMAP, NULL);
+        if (elf == NULL)
+                return 0;
+
+        do {
+                if (gelf_getehdr(elf, &ehdr) == NULL)
+                        break;
+
+                if (!elf_section_by_name(elf, &ehdr, &shdr, name))
+                        break;
+
+                offset = shdr.sh_offset;
+        } while (0);
+
+        elf_end(elf);
+        return offset;
+}
+
+struct table_entry {
+        u32 start_ip_offset;
+        u32 fde_offset;
+};
+
+struct eh_frame_hdr {
+        unsigned char version;
+        unsigned char eh_frame_ptr_enc;
+        unsigned char fde_count_enc;
+        unsigned char table_enc;
+
+        /*
+         * The rest of the header is variable-length and consists of the
+         * following members:
+         *
+         *      encoded_t eh_frame_ptr;
+         *      encoded_t fde_count;
+         */
+
+        /* A single encoded pointer should not be more than 8 bytes. */
+        u64 enc[2];
+
+        /*
+         * struct {
+         *    encoded_t start_ip;
+         *    encoded_t fde_addr;
+         * } binary_search_table[fde_count];
+         */
+        char data[0];
+} __packed;
+
+static int unwind_spec_ehframe(struct dso *dso, struct machine *machine,
+                               u64 offset, u64 *table_data, u64 *segbase,
+                               u64 *fde_count)
+{
+        struct eh_frame_hdr hdr;
+        u8 *enc = (u8 *) &hdr.enc;
+        u8 *end = (u8 *) &hdr.data;
+        ssize_t r;
+
+        r = dso__data_read_offset(dso, machine, offset,
+                                  (u8 *) &hdr, sizeof(hdr));
+        if (r != sizeof(hdr))
+                return -EINVAL;
+
+        /* We dont need eh_frame_ptr, just skip it. */
+        dw_read_encoded_value(enc, end, hdr.eh_frame_ptr_enc);
+
+        *fde_count  = dw_read_encoded_value(enc, end, hdr.fde_count_enc);
+        *segbase    = offset;
+        *table_data = (enc - (u8 *) &hdr) + offset;
+        return 0;
+}
+
+static int read_unwind_spec(struct dso *dso, struct machine *machine,
+                            u64 *table_data, u64 *segbase, u64 *fde_count)
+{
+        int ret = -EINVAL, fd;
+        u64 offset;
+
+        fd = dso__data_fd(dso, machine);
+        if (fd < 0)
+                return -EINVAL;
+
+        offset = elf_section_offset(fd, ".eh_frame_hdr");
+        close(fd);
+
+        if (offset)
+                ret = unwind_spec_ehframe(dso, machine, offset,
+                                          table_data, segbase,
+                                          fde_count);
+
+        /* TODO .debug_frame check if eh_frame_hdr fails */
+        return ret;
+}
+
+static struct map *find_map(unw_word_t ip, struct unwind_info *ui)
+{
+        struct addr_location al;
+
+        thread__find_addr_map(ui->thread, ui->machine, PERF_RECORD_MISC_USER,
+                              MAP__FUNCTION, ip, &al);
+        return al.map;
+}
+
+static int
+find_proc_info(unw_addr_space_t as, unw_word_t ip, unw_proc_info_t *pi,
+               int need_unwind_info, void *arg)
+{
+        struct unwind_info *ui = arg;
+        struct map *map;
+        unw_dyn_info_t di;
+        u64 table_data, segbase, fde_count;
+
+        map = find_map(ip, ui);
+        if (!map || !map->dso)
+                return -EINVAL;
+
+        pr_debug("unwind: find_proc_info dso %s\n", map->dso->name);
+
+        if (read_unwind_spec(map->dso, ui->machine,
+                             &table_data, &segbase, &fde_count))
+                return -EINVAL;
+
+        memset(&di, 0, sizeof(di));
+        di.format   = UNW_INFO_FORMAT_REMOTE_TABLE;
+        di.start_ip = map->start;
+        di.end_ip   = map->end;
+        di.u.rti.segbase    = map->start + segbase;
+        di.u.rti.table_data = map->start + table_data;
+        di.u.rti.table_len  = fde_count * sizeof(struct table_entry)
+                              / sizeof(unw_word_t);
+        return dwarf_search_unwind_table(as, ip, &di, pi,
+                                         need_unwind_info, arg);
+}
+
+static int access_fpreg(unw_addr_space_t __maybe_unused as,
+                        unw_regnum_t __maybe_unused num,
+                        unw_fpreg_t __maybe_unused *val,
+                        int __maybe_unused __write,
+                        void __maybe_unused *arg)
+{
+        pr_err("unwind: access_fpreg unsupported\n");
+        return -UNW_EINVAL;
+}
+
+static int get_dyn_info_list_addr(unw_addr_space_t __maybe_unused as,
+                                  unw_word_t __maybe_unused *dil_addr,
+                                  void __maybe_unused *arg)
+{
+        return -UNW_ENOINFO;
+}
+
+static int resume(unw_addr_space_t __maybe_unused as,
+                  unw_cursor_t __maybe_unused *cu,
+                  void __maybe_unused *arg)
+{
+        pr_err("unwind: resume unsupported\n");
+        return -UNW_EINVAL;
+}
+
+static int
+get_proc_name(unw_addr_space_t __maybe_unused as,
+              unw_word_t __maybe_unused addr,
+                char __maybe_unused *bufp, size_t __maybe_unused buf_len,
+                unw_word_t __maybe_unused *offp, void __maybe_unused *arg)
+{
+        pr_err("unwind: get_proc_name unsupported\n");
+        return -UNW_EINVAL;
+}
+
+static int access_dso_mem(struct unwind_info *ui, unw_word_t addr,
+                          unw_word_t *data)
+{
+        struct addr_location al;
+        ssize_t size;
+
+        thread__find_addr_map(ui->thread, ui->machine, PERF_RECORD_MISC_USER,
+                              MAP__FUNCTION, addr, &al);
+        if (!al.map) {
+                pr_debug("unwind: no map for %lx\n", (unsigned long)addr);
+                return -1;
+        }
+
+        if (!al.map->dso)
+                return -1;
+
+        size = dso__data_read_addr(al.map->dso, al.map, ui->machine,
+                                   addr, (u8 *) data, sizeof(*data));
+
+        return !(size == sizeof(*data));
+}
+
+static int reg_value(unw_word_t *valp, struct regs_dump *regs, int id,
+                     u64 sample_regs)
+{
+        int i, idx = 0;
+
+        if (!(sample_regs & (1 << id)))
+                return -EINVAL;
+
+        for (i = 0; i < id; i++) {
+                if (sample_regs & (1 << i))
+                        idx++;
+        }
+
+        *valp = regs->regs[idx];
+        return 0;
+}
+
+static int access_mem(unw_addr_space_t __maybe_unused as,
+                      unw_word_t addr, unw_word_t *valp,
+                      int __write, void *arg)
+{
+        struct unwind_info *ui = arg;
+        struct stack_dump *stack = &ui->sample->user_stack;
+        unw_word_t start, end;
+        int offset;
+        int ret;
+
+        /* Don't support write, probably not needed. */
+        if (__write || !stack || !ui->sample->user_regs.regs) {
+                *valp = 0;
+                return 0;
+        }
+
+        ret = reg_value(&start, &ui->sample->user_regs, PERF_REG_SP,
+                        ui->sample_uregs);
+        if (ret)
+                return ret;
+
+        end = start + stack->size;
+
+        /* Check overflow. */
+        if (addr + sizeof(unw_word_t) < addr)
+                return -EINVAL;
+
+        if (addr < start || addr + sizeof(unw_word_t) >= end) {
+                ret = access_dso_mem(ui, addr, valp);
+                if (ret) {
+                        pr_debug("unwind: access_mem %p not inside range %p-%p\n",
+                                (void *)addr, (void *)start, (void *)end);
+                        *valp = 0;
+                        return ret;
+                }
+                return 0;
+        }
+
+        offset = addr - start;
+        *valp  = *(unw_word_t *)&stack->data[offset];
+        pr_debug("unwind: access_mem addr %p, val %lx, offset %d\n",
+                 (void *)addr, (unsigned long)*valp, offset);
+        return 0;
+}
+
+static int access_reg(unw_addr_space_t __maybe_unused as,
+                      unw_regnum_t regnum, unw_word_t *valp,
+                      int __write, void *arg)
+{
+        struct unwind_info *ui = arg;
+        int id, ret;
+
+        /* Don't support write, I suspect we don't need it. */
+        if (__write) {
+                pr_err("unwind: access_reg w %d\n", regnum);
+                return 0;
+        }
+
+        if (!ui->sample->user_regs.regs) {
+                *valp = 0;
+                return 0;
+        }
+
+        id = unwind__arch_reg_id(regnum);
+        if (id < 0)
+                return -EINVAL;
+
+        ret = reg_value(valp, &ui->sample->user_regs, id, ui->sample_uregs);
+        if (ret) {
+                pr_err("unwind: can't read reg %d\n", regnum);
+                return ret;
+        }
+
+        pr_debug("unwind: reg %d, val %lx\n", regnum, (unsigned long)*valp);
+        return 0;
+}
+
+static void put_unwind_info(unw_addr_space_t __maybe_unused as,
+                            unw_proc_info_t *pi __maybe_unused,
+                            void *arg __maybe_unused)
+{
+        pr_debug("unwind: put_unwind_info called\n");
+}
+
+static int entry(u64 ip, struct thread *thread, struct machine *machine,
+                 unwind_entry_cb_t cb, void *arg)
+{
+        struct unwind_entry e;
+        struct addr_location al;
+
+        thread__find_addr_location(thread, machine,
+                                   PERF_RECORD_MISC_USER,
+                                   MAP__FUNCTION, ip, &al, NULL);
+
+        e.ip = ip;
+        e.map = al.map;
+        e.sym = al.sym;
+
+        pr_debug("unwind: %s:ip = 0x%" PRIx64 " (0x%" PRIx64 ")\n",
+                 al.sym ? al.sym->name : "''",
+                 ip,
+                 al.map ? al.map->map_ip(al.map, ip) : (u64) 0);
+
+        return cb(&e, arg);
+}
+
+static void display_error(int err)
+{
+        switch (err) {
+        case UNW_EINVAL:
+                pr_err("unwind: Only supports local.\n");
+                break;
+        case UNW_EUNSPEC:
+                pr_err("unwind: Unspecified error.\n");
+                break;
+        case UNW_EBADREG:
+                pr_err("unwind: Register unavailable.\n");
+                break;
+        default:
+                break;
+        }
+}
+
+static unw_accessors_t accessors = {
+        .find_proc_info         = find_proc_info,
+        .put_unwind_info        = put_unwind_info,
+        .get_dyn_info_list_addr = get_dyn_info_list_addr,
+        .access_mem             = access_mem,
+        .access_reg             = access_reg,
+        .access_fpreg           = access_fpreg,
+        .resume                 = resume,
+        .get_proc_name          = get_proc_name,
+};
+
+static int get_entries(struct unwind_info *ui, unwind_entry_cb_t cb,
+                       void *arg)
+{
+        unw_addr_space_t addr_space;
+        unw_cursor_t c;
+        int ret;
+
+        addr_space = unw_create_addr_space(&accessors, 0);
+        if (!addr_space) {
+                pr_err("unwind: Can't create unwind address space.\n");
+                return -ENOMEM;
+        }
+
+        ret = unw_init_remote(&c, addr_space, ui);
+        if (ret)
+                display_error(ret);
+
+        while (!ret && (unw_step(&c) > 0)) {
+                unw_word_t ip;
+
+                unw_get_reg(&c, UNW_REG_IP, &ip);
+                ret = entry(ip, ui->thread, ui->machine, cb, arg);
+        }
+
+        unw_destroy_addr_space(addr_space);
+        return ret;
+}
+
+int unwind__get_entries(unwind_entry_cb_t cb, void *arg,
+                        struct machine *machine, struct thread *thread,
+                        u64 sample_uregs, struct perf_sample *data)
+{
+        unw_word_t ip;
+        struct unwind_info ui = {
+                .sample       = data,
+                .sample_uregs = sample_uregs,
+                .thread       = thread,
+                .machine      = machine,
+        };
+        int ret;
+
+        if (!data->user_regs.regs)
+                return -EINVAL;
+
+        ret = reg_value(&ip, &data->user_regs, PERF_REG_IP, sample_uregs);
+        if (ret)
+                return ret;
+
+        ret = entry(ip, thread, machine, cb, arg);
+        if (ret)
+                return -ENOMEM;
+
+        return get_entries(&ui, cb, arg);
+}
diff --git a/tools/perf/util/unwind.h b/tools/perf/util/unwind.h
new file mode 100644
index 000000000000..a78c8b303bb5
--- /dev/null
+++ b/tools/perf/util/unwind.h
@@ -0,0 +1,35 @@
+#ifndef __UNWIND_H
+#define __UNWIND_H
+
+#include "types.h"
+#include "event.h"
+#include "symbol.h"
+
+struct unwind_entry {
+        struct map      *map;
+        struct symbol   *sym;
+        u64             ip;
+};
+
+typedef int (*unwind_entry_cb_t)(struct unwind_entry *entry, void *arg);
+
+#ifndef NO_LIBUNWIND_SUPPORT
+int unwind__get_entries(unwind_entry_cb_t cb, void *arg,
+                        struct machine *machine,
+                        struct thread *thread,
+                        u64 sample_uregs,
+                        struct perf_sample *data);
+int unwind__arch_reg_id(int regnum);
+#else
+static inline int
+unwind__get_entries(unwind_entry_cb_t cb __maybe_unused,
+                    void *arg __maybe_unused,
+                    struct machine *machine __maybe_unused,
+                    struct thread *thread __maybe_unused,
+                    u64 sample_uregs __maybe_unused,
+                    struct perf_sample *data __maybe_unused)
+{
+        return 0;
+}
+#endif /* NO_LIBUNWIND_SUPPORT */
+#endif /* __UNWIND_H */
diff --git a/tools/perf/util/util.c b/tools/perf/util/util.c
index d03599fbe78b..2055cf38041c 100644
--- a/tools/perf/util/util.c
+++ b/tools/perf/util/util.c
@@ -1,6 +1,11 @@
 #include "../perf.h"
 #include "util.h"
 #include <sys/mman.h>
+#ifndef NO_BACKTRACE
+#include <execinfo.h>
+#endif
+#include <stdio.h>
+#include <stdlib.h>
 
 /*
  * XXX We need to find a better place for these things...
@@ -158,3 +163,23 @@ size_t hex_width(u64 v)
 
         return n;
 }
+
+/* Obtain a backtrace and print it to stdout. */
+#ifndef NO_BACKTRACE
+void dump_stack(void)
+{
+        void *array[16];
+        size_t size = backtrace(array, ARRAY_SIZE(array));
+        char **strings = backtrace_symbols(array, size);
+        size_t i;
+
+        printf("Obtained %zd stack frames.\n", size);
+
+        for (i = 0; i < size; i++)
+                printf("%s\n", strings[i]);
+
+        free(strings);
+}
+#else
+void dump_stack(void) {}
+#endif
diff --git a/tools/perf/util/util.h b/tools/perf/util/util.h
index b13c7331eaf8..70fa70b535b2 100644
--- a/tools/perf/util/util.h
+++ b/tools/perf/util/util.h
@@ -69,13 +69,8 @@
 #include <sys/poll.h>
 #include <sys/socket.h>
 #include <sys/ioctl.h>
-#include <sys/select.h>
-#include <netinet/in.h>
-#include <netinet/tcp.h>
-#include <arpa/inet.h>
-#include <netdb.h>
 #include <inttypes.h>
-#include "../../../include/linux/magic.h"
+#include <linux/magic.h>
 #include "types.h"
 #include <sys/ttydefaults.h>
 
@@ -266,4 +261,6 @@ size_t hex_width(u64 v);
 
 char *rtrim(char *s);
 
+void dump_stack(void);
+
 #endif
diff --git a/tools/perf/util/vdso.c b/tools/perf/util/vdso.c
new file mode 100644
index 000000000000..e60951fcdb12
--- /dev/null
+++ b/tools/perf/util/vdso.c
@@ -0,0 +1,111 @@
+
+#include <unistd.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <linux/kernel.h>
+
+#include "vdso.h"
+#include "util.h"
+#include "symbol.h"
+#include "linux/string.h"
+
+static bool vdso_found;
+static char vdso_file[] = "/tmp/perf-vdso.so-XXXXXX";
+
+static int find_vdso_map(void **start, void **end)
+{
+        FILE *maps;
+        char line[128];
+        int found = 0;
+
+        maps = fopen("/proc/self/maps", "r");
+        if (!maps) {
+                pr_err("vdso: cannot open maps\n");
+                return -1;
+        }
+
+        while (!found && fgets(line, sizeof(line), maps)) {
+                int m = -1;
+
+                /* We care only about private r-x mappings. */
+                if (2 != sscanf(line, "%p-%p r-xp %*x %*x:%*x %*u %n",
+                                start, end, &m))
+                        continue;
+                if (m < 0)
+                        continue;
+
+                if (!strncmp(&line[m], VDSO__MAP_NAME,
+                             sizeof(VDSO__MAP_NAME) - 1))
+                        found = 1;
+        }
+
+        fclose(maps);
+        return !found;
+}
+
+static char *get_file(void)
+{
+        char *vdso = NULL;
+        char *buf = NULL;
+        void *start, *end;
+        size_t size;
+        int fd;
+
+        if (vdso_found)
+                return vdso_file;
+
+        if (find_vdso_map(&start, &end))
+                return NULL;
+
+        size = end - start;
+
+        buf = memdup(start, size);
+        if (!buf)
+                return NULL;
+
+        fd = mkstemp(vdso_file);
+        if (fd < 0)
+                goto out;
+
+        if (size == (size_t) write(fd, buf, size))
+                vdso = vdso_file;
+
+        close(fd);
+
+ out:
+        free(buf);
+
+        vdso_found = (vdso != NULL);
+        return vdso;
+}
+
+void vdso__exit(void)
+{
+        if (vdso_found)
+                unlink(vdso_file);
+}
+
+struct dso *vdso__dso_findnew(struct list_head *head)
+{
+        struct dso *dso = dsos__find(head, VDSO__MAP_NAME);
+
+        if (!dso) {
+                char *file;
+
+                file = get_file();
+                if (!file)
+                        return NULL;
+
+                dso = dso__new(VDSO__MAP_NAME);
+                if (dso != NULL) {
+                        dsos__add(head, dso);
+                        dso__set_long_name(dso, file);
+                }
+        }
+
+        return dso;
+}
diff --git a/tools/perf/util/vdso.h b/tools/perf/util/vdso.h
new file mode 100644
index 000000000000..0f76e7caf6f8
--- /dev/null
+++ b/tools/perf/util/vdso.h
@@ -0,0 +1,18 @@
+#ifndef __PERF_VDSO__
+#define __PERF_VDSO__
+
+#include <linux/types.h>
+#include <string.h>
+#include <stdbool.h>
+
+#define VDSO__MAP_NAME "[vdso]"
+
+static inline bool is_vdso_map(const char *filename)
+{
+        return !strcmp(filename, VDSO__MAP_NAME);
+}
+
+struct dso *vdso__dso_findnew(struct list_head *head);
+void vdso__exit(void);
+
+#endif /* __PERF_VDSO__ */
diff --git a/tools/perf/util/wrapper.c b/tools/perf/util/wrapper.c
index 73e900edb5a2..19f15b650703 100644
--- a/tools/perf/util/wrapper.c
+++ b/tools/perf/util/wrapper.c
@@ -7,7 +7,8 @@
  * There's no pack memory to release - but stay close to the Git
  * version so wrap this away:
  */
-static inline void release_pack_memory(size_t size __used, int flag __used)
+static inline void release_pack_memory(size_t size __maybe_unused,
+                                       int flag __maybe_unused)
 {
 }