Merge tag 'perf-core-for-mingo' of git://git.kernel.org/pub/scm/linux/kernel/git/acme/linux into perf/core

Pull perf/core improvements and fixes from Arnaldo Carvalho de Melo:

 * Don't pass const char pointers to basename, so that we can unconditionally
   use libgen.h and thus avoid ifdef BIONIC lines, from David Ahern

 * Fix assert/BUG_ON when NDEBUG is defined, from Irina Tirdea.

 * Refactor hist formatting so that it can be reused with the GTK browser,
   From Namhyung Kim

Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
Signed-off-by: Ingo Molnar <mingo@kernel.org>

17 files changed, 665 insertions, 280 deletions

diff --git a/tools/perf/Makefile b/tools/perf/Makefile
index 3eda4921573..e4b2e8f2606 100644
--- a/tools/perf/Makefile
+++ b/tools/perf/Makefile
@@ -403,7 +403,9 @@ LIB_OBJS += $(OUTPUT)util/cgroup.o
 LIB_OBJS += $(OUTPUT)util/target.o
 LIB_OBJS += $(OUTPUT)util/rblist.o
 LIB_OBJS += $(OUTPUT)util/intlist.o
+
 LIB_OBJS += $(OUTPUT)ui/helpline.o
+LIB_OBJS += $(OUTPUT)ui/hist.o
 LIB_OBJS += $(OUTPUT)ui/stdio/hist.o
 
 BUILTIN_OBJS += $(OUTPUT)builtin-annotate.o
