1 files changed, 769 insertions, 116 deletions

diff --git a/tools/perf/ui/browsers/hists.c b/tools/perf/ui/browsers/hists.c
index 08c09ad755d2..4b9816555946 100644
--- a/tools/perf/ui/browsers/hists.c
+++ b/tools/perf/ui/browsers/hists.c
@@ -32,6 +32,7 @@ struct hist_browser {
         bool                 show_headers;
         float                min_pcnt;
         u64                  nr_non_filtered_entries;
+        u64                  nr_hierarchy_entries;
         u64                  nr_callchain_rows;
 };
 
@@ -58,11 +59,11 @@ static int hist_browser__get_folding(struct hist_browser *browser)
 
         for (nd = rb_first(&hists->entries);
              (nd = hists__filter_entries(nd, browser->min_pcnt)) != NULL;
-             nd = rb_next(nd)) {
+             nd = rb_hierarchy_next(nd)) {
                 struct hist_entry *he =
                         rb_entry(nd, struct hist_entry, rb_node);
 
-                if (he->unfolded)
+                if (he->leaf && he->unfolded)
                         unfolded_rows += he->nr_rows;
         }
         return unfolded_rows;
@@ -72,7 +73,9 @@ static u32 hist_browser__nr_entries(struct hist_browser *hb)
 {
         u32 nr_entries;
 
-        if (hist_browser__has_filter(hb))
+        if (symbol_conf.report_hierarchy)
+                nr_entries = hb->nr_hierarchy_entries;
+        else if (hist_browser__has_filter(hb))
                 nr_entries = hb->nr_non_filtered_entries;
         else
                 nr_entries = hb->hists->nr_entries;
@@ -247,6 +250,38 @@ static int callchain__count_rows(struct rb_root *chain)
         return n;
 }
 
