28 files changed, 382 insertions, 154 deletions

diff --git a/tools/perf/arch/powerpc/Makefile b/tools/perf/arch/powerpc/Makefile
index 56e05f126ad8..cc3930904d68 100644
--- a/tools/perf/arch/powerpc/Makefile
+++ b/tools/perf/arch/powerpc/Makefile
@@ -3,4 +3,5 @@ PERF_HAVE_DWARF_REGS := 1
 endif
 
 HAVE_KVM_STAT_SUPPORT := 1
+PERF_HAVE_ARCH_REGS_QUERY_REGISTER_OFFSET := 1
 PERF_HAVE_JITDUMP := 1
diff --git a/tools/perf/arch/powerpc/util/dwarf-regs.c b/tools/perf/arch/powerpc/util/dwarf-regs.c
index 733151cdf46e..41bdf9530d82 100644
--- a/tools/perf/arch/powerpc/util/dwarf-regs.c
+++ b/tools/perf/arch/powerpc/util/dwarf-regs.c
@@ -10,19 +10,26 @@
  */
 
 #include <stddef.h>
+#include <errno.h>
+#include <string.h>
 #include <dwarf-regs.h>
-
+#include <linux/ptrace.h>
+#include <linux/kernel.h>
+#include "util.h"
 
 struct pt_regs_dwarfnum {
         const char *name;
         unsigned int dwarfnum;
+        unsigned int ptregs_offset;
 };
 