diff --git a/tools/perf/bench/sched-pipe.c b/tools/perf/bench/sched-pipe.c
index 0c7454f8b8a..15911e9c587 100644
--- a/tools/perf/bench/sched-pipe.c
+++ b/tools/perf/bench/sched-pipe.c
@@ -56,13 +56,13 @@ int bench_sched_pipe(int argc, const char **argv,
          * causes error in building environment for perf
          */
         int __used ret, wait_stat;
-        pid_t pid, retpid;
+        pid_t pid, retpid __used;
 
         argc = parse_options(argc, argv, options,
                              bench_sched_pipe_usage, 0);
 
-        assert(!pipe(pipe_1));
-        assert(!pipe(pipe_2));
+        BUG_ON(pipe(pipe_1));
+        BUG_ON(pipe(pipe_2));
 
         pid = fork();
         assert(pid >= 0);
diff --git a/tools/perf/builtin-diff.c b/tools/perf/builtin-diff.c
index e9933fdd256..c4c6d76b70e 100644
--- a/tools/perf/builtin-diff.c
+++ b/tools/perf/builtin-diff.c
@@ -264,6 +264,7 @@ int cmd_diff(int argc, const char **argv, const char *prefix __used)
         if (symbol__init() < 0)
                 return -1;
 
+        perf_hpp__init(true, show_displacement);
         setup_sorting(diff_usage, options);
         setup_pager();
 
diff --git a/tools/perf/ui/browsers/hists.c b/tools/perf/ui/browsers/hists.c
index 81bd8c2af73..5a5739bbe6a 100644
--- a/tools/perf/ui/browsers/hists.c
+++ b/tools/perf/ui/browsers/hists.c
@@ -28,6 +28,8 @@ struct hist_browser {
         bool                 has_symbols;
 };
 
+extern void hist_browser__init_hpp(void);
+
 static int hists__browser_title(struct hists *hists, char *bf, size_t size,
                                 const char *ev_name);
 
@@ -563,14 +565,47 @@ static int hist_browser__show_callchain(struct hist_browser *browser,
         return row - first_row;
 }
 
+#define HPP__COLOR_FN(_name, _field)                                    \
+static int hist_browser__hpp_color_ ## _name(struct perf_hpp *hpp,      \
+                                             struct hist_entry *he)     \
+{                                                                       \
+        double percent = 100.0 * he->_field / hpp->total_period;        \
+        *(double *)hpp->ptr = percent;                                  \
+        return scnprintf(hpp->buf, hpp->size, "%5.2f%%", percent);      \
+}
+
+HPP__COLOR_FN(overhead, period)
+HPP__COLOR_FN(overhead_sys, period_sys)
+HPP__COLOR_FN(overhead_us, period_us)
+HPP__COLOR_FN(overhead_guest_sys, period_guest_sys)
+HPP__COLOR_FN(overhead_guest_us, period_guest_us)
+
+#undef HPP__COLOR_FN
+
+void hist_browser__init_hpp(void)
+{
+        perf_hpp__init(false, false);
+
+        perf_hpp__format[PERF_HPP__OVERHEAD].color =
+                                hist_browser__hpp_color_overhead;
+        perf_hpp__format[PERF_HPP__OVERHEAD_SYS].color =
+                                hist_browser__hpp_color_overhead_sys;
+        perf_hpp__format[PERF_HPP__OVERHEAD_US].color =
+                                hist_browser__hpp_color_overhead_us;
+        perf_hpp__format[PERF_HPP__OVERHEAD_GUEST_SYS].color =
+                                hist_browser__hpp_color_overhead_guest_sys;
+        perf_hpp__format[PERF_HPP__OVERHEAD_GUEST_US].color =
+                                hist_browser__hpp_color_overhead_guest_us;
+}
+
 static int hist_browser__show_entry(struct hist_browser *browser,
                                     struct hist_entry *entry,
                                     unsigned short row)
 {
         char s[256];
         double percent;
-        int printed = 0;
-        int width = browser->b.width - 6; /* The percentage */
+        int i, printed = 0;
+        int width = browser->b.width - 1;
         char folded_sign = ' ';
         bool current_entry = ui_browser__is_current_entry(&browser->b, row);
         off_t row_offset = entry->row_offset;
@@ -586,35 +621,50 @@ static int hist_browser__show_entry(struct hist_browser *browser,
         }
 
         if (row_offset == 0) {
-                hist_entry__sort_snprintf(entry, s, sizeof(s), browser->hists);
-                percent = (entry->period * 100.0) / browser->hists->stats.total_period;
+                struct perf_hpp hpp = {
+                        .buf            = s,
+                        .size           = sizeof(s),
+                        .total_period   = browser->hists->stats.total_period,
+                };
 
-                ui_browser__set_percent_color(&browser->b, percent, current_entry);
-                ui_browser__gotorc(&browser->b, row, 0);
-                if (symbol_conf.use_callchain) {
-                        slsmg_printf("%c ", folded_sign);
-                        width -= 2;
-                }
+                ui_browser__gotorc(&browser->b, row, 1);
 
-                slsmg_printf(" %5.2f%%", percent);
+                for (i = 0; i < PERF_HPP__MAX_INDEX; i++) {
+                        if (!perf_hpp__format[i].cond)
+                                continue;
 
-                /* The scroll bar isn't being used */
-                if (!browser->b.navkeypressed)
-                        width += 1;
+                        if (i) {
+                                slsmg_printf("  ");
+                                width -= 2;
+                        }
 
-                if (!current_entry || !browser->b.navkeypressed)
-                        ui_browser__set_color(&browser->b, HE_COLORSET_NORMAL);
+                        if (perf_hpp__format[i].color) {
+                                hpp.ptr = &percent;
+                                /* It will set percent for us. See HPP__COLOR_FN above. */
+                                width -= perf_hpp__format[i].color(&hpp, entry);
 
-                if (symbol_conf.show_nr_samples) {
-                        slsmg_printf(" %11u", entry->nr_events);
-                        width -= 12;
-                }
+                                ui_browser__set_percent_color(&browser->b, percent, current_entry);
+
+                                if (i == 0 && symbol_conf.use_callchain) {
+                                        slsmg_printf("%c ", folded_sign);
+                                        width -= 2;
+                                }
+
+                                slsmg_printf("%s", s);
 
-                if (symbol_conf.show_total_period) {
-                        slsmg_printf(" %12" PRIu64, entry->period);
-                        width -= 13;
+                                if (!current_entry || !browser->b.navkeypressed)
+                                        ui_browser__set_color(&browser->b, HE_COLORSET_NORMAL);
+                        } else {
+                                width -= perf_hpp__format[i].entry(&hpp, entry);
+                                slsmg_printf("%s", s);
+                        }
                 }
 
+                /* The scroll bar isn't being used */
+                if (!browser->b.navkeypressed)
+                        width += 1;
+
+                hist_entry__sort_snprintf(entry, s, sizeof(s), browser->hists);
                 slsmg_write_nstring(s, width);
                 ++row;
                 ++printed;
diff --git a/tools/perf/ui/gtk/browser.c b/tools/perf/ui/gtk/browser.c
index 26b5b652a8c..3c16ab50e0f 100644
--- a/tools/perf/ui/gtk/browser.c
+++ b/tools/perf/ui/gtk/browser.c
@@ -36,6 +36,57 @@ static void perf_gtk__resize_window(GtkWidget *window)
         gtk_window_resize(GTK_WINDOW(window), width, height);
 }
 
+static const char *perf_gtk__get_percent_color(double percent)
+{
+        if (percent >= MIN_RED)
+                return "<span fgcolor='red'>";
+        if (percent >= MIN_GREEN)
+                return "<span fgcolor='dark green'>";
+        return NULL;
+}
+
+#define HPP__COLOR_FN(_name, _field)                                            \
+static int perf_gtk__hpp_color_ ## _name(struct perf_hpp *hpp,                  \
+                                         struct hist_entry *he)                 \
+{                                                                               \
+        double percent = 100.0 * he->_field / hpp->total_period;                \
+        const char *markup;                                                     \
+        int ret = 0;                                                            \
+                                                                                \
+        markup = perf_gtk__get_percent_color(percent);                          \
+        if (markup)                                                             \
+                ret += scnprintf(hpp->buf, hpp->size, "%s", markup);            \
+        ret += scnprintf(hpp->buf + ret, hpp->size - ret, "%5.2f%%", percent);  \
+        if (markup)                                                             \
+                ret += scnprintf(hpp->buf + ret, hpp->size - ret, "</span>");   \
+                                                                                \
+        return ret;                                                             \
+}
+
+HPP__COLOR_FN(overhead, period)
+HPP__COLOR_FN(overhead_sys, period_sys)
+HPP__COLOR_FN(overhead_us, period_us)
+HPP__COLOR_FN(overhead_guest_sys, period_guest_sys)
+HPP__COLOR_FN(overhead_guest_us, period_guest_us)
+
+#undef HPP__COLOR_FN
+
+void perf_gtk__init_hpp(void)
+{
+        perf_hpp__init(false, false);
+
+        perf_hpp__format[PERF_HPP__OVERHEAD].color =
+                                perf_gtk__hpp_color_overhead;
+        perf_hpp__format[PERF_HPP__OVERHEAD_SYS].color =
+                                perf_gtk__hpp_color_overhead_sys;
+        perf_hpp__format[PERF_HPP__OVERHEAD_US].color =
+                                perf_gtk__hpp_color_overhead_us;
+        perf_hpp__format[PERF_HPP__OVERHEAD_GUEST_SYS].color =
+                                perf_gtk__hpp_color_overhead_guest_sys;
+        perf_hpp__format[PERF_HPP__OVERHEAD_GUEST_US].color =
+                                perf_gtk__hpp_color_overhead_guest_us;
+}
+
 static void perf_gtk__show_hists(GtkWidget *window, struct hists *hists)
 {
         GType col_types[MAX_COLUMNS];
@@ -43,15 +94,25 @@ static void perf_gtk__show_hists(GtkWidget *window, struct hists *hists)
         struct sort_entry *se;
         GtkListStore *store;
         struct rb_node *nd;
-        u64 total_period;
         GtkWidget *view;
-        int col_idx;
+        int i, col_idx;
         int nr_cols;
+        char s[512];
+
+        struct perf_hpp hpp = {
+                .buf            = s,
+                .size           = sizeof(s),
+                .total_period   = hists->stats.total_period,
+        };
 
         nr_cols = 0;
 
-        /* The percentage column */
-        col_types[nr_cols++] = G_TYPE_STRING;
+        for (i = 0; i < PERF_HPP__MAX_INDEX; i++) {
+                if (!perf_hpp__format[i].cond)
+                        continue;
+
+                col_types[nr_cols++] = G_TYPE_STRING;
+        }
 
         list_for_each_entry(se, &hist_entry__sort_list, list) {
                 if (se->elide)
@@ -68,11 +129,17 @@ static void perf_gtk__show_hists(GtkWidget *window, struct hists *hists)
 
         col_idx = 0;
 
-        /* The percentage column */
-        gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view),
-                                                    -1, "Overhead (%)",
-                                                    renderer, "text",
-                                                    col_idx++, NULL);
+        for (i = 0; i < PERF_HPP__MAX_INDEX; i++) {
+                if (!perf_hpp__format[i].cond)
+                        continue;
+
+                perf_hpp__format[i].header(&hpp);
+
+                gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(view),
+                                                            -1, s,
+                                                            renderer, "markup",
+                                                            col_idx++, NULL);
+        }
 
         list_for_each_entry(se, &hist_entry__sort_list, list) {
                 if (se->elide)
@@ -88,13 +155,9 @@ static void perf_gtk__show_hists(GtkWidget *window, struct hists *hists)
 
         g_object_unref(GTK_TREE_MODEL(store));
 
-        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);
                 GtkTreeIter iter;