+static int hierarchy_count_rows(struct hist_browser *hb, struct hist_entry *he,
+                                bool include_children)
+{
+        int count = 0;
+        struct rb_node *node;
+        struct hist_entry *child;
+
+        if (he->leaf)
+                return callchain__count_rows(&he->sorted_chain);
+
+        if (he->has_no_entry)
+                return 1;
+
+        node = rb_first(&he->hroot_out);
+        while (node) {
+                float percent;
+
+                child = rb_entry(node, struct hist_entry, rb_node);
+                percent = hist_entry__get_percent_limit(child);
+
+                if (!child->filtered && percent >= hb->min_pcnt) {
+                        count++;
+
+                        if (include_children && child->unfolded)
+                                count += hierarchy_count_rows(hb, child, true);
+                }
+
+                node = rb_next(node);
+        }
+        return count;
+}
+
 static bool hist_entry__toggle_fold(struct hist_entry *he)
 {
         if (!he)
@@ -326,11 +361,17 @@ static void callchain__init_have_children(struct rb_root *root)
 
 static void hist_entry__init_have_children(struct hist_entry *he)
 {
-        if (!he->init_have_children) {
+        if (he->init_have_children)
+                return;
+
+        if (he->leaf) {
                 he->has_children = !RB_EMPTY_ROOT(&he->sorted_chain);
                 callchain__init_have_children(&he->sorted_chain);
-                he->init_have_children = true;
+        } else {
+                he->has_children = !RB_EMPTY_ROOT(&he->hroot_out);
         }
+
+        he->init_have_children = true;
 }
 
 static bool hist_browser__toggle_fold(struct hist_browser *browser)
@@ -349,17 +390,49 @@ static bool hist_browser__toggle_fold(struct hist_browser *browser)
                 has_children = callchain_list__toggle_fold(cl);
 
         if (has_children) {
+                int child_rows = 0;
+
                 hist_entry__init_have_children(he);
                 browser->b.nr_entries -= he->nr_rows;
-                browser->nr_callchain_rows -= he->nr_rows;
 
-                if (he->unfolded)
-                        he->nr_rows = callchain__count_rows(&he->sorted_chain);
+                if (he->leaf)
+                        browser->nr_callchain_rows -= he->nr_rows;
                 else
+                        browser->nr_hierarchy_entries -= he->nr_rows;
+
+                if (symbol_conf.report_hierarchy)
+                        child_rows = hierarchy_count_rows(browser, he, true);
+
+                if (he->unfolded) {
+                        if (he->leaf)
+                                he->nr_rows = callchain__count_rows(&he->sorted_chain);
+                        else
+                                he->nr_rows = hierarchy_count_rows(browser, he, false);
+
+                        /* account grand children */
+                        if (symbol_conf.report_hierarchy)
+                                browser->b.nr_entries += child_rows - he->nr_rows;
+
+                        if (!he->leaf && he->nr_rows == 0) {
+                                he->has_no_entry = true;
+                                he->nr_rows = 1;
+                        }
+                } else {
+                        if (symbol_conf.report_hierarchy)
+                                browser->b.nr_entries -= child_rows - he->nr_rows;
+
+                        if (he->has_no_entry)
+                                he->has_no_entry = false;
+
                         he->nr_rows = 0;
+                }
 
                 browser->b.nr_entries += he->nr_rows;
-                browser->nr_callchain_rows += he->nr_rows;
+
+                if (he->leaf)
+                        browser->nr_callchain_rows += he->nr_rows;
+                else
+                        browser->nr_hierarchy_entries += he->nr_rows;
 
                 return true;
         }
@@ -422,13 +495,38 @@ static int callchain__set_folding(struct rb_root *chain, bool unfold)
         return n;
 }
 
-static void hist_entry__set_folding(struct hist_entry *he, bool unfold)
+static int hierarchy_set_folding(struct hist_browser *hb, struct hist_entry *he,
+                                 bool unfold __maybe_unused)
+{
+        float percent;
+        struct rb_node *nd;
+        struct hist_entry *child;
+        int n = 0;
+
+        for (nd = rb_first(&he->hroot_out); nd; nd = rb_next(nd)) {
+                child = rb_entry(nd, struct hist_entry, rb_node);
+                percent = hist_entry__get_percent_limit(child);
+                if (!child->filtered && percent >= hb->min_pcnt)
+                        n++;
+        }
+
+        return n;
+}
+
+static void hist_entry__set_folding(struct hist_entry *he,
+                                    struct hist_browser *hb, bool unfold)
 {
         hist_entry__init_have_children(he);
         he->unfolded = unfold ? he->has_children : false;
 
         if (he->has_children) {
-                int n = callchain__set_folding(&he->sorted_chain, unfold);
+                int n;
+
+                if (he->leaf)
+                        n = callchain__set_folding(&he->sorted_chain, unfold);
+                else
+                        n = hierarchy_set_folding(hb, he, unfold);
+
                 he->nr_rows = unfold ? n : 0;
         } else
                 he->nr_rows = 0;
@@ -438,19 +536,38 @@ static void
 __hist_browser__set_folding(struct hist_browser *browser, bool unfold)
 {
         struct rb_node *nd;
-        struct hists *hists = browser->hists;
+        struct hist_entry *he;
+        double percent;
 
-        for (nd = rb_first(&hists->entries);
-             (nd = hists__filter_entries(nd, browser->min_pcnt)) != NULL;
-             nd = rb_next(nd)) {
-                struct hist_entry *he = rb_entry(nd, struct hist_entry, rb_node);
-                hist_entry__set_folding(he, unfold);
-                browser->nr_callchain_rows += he->nr_rows;
+        nd = rb_first(&browser->hists->entries);
+        while (nd) {
+                he = rb_entry(nd, struct hist_entry, rb_node);
+
+                /* set folding state even if it's currently folded */
+                nd = __rb_hierarchy_next(nd, HMD_FORCE_CHILD);
+
+                hist_entry__set_folding(he, browser, unfold);
+
+                percent = hist_entry__get_percent_limit(he);
+                if (he->filtered || percent < browser->min_pcnt)
+                        continue;
+
+                if (!he->depth || unfold)
+                        browser->nr_hierarchy_entries++;
+                if (he->leaf)
+                        browser->nr_callchain_rows += he->nr_rows;
+                else if (unfold && !hist_entry__has_hierarchy_children(he, browser->min_pcnt)) {
+                        browser->nr_hierarchy_entries++;
+                        he->has_no_entry = true;
+                        he->nr_rows = 1;
+                } else
+                        he->has_no_entry = false;
         }
 }
 
 static void hist_browser__set_folding(struct hist_browser *browser, bool unfold)
 {
+        browser->nr_hierarchy_entries = 0;
         browser->nr_callchain_rows = 0;
         __hist_browser__set_folding(browser, unfold);
 
@@ -657,9 +774,24 @@ static int hist_browser__show_callchain_list(struct hist_browser *browser,
         return 1;
 }
 
+static bool check_percent_display(struct rb_node *node, u64 parent_total)
+{
+        struct callchain_node *child;
+
+        if (node == NULL)
+                return false;
+
+        if (rb_next(node))
+                return true;
+
+        child = rb_entry(node, struct callchain_node, rb_node);
+        return callchain_cumul_hits(child) != parent_total;
+}
+
 static int hist_browser__show_callchain_flat(struct hist_browser *browser,
                                              struct rb_root *root,
                                              unsigned short row, u64 total,
+                                             u64 parent_total,
                                              print_callchain_entry_fn print,
                                              struct callchain_print_arg *arg,
                                              check_output_full_fn is_output_full)
@@ -669,7 +801,7 @@ static int hist_browser__show_callchain_flat(struct hist_browser *browser,
         bool need_percent;
 
         node = rb_first(root);
-        need_percent = node && rb_next(node);
+        need_percent = check_percent_display(node, parent_total);
 
         while (node) {
                 struct callchain_node *child = rb_entry(node, struct callchain_node, rb_node);
@@ -763,6 +895,7 @@ static char *hist_browser__folded_callchain_str(struct hist_browser *browser,
 static int hist_browser__show_callchain_folded(struct hist_browser *browser,
                                                struct rb_root *root,
                                                unsigned short row, u64 total,
+                                               u64 parent_total,
                                                print_callchain_entry_fn print,
                                                struct callchain_print_arg *arg,
                                                check_output_full_fn is_output_full)
@@ -772,7 +905,7 @@ static int hist_browser__show_callchain_folded(struct hist_browser *browser,
         bool need_percent;
 
         node = rb_first(root);
-        need_percent = node && rb_next(node);
+        need_percent = check_percent_display(node, parent_total);
 
         while (node) {
                 struct callchain_node *child = rb_entry(node, struct callchain_node, rb_node);
@@ -844,20 +977,24 @@ next:
         return row - first_row;
 }
 
-static int hist_browser__show_callchain(struct hist_browser *browser,
+static int hist_browser__show_callchain_graph(struct hist_browser *browser,
                                         struct rb_root *root, int level,
                                         unsigned short row, u64 total,
+                                        u64 parent_total,
                                         print_callchain_entry_fn print,
                                         struct callchain_print_arg *arg,
                                         check_output_full_fn is_output_full)
 {
         struct rb_node *node;
         int first_row = row, offset = level * LEVEL_OFFSET_STEP;
-        u64 new_total;
         bool need_percent;
+        u64 percent_total = total;
+
+        if (callchain_param.mode == CHAIN_GRAPH_REL)
+                percent_total = parent_total;
 
         node = rb_first(root);
-        need_percent = node && rb_next(node);
+        need_percent = check_percent_display(node, parent_total);
 
         while (node) {
                 struct callchain_node *child = rb_entry(node, struct callchain_node, rb_node);
@@ -878,7 +1015,7 @@ static int hist_browser__show_callchain(struct hist_browser *browser,
                         folded_sign = callchain_list__folded(chain);
 
                         row += hist_browser__show_callchain_list(browser, child,
-                                                        chain, row, total,
+                                                        chain, row, percent_total,
                                                         was_first && need_percent,
                                                         offset + extra_offset,
                                                         print, arg);
@@ -893,13 +1030,9 @@ static int hist_browser__show_callchain(struct hist_browser *browser,
                 if (folded_sign == '-') {
                         const int new_level = level + (extra_offset ? 2 : 1);
 
-                        if (callchain_param.mode == CHAIN_GRAPH_REL)
-                                new_total = child->children_hit;
-                        else
-                                new_total = total;
-
-                        row += hist_browser__show_callchain(browser, &child->rb_root,
-                                                            new_level, row, new_total,
+                        row += hist_browser__show_callchain_graph(browser, &child->rb_root,
+                                                            new_level, row, total,
+                                                            child->children_hit,
                                                             print, arg, is_output_full);
                 }
                 if (is_output_full(browser, row))
@@ -910,6 +1043,45 @@ out:
         return row - first_row;
 }
 
+static int hist_browser__show_callchain(struct hist_browser *browser,
+                                        struct hist_entry *entry, int level,
+                                        unsigned short row,
+                                        print_callchain_entry_fn print,
+                                        struct callchain_print_arg *arg,
+                                        check_output_full_fn is_output_full)
+{
+        u64 total = hists__total_period(entry->hists);
+        u64 parent_total;
+        int printed;
+
+        if (symbol_conf.cumulate_callchain)
+                parent_total = entry->stat_acc->period;
+        else
+                parent_total = entry->stat.period;
+
+        if (callchain_param.mode == CHAIN_FLAT) {
+                printed = hist_browser__show_callchain_flat(browser,
+                                                &entry->sorted_chain, row,
+                                                total, parent_total, print, arg,
+                                                is_output_full);
+        } else if (callchain_param.mode == CHAIN_FOLDED) {
+                printed = hist_browser__show_callchain_folded(browser,
+                                                &entry->sorted_chain, row,
+                                                total, parent_total, print, arg,
+                                                is_output_full);
+        } else {
+                printed = hist_browser__show_callchain_graph(browser,
+                                                &entry->sorted_chain, level, row,
+                                                total, parent_total, print, arg,
+                                                is_output_full);
+        }
+
+        if (arg->is_current_entry)
+                browser->he_selection = entry;
+
+        return printed;
+}
+
 struct hpp_arg {
         struct ui_browser *b;
         char folded_sign;
@@ -1006,7 +1178,6 @@ static int hist_browser__show_entry(struct hist_browser *browser,
                                     struct hist_entry *entry,
                                     unsigned short row)
 {
-        char s[256];
         int printed = 0;
         int width = browser->b.width;
         char folded_sign = ' ';
@@ -1031,16 +1202,18 @@ static int hist_browser__show_entry(struct hist_browser *browser,
                         .folded_sign    = folded_sign,
                         .current_entry  = current_entry,
                 };
-                struct perf_hpp hpp = {
-                        .buf            = s,
-                        .size           = sizeof(s),
-                        .ptr            = &arg,
-                };
                 int column = 0;
 
                 hist_browser__gotorc(browser, row, 0);
 
-                perf_hpp__for_each_format(fmt) {
+                hists__for_each_format(browser->hists, fmt) {
+                        char s[2048];
+                        struct perf_hpp hpp = {
+                                .buf    = s,
+                                .size   = sizeof(s),
+                                .ptr    = &arg,
+                        };
+
                         if (perf_hpp__should_skip(fmt, entry->hists) ||
                             column++ < browser->b.horiz_scroll)
                                 continue;
@@ -1065,11 +1238,18 @@ static int hist_browser__show_entry(struct hist_browser *browser,
                         }
 
                         if (fmt->color) {
-                                width -= fmt->color(fmt, &hpp, entry);
+                                int ret = fmt->color(fmt, &hpp, entry);
+                                hist_entry__snprintf_alignment(entry, &hpp, fmt, ret);
+                                /*
+                                 * fmt->color() already used ui_browser to
+                                 * print the non alignment bits, skip it (+ret):
+                                 */
+                                ui_browser__printf(&browser->b, "%s", s + ret);
                         } else {
-                                width -= fmt->entry(fmt, &hpp, entry);
+                                hist_entry__snprintf_alignment(entry, &hpp, fmt, fmt->entry(fmt, &hpp, entry));
                                 ui_browser__printf(&browser->b, "%s", s);
                         }
+                        width -= hpp.buf - s;
                 }
 
                 /* The scroll bar isn't being used */
@@ -1084,43 +1264,246 @@ static int hist_browser__show_entry(struct hist_browser *browser,
                 --row_offset;
 
         if (folded_sign == '-' && row != browser->b.rows) {
-                u64 total = hists__total_period(entry->hists);
                 struct callchain_print_arg arg = {
                         .row_offset = row_offset,
                         .is_current_entry = current_entry,
                 };
 
-                if (callchain_param.mode == CHAIN_GRAPH_REL) {
-                        if (symbol_conf.cumulate_callchain)
-                                total = entry->stat_acc->period;
-                        else
-                                total = entry->stat.period;
-                }
-
-                if (callchain_param.mode == CHAIN_FLAT) {
-                        printed += hist_browser__show_callchain_flat(browser,
-                                        &entry->sorted_chain, row, total,
-                                        hist_browser__show_callchain_entry, &arg,
-                                        hist_browser__check_output_full);
-                } else if (callchain_param.mode == CHAIN_FOLDED) {
-                        printed += hist_browser__show_callchain_folded(browser,
-                                        &entry->sorted_chain, row, total,
+                printed += hist_browser__show_callchain(browser, entry, 1, row,
                                         hist_browser__show_callchain_entry, &arg,
                                         hist_browser__check_output_full);
+        }
+
+        return printed;
+}
+
+static int hist_browser__show_hierarchy_entry(struct hist_browser *browser,
+                                              struct hist_entry *entry,
+                                              unsigned short row,
+                                              int level)
+{
+        int printed = 0;
+        int width = browser->b.width;
+        char folded_sign = ' ';
+        bool current_entry = ui_browser__is_current_entry(&browser->b, row);
+        off_t row_offset = entry->row_offset;
+        bool first = true;
+        struct perf_hpp_fmt *fmt;
+        struct perf_hpp_list_node *fmt_node;
+        struct hpp_arg arg = {
+                .b              = &browser->b,
+                .current_entry  = current_entry,
+        };
+        int column = 0;
+        int hierarchy_indent = (entry->hists->nr_hpp_node - 2) * HIERARCHY_INDENT;
+
+        if (current_entry) {
+                browser->he_selection = entry;
+                browser->selection = &entry->ms;
+        }
+
+        hist_entry__init_have_children(entry);
+        folded_sign = hist_entry__folded(entry);
+        arg.folded_sign = folded_sign;
+
+        if (entry->leaf && row_offset) {
+                row_offset--;
+                goto show_callchain;
+        }
+
+        hist_browser__gotorc(browser, row, 0);
+
+        if (current_entry && browser->b.navkeypressed)
+                ui_browser__set_color(&browser->b, HE_COLORSET_SELECTED);
+        else
+                ui_browser__set_color(&browser->b, HE_COLORSET_NORMAL);
+
+        ui_browser__write_nstring(&browser->b, "", level * HIERARCHY_INDENT);
+        width -= level * HIERARCHY_INDENT;
+
+        /* the first hpp_list_node is for overhead columns */
+        fmt_node = list_first_entry(&entry->hists->hpp_formats,
+                                    struct perf_hpp_list_node, list);
+        perf_hpp_list__for_each_format(&fmt_node->hpp, fmt) {
+                char s[2048];
+                struct perf_hpp hpp = {
+                        .buf            = s,
+                        .size           = sizeof(s),
+                        .ptr            = &arg,
+                };
+
+                if (perf_hpp__should_skip(fmt, entry->hists) ||
+                    column++ < browser->b.horiz_scroll)
+                        continue;
+
+                if (current_entry && browser->b.navkeypressed) {
+                        ui_browser__set_color(&browser->b,
+                                              HE_COLORSET_SELECTED);
                 } else {
-                        printed += hist_browser__show_callchain(browser,
-                                        &entry->sorted_chain, 1, row, total,
-                                        hist_browser__show_callchain_entry, &arg,
-                                        hist_browser__check_output_full);
+                        ui_browser__set_color(&browser->b,
+                                              HE_COLORSET_NORMAL);
+                }
+
+                if (first) {
+                        ui_browser__printf(&browser->b, "%c", folded_sign);
+                        width--;
+                        first = false;
+                } else {
+                        ui_browser__printf(&browser->b, "  ");
+                        width -= 2;
+                }
+
+                if (fmt->color) {
+                        int ret = fmt->color(fmt, &hpp, entry);
+                        hist_entry__snprintf_alignment(entry, &hpp, fmt, ret);
+                        /*
+                         * fmt->color() already used ui_browser to
+                         * print the non alignment bits, skip it (+ret):
+                         */
+                        ui_browser__printf(&browser->b, "%s", s + ret);
+                } else {
+                        int ret = fmt->entry(fmt, &hpp, entry);
+                        hist_entry__snprintf_alignment(entry, &hpp, fmt, ret);
+                        ui_browser__printf(&browser->b, "%s", s);
+                }
+                width -= hpp.buf - s;
+        }
+
+        ui_browser__write_nstring(&browser->b, "", hierarchy_indent);
+        width -= hierarchy_indent;
+
+        if (column >= browser->b.horiz_scroll) {
+                char s[2048];
+                struct perf_hpp hpp = {
+                        .buf            = s,
+                        .size           = sizeof(s),
+                        .ptr            = &arg,
+                };
+
+                if (current_entry && browser->b.navkeypressed) {
+                        ui_browser__set_color(&browser->b,
+                                              HE_COLORSET_SELECTED);
+                } else {
+                        ui_browser__set_color(&browser->b,
+                                              HE_COLORSET_NORMAL);
                 }
 
-                if (arg.is_current_entry)
-                        browser->he_selection = entry;
+                perf_hpp_list__for_each_format(entry->hpp_list, fmt) {
+                        ui_browser__write_nstring(&browser->b, "", 2);
+                        width -= 2;
+
+                        /*
+                         * No need to call hist_entry__snprintf_alignment()
+                         * since this fmt is always the last column in the
+                         * hierarchy mode.
+                         */
+                        if (fmt->color) {
+                                width -= fmt->color(fmt, &hpp, entry);
+                        } else {
+                                int i = 0;
+
+                                width -= fmt->entry(fmt, &hpp, entry);
+                                ui_browser__printf(&browser->b, "%s", ltrim(s));
+
+                                while (isspace(s[i++]))
+                                        width++;
+                        }
+                }
+        }
+
+        /* The scroll bar isn't being used */
+        if (!browser->b.navkeypressed)
+                width += 1;
+
+        ui_browser__write_nstring(&browser->b, "", width);
+
+        ++row;
+        ++printed;
+
+show_callchain:
+        if (entry->leaf && folded_sign == '-' && row != browser->b.rows) {
+                struct callchain_print_arg carg = {
+                        .row_offset = row_offset,
+                };
+
+                printed += hist_browser__show_callchain(browser, entry,
+                                        level + 1, row,
+                                        hist_browser__show_callchain_entry, &carg,
+                                        hist_browser__check_output_full);
         }
 
         return printed;
 }
 
+static int hist_browser__show_no_entry(struct hist_browser *browser,
+                                       unsigned short row, int level)
+{
+        int width = browser->b.width;
+        bool current_entry = ui_browser__is_current_entry(&browser->b, row);
+        bool first = true;
+        int column = 0;
+        int ret;
+        struct perf_hpp_fmt *fmt;
+        struct perf_hpp_list_node *fmt_node;
+        int indent = browser->hists->nr_hpp_node - 2;
+
+        if (current_entry) {
+                browser->he_selection = NULL;
+                browser->selection = NULL;
+        }
+
+        hist_browser__gotorc(browser, row, 0);
+
+        if (current_entry && browser->b.navkeypressed)
+                ui_browser__set_color(&browser->b, HE_COLORSET_SELECTED);
+        else
+                ui_browser__set_color(&browser->b, HE_COLORSET_NORMAL);
+
+        ui_browser__write_nstring(&browser->b, "", level * HIERARCHY_INDENT);
+        width -= level * HIERARCHY_INDENT;
+
+        /* the first hpp_list_node is for overhead columns */
+        fmt_node = list_first_entry(&browser->hists->hpp_formats,
+                                    struct perf_hpp_list_node, list);
+        perf_hpp_list__for_each_format(&fmt_node->hpp, fmt) {
+                if (perf_hpp__should_skip(fmt, browser->hists) ||
+                    column++ < browser->b.horiz_scroll)
+                        continue;
+
+                ret = fmt->width(fmt, NULL, hists_to_evsel(browser->hists));
+
+                if (first) {
+                        /* for folded sign */
+                        first = false;
+                        ret++;
+                } else {
+                        /* space between columns */
+                        ret += 2;
+                }
+
+                ui_browser__write_nstring(&browser->b, "", ret);
+                width -= ret;
+        }
+
+        ui_browser__write_nstring(&browser->b, "", indent * HIERARCHY_INDENT);
+        width -= indent * HIERARCHY_INDENT;
+
+        if (column >= browser->b.horiz_scroll) {
+                char buf[32];
+
+                ret = snprintf(buf, sizeof(buf), "no entry >= %.2f%%", browser->min_pcnt);
+                ui_browser__printf(&browser->b, "  %s", buf);
+                width -= ret + 2;
+        }
+
+        /* The scroll bar isn't being used */
+        if (!browser->b.navkeypressed)
+                width += 1;
+
+        ui_browser__write_nstring(&browser->b, "", width);
+        return 1;
+}
+
 static int advance_hpp_check(struct perf_hpp *hpp, int inc)
 {
         advance_hpp(hpp, inc);
@@ -1144,7 +1527,7 @@ static int hists_browser__scnprintf_headers(struct hist_browser *browser, char *
                         return ret;
         }
 
-        perf_hpp__for_each_format(fmt) {
+        hists__for_each_format(browser->hists, fmt) {
                 if (perf_hpp__should_skip(fmt, hists)  || column++ < browser->b.horiz_scroll)
                         continue;
 
@@ -1160,11 +1543,96 @@ static int hists_browser__scnprintf_headers(struct hist_browser *browser, char *
         return ret;
 }
 
+static int hists_browser__scnprintf_hierarchy_headers(struct hist_browser *browser, char *buf, size_t size)
+{
+        struct hists *hists = browser->hists;
+        struct perf_hpp dummy_hpp = {
+                .buf    = buf,
+                .size   = size,
+        };
+        struct perf_hpp_fmt *fmt;
+        struct perf_hpp_list_node *fmt_node;
+        size_t ret = 0;
+        int column = 0;
+        int indent = hists->nr_hpp_node - 2;
+        bool first_node, first_col;
+
+        ret = scnprintf(buf, size, " ");
+        if (advance_hpp_check(&dummy_hpp, ret))
+                return ret;
+
+        /* the first hpp_list_node is for overhead columns */
+        fmt_node = list_first_entry(&hists->hpp_formats,
+                                    struct perf_hpp_list_node, list);
+        perf_hpp_list__for_each_format(&fmt_node->hpp, fmt) {
+                if (column++ < browser->b.horiz_scroll)
+                        continue;
+
+                ret = fmt->header(fmt, &dummy_hpp, hists_to_evsel(hists));
+                if (advance_hpp_check(&dummy_hpp, ret))
+                        break;
+
+                ret = scnprintf(dummy_hpp.buf, dummy_hpp.size, "  ");
+                if (advance_hpp_check(&dummy_hpp, ret))
+                        break;
+        }
+
+        ret = scnprintf(dummy_hpp.buf, dummy_hpp.size, "%*s",
+                        indent * HIERARCHY_INDENT, "");
+        if (advance_hpp_check(&dummy_hpp, ret))
+                return ret;
+
+        first_node = true;
+        list_for_each_entry_continue(fmt_node, &hists->hpp_formats, list) {
+                if (!first_node) {
+                        ret = scnprintf(dummy_hpp.buf, dummy_hpp.size, " / ");
+                        if (advance_hpp_check(&dummy_hpp, ret))
+                                break;
+                }
+                first_node = false;
+
+                first_col = true;
+                perf_hpp_list__for_each_format(&fmt_node->hpp, fmt) {
+                        char *start;
+
+                        if (perf_hpp__should_skip(fmt, hists))
+                                continue;
+
+                        if (!first_col) {
+                                ret = scnprintf(dummy_hpp.buf, dummy_hpp.size, "+");
+                                if (advance_hpp_check(&dummy_hpp, ret))
+                                        break;
+                        }
+                        first_col = false;
+
+                        ret = fmt->header(fmt, &dummy_hpp, hists_to_evsel(hists));
+                        dummy_hpp.buf[ret] = '\0';
+                        rtrim(dummy_hpp.buf);
+
+                        start = ltrim(dummy_hpp.buf);
+                        ret = strlen(start);
+
+                        if (start != dummy_hpp.buf)
+                                memmove(dummy_hpp.buf, start, ret + 1);
+
+                        if (advance_hpp_check(&dummy_hpp, ret))
+                                break;
+                }
+        }
+
+        return ret;
+}
+
 static void hist_browser__show_headers(struct hist_browser *browser)
 {
         char headers[1024];
 
-        hists_browser__scnprintf_headers(browser, headers, sizeof(headers));
+        if (symbol_conf.report_hierarchy)
+                hists_browser__scnprintf_hierarchy_headers(browser, headers,
+                                                           sizeof(headers));
+        else
+                hists_browser__scnprintf_headers(browser, headers,
+                                                 sizeof(headers));
         ui_browser__gotorc(&browser->b, 0, 0);
         ui_browser__set_color(&browser->b, HE_COLORSET_ROOT);
         ui_browser__write_nstring(&browser->b, headers, browser->b.width + 1);
@@ -1196,18 +1664,34 @@ static unsigned int hist_browser__refresh(struct ui_browser *browser)
         hb->he_selection = NULL;
         hb->selection = NULL;
 
-        for (nd = browser->top; nd; nd = rb_next(nd)) {
+        for (nd = browser->top; nd; nd = rb_hierarchy_next(nd)) {
                 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
                 float percent;
 
-                if (h->filtered)
+                if (h->filtered) {
+                        /* let it move to sibling */
+                        h->unfolded = false;
                         continue;
+                }
 
                 percent = hist_entry__get_percent_limit(h);
                 if (percent < hb->min_pcnt)
                         continue;
 
-                row += hist_browser__show_entry(hb, h, row);
+                if (symbol_conf.report_hierarchy) {
+                        row += hist_browser__show_hierarchy_entry(hb, h, row,
+                                                                  h->depth);
+                        if (row == browser->rows)
+                                break;
+
+                        if (h->has_no_entry) {
+                                hist_browser__show_no_entry(hb, row, h->depth + 1);
+                                row++;
+                        }
+                } else {
+                        row += hist_browser__show_entry(hb, h, row);
+                }
+
                 if (row == browser->rows)
                         break;
         }
@@ -1225,7 +1709,14 @@ static struct rb_node *hists__filter_entries(struct rb_node *nd,
                 if (!h->filtered && percent >= min_pcnt)
                         return nd;
 
-                nd = rb_next(nd);
+                /*
+                 * If it's filtered, its all children also were filtered.
+                 * So move to sibling node.
+                 */
+                if (rb_next(nd))
+                        nd = rb_next(nd);
+                else
+                        nd = rb_hierarchy_next(nd);
         }
 
         return NULL;
@@ -1241,7 +1732,7 @@ static struct rb_node *hists__filter_prev_entries(struct rb_node *nd,
                 if (!h->filtered && percent >= min_pcnt)
                         return nd;
 
-                nd = rb_prev(nd);
+                nd = rb_hierarchy_prev(nd);
         }
 
         return NULL;
@@ -1271,8 +1762,8 @@ static void ui_browser__hists_seek(struct ui_browser *browser,
                 nd = browser->top;
                 goto do_offset;
         case SEEK_END:
-                nd = hists__filter_prev_entries(rb_last(browser->entries),
-                                                hb->min_pcnt);
+                nd = rb_hierarchy_last(rb_last(browser->entries));
+                nd = hists__filter_prev_entries(nd, hb->min_pcnt);
                 first = false;
                 break;
         default:
@@ -1306,7 +1797,7 @@ do_offset:
         if (offset > 0) {
                 do {
                         h = rb_entry(nd, struct hist_entry, rb_node);
-                        if (h->unfolded) {
+                        if (h->unfolded && h->leaf) {
                                 u16 remaining = h->nr_rows - h->row_offset;
                                 if (offset > remaining) {
                                         offset -= remaining;
@@ -1318,7 +1809,8 @@ do_offset:
                                         break;
                                 }
                         }
-                        nd = hists__filter_entries(rb_next(nd), hb->min_pcnt);
+                        nd = hists__filter_entries(rb_hierarchy_next(nd),
+                                                   hb->min_pcnt);
                         if (nd == NULL)
                                 break;
                         --offset;
@@ -1327,7 +1819,7 @@ do_offset:
         } else if (offset < 0) {
                 while (1) {
                         h = rb_entry(nd, struct hist_entry, rb_node);
-                        if (h->unfolded) {
+                        if (h->unfolded && h->leaf) {
                                 if (first) {
                                         if (-offset > h->row_offset) {
                                                 offset += h->row_offset;
@@ -1351,7 +1843,7 @@ do_offset:
                                 }
                         }
 
-                        nd = hists__filter_prev_entries(rb_prev(nd),
+                        nd = hists__filter_prev_entries(rb_hierarchy_prev(nd),
                                                         hb->min_pcnt);
                         if (nd == NULL)
                                 break;
@@ -1364,7 +1856,7 @@ do_offset:
                                  * row_offset at its last entry.
                                  */
                                 h = rb_entry(nd, struct hist_entry, rb_node);
-                                if (h->unfolded)
+                                if (h->unfolded && h->leaf)
                                         h->row_offset = h->nr_rows;
                                 break;
                         }
@@ -1378,17 +1870,14 @@ do_offset:
 }
 
 static int hist_browser__fprintf_callchain(struct hist_browser *browser,
-                                           struct hist_entry *he, FILE *fp)
+                                           struct hist_entry *he, FILE *fp,
+                                           int level)
 {
-        u64 total = hists__total_period(he->hists);
         struct callchain_print_arg arg  = {
                 .fp = fp,
         };
 
-        if (symbol_conf.cumulate_callchain)
-                total = he->stat_acc->period;
-
-        hist_browser__show_callchain(browser, &he->sorted_chain, 1, 0, total,
+        hist_browser__show_callchain(browser, he, level, 0,
                                      hist_browser__fprintf_callchain_entry, &arg,
                                      hist_browser__check_dump_full);
         return arg.printed;
@@ -1414,7 +1903,7 @@ static int hist_browser__fprintf_entry(struct hist_browser *browser,
         if (symbol_conf.use_callchain)
                 printed += fprintf(fp, "%c ", folded_sign);
 
-        perf_hpp__for_each_format(fmt) {
+        hists__for_each_format(browser->hists, fmt) {
                 if (perf_hpp__should_skip(fmt, he->hists))
                         continue;
 
@@ -1425,12 +1914,71 @@ static int hist_browser__fprintf_entry(struct hist_browser *browser,
                         first = false;
 
                 ret = fmt->entry(fmt, &hpp, he);
+                ret = hist_entry__snprintf_alignment(he, &hpp, fmt, ret);
                 advance_hpp(&hpp, ret);
         }
-        printed += fprintf(fp, "%s\n", rtrim(s));
+        printed += fprintf(fp, "%s\n", s);
 
         if (folded_sign == '-')
-                printed += hist_browser__fprintf_callchain(browser, he, fp);
+                printed += hist_browser__fprintf_callchain(browser, he, fp, 1);
+
+        return printed;
+}
+
+
+static int hist_browser__fprintf_hierarchy_entry(struct hist_browser *browser,
+                                                 struct hist_entry *he,
+                                                 FILE *fp, int level)
+{
+        char s[8192];
+        int printed = 0;
+        char folded_sign = ' ';
+        struct perf_hpp hpp = {
+                .buf = s,
+                .size = sizeof(s),
+        };
+        struct perf_hpp_fmt *fmt;
+        struct perf_hpp_list_node *fmt_node;
+        bool first = true;
+        int ret;
+        int hierarchy_indent = (he->hists->nr_hpp_node - 2) * HIERARCHY_INDENT;
+
+        printed = fprintf(fp, "%*s", level * HIERARCHY_INDENT, "");
+
+        folded_sign = hist_entry__folded(he);
+        printed += fprintf(fp, "%c", folded_sign);
+
+        /* the first hpp_list_node is for overhead columns */
+        fmt_node = list_first_entry(&he->hists->hpp_formats,
+                                    struct perf_hpp_list_node, list);
+        perf_hpp_list__for_each_format(&fmt_node->hpp, fmt) {
+                if (!first) {
+                        ret = scnprintf(hpp.buf, hpp.size, "  ");
+                        advance_hpp(&hpp, ret);
+                } else
+                        first = false;
+
+                ret = fmt->entry(fmt, &hpp, he);
+                advance_hpp(&hpp, ret);
+        }
+
+        ret = scnprintf(hpp.buf, hpp.size, "%*s", hierarchy_indent, "");
+        advance_hpp(&hpp, ret);
+
+        perf_hpp_list__for_each_format(he->hpp_list, fmt) {
+                ret = scnprintf(hpp.buf, hpp.size, "  ");
+                advance_hpp(&hpp, ret);
+
+                ret = fmt->entry(fmt, &hpp, he);
+                advance_hpp(&hpp, ret);
+        }
+
+        printed += fprintf(fp, "%s\n", rtrim(s));
+
+        if (he->leaf && folded_sign == '-') {
+                printed += hist_browser__fprintf_callchain(browser, he, fp,
+                                                           he->depth + 1);
+        }
 
         return printed;
 }
@@ -1444,8 +1992,16 @@ static int hist_browser__fprintf(struct hist_browser *browser, FILE *fp)
         while (nd) {
                 struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
 
-                printed += hist_browser__fprintf_entry(browser, h, fp);
-                nd = hists__filter_entries(rb_next(nd), browser->min_pcnt);
+                if (symbol_conf.report_hierarchy) {
+                        printed += hist_browser__fprintf_hierarchy_entry(browser,
+                                                                         h, fp,
+                                                                         h->depth);
+                } else {
+                        printed += hist_browser__fprintf_entry(browser, h, fp);
+                }
+
+                nd = hists__filter_entries(rb_hierarchy_next(nd),
+                                           browser->min_pcnt);
         }
 
         return printed;
@@ -1580,11 +2136,18 @@ static int hists__browser_title(struct hists *hists,
         if (hists->uid_filter_str)
                 printed += snprintf(bf + printed, size - printed,
                                     ", UID: %s", hists->uid_filter_str);
-        if (thread)
-                printed += scnprintf(bf + printed, size - printed,
+        if (thread) {
+                if (sort__has_thread) {
+                        printed += scnprintf(bf + printed, size - printed,
                                     ", Thread: %s(%d)",
                                      (thread->comm_set ? thread__comm_str(thread) : ""),
                                     thread->tid);
+                } else {
+                        printed += scnprintf(bf + printed, size - printed,
+                                    ", Thread: %s",
+                                     (thread->comm_set ? thread__comm_str(thread) : ""));
+                }
+        }
         if (dso)
                 printed += scnprintf(bf + printed, size - printed,
                                     ", DSO: %s", dso->short_name);
@@ -1759,15 +2322,24 @@ 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)
+                return 0;
+
         if (browser->hists->thread_filter) {
                 pstack__remove(browser->pstack, &browser->hists->thread_filter);
                 perf_hpp__set_elide(HISTC_THREAD, false);
                 thread__zput(browser->hists->thread_filter);
                 ui_helpline__pop();
         } else {
-                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);
+                if (sort__has_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);
+                } else {
+                        ui_helpline__fpush("To zoom out press ESC or ENTER + \"Zoom out of %s thread\"",
+                                           thread->comm_set ? thread__comm_str(thread) : "");
+                }
+
                 browser->hists->thread_filter = thread__get(thread);
                 perf_hpp__set_elide(HISTC_THREAD, false);
                 pstack__push(browser->pstack, &browser->hists->thread_filter);
@@ -1782,13 +2354,22 @@ static int
 add_thread_opt(struct hist_browser *browser, struct popup_action *act,
                char **optstr, struct thread *thread)
 {
-        if (thread == NULL)
+        int ret;
+
+        if ((!sort__has_thread && !sort__has_comm) || thread == NULL)
                 return 0;
 
-        if (asprintf(optstr, "Zoom %s %s(%d) thread",
-                     browser->hists->thread_filter ? "out of" : "into",
-                     thread->comm_set ? thread__comm_str(thread) : "",
-                     thread->tid) < 0)
+        if (sort__has_thread) {
+                ret = asprintf(optstr, "Zoom %s %s(%d) thread",
+                               browser->hists->thread_filter ? "out of" : "into",
+                               thread->comm_set ? thread__comm_str(thread) : "",
+                               thread->tid);
+        } else {
+                ret = asprintf(optstr, "Zoom %s %s thread",
+                               browser->hists->thread_filter ? "out of" : "into",
+                               thread->comm_set ? thread__comm_str(thread) : "");
+        }
+        if (ret < 0)
                 return 0;
 
         act->thread = thread;
@@ -1801,6 +2382,9 @@ do_zoom_dso(struct hist_browser *browser, struct popup_action *act)
 {
         struct map *map = act->ms.map;
 
+        if (!sort__has_dso || map == NULL)
+                return 0;
+
         if (browser->hists->dso_filter) {
                 pstack__remove(browser->pstack, &browser->hists->dso_filter);
                 perf_hpp__set_elide(HISTC_DSO, false);
@@ -1825,7 +2409,7 @@ static int
 add_dso_opt(struct hist_browser *browser, struct popup_action *act,
             char **optstr, struct map *map)
 {
-        if (map == NULL)
+        if (!sort__has_dso || map == NULL)
                 return 0;
 
         if (asprintf(optstr, "Zoom %s %s DSO",
@@ -1850,7 +2434,7 @@ static int
 add_map_opt(struct hist_browser *browser __maybe_unused,
             struct popup_action *act, char **optstr, struct map *map)
 {
-        if (map == NULL)
+        if (!sort__has_dso || map == NULL)
                 return 0;
 
         if (asprintf(optstr, "Browse map details") < 0)
@@ -1952,6 +2536,9 @@ 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)
+                return 0;
+
         if (browser->hists->socket_filter > -1) {
                 pstack__remove(browser->pstack, &browser->hists->socket_filter);
                 browser->hists->socket_filter = -1;
@@ -1971,7 +2558,7 @@ static int
 add_socket_opt(struct hist_browser *browser, struct popup_action *act,
                char **optstr, int socket_id)
 {
-        if (socket_id < 0)
+        if (!sort__has_socket || socket_id < 0)
                 return 0;
 
         if (asprintf(optstr, "Zoom %s Processor Socket %d",
@@ -1989,17 +2576,60 @@ static void hist_browser__update_nr_entries(struct hist_browser *hb)
         u64 nr_entries = 0;
         struct rb_node *nd = rb_first(&hb->hists->entries);
 
-        if (hb->min_pcnt == 0) {
+        if (hb->min_pcnt == 0 && !symbol_conf.report_hierarchy) {
                 hb->nr_non_filtered_entries = hb->hists->nr_non_filtered_entries;
                 return;
         }
 
         while ((nd = hists__filter_entries(nd, hb->min_pcnt)) != NULL) {
                 nr_entries++;
-                nd = rb_next(nd);
+                nd = rb_hierarchy_next(nd);
         }
 
         hb->nr_non_filtered_entries = nr_entries;
+        hb->nr_hierarchy_entries = nr_entries;
+}
+
+static void hist_browser__update_percent_limit(struct hist_browser *hb,
+                                               double percent)
+{
+        struct hist_entry *he;
+        struct rb_node *nd = rb_first(&hb->hists->entries);
+        u64 total = hists__total_period(hb->hists);
+        u64 min_callchain_hits = total * (percent / 100);
+
+        hb->min_pcnt = callchain_param.min_percent = percent;
+
+        while ((nd = hists__filter_entries(nd, hb->min_pcnt)) != NULL) {
+                he = rb_entry(nd, struct hist_entry, rb_node);
+
+                if (he->has_no_entry) {
+                        he->has_no_entry = false;
+                        he->nr_rows = 0;
+                }
+
+                if (!he->leaf || !symbol_conf.use_callchain)
+                        goto next;
+
+                if (callchain_param.mode == CHAIN_GRAPH_REL) {
+                        total = he->stat.period;
+
+                        if (symbol_conf.cumulate_callchain)
+                                total = he->stat_acc->period;
+
+                        min_callchain_hits = total * (percent / 100);
+                }
+
+                callchain_param.sort(&he->sorted_chain, he->callchain,
+                                     min_callchain_hits, &callchain_param);
+
+next:
+                nd = __rb_hierarchy_next(nd, HMD_FORCE_CHILD);
+
+                /* force to re-evaluate folding state of callchains */
+                he->init_have_children = false;
+                hist_entry__set_folding(he, hb, false);
+        }
 }
 
 static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
@@ -2037,6 +2667,7 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
         "E             Expand all callchains\n"                         \
         "F             Toggle percentage of filtered entries\n"         \
         "H             Display column headers\n"                        \
+        "L             Change percent limit\n"                          \
         "m             Display context menu\n"                          \
         "S             Zoom into current Processor Socket\n"            \
 
@@ -2077,7 +2708,7 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
         memset(options, 0, sizeof(options));
         memset(actions, 0, sizeof(actions));
 
-        perf_hpp__for_each_format(fmt) {
+        hists__for_each_format(browser->hists, fmt) {
                 perf_hpp__reset_width(fmt, hists);
                 /*
                  * This is done just once, and activates the horizontal scrolling
@@ -2192,6 +2823,24 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
                                 top->zero = !top->zero;
                         }
                         continue;
+                case 'L':
+                        if (ui_browser__input_window("Percent Limit",
+                                        "Please enter the value you want to hide entries under that percent.",
+                                        buf, "ENTER: OK, ESC: Cancel",
+                                        delay_secs * 2) == K_ENTER) {
+                                char *end;
+                                double new_percent = strtod(buf, &end);
+
+                                if (new_percent < 0 || new_percent > 100) {
+                                        ui_browser__warning(&browser->b, delay_secs * 2,
+                                                "Invalid percent: %.2f", new_percent);
+                                        continue;
+                                }
+
+                                hist_browser__update_percent_limit(browser, new_percent);
+                                hist_browser__reset(browser);
+                        }
+                        continue;
                 case K_F1:
                 case 'h':
                 case '?':
@@ -2263,10 +2912,7 @@ static int perf_evsel__hists_browse(struct perf_evsel *evsel, int nr_events,
                         continue;
                 }
 
-                if (!sort__has_sym)
-                        goto add_exit_option;
-
-                if (browser->selection == NULL)
+                if (!sort__has_sym || browser->selection == NULL)
                         goto skip_annotation;
 
                 if (sort__mode == SORT_MODE__BRANCH) {
@@ -2306,11 +2952,16 @@ skip_annotation:
                                              &options[nr_options],
                                              socked_id);
                 /* perf script support */
+                if (!is_report_browser(hbt))
+                        goto skip_scripting;
+
                 if (browser->he_selection) {
-                        nr_options += add_script_opt(browser,
-                                                     &actions[nr_options],
-                                                     &options[nr_options],
-                                                     thread, NULL);
+                        if (sort__has_thread && thread) {
+                                nr_options += add_script_opt(browser,
+                                                             &actions[nr_options],
+                                                             &options[nr_options],
+                                                             thread, NULL);
+                        }
                         /*
                          * Note that browser->selection != NULL
                          * when browser->he_selection is not NULL,
@@ -2320,16 +2971,18 @@ skip_annotation:
                          *
                          * See hist_browser__show_entry.
                          */
-                        nr_options += add_script_opt(browser,
-                                                     &actions[nr_options],
-                                                     &options[nr_options],
-                                                     NULL, browser->selection->sym);
+                        if (sort__has_sym && browser->selection->sym) {
+                                nr_options += add_script_opt(browser,
+                                                             &actions[nr_options],
+                                                             &options[nr_options],
+                                                             NULL, browser->selection->sym);
+                        }
                 }
                 nr_options += add_script_opt(browser, &actions[nr_options],
                                              &options[nr_options], NULL, NULL);
                 nr_options += add_switch_opt(browser, &actions[nr_options],
                                              &options[nr_options]);
-add_exit_option:
+skip_scripting:
                 nr_options += add_exit_opt(browser, &actions[nr_options],
                                            &options[nr_options]);