-#define STR(s) #s
-#define REG_DWARFNUM_NAME(r, num) {.name = r, .dwarfnum = num}
-#define GPR_DWARFNUM_NAME(num)  \
-        {.name = STR(%gpr##num), .dwarfnum = num}
-#define REG_DWARFNUM_END {.name = NULL, .dwarfnum = 0}
+#define REG_DWARFNUM_NAME(r, num)                                       \
+                {.name = STR(%)STR(r), .dwarfnum = num,                 \
+                .ptregs_offset = offsetof(struct pt_regs, r)}
+#define GPR_DWARFNUM_NAME(num)                                          \
+                {.name = STR(%gpr##num), .dwarfnum = num,               \
+                .ptregs_offset = offsetof(struct pt_regs, gpr[num])}
+#define REG_DWARFNUM_END {.name = NULL, .dwarfnum = 0, .ptregs_offset = 0}
 
 /*
  * Reference:
@@ -61,12 +68,12 @@ static const struct pt_regs_dwarfnum regdwarfnum_table[] = {
         GPR_DWARFNUM_NAME(29),
         GPR_DWARFNUM_NAME(30),
         GPR_DWARFNUM_NAME(31),
-        REG_DWARFNUM_NAME("%msr",   66),
-        REG_DWARFNUM_NAME("%ctr",   109),
-        REG_DWARFNUM_NAME("%link",  108),
-        REG_DWARFNUM_NAME("%xer",   101),
-        REG_DWARFNUM_NAME("%dar",   119),
-        REG_DWARFNUM_NAME("%dsisr", 118),
+        REG_DWARFNUM_NAME(msr,   66),
+        REG_DWARFNUM_NAME(ctr,   109),
+        REG_DWARFNUM_NAME(link,  108),
+        REG_DWARFNUM_NAME(xer,   101),
+        REG_DWARFNUM_NAME(dar,   119),
+        REG_DWARFNUM_NAME(dsisr, 118),
         REG_DWARFNUM_END,
 };
 
@@ -86,3 +93,12 @@ const char *get_arch_regstr(unsigned int n)
                         return roff->name;
         return NULL;
 }
+
+int regs_query_register_offset(const char *name)
+{
+        const struct pt_regs_dwarfnum *roff;
+        for (roff = regdwarfnum_table; roff->name != NULL; roff++)
+                if (!strcmp(roff->name, name))
+                        return roff->ptregs_offset;
+        return -EINVAL;
+}
diff --git a/tools/perf/arch/powerpc/util/sym-handling.c b/tools/perf/arch/powerpc/util/sym-handling.c
index bbc1a50768dd..c6d0f91731a1 100644
--- a/tools/perf/arch/powerpc/util/sym-handling.c
+++ b/tools/perf/arch/powerpc/util/sym-handling.c
@@ -19,12 +19,6 @@ bool elf__needs_adjust_symbols(GElf_Ehdr ehdr)
                ehdr.e_type == ET_DYN;
 }
 
-#if defined(_CALL_ELF) && _CALL_ELF == 2
-void arch__elf_sym_adjust(GElf_Sym *sym)
-{
-        sym->st_value += PPC64_LOCAL_ENTRY_OFFSET(sym->st_other);
-}
-#endif
 #endif
 
 #if !defined(_CALL_ELF) || _CALL_ELF != 2
@@ -65,18 +59,45 @@ bool arch__prefers_symtab(void)
         return true;
 }
 
+#ifdef HAVE_LIBELF_SUPPORT
+void arch__sym_update(struct symbol *s, GElf_Sym *sym)
+{
+        s->arch_sym = sym->st_other;
+}
+#endif
+
 #define PPC64LE_LEP_OFFSET      8
 
 void arch__fix_tev_from_maps(struct perf_probe_event *pev,
-                             struct probe_trace_event *tev, struct map *map)
+                             struct probe_trace_event *tev, struct map *map,
+                             struct symbol *sym)
 {
+        int lep_offset;
+
         /*
-         * ppc64 ABIv2 local entry point is currently always 2 instructions
-         * (8 bytes) after the global entry point.
+         * When probing at a function entry point, we normally always want the
+         * LEP since that catches calls to the function through both the GEP and
+         * the LEP. Hence, we would like to probe at an offset of 8 bytes if
+         * the user only specified the function entry.
+         *
+         * However, if the user specifies an offset, we fall back to using the
+         * GEP since all userspace applications (objdump/readelf) show function
+         * disassembly with offsets from the GEP.
+         *
+         * In addition, we shouldn't specify an offset for kretprobes.
          */
-        if (!pev->uprobes && map->dso->symtab_type == DSO_BINARY_TYPE__KALLSYMS) {
-                tev->point.address += PPC64LE_LEP_OFFSET;
+        if (pev->point.offset || pev->point.retprobe || !map || !sym)
+                return;
+
+        lep_offset = PPC64_LOCAL_ENTRY_OFFSET(sym->arch_sym);
+
+        if (map->dso->symtab_type == DSO_BINARY_TYPE__KALLSYMS)
                 tev->point.offset += PPC64LE_LEP_OFFSET;
+        else if (lep_offset) {
+                if (pev->uprobes)
+                        tev->point.address += lep_offset;
+                else
+                        tev->point.offset += lep_offset;
         }
 }
 #endif
diff --git a/tools/perf/builtin-diff.c b/tools/perf/builtin-diff.c
index 8053a8ceefda..9ce354f469dc 100644
--- a/tools/perf/builtin-diff.c
+++ b/tools/perf/builtin-diff.c
@@ -428,7 +428,7 @@ static void hists__baseline_only(struct hists *hists)
         struct rb_root *root;
         struct rb_node *next;
 
-        if (sort__need_collapse)
+        if (hists__has(hists, need_collapse))
                 root = &hists->entries_collapsed;
         else
                 root = hists->entries_in;
@@ -450,7 +450,7 @@ static void hists__precompute(struct hists *hists)
         struct rb_root *root;
         struct rb_node *next;
 
-        if (sort__need_collapse)
+        if (hists__has(hists, need_collapse))
                 root = &hists->entries_collapsed;
         else
                 root = hists->entries_in;
diff --git a/tools/perf/builtin-report.c b/tools/perf/builtin-report.c
index 8d9b88af901d..87d40e3c4078 100644
--- a/tools/perf/builtin-report.c
+++ b/tools/perf/builtin-report.c
@@ -234,7 +234,7 @@ static int report__setup_sample_type(struct report *rep)
                 sample_type |= PERF_SAMPLE_BRANCH_STACK;
 
         if (!is_pipe && !(sample_type & PERF_SAMPLE_CALLCHAIN)) {
-                if (sort__has_parent) {
+                if (perf_hpp_list.parent) {
                         ui__error("Selected --sort parent, but no "
                                     "callchain data. Did you call "
                                     "'perf record' without -g?\n");
@@ -936,7 +936,7 @@ repeat:
                         goto error;
                 }
 
-                sort__need_collapse = true;
+                perf_hpp_list.need_collapse = true;
         }
 
         /* Force tty output for header output and per-thread stat. */
diff --git a/tools/perf/builtin-top.c b/tools/perf/builtin-top.c
index da18517b1d40..1793da585676 100644
--- a/tools/perf/builtin-top.c
+++ b/tools/perf/builtin-top.c
@@ -688,7 +688,7 @@ static int hist_iter__top_callback(struct hist_entry_iter *iter,
         struct hist_entry *he = iter->he;
         struct perf_evsel *evsel = iter->evsel;
 
-        if (sort__has_sym && single)
+        if (perf_hpp_list.sym && single)
                 perf_top__record_precise_ip(top, he, evsel->idx, al->addr);
 
         hist__account_cycles(iter->sample->branch_stack, al, iter->sample,
@@ -919,7 +919,7 @@ out_err:
 
 static int callchain_param__setup_sample_type(struct callchain_param *callchain)
 {
-        if (!sort__has_sym) {
+        if (!perf_hpp_list.sym) {
                 if (callchain->enabled) {
                         ui__error("Selected -g but \"sym\" not present in --sort/-s.");
                         return -EINVAL;
@@ -962,7 +962,7 @@ static int __cmd_top(struct perf_top *top)
         machine__synthesize_threads(&top->session->machines.host, &opts->target,
                                     top->evlist->threads, false, opts->proc_map_timeout);
 
-        if (sort__has_socket) {
+        if (perf_hpp_list.socket) {
                 ret = perf_env__read_cpu_topology_map(&perf_env);
                 if (ret < 0)
                         goto out_err_cpu_topo;
@@ -1255,7 +1255,7 @@ int cmd_top(int argc, const char **argv, const char *prefix __maybe_unused)
 
         sort__mode = SORT_MODE__TOP;
         /* display thread wants entries to be collapsed in a different tree */
-        sort__need_collapse = 1;
+        perf_hpp_list.need_collapse = 1;
 
         if (top.use_stdio)
                 use_browser = 0;
diff --git a/tools/perf/builtin-trace.c b/tools/perf/builtin-trace.c
index 9e38fe973f0c..66aa2a00414b 100644
--- a/tools/perf/builtin-trace.c
+++ b/tools/perf/builtin-trace.c
@@ -36,6 +36,7 @@
 #include "util/bpf-loader.h"
 #include "callchain.h"
 #include "syscalltbl.h"
+#include "rb_resort.h"
 
 #include <libaudit.h> /* FIXME: Still needed for audit_errno_to_name */
 #include <stdlib.h>
@@ -2784,15 +2785,29 @@ static size_t trace__fprintf_threads_header(FILE *fp)
         return printed;
 }
 
+DEFINE_RESORT_RB(syscall_stats, a->msecs > b->msecs,
+        struct stats    *stats;
+        double          msecs;
+        int             syscall;
+)
+{
+        struct int_node *source = rb_entry(nd, struct int_node, rb_node);
+        struct stats *stats = source->priv;
+
+        entry->syscall = source->i;
+        entry->stats   = stats;
+        entry->msecs   = stats ? (u64)stats->n * (avg_stats(stats) / NSEC_PER_MSEC) : 0;
+}
+
 static size_t thread__dump_stats(struct thread_trace *ttrace,
                                  struct trace *trace, FILE *fp)
 {
-        struct stats *stats;
         size_t printed = 0;
         struct syscall *sc;
-        struct int_node *inode = intlist__first(ttrace->syscall_stats);
+        struct rb_node *nd;
+        DECLARE_RESORT_RB_INTLIST(syscall_stats, ttrace->syscall_stats);
 
-        if (inode == NULL)
+        if (syscall_stats == NULL)
                 return 0;
 
         printed += fprintf(fp, "\n");
@@ -2801,9 +2816,8 @@ static size_t thread__dump_stats(struct thread_trace *ttrace,
         printed += fprintf(fp, "                               (msec)    (msec)    (msec)    (msec)        (%%)\n");
         printed += fprintf(fp, "   --------------- -------- --------- --------- --------- ---------     ------\n");
 
-        /* each int_node is a syscall */
-        while (inode) {
-                stats = inode->priv;
+        resort_rb__for_each(nd, syscall_stats) {
+                struct stats *stats = syscall_stats_entry->stats;
                 if (stats) {
                         double min = (double)(stats->min) / NSEC_PER_MSEC;
                         double max = (double)(stats->max) / NSEC_PER_MSEC;
@@ -2814,34 +2828,23 @@ static size_t thread__dump_stats(struct thread_trace *ttrace,
                         pct = avg ? 100.0 * stddev_stats(stats)/avg : 0.0;
                         avg /= NSEC_PER_MSEC;
 
-                        sc = &trace->syscalls.table[inode->i];
+                        sc = &trace->syscalls.table[syscall_stats_entry->syscall];
                         printed += fprintf(fp, "   %-15s", sc->name);
                         printed += fprintf(fp, " %8" PRIu64 " %9.3f %9.3f %9.3f",
-                                           n, avg * n, min, avg);
+                                           n, syscall_stats_entry->msecs, min, avg);
                         printed += fprintf(fp, " %9.3f %9.2f%%\n", max, pct);
                 }
-
-                inode = intlist__next(inode);
         }
 
+        resort_rb__delete(syscall_stats);
         printed += fprintf(fp, "\n\n");
 
         return printed;
 }
 
-/* struct used to pass data to per-thread function */
-struct summary_data {
-        FILE *fp;
-        struct trace *trace;
-        size_t printed;
-};
-
-static int trace__fprintf_one_thread(struct thread *thread, void *priv)
+static size_t trace__fprintf_thread(FILE *fp, struct thread *thread, struct trace *trace)
 {
-        struct summary_data *data = priv;
-        FILE *fp = data->fp;
-        size_t printed = data->printed;
-        struct trace *trace = data->trace;
+        size_t printed = 0;
         struct thread_trace *ttrace = thread__priv(thread);
         double ratio;
 
@@ -2857,25 +2860,45 @@ static int trace__fprintf_one_thread(struct thread *thread, void *priv)
                 printed += fprintf(fp, ", %lu majfaults", ttrace->pfmaj);
         if (ttrace->pfmin)
                 printed += fprintf(fp, ", %lu minfaults", ttrace->pfmin);
-        printed += fprintf(fp, ", %.3f msec\n", ttrace->runtime_ms);
+        if (trace->sched)
+                printed += fprintf(fp, ", %.3f msec\n", ttrace->runtime_ms);
+        else if (fputc('\n', fp) != EOF)
+                ++printed;
+
         printed += thread__dump_stats(ttrace, trace, fp);
 
-        data->printed += printed;
+        return printed;
+}
+
+static unsigned long thread__nr_events(struct thread_trace *ttrace)
+{
+        return ttrace ? ttrace->nr_events : 0;
+}
 
-        return 0;
+DEFINE_RESORT_RB(threads, (thread__nr_events(a->thread->priv) < thread__nr_events(b->thread->priv)),
+        struct thread *thread;
+)
+{
+        entry->thread = rb_entry(nd, struct thread, rb_node);
 }
 
 static size_t trace__fprintf_thread_summary(struct trace *trace, FILE *fp)
 {
-        struct summary_data data = {
-                .fp = fp,
-                .trace = trace
-        };
-        data.printed = trace__fprintf_threads_header(fp);
+        DECLARE_RESORT_RB_MACHINE_THREADS(threads, trace->host);
+        size_t printed = trace__fprintf_threads_header(fp);
+        struct rb_node *nd;
+
+        if (threads == NULL) {
+                fprintf(fp, "%s", "Error sorting output by nr_events!\n");
+                return 0;
+        }
+
+        resort_rb__for_each(nd, threads)
+                printed += trace__fprintf_thread(fp, threads_entry->thread, trace);
 
-        machine__for_each_thread(trace->host, trace__fprintf_one_thread, &data);
+        resort_rb__delete(threads);
 
-        return data.printed;
+        return printed;
 }
 
 static int trace__set_duration(const struct option *opt, const char *str,
diff --git a/tools/perf/tests/hists_common.c b/tools/perf/tests/hists_common.c
index f55f4bd47932..6b21746d6eec 100644
--- a/tools/perf/tests/hists_common.c
+++ b/tools/perf/tests/hists_common.c
@@ -161,7 +161,7 @@ void print_hists_in(struct hists *hists)
         struct rb_root *root;
         struct rb_node *node;
 
-        if (sort__need_collapse)
+        if (hists__has(hists, need_collapse))
                 root = &hists->entries_collapsed;
         else
                 root = hists->entries_in;
diff --git a/tools/perf/tests/hists_cumulate.c b/tools/perf/tests/hists_cumulate.c
index 4a2bbff9b1ee..a9e3db3afac4 100644
--- a/tools/perf/tests/hists_cumulate.c
+++ b/tools/perf/tests/hists_cumulate.c
@@ -126,7 +126,7 @@ static void del_hist_entries(struct hists *hists)
         struct rb_root *root_out;
         struct rb_node *node;
 
-        if (sort__need_collapse)
+        if (hists__has(hists, need_collapse))
                 root_in = &hists->entries_collapsed;
         else
                 root_in = hists->entries_in;
diff --git a/tools/perf/tests/hists_link.c b/tools/perf/tests/hists_link.c
index 358324e47805..acf5a1301c07 100644
--- a/tools/perf/tests/hists_link.c
+++ b/tools/perf/tests/hists_link.c
@@ -145,7 +145,7 @@ static int __validate_match(struct hists *hists)
         /*
          * Only entries from fake_common_samples should have a pair.
          */
-        if (sort__need_collapse)
+        if (hists__has(hists, need_collapse))
                 root = &hists->entries_collapsed;
         else
                 root = hists->entries_in;
@@ -197,7 +197,7 @@ static int __validate_link(struct hists *hists, int idx)
          * and some entries will have no pair.  However every entry
          * in other hists should have (dummy) pair.
          */
-        if (sort__need_collapse)
+        if (hists__has(hists, need_collapse))
                 root = &hists->entries_collapsed;
         else
                 root = hists->entries_in;
diff --git a/tools/perf/tests/hists_output.c b/tools/perf/tests/hists_output.c
index 7cd8738e842f..63c5efaba1b5 100644
--- a/tools/perf/tests/hists_output.c
+++ b/tools/perf/tests/hists_output.c
@@ -92,7 +92,7 @@ static void del_hist_entries(struct hists *hists)
         struct rb_root *root_out;
         struct rb_node *node;
 
-        if (sort__need_collapse)
+        if (hists__has(hists, need_collapse))
                 root_in = &hists->entries_collapsed;
         else
                 root_in = hists->entries_in;
diff --git a/tools/perf/ui/browsers/hists.c b/tools/perf/ui/browsers/hists.c
index 6a4681932ba5..538bae880bfe 100644
--- a/tools/perf/ui/browsers/hists.c
+++ b/tools/perf/ui/browsers/hists.c
@@ -2135,7 +2135,7 @@ static int hists__browser_title(struct hists *hists,
                 printed += snprintf(bf + printed, size - printed,
                                     ", UID: %s", hists->uid_filter_str);
         if (thread) {
-                if (sort__has_thread) {
+                if (hists__has(hists, thread)) {
                         printed += scnprintf(bf + printed, size - printed,
                                     ", Thread: %s(%d)",
                                      (thread->comm_set ? thread__comm_str(thread) : ""),
@@ -2320,7 +2320,8 @@ do_zoom_thread(struct hist_browser *browser, struct popup_action *act)
 {
         struct thread *thread = act->thread;
 
-        if ((!sort__has_thread && !sort__has_comm) || thread == NULL)
+        if ((!hists__has(browser->hists, thread) &&
+             !hists__has(browser->hists, comm)) || thread == NULL)
                 return 0;
 
         if (browser->hists->thread_filter) {
@@ -2329,7 +2330,7 @@ do_zoom_thread(struct hist_browser *browser, struct popup_action *act)
                 thread__zput(browser->hists->thread_filter);
                 ui_helpline__pop();
         } else {
-                if (sort__has_thread) {
+                if (hists__has(browser->hists, thread)) {
                         ui_helpline__fpush("To zoom out press ESC or ENTER + \"Zoom out of %s(%d) thread\"",
                                            thread->comm_set ? thread__comm_str(thread) : "",
                                            thread->tid);
@@ -2354,10 +2355,11 @@ add_thread_opt(struct hist_browser *browser, struct popup_action *act,
 {
         int ret;
 
-        if ((!sort__has_thread && !sort__has_comm) || thread == NULL)
+        if ((!hists__has(browser->hists, thread) &&
+             !hists__has(browser->hists, comm)) || thread == NULL)
                 return 0;
 
-        if (sort__has_thread) {
+        if (hists__has(browser->hists, thread)) {
                 ret = asprintf(optstr, "Zoom %s %s(%d) thread",
                                browser->hists->thread_filter ? "out of" : "into",
                                thread->comm_set ? thread__comm_str(thread) : "",
@@ -2380,7 +2382,7 @@ do_zoom_dso(struct hist_browser *browser, struct popup_action *act)
 {
         struct map *map = act->ms.map;
 
-        if (!sort__has_dso || map == NULL)
+        if (!hists__has(browser->hists, dso) || map == NULL)
                 return 0;
 
         if (browser->hists->dso_filter) {
@@ -2407,7 +2409,7 @@ static int
 add_dso_opt(struct hist_browser *browser, struct popup_action *act,
             char **optstr, struct map *map)
 {
-        if (!sort__has_dso || map == NULL)
+        if (!hists__has(browser->hists, dso) || map == NULL)
                 return 0;
 
         if (asprintf(optstr, "Zoom %s %s DSO",
@@ -2429,10 +2431,10 @@ do_browse_map(struct hist_browser *browser __maybe_unused,
 }
 
 static int
-add_map_opt(struct hist_browser *browser __maybe_unused,
+add_map_opt(struct hist_browser *browser,
             struct popup_action *act, char **optstr, struct map *map)
 {
-        if (!sort__has_dso || map == NULL)
+        if (!hists__has(browser->hists, dso) || map == NULL)
                 return 0;
 
         if (asprintf(optstr, "Browse map details") < 0)
@@ -2534,7 +2536,7 @@ add_exit_opt(struct hist_browser *browser __maybe_unused,
 static int
 do_zoom_socket(struct hist_browser *browser, struct popup_action *act)
 {
-        if (!sort__has_socket || act->socket < 0)
+        if (!hists__has(browser->hists, socket) || act->socket < 0)
                 return 0;
 
         if (browser->hists->socket_filter > -1) {
@@ -2556,7 +2558,7 @@ static int
 add_socket_opt(struct hist_browser *browser, struct popup_action *act,
                char **optstr, int socket_id)
 {
-        if (!sort__has_socket || socket_id < 0)
+        if (!hists__has(browser->hists, socket) || socket_id < 0)
                 return 0;
 
         if (asprintf(optstr, "Zoom %s Processor Socket %d",
@@ -2747,7 +2749,7 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
                          */
                         goto out_free_stack;
                 case 'a':
-                        if (!sort__has_sym) {
+                        if (!hists__has(hists, sym)) {
                                 ui_browser__warning(&browser->b, delay_secs * 2,
                         "Annotation is only available for symbolic views, "
                         "include \"sym*\" in --sort to use it.");
@@ -2910,7 +2912,7 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
                         continue;
                 }
 
-                if (!sort__has_sym || browser->selection == NULL)
+                if (!hists__has(hists, sym) || browser->selection == NULL)
                         goto skip_annotation;
 
                 if (sort__mode == SORT_MODE__BRANCH) {
@@ -2954,7 +2956,7 @@ skip_annotation:
                         goto skip_scripting;
 
                 if (browser->he_selection) {
-                        if (sort__has_thread && thread) {
+                        if (hists__has(hists, thread) && thread) {
                                 nr_options += add_script_opt(browser,
                                                              &actions[nr_options],
                                                              &options[nr_options],
@@ -2969,7 +2971,7 @@ skip_annotation:
                          *
                          * See hist_browser__show_entry.
                          */
-                        if (sort__has_sym && browser->selection->sym) {
+                        if (hists__has(hists, sym) && browser->selection->sym) {
                                 nr_options += add_script_opt(browser,
                                                              &actions[nr_options],
                                                              &options[nr_options],
diff --git a/tools/perf/ui/gtk/hists.c b/tools/perf/ui/gtk/hists.c
index 2aa45b606fa4..932adfaa05af 100644
--- a/tools/perf/ui/gtk/hists.c
+++ b/tools/perf/ui/gtk/hists.c
@@ -379,7 +379,7 @@ static void perf_gtk__show_hists(GtkWidget *window, struct hists *hists,
                         gtk_tree_store_set(store, &iter, col_idx++, s, -1);
                 }
 
-                if (symbol_conf.use_callchain && sort__has_sym) {
+                if (symbol_conf.use_callchain && hists__has(hists, sym)) {
                         if (callchain_param.mode == CHAIN_GRAPH_REL)
                                 total = symbol_conf.cumulate_callchain ?
                                         h->stat_acc->period : h->stat.period;
diff --git a/tools/perf/ui/hist.c b/tools/perf/ui/hist.c
index 3baeaa6e71b5..af07ffb129ca 100644
--- a/tools/perf/ui/hist.c
+++ b/tools/perf/ui/hist.c
@@ -635,7 +635,7 @@ unsigned int hists__sort_list_width(struct hists *hists)
                 ret += fmt->width(fmt, &dummy_hpp, hists_to_evsel(hists));
         }
 
-        if (verbose && sort__has_sym) /* Addr + origin */
+        if (verbose && hists__has(hists, sym)) /* Addr + origin */
                 ret += 3 + BITS_PER_LONG / 4;
 
         return ret;
diff --git a/tools/perf/util/annotate.c b/tools/perf/util/annotate.c
index b795b6994144..d4b3d034c503 100644
--- a/tools/perf/util/annotate.c
+++ b/tools/perf/util/annotate.c
@@ -1665,5 +1665,5 @@ int hist_entry__annotate(struct hist_entry *he, size_t privsize)
 
 bool ui__has_annotation(void)
 {
-        return use_browser == 1 && sort__has_sym;
+        return use_browser == 1 && perf_hpp_list.sym;
 }
diff --git a/tools/perf/util/callchain.c b/tools/perf/util/callchain.c
index aa248dcb4440..07fd30bc2f81 100644
--- a/tools/perf/util/callchain.c
+++ b/tools/perf/util/callchain.c
@@ -799,7 +799,7 @@ int sample__resolve_callchain(struct perf_sample *sample,
                 return 0;
 
         if (symbol_conf.use_callchain || symbol_conf.cumulate_callchain ||
-            sort__has_parent) {
+            perf_hpp_list.parent) {
                 return thread__resolve_callchain(al->thread, cursor, evsel, sample,
                                                  parent, al, max_stack);
         }
diff --git a/tools/perf/util/evlist.c b/tools/perf/util/evlist.c
index 85271e54a63b..17cd01421e7f 100644
--- a/tools/perf/util/evlist.c
+++ b/tools/perf/util/evlist.c
@@ -679,39 +679,31 @@ static struct perf_evsel *perf_evlist__event2evsel(struct perf_evlist *evlist,
         return NULL;
 }
 
-union perf_event *perf_evlist__mmap_read(struct perf_evlist *evlist, int idx)
+/* When check_messup is true, 'end' must points to a good entry */
+static union perf_event *
+perf_mmap__read(struct perf_mmap *md, bool check_messup, u64 start,
+                u64 end, u64 *prev)
 {
-        struct perf_mmap *md = &evlist->mmap[idx];
-        u64 head;
-        u64 old = md->prev;
-        int diff;
         unsigned char *data = md->base + page_size;
         union perf_event *event = NULL;
+        int diff = end - start;
 
-        /*
-         * Check if event was unmapped due to a POLLHUP/POLLERR.
-         */
-        if (!atomic_read(&md->refcnt))
-                return NULL;
-
-        head = perf_mmap__read_head(md);
-        diff = head - old;
-        if (evlist->overwrite) {
+        if (check_messup) {
                 /*
                  * If we're further behind than half the buffer, there's a chance
                  * the writer will bite our tail and mess up the samples under us.
                  *
-                 * If we somehow ended up ahead of the head, we got messed up.
+                 * If we somehow ended up ahead of the 'end', we got messed up.
                  *
-                 * In either case, truncate and restart at head.
+                 * In either case, truncate and restart at 'end'.
                  */
                 if (diff > md->mask / 2 || diff < 0) {
                         fprintf(stderr, "WARNING: failed to keep up with mmap data.\n");
 
                         /*
-                         * head points to a known good entry, start there.
+                         * 'end' points to a known good entry, start there.
                          */
-                        old = head;
+                        start = end;
                         diff = 0;
                 }
         }
@@ -719,7 +711,7 @@ union perf_event *perf_evlist__mmap_read(struct perf_evlist *evlist, int idx)
         if (diff >= (int)sizeof(event->header)) {
                 size_t size;
 
-                event = (union perf_event *)&data[old & md->mask];
+                event = (union perf_event *)&data[start & md->mask];
                 size = event->header.size;
 
                 if (size < sizeof(event->header) || diff < (int)size) {
@@ -731,8 +723,8 @@ union perf_event *perf_evlist__mmap_read(struct perf_evlist *evlist, int idx)
                  * Event straddles the mmap boundary -- header should always
                  * be inside due to u64 alignment of output.
                  */
-                if ((old & md->mask) + size != ((old + size) & md->mask)) {
-                        unsigned int offset = old;
+                if ((start & md->mask) + size != ((start + size) & md->mask)) {
+                        unsigned int offset = start;
                         unsigned int len = min(sizeof(*event), size), cpy;
                         void *dst = md->event_copy;
 
@@ -747,15 +739,33 @@ union perf_event *perf_evlist__mmap_read(struct perf_evlist *evlist, int idx)
                         event = (union perf_event *) md->event_copy;
                 }
 
-                old += size;
+                start += size;
         }
 
 broken_event:
-        md->prev = old;
+        if (prev)
+                *prev = start;
 
         return event;
 }
 
+union perf_event *perf_evlist__mmap_read(struct perf_evlist *evlist, int idx)
+{
+        struct perf_mmap *md = &evlist->mmap[idx];
+        u64 head;
+        u64 old = md->prev;
+
+        /*
+         * Check if event was unmapped due to a POLLHUP/POLLERR.
+         */
+        if (!atomic_read(&md->refcnt))
+                return NULL;
+
+        head = perf_mmap__read_head(md);
+
+        return perf_mmap__read(md, evlist->overwrite, old, head, &md->prev);
+}
+
 static bool perf_mmap__empty(struct perf_mmap *md)
 {
         return perf_mmap__read_head(md) == md->prev && !md->auxtrace_mmap.base;
diff --git a/tools/perf/util/hist.c b/tools/perf/util/hist.c
index 0f33d7e698c4..cfab531437c7 100644
--- a/tools/perf/util/hist.c
+++ b/tools/perf/util/hist.c
@@ -295,7 +295,7 @@ static void hists__delete_entry(struct hists *hists, struct hist_entry *he)
                 root_in  = &he->parent_he->hroot_in;
                 root_out = &he->parent_he->hroot_out;
         } else {
-                if (sort__need_collapse)
+                if (hists__has(hists, need_collapse))
                         root_in = &hists->entries_collapsed;
                 else
                         root_in = hists->entries_in;
@@ -1373,7 +1373,7 @@ int hists__collapse_resort(struct hists *hists, struct ui_progress *prog)
         struct hist_entry *n;
         int ret;
 
-        if (!sort__need_collapse)
+        if (!hists__has(hists, need_collapse))
                 return 0;
 
         hists->nr_entries = 0;
@@ -1632,7 +1632,7 @@ static void output_resort(struct hists *hists, struct ui_progress *prog,
                 return;
         }
 
-        if (sort__need_collapse)
+        if (hists__has(hists, need_collapse))
                 root = &hists->entries_collapsed;
         else
                 root = hists->entries_in;
@@ -2036,7 +2036,7 @@ static struct hist_entry *hists__add_dummy_entry(struct hists *hists,
         struct hist_entry *he;
         int64_t cmp;
 
-        if (sort__need_collapse)
+        if (hists__has(hists, need_collapse))
                 root = &hists->entries_collapsed;
         else
                 root = hists->entries_in;
@@ -2078,7 +2078,7 @@ static struct hist_entry *hists__find_entry(struct hists *hists,
 {
         struct rb_node *n;
 
-        if (sort__need_collapse)
+        if (hists__has(hists, need_collapse))
                 n = hists->entries_collapsed.rb_node;
         else
                 n = hists->entries_in->rb_node;
@@ -2107,7 +2107,7 @@ void hists__match(struct hists *leader, struct hists *other)
         struct rb_node *nd;
         struct hist_entry *pos, *pair;
 
-        if (sort__need_collapse)
+        if (hists__has(leader, need_collapse))
                 root = &leader->entries_collapsed;
         else
                 root = leader->entries_in;
@@ -2132,7 +2132,7 @@ int hists__link(struct hists *leader, struct hists *other)
         struct rb_node *nd;
         struct hist_entry *pos, *pair;
 
-        if (sort__need_collapse)
+        if (hists__has(other, need_collapse))
                 root = &other->entries_collapsed;
         else
                 root = other->entries_in;
diff --git a/tools/perf/util/hist.h b/tools/perf/util/hist.h
index 588596561cb3..0f84bfb42bb1 100644
--- a/tools/perf/util/hist.h
+++ b/tools/perf/util/hist.h
@@ -82,6 +82,8 @@ struct hists {
         int                     nr_hpp_node;
 };
 
+#define hists__has(__h, __f) (__h)->hpp_list->__f
+
 struct hist_entry_iter;
 
 struct hist_iter_ops {
@@ -238,6 +240,14 @@ struct perf_hpp_fmt {
 struct perf_hpp_list {
         struct list_head fields;
         struct list_head sorts;
+
+        int need_collapse;
+        int parent;
+        int sym;
+        int dso;
+        int socket;
+        int thread;
+        int comm;
 };
 
 extern struct perf_hpp_list perf_hpp_list;
diff --git a/tools/perf/util/machine.c b/tools/perf/util/machine.c
index 2cb95bbf9ea6..8c7bf4dbd479 100644
--- a/tools/perf/util/machine.c
+++ b/tools/perf/util/machine.c
@@ -32,6 +32,7 @@ int machine__init(struct machine *machine, const char *root_dir, pid_t pid)
 
         machine->threads = RB_ROOT;
         pthread_rwlock_init(&machine->threads_lock, NULL);
+        machine->nr_threads = 0;
         INIT_LIST_HEAD(&machine->dead_threads);
         machine->last_match = NULL;
 
@@ -430,6 +431,7 @@ static struct thread *____machine__findnew_thread(struct machine *machine,
                  */
                 thread__get(th);
                 machine->last_match = th;
+                ++machine->nr_threads;
         }
 
         return th;
@@ -681,11 +683,13 @@ size_t machine__fprintf_vmlinux_path(struct machine *machine, FILE *fp)
 
 size_t machine__fprintf(struct machine *machine, FILE *fp)
 {
-        size_t ret = 0;
+        size_t ret;
         struct rb_node *nd;
 
         pthread_rwlock_rdlock(&machine->threads_lock);
 
+        ret = fprintf(fp, "Threads: %u\n", machine->nr_threads);
+
         for (nd = rb_first(&machine->threads); nd; nd = rb_next(nd)) {
                 struct thread *pos = rb_entry(nd, struct thread, rb_node);
 
@@ -1419,6 +1423,7 @@ static void __machine__remove_thread(struct machine *machine, struct thread *th,
                 pthread_rwlock_wrlock(&machine->threads_lock);
         rb_erase_init(&th->rb_node, &machine->threads);
         RB_CLEAR_NODE(&th->rb_node);
+        --machine->nr_threads;
         /*
          * Move it first to the dead_threads list, then drop the reference,
          * if this is the last reference, then the thread__delete destructor
@@ -1647,7 +1652,7 @@ static int add_callchain_ip(struct thread *thread,
         }
 
         if (al.sym != NULL) {
-                if (sort__has_parent && !*parent &&
+                if (perf_hpp_list.parent && !*parent &&
                     symbol__match_regex(al.sym, &parent_regex))
                         *parent = al.sym;
                 else if (have_ignore_callees && root_al &&
diff --git a/tools/perf/util/machine.h b/tools/perf/util/machine.h
index 4822de5e4544..83f46790c52f 100644
--- a/tools/perf/util/machine.h
+++ b/tools/perf/util/machine.h
@@ -31,6 +31,7 @@ struct machine {
         char              *root_dir;
         struct rb_root    threads;
         pthread_rwlock_t  threads_lock;
+        unsigned int      nr_threads;
         struct list_head  dead_threads;
         struct thread     *last_match;
         struct vdso_info  *vdso_info;
diff --git a/tools/perf/util/probe-event.c b/tools/perf/util/probe-event.c
index 85d82f4dc5e9..c82c625395ab 100644
--- a/tools/perf/util/probe-event.c
+++ b/tools/perf/util/probe-event.c
@@ -2477,7 +2477,8 @@ static int find_probe_functions(struct map *map, char *name,
 
 void __weak arch__fix_tev_from_maps(struct perf_probe_event *pev __maybe_unused,
                                 struct probe_trace_event *tev __maybe_unused,
-                                struct map *map __maybe_unused) { }
+                                struct map *map __maybe_unused,
+                                struct symbol *sym __maybe_unused) { }
 
 /*
  * Find probe function addresses from map.
@@ -2614,7 +2615,7 @@ static int find_probe_trace_events_from_map(struct perf_probe_event *pev,
                                         strdup_or_goto(pev->args[i].type,
                                                         nomem_out);
                 }
-                arch__fix_tev_from_maps(pev, tev, map);
+                arch__fix_tev_from_maps(pev, tev, map, sym);
         }
         if (ret == skipped) {
                 ret = -ENOENT;
diff --git a/tools/perf/util/probe-event.h b/tools/perf/util/probe-event.h
index e2209623f981..5a27eb4fad05 100644
--- a/tools/perf/util/probe-event.h
+++ b/tools/perf/util/probe-event.h
@@ -154,7 +154,8 @@ int show_available_vars(struct perf_probe_event *pevs, int npevs,
 int show_available_funcs(const char *module, struct strfilter *filter, bool user);
 bool arch__prefers_symtab(void);
 void arch__fix_tev_from_maps(struct perf_probe_event *pev,
-                             struct probe_trace_event *tev, struct map *map);
+                             struct probe_trace_event *tev, struct map *map,
+                             struct symbol *sym);
 
 /* If there is no space to write, returns -E2BIG. */
 int e_snprintf(char *str, size_t size, const char *format, ...)
diff --git a/tools/perf/util/rb_resort.h b/tools/perf/util/rb_resort.h
new file mode 100644
index 000000000000..abc76e3d3098
--- /dev/null
+++ b/tools/perf/util/rb_resort.h
@@ -0,0 +1,149 @@
+#ifndef _PERF_RESORT_RB_H_
+#define _PERF_RESORT_RB_H_
+/*
+ * Template for creating a class to resort an existing rb_tree according to
+ * a new sort criteria, that must be present in the entries of the source
+ * rb_tree.
+ *
+ * (c) 2016 Arnaldo Carvalho de Melo <acme@redhat.com>
+ *
+ * Quick example, resorting threads by its shortname:
+ *
+ * First define the prefix (threads) to be used for the functions and data
+ * structures created, and provide an expression for the sorting, then the
+ * fields to be present in each of the entries in the new, sorted, rb_tree.
+ *
+ * The body of the init function should collect the fields, maybe
+ * pre-calculating them from multiple entries in the original 'entry' from
+ * the rb_tree used as a source for the entries to be sorted:
+
+DEFINE_RB_RESORT_RB(threads, strcmp(a->thread->shortname,
+                                    b->thread->shortname) < 0,
+        struct thread *thread;
+)
+{
+        entry->thread = rb_entry(nd, struct thread, rb_node);
+}
+
+ * After this it is just a matter of instantiating it and iterating it,
+ * for a few data structures with existing rb_trees, such as 'struct machine',
+ * helpers are available to get the rb_root and the nr_entries:
+
+        DECLARE_RESORT_RB_MACHINE_THREADS(threads, machine_ptr);
+
+ * This will instantiate the new rb_tree and a cursor for it, that can be used as:
+
+        struct rb_node *nd;
+
+        resort_rb__for_each(nd, threads) {
+                struct thread *t = threads_entry;
+                printf("%s: %d\n", t->shortname, t->tid);
+        }
+
+ * Then delete it:
+
+        resort_rb__delete(threads);
+
+ * The name of the data structures and functions will have a _sorted suffix
+ * right before the method names, i.e. will look like:
+ *
+ *      struct threads_sorted_entry {}
+ *      threads_sorted__insert()
+ */
+
+#define DEFINE_RESORT_RB(__name, __comp, ...)                                   \
+struct __name##_sorted_entry {                                                  \
+        struct rb_node  rb_node;                                                \
+        __VA_ARGS__                                                             \
+};                                                                              \
+static void __name##_sorted__init_entry(struct rb_node *nd,                     \
+                                        struct __name##_sorted_entry *entry);   \
+                                                                                \
+static int __name##_sorted__cmp(struct rb_node *nda, struct rb_node *ndb)       \
+{                                                                               \
+        struct __name##_sorted_entry *a, *b;                                    \
+        a = rb_entry(nda, struct __name##_sorted_entry, rb_node);               \
+        b = rb_entry(ndb, struct __name##_sorted_entry, rb_node);               \
+        return __comp;                                                          \
+}                                                                               \
+                                                                                \
+struct __name##_sorted {                                                        \
+       struct rb_root               entries;                                    \
+       struct __name##_sorted_entry nd[0];                                      \
+};                                                                              \
+                                                                                \
+static void __name##_sorted__insert(struct __name##_sorted *sorted,             \
+                                      struct rb_node *sorted_nd)                \
+{                                                                               \
+        struct rb_node **p = &sorted->entries.rb_node, *parent = NULL;          \
+        while (*p != NULL) {                                                    \
+                parent = *p;                                                    \
+                if (__name##_sorted__cmp(sorted_nd, parent))                    \
+                        p = &(*p)->rb_left;                                     \
+                else                                                            \
+                        p = &(*p)->rb_right;                                    \
+        }                                                                       \
+        rb_link_node(sorted_nd, parent, p);                                     \
+        rb_insert_color(sorted_nd, &sorted->entries);                           \
+}                                                                               \
+                                                                                \
+static void __name##_sorted__sort(struct __name##_sorted *sorted,               \
+                                    struct rb_root *entries)                    \
+{                                                                               \
+        struct rb_node *nd;                                                     \
+        unsigned int i = 0;                                                     \
+        for (nd = rb_first(entries); nd; nd = rb_next(nd)) {                    \
+                struct __name##_sorted_entry *snd = &sorted->nd[i++];           \
+                __name##_sorted__init_entry(nd, snd);                           \
+                __name##_sorted__insert(sorted, &snd->rb_node);                 \
+        }                                                                       \
+}                                                                               \
+                                                                                \
+static struct __name##_sorted *__name##_sorted__new(struct rb_root *entries,    \
+                                                    int nr_entries)             \
+{                                                                               \
+        struct __name##_sorted *sorted;                                         \
+        sorted = malloc(sizeof(*sorted) + sizeof(sorted->nd[0]) * nr_entries);  \
+        if (sorted) {                                                           \
+                sorted->entries = RB_ROOT;                                      \
+                __name##_sorted__sort(sorted, entries);                         \
+        }                                                                       \
+        return sorted;                                                          \
+}                                                                               \
+                                                                                \
+static void __name##_sorted__delete(struct __name##_sorted *sorted)             \
+{                                                                               \
+        free(sorted);                                                           \
+}                                                                               \
+                                                                                \
+static void __name##_sorted__init_entry(struct rb_node *nd,                     \
+                                        struct __name##_sorted_entry *entry)
+
+#define DECLARE_RESORT_RB(__name)                                               \
+struct __name##_sorted_entry *__name##_entry;                                   \
+struct __name##_sorted *__name = __name##_sorted__new
+
+#define resort_rb__for_each(__nd, __name)                                       \
+        for (__nd = rb_first(&__name->entries);                                 \
+             __name##_entry = rb_entry(__nd, struct __name##_sorted_entry,      \
+                                       rb_node), __nd;                          \
+             __nd = rb_next(__nd))
+
+#define resort_rb__delete(__name)                                               \
+        __name##_sorted__delete(__name), __name = NULL
+
+/*
+ * Helpers for other classes that contains both an rbtree and the
+ * number of entries in it:
+ */
+
+/* For 'struct intlist' */
+#define DECLARE_RESORT_RB_INTLIST(__name, __ilist)                              \
+        DECLARE_RESORT_RB(__name)(&__ilist->rblist.entries,                     \
+                                  __ilist->rblist.nr_entries)
+
+/* For 'struct machine->threads' */
+#define DECLARE_RESORT_RB_MACHINE_THREADS(__name, __machine)                    \
+        DECLARE_RESORT_RB(__name)(&__machine->threads, __machine->nr_threads)
+
+#endif /* _PERF_RESORT_RB_H_ */
diff --git a/tools/perf/util/sort.c b/tools/perf/util/sort.c
index 47966a1618c7..772e2e461ec3 100644
--- a/tools/perf/util/sort.c
+++ b/tools/perf/util/sort.c
@@ -21,13 +21,6 @@ const char	*sort_order;
 const char      *field_order;
 regex_t         ignore_callees_regex;
 int             have_ignore_callees = 0;
-int             sort__need_collapse = 0;
-int             sort__has_parent = 0;
-int             sort__has_sym = 0;
-int             sort__has_dso = 0;
-int             sort__has_socket = 0;
-int             sort__has_thread = 0;
-int             sort__has_comm = 0;
 enum sort_mode  sort__mode = SORT_MODE__NORMAL;
 
 /*
@@ -244,7 +237,7 @@ sort__sym_cmp(struct hist_entry *left, struct hist_entry *right)
          * comparing symbol address alone is not enough since it's a
          * relative address within a dso.
          */
-        if (!sort__has_dso) {
+        if (!hists__has(left->hists, dso) || hists__has(right->hists, dso)) {
                 ret = sort__dso_cmp(left, right);
                 if (ret != 0)
                         return ret;
@@ -2163,7 +2156,7 @@ static int __sort_dimension__add(struct sort_dimension *sd,
                 return -1;
 
         if (sd->entry->se_collapse)
-                sort__need_collapse = 1;
+                list->need_collapse = 1;
 
         sd->taken = 1;
 
@@ -2245,9 +2238,9 @@ static int sort_dimension__add(struct perf_hpp_list *list, const char *tok,
                                 pr_err("Invalid regex: %s\n%s", parent_pattern, err);
                                 return -EINVAL;
                         }
-                        sort__has_parent = 1;
+                        list->parent = 1;
                 } else if (sd->entry == &sort_sym) {
-                        sort__has_sym = 1;
+                        list->sym = 1;
                         /*
                          * perf diff displays the performance difference amongst
                          * two or more perf.data files. Those files could come
@@ -2258,13 +2251,13 @@ static int sort_dimension__add(struct perf_hpp_list *list, const char *tok,
                                 sd->entry->se_collapse = sort__sym_sort;
 
                 } else if (sd->entry == &sort_dso) {
-                        sort__has_dso = 1;
+                        list->dso = 1;
                 } else if (sd->entry == &sort_socket) {
-                        sort__has_socket = 1;
+                        list->socket = 1;
                 } else if (sd->entry == &sort_thread) {
-                        sort__has_thread = 1;
+                        list->thread = 1;
                 } else if (sd->entry == &sort_comm) {
-                        sort__has_comm = 1;
+                        list->comm = 1;
                 }
 
                 return __sort_dimension__add(sd, list, level);
@@ -2289,7 +2282,7 @@ static int sort_dimension__add(struct perf_hpp_list *list, const char *tok,
                         return -EINVAL;
 
                 if (sd->entry == &sort_sym_from || sd->entry == &sort_sym_to)
-                        sort__has_sym = 1;
+                        list->sym = 1;
 
                 __sort_dimension__add(sd, list, level);
                 return 0;
@@ -2305,7 +2298,7 @@ static int sort_dimension__add(struct perf_hpp_list *list, const char *tok,
                         return -EINVAL;
 
                 if (sd->entry == &sort_mem_daddr_sym)
-                        sort__has_sym = 1;
+                        list->sym = 1;
 
                 __sort_dimension__add(sd, list, level);
                 return 0;
@@ -2746,10 +2739,10 @@ int setup_sorting(struct perf_evlist *evlist)
 
 void reset_output_field(void)
 {
-        sort__need_collapse = 0;
-        sort__has_parent = 0;
-        sort__has_sym = 0;
-        sort__has_dso = 0;
+        perf_hpp_list.need_collapse = 0;
+        perf_hpp_list.parent = 0;
+        perf_hpp_list.sym = 0;
+        perf_hpp_list.dso = 0;
 
         field_order = NULL;
         sort_order = NULL;
diff --git a/tools/perf/util/sort.h b/tools/perf/util/sort.h
index 3f4e35998119..42927f448bcb 100644
--- a/tools/perf/util/sort.h
+++ b/tools/perf/util/sort.h
@@ -31,13 +31,6 @@ extern const char *parent_pattern;
 extern const char default_sort_order[];
 extern regex_t ignore_callees_regex;
 extern int have_ignore_callees;
-extern int sort__need_collapse;
-extern int sort__has_dso;
-extern int sort__has_parent;
-extern int sort__has_sym;
-extern int sort__has_socket;
-extern int sort__has_thread;
-extern int sort__has_comm;
 extern enum sort_mode sort__mode;
 extern struct sort_entry sort_comm;
 extern struct sort_entry sort_dso;
diff --git a/tools/perf/util/symbol-elf.c b/tools/perf/util/symbol-elf.c
index 3f9d6798bd18..87a297dd8901 100644
--- a/tools/perf/util/symbol-elf.c
+++ b/tools/perf/util/symbol-elf.c
@@ -770,7 +770,8 @@ static bool want_demangle(bool is_kernel_sym)
         return is_kernel_sym ? symbol_conf.demangle_kernel : symbol_conf.demangle;
 }
 
-void __weak arch__elf_sym_adjust(GElf_Sym *sym __maybe_unused) { }
+void __weak arch__sym_update(struct symbol *s __maybe_unused,
+                GElf_Sym *sym __maybe_unused) { }
 
 int dso__load_sym(struct dso *dso, struct map *map,
                   struct symsrc *syms_ss, struct symsrc *runtime_ss,
@@ -947,8 +948,6 @@ int dso__load_sym(struct dso *dso, struct map *map,
                     (sym.st_value & 1))
                         --sym.st_value;
 
-                arch__elf_sym_adjust(&sym);
-
                 if (dso->kernel || kmodule) {
                         char dso_name[PATH_MAX];
 
@@ -1082,6 +1081,8 @@ new_symbol:
                 if (!f)
                         goto out_elf_end;
 
+                arch__sym_update(f, &sym);
+
                 if (filter && filter(curr_map, f))
                         symbol__delete(f);
                 else {
diff --git a/tools/perf/util/symbol.h b/tools/perf/util/symbol.h
index c8e43979ed5c..07211c2f8456 100644
--- a/tools/perf/util/symbol.h
+++ b/tools/perf/util/symbol.h
@@ -55,6 +55,7 @@ struct symbol {
         u16             namelen;
         u8              binding;
         bool            ignore;
+        u8              arch_sym;
         char            name[0];
 };
 
@@ -323,7 +324,7 @@ int setup_intlist(struct intlist **list, const char *list_str,
 
 #ifdef HAVE_LIBELF_SUPPORT
 bool elf__needs_adjust_symbols(GElf_Ehdr ehdr);
-void arch__elf_sym_adjust(GElf_Sym *sym);
+void arch__sym_update(struct symbol *s, GElf_Sym *sym);
 #endif
 
 #define SYMBOL_A 0