-                double percent;
-                char s[512];
 
                 if (h->filtered)
                         continue;
@@ -103,11 +166,17 @@ static void perf_gtk__show_hists(GtkWidget *window, struct hists *hists)
 
                 col_idx = 0;
 
-                percent = (h->period * 100.0) / total_period;
+                for (i = 0; i < PERF_HPP__MAX_INDEX; i++) {
+                        if (!perf_hpp__format[i].cond)
+                                continue;
 
-                snprintf(s, ARRAY_SIZE(s), "%.2f", percent);
+                        if (perf_hpp__format[i].color)
+                                perf_hpp__format[i].color(&hpp, h);
+                        else
+                                perf_hpp__format[i].entry(&hpp, h);
 
-                gtk_list_store_set(store, &iter, col_idx++, s, -1);
+                        gtk_list_store_set(store, &iter, col_idx++, s, -1);
+                }
 
                 list_for_each_entry(se, &hist_entry__sort_list, list) {
                         if (se->elide)
diff --git a/tools/perf/ui/gtk/gtk.h b/tools/perf/ui/gtk/gtk.h
index 793cb6116dd..687af0bba18 100644
--- a/tools/perf/ui/gtk/gtk.h
+++ b/tools/perf/ui/gtk/gtk.h
@@ -30,6 +30,7 @@ struct perf_gtk_context *perf_gtk__activate_context(GtkWidget *window);
 int perf_gtk__deactivate_context(struct perf_gtk_context **ctx);
 
 void perf_gtk__init_helpline(void);
+void perf_gtk__init_hpp(void);
 
 #ifndef HAVE_GTK_INFO_BAR
 static inline GtkWidget *perf_gtk__setup_info_bar(void)
diff --git a/tools/perf/ui/gtk/setup.c b/tools/perf/ui/gtk/setup.c
index ec1ee26b485..26429437e19 100644
--- a/tools/perf/ui/gtk/setup.c
+++ b/tools/perf/ui/gtk/setup.c
@@ -8,6 +8,7 @@ int perf_gtk__init(void)
 {
         perf_error__register(&perf_gtk_eops);
         perf_gtk__init_helpline();
+        perf_gtk__init_hpp();
         return gtk_init_check(NULL, NULL) ? 0 : -1;
 }
 
diff --git a/tools/perf/ui/hist.c b/tools/perf/ui/hist.c
new file mode 100644
index 00000000000..031b349a3f8
--- /dev/null
+++ b/tools/perf/ui/hist.c
@@ -0,0 +1,389 @@
+#include <math.h>
+
+#include "../util/hist.h"
+#include "../util/util.h"
+#include "../util/sort.h"
+
+
+/* hist period print (hpp) functions */
+static int hpp__header_overhead(struct perf_hpp *hpp)
+{
+        const char *fmt = hpp->ptr ? "Baseline" : "Overhead";
+
+        return scnprintf(hpp->buf, hpp->size, fmt);
+}
+
+static int hpp__width_overhead(struct perf_hpp *hpp __used)
+{
+        return 8;
+}
+
+static int hpp__color_overhead(struct perf_hpp *hpp, struct hist_entry *he)
+{
+        double percent = 100.0 * he->period / hpp->total_period;
+
+        if (hpp->ptr) {
+                struct hists *old_hists = hpp->ptr;
+                u64 total_period = old_hists->stats.total_period;
+                u64 base_period = he->pair ? he->pair->period : 0;
+
+                if (total_period)
+                        percent = 100.0 * base_period / total_period;
+                else
+                        percent = 0.0;
+        }
+
+        return percent_color_snprintf(hpp->buf, hpp->size, "  %5.2f%%", percent);
+}
+
+static int hpp__entry_overhead(struct perf_hpp *hpp, struct hist_entry *he)
+{
+        double percent = 100.0 * he->period / hpp->total_period;
+        const char *fmt = symbol_conf.field_sep ? "%.2f" : "  %5.2f%%";
+
+        if (hpp->ptr) {
+                struct hists *old_hists = hpp->ptr;
+                u64 total_period = old_hists->stats.total_period;
+                u64 base_period = he->pair ? he->pair->period : 0;
+
+                if (total_period)
+                        percent = 100.0 * base_period / total_period;
+                else
+                        percent = 0.0;
+        }
+
+        return scnprintf(hpp->buf, hpp->size, fmt, percent);
+}
+
+static int hpp__header_overhead_sys(struct perf_hpp *hpp)
+{
+        const char *fmt = symbol_conf.field_sep ? "%s" : "%6s";
+
+        return scnprintf(hpp->buf, hpp->size, fmt, "sys");
+}
+
+static int hpp__width_overhead_sys(struct perf_hpp *hpp __used)
+{
+        return 6;
+}
+
+static int hpp__color_overhead_sys(struct perf_hpp *hpp, struct hist_entry *he)
+{
+        double percent = 100.0 * he->period_sys / hpp->total_period;
+        return percent_color_snprintf(hpp->buf, hpp->size, "%5.2f%%", percent);
+}
+
+static int hpp__entry_overhead_sys(struct perf_hpp *hpp, struct hist_entry *he)
+{
+        double percent = 100.0 * he->period_sys / hpp->total_period;
+        const char *fmt = symbol_conf.field_sep ? "%.2f" : "%5.2f%%";
+
+        return scnprintf(hpp->buf, hpp->size, fmt, percent);
+}
+
+static int hpp__header_overhead_us(struct perf_hpp *hpp)
+{
+        const char *fmt = symbol_conf.field_sep ? "%s" : "%6s";
+
+        return scnprintf(hpp->buf, hpp->size, fmt, "user");
+}
+
+static int hpp__width_overhead_us(struct perf_hpp *hpp __used)
+{
+        return 6;
+}
+
+static int hpp__color_overhead_us(struct perf_hpp *hpp, struct hist_entry *he)
+{
+        double percent = 100.0 * he->period_us / hpp->total_period;
+        return percent_color_snprintf(hpp->buf, hpp->size, "%5.2f%%", percent);
+}
+
+static int hpp__entry_overhead_us(struct perf_hpp *hpp, struct hist_entry *he)
+{
+        double percent = 100.0 * he->period_us / hpp->total_period;
+        const char *fmt = symbol_conf.field_sep ? "%.2f" : "%5.2f%%";
+
+        return scnprintf(hpp->buf, hpp->size, fmt, percent);
+}
+
+static int hpp__header_overhead_guest_sys(struct perf_hpp *hpp)
+{
+        return scnprintf(hpp->buf, hpp->size, "guest sys");
+}
+
+static int hpp__width_overhead_guest_sys(struct perf_hpp *hpp __used)
+{
+        return 9;
+}
+
+static int hpp__color_overhead_guest_sys(struct perf_hpp *hpp,
+                                         struct hist_entry *he)
+{
+        double percent = 100.0 * he->period_guest_sys / hpp->total_period;
+        return percent_color_snprintf(hpp->buf, hpp->size, "  %5.2f%% ", percent);
+}
+
+static int hpp__entry_overhead_guest_sys(struct perf_hpp *hpp,
+                                         struct hist_entry *he)
+{
+        double percent = 100.0 * he->period_guest_sys / hpp->total_period;
+        const char *fmt = symbol_conf.field_sep ? "%.2f" : "  %5.2f%% ";
+
+        return scnprintf(hpp->buf, hpp->size, fmt, percent);
+}
+
+static int hpp__header_overhead_guest_us(struct perf_hpp *hpp)
+{
+        return scnprintf(hpp->buf, hpp->size, "guest usr");
+}
+
+static int hpp__width_overhead_guest_us(struct perf_hpp *hpp __used)
+{
+        return 9;
+}
+
+static int hpp__color_overhead_guest_us(struct perf_hpp *hpp,
+                                        struct hist_entry *he)
+{
+        double percent = 100.0 * he->period_guest_us / hpp->total_period;
+        return percent_color_snprintf(hpp->buf, hpp->size, "  %5.2f%% ", percent);
+}
+
+static int hpp__entry_overhead_guest_us(struct perf_hpp *hpp,
+                                        struct hist_entry *he)
+{
+        double percent = 100.0 * he->period_guest_us / hpp->total_period;
+        const char *fmt = symbol_conf.field_sep ? "%.2f" : "  %5.2f%% ";
+
+        return scnprintf(hpp->buf, hpp->size, fmt, percent);
+}
+
+static int hpp__header_samples(struct perf_hpp *hpp)
+{
+        const char *fmt = symbol_conf.field_sep ? "%s" : "%11s";
+
+        return scnprintf(hpp->buf, hpp->size, fmt, "Samples");
+}
+
+static int hpp__width_samples(struct perf_hpp *hpp __used)
+{
+        return 11;
+}
+
+static int hpp__entry_samples(struct perf_hpp *hpp, struct hist_entry *he)
+{
+        const char *fmt = symbol_conf.field_sep ? "%" PRIu64 : "%11" PRIu64;
+
+        return scnprintf(hpp->buf, hpp->size, fmt, he->nr_events);
+}
+
+static int hpp__header_period(struct perf_hpp *hpp)
+{
+        const char *fmt = symbol_conf.field_sep ? "%s" : "%12s";
+
+        return scnprintf(hpp->buf, hpp->size, fmt, "Period");
+}
+
+static int hpp__width_period(struct perf_hpp *hpp __used)
+{
+        return 12;
+}
+
+static int hpp__entry_period(struct perf_hpp *hpp, struct hist_entry *he)
+{
+        const char *fmt = symbol_conf.field_sep ? "%" PRIu64 : "%12" PRIu64;
+
+        return scnprintf(hpp->buf, hpp->size, fmt, he->period);
+}
+
+static int hpp__header_delta(struct perf_hpp *hpp)
+{
+        const char *fmt = symbol_conf.field_sep ? "%s" : "%7s";
+
+        return scnprintf(hpp->buf, hpp->size, fmt, "Delta");
+}
+
+static int hpp__width_delta(struct perf_hpp *hpp __used)
+{
+        return 7;
+}
+
+static int hpp__entry_delta(struct perf_hpp *hpp, struct hist_entry *he)
+{
+        struct hists *pair_hists = hpp->ptr;
+        u64 old_total, new_total;
+        double old_percent = 0, new_percent = 0;
+        double diff;
+        const char *fmt = symbol_conf.field_sep ? "%s" : "%7.7s";
+        char buf[32] = " ";
+
+        old_total = pair_hists->stats.total_period;
+        if (old_total > 0 && he->pair)
+                old_percent = 100.0 * he->pair->period / old_total;
+
+        new_total = hpp->total_period;
+        if (new_total > 0)
+                new_percent = 100.0 * he->period / new_total;
+
+        diff = new_percent - old_percent;
+        if (fabs(diff) >= 0.01)
+                scnprintf(buf, sizeof(buf), "%+4.2F%%", diff);
+
+        return scnprintf(hpp->buf, hpp->size, fmt, buf);
+}
+
+static int hpp__header_displ(struct perf_hpp *hpp)
+{
+        return scnprintf(hpp->buf, hpp->size, "Displ.");
+}
+
+static int hpp__width_displ(struct perf_hpp *hpp __used)
+{
+        return 6;
+}
+
+static int hpp__entry_displ(struct perf_hpp *hpp, struct hist_entry *he __used)
+{
+        const char *fmt = symbol_conf.field_sep ? "%s" : "%6.6s";
+        char buf[32] = " ";
+
+        if (hpp->displacement)
+                scnprintf(buf, sizeof(buf), "%+4ld", hpp->displacement);
+
+        return scnprintf(hpp->buf, hpp->size, fmt, buf);
+}
+
+#define HPP__COLOR_PRINT_FNS(_name)             \
+        .header = hpp__header_ ## _name,                \
+        .width  = hpp__width_ ## _name,         \
+        .color  = hpp__color_ ## _name,         \
+        .entry  = hpp__entry_ ## _name
+
+#define HPP__PRINT_FNS(_name)                   \
+        .header = hpp__header_ ## _name,                \
+        .width  = hpp__width_ ## _name,         \
+        .entry  = hpp__entry_ ## _name
+
+struct perf_hpp_fmt perf_hpp__format[] = {
+        { .cond = true,  HPP__COLOR_PRINT_FNS(overhead) },
+        { .cond = false, HPP__COLOR_PRINT_FNS(overhead_sys) },
+        { .cond = false, HPP__COLOR_PRINT_FNS(overhead_us) },
+        { .cond = false, HPP__COLOR_PRINT_FNS(overhead_guest_sys) },
+        { .cond = false, HPP__COLOR_PRINT_FNS(overhead_guest_us) },
+        { .cond = false, HPP__PRINT_FNS(samples) },
+        { .cond = false, HPP__PRINT_FNS(period) },
+        { .cond = false, HPP__PRINT_FNS(delta) },
+        { .cond = false, HPP__PRINT_FNS(displ) }
+};
+
+#undef HPP__COLOR_PRINT_FNS
+#undef HPP__PRINT_FNS
+
+void perf_hpp__init(bool need_pair, bool show_displacement)
+{
+        if (symbol_conf.show_cpu_utilization) {
+                perf_hpp__format[PERF_HPP__OVERHEAD_SYS].cond = true;
+                perf_hpp__format[PERF_HPP__OVERHEAD_US].cond = true;
+
+                if (perf_guest) {
+                        perf_hpp__format[PERF_HPP__OVERHEAD_GUEST_SYS].cond = true;
+                        perf_hpp__format[PERF_HPP__OVERHEAD_GUEST_US].cond = true;
+                }
+        }
+
+        if (symbol_conf.show_nr_samples)
+                perf_hpp__format[PERF_HPP__SAMPLES].cond = true;
+
+        if (symbol_conf.show_total_period)
+                perf_hpp__format[PERF_HPP__PERIOD].cond = true;
+
+        if (need_pair) {
+                perf_hpp__format[PERF_HPP__DELTA].cond = true;
+
+                if (show_displacement)
+                        perf_hpp__format[PERF_HPP__DISPL].cond = true;
+        }
+}
+
+static inline void advance_hpp(struct perf_hpp *hpp, int inc)
+{
+        hpp->buf  += inc;
+        hpp->size -= inc;
+}
+
+int hist_entry__period_snprintf(struct perf_hpp *hpp, struct hist_entry *he,
+                                bool color)
+{
+        const char *sep = symbol_conf.field_sep;
+        char *start = hpp->buf;
+        int i, ret;
+
+        if (symbol_conf.exclude_other && !he->parent)
+                return 0;
+
+        for (i = 0; i < PERF_HPP__MAX_INDEX; i++) {
+                if (!perf_hpp__format[i].cond)
+                        continue;
+
+                if (!sep || i > 0) {
+                        ret = scnprintf(hpp->buf, hpp->size, "%s", sep ?: "  ");
+                        advance_hpp(hpp, ret);
+                }
+
+                if (color && perf_hpp__format[i].color)
+                        ret = perf_hpp__format[i].color(hpp, he);
+                else
+                        ret = perf_hpp__format[i].entry(hpp, he);
+
+                advance_hpp(hpp, ret);
+        }
+
+        return hpp->buf - start;
+}
+
+int hist_entry__sort_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;
+}
+
+/*
+ * See hists__fprintf to match the column widths
+ */
+unsigned int hists__sort_list_width(struct hists *hists)
+{
+        struct sort_entry *se;
+        int i, ret = 0;
+
+        for (i = 0; i < PERF_HPP__MAX_INDEX; i++) {
+                if (!perf_hpp__format[i].cond)
+                        continue;
+                if (i)
+                        ret += 2;
+
+                ret += perf_hpp__format[i].width(NULL);
+        }
+
+        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;
+}
diff --git a/tools/perf/ui/setup.c b/tools/perf/ui/setup.c
index c7820e56966..bd7d460f844 100644
--- a/tools/perf/ui/setup.c
+++ b/tools/perf/ui/setup.c
@@ -1,8 +1,8 @@
 #include <pthread.h>
 
-#include "../cache.h"
-#include "../debug.h"
-
+#include "../util/cache.h"
+#include "../util/debug.h"
+#include "../util/hist.h"
 
 pthread_mutex_t ui__lock = PTHREAD_MUTEX_INITIALIZER;
 
@@ -29,6 +29,8 @@ void setup_browser(bool fallback_to_pager)
                 use_browser = 0;
                 if (fallback_to_pager)
                         setup_pager();
+
+                perf_hpp__init(false, false);
                 break;
         }
 }
diff --git a/tools/perf/ui/stdio/hist.c b/tools/perf/ui/stdio/hist.c
index 9bf7e9e5a72..882461a4283 100644
--- a/tools/perf/ui/stdio/hist.c
+++ b/tools/perf/ui/stdio/hist.c
@@ -1,5 +1,4 @@
 #include <stdio.h>
-#include <math.h>
 
 #include "../../util/util.h"
 #include "../../util/hist.h"
@@ -291,138 +290,6 @@ static size_t hist_entry_callchain__fprintf(struct hist_entry *he,
         return 0;
 }
 
-static int hist_entry__period_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__sort_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 size_t hist_entry__callchain_fprintf(struct hist_entry *he,
                                             struct hists *hists,
                                             u64 total_period, FILE *fp)
@@ -441,18 +308,23 @@ static size_t hist_entry__callchain_fprintf(struct hist_entry *he,
 
 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)
+                               long displacement, u64 total_period, FILE *fp)
 {
         char bf[512];
         int ret;
+        struct perf_hpp hpp = {
+                .buf            = bf,
+                .size           = size,
+                .total_period   = total_period,
+                .displacement   = displacement,
+                .ptr            = pair_hists,
+        };
+        bool color = !symbol_conf.field_sep;
 
         if (size == 0 || size > sizeof(bf))
-                size = sizeof(bf);
+                size = hpp.size = sizeof(bf);
 
-        ret = hist_entry__period_snprintf(he, bf, size, pair_hists,
-                                          show_displacement, displacement,
-                                          true, total_period);
+        ret = hist_entry__period_snprintf(&hpp, he, color);
         hist_entry__sort_snprintf(he, bf + ret, size - ret, hists);
 
         ret = fprintf(fp, "%s\n", bf);
@@ -477,59 +349,29 @@ size_t hists__fprintf(struct hists *hists, struct hists *pair,
         unsigned int width;
         const char *sep = symbol_conf.field_sep;
         const char *col_width = symbol_conf.col_width_list_str;
-        int nr_rows = 0;
+        int idx, nr_rows = 0;
+        char bf[64];
+        struct perf_hpp dummy_hpp = {
+                .buf    = bf,
+                .size   = sizeof(bf),
+                .ptr    = pair,
+        };
 
         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    ");
-        }
+        fprintf(fp, "# ");
+        for (idx = 0; idx < PERF_HPP__MAX_INDEX; idx++) {
+                if (!perf_hpp__format[idx].cond)
+                        continue;
 
-        if (pair) {
-                if (sep)
-                        ret += fprintf(fp, "%cDelta", *sep);
-                else
-                        ret += fprintf(fp, "  Delta    ");
+                if (idx)
+                        fprintf(fp, "%s", sep ?: "  ");
 
-                if (show_displacement) {
-                        if (sep)
-                                ret += fprintf(fp, "%cDisplacement", *sep);
-                        else
-                                ret += fprintf(fp, " Displ");
-                }
+                perf_hpp__format[idx].header(&dummy_hpp);
+                fprintf(fp, "%s", bf);
         }
 
         list_for_each_entry(se, &hist_entry__sort_list, list) {
@@ -561,18 +403,21 @@ size_t hists__fprintf(struct hists *hists, struct hists *pair,
         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, " .....");
+        fprintf(fp, "# ");
+        for (idx = 0; idx < PERF_HPP__MAX_INDEX; idx++) {
+                unsigned int i;
+
+                if (!perf_hpp__format[idx].cond)
+                        continue;
+
+                if (idx)
+                        fprintf(fp, "%s", sep ?: "  ");
+
+                width = perf_hpp__format[idx].width(&dummy_hpp);
+                for (i = 0; i < width; i++)
+                        fprintf(fp, ".");
         }
+
         list_for_each_entry(se, &hist_entry__sort_list, list) {
                 unsigned int i;
 
@@ -612,8 +457,8 @@ print_entries:
                                 displacement = 0;
                         ++position;
                 }
-                ret += hist_entry__fprintf(h, max_cols, hists, pair, show_displacement,
-                                           displacement, total_period, fp);
+                ret += hist_entry__fprintf(h, max_cols, hists, pair, displacement,
+                                           total_period, fp);
 
                 if (max_rows && ++nr_rows >= max_rows)
                         goto out;
diff --git a/tools/perf/ui/tui/setup.c b/tools/perf/ui/tui/setup.c
index 4c936e09931..4dc0887c04f 100644
--- a/tools/perf/ui/tui/setup.c
+++ b/tools/perf/ui/tui/setup.c
@@ -15,6 +15,8 @@ static volatile int ui__need_resize;
 
 extern struct perf_error_ops perf_tui_eops;
 
+extern void hist_browser__init_hpp(void);
+
 void ui__refresh_dimensions(bool force)
 {
         if (force || ui__need_resize) {
@@ -124,6 +126,8 @@ int ui__init(void)
         signal(SIGTERM, ui__signal);
 
         perf_error__register(&perf_tui_eops);
+
+        hist_browser__init_hpp();
 out:
         return err;
 }
diff --git a/tools/perf/util/annotate.c b/tools/perf/util/annotate.c
index 51ef69c9841..04eafd3939d 100644
--- a/tools/perf/util/annotate.c
+++ b/tools/perf/util/annotate.c
@@ -984,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);
@@ -992,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
@@ -1042,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/hist.c b/tools/perf/util/hist.c
index b1817f15bb8..0ba65ad07cd 100644
--- a/tools/perf/util/hist.c
+++ b/tools/perf/util/hist.c
@@ -563,39 +563,6 @@ void hists__output_resort_threaded(struct hists *hists)
         return __hists__output_resort(hists, true);
 }
 
-/*
- * 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)
 {
diff --git a/tools/perf/util/hist.h b/tools/perf/util/hist.h
index 2e650ffb7d2..4146f51124f 100644
--- a/tools/perf/util/hist.h
+++ b/tools/perf/util/hist.h
@@ -115,6 +115,43 @@ 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
diff --git a/tools/perf/util/include/linux/kernel.h b/tools/perf/util/include/linux/kernel.h
index b6842c1d02a..4af9a10cc2d 100644
--- a/tools/perf/util/include/linux/kernel.h
+++ b/tools/perf/util/include/linux/kernel.h
@@ -47,8 +47,12 @@
 #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/probe-event.c b/tools/perf/util/probe-event.c
index 0dda25d82d0..e8c72de0f70 100644
--- a/tools/perf/util/probe-event.c
+++ b/tools/perf/util/probe-event.c
@@ -2307,10 +2307,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 +2326,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/symbol.h b/tools/perf/util/symbol.h
index d3b330cbc3e..41a15dac412 100644
--- a/tools/perf/util/symbol.h
+++ b/tools/perf/util/symbol.h
@@ -10,9 +10,7 @@
 #include <linux/rbtree.h>
 #include <stdio.h>
 #include <byteswap.h>
-#if defined(__BIONIC__)
 #include <libgen.h>
-#endif
 
 #ifndef NO_LIBELF_SUPPORT
 #include <libelf.h>