1 files changed, 138 insertions, 214 deletions

diff --git a/tools/perf/builtin-annotate.c b/tools/perf/builtin-annotate.c
index 593ff25006de..96db5248e995 100644
--- a/tools/perf/builtin-annotate.c
+++ b/tools/perf/builtin-annotate.c
@@ -14,7 +14,6 @@
 #include "util/cache.h"
 #include <linux/rbtree.h>
 #include "util/symbol.h"
-#include "util/string.h"
 
 #include "perf.h"
 #include "util/debug.h"
@@ -29,175 +28,67 @@
 
 static char             const *input_name = "perf.data";
 
-static int              force;
+static bool             force;
 
-static int              full_paths;
+static bool             full_paths;
 
-static int              print_line;
-
-struct sym_hist {
-        u64             sum;
-        u64             ip[0];
-};
-
-struct sym_ext {
-        struct rb_node  node;
-        double          percent;
-        char            *path;
-};
-
-struct sym_priv {
-        struct sym_hist *hist;
-        struct sym_ext  *ext;
-};
+static bool             print_line;
 
 static const char *sym_hist_filter;
 
-static int symbol_filter(struct map *map __used, struct symbol *sym)
+static int hists__add_entry(struct hists *self, struct addr_location *al)
 {
-        if (sym_hist_filter == NULL ||
-            strcmp(sym->name, sym_hist_filter) == 0) {
-                struct sym_priv *priv = symbol__priv(sym);
-                const int size = (sizeof(*priv->hist) +
-                                  (sym->end - sym->start) * sizeof(u64));
-
-                priv->hist = malloc(size);
-                if (priv->hist)
-                        memset(priv->hist, 0, size);
+        struct hist_entry *he;
+
+        if (sym_hist_filter != NULL &&
+            (al->sym == NULL || strcmp(sym_hist_filter, al->sym->name) != 0)) {
+                /* We're only interested in a symbol named sym_hist_filter */
+                if (al->sym != NULL) {
+                        rb_erase(&al->sym->rb_node,
+                                 &al->map->dso->symbols[al->map->type]);
+                        symbol__delete(al->sym);
+                }
                 return 0;
         }
-        /*
-         * FIXME: We should really filter it out, as we don't want to go thru symbols
-         * we're not interested, and if a DSO ends up with no symbols, delete it too,
-         * but right now the kernel loading routines in symbol.c bail out if no symbols
-         * are found, fix it later.
-         */
-        return 0;
-}
-
-/*
- * collect histogram counts
- */
-static void hist_hit(struct hist_entry *he, u64 ip)
-{
-        unsigned int sym_size, offset;
-        struct symbol *sym = he->sym;
-        struct sym_priv *priv;
-        struct sym_hist *h;
-
-        he->count++;
-
-        if (!sym || !he->map)
-                return;
 
-        priv = symbol__priv(sym);
-        if (!priv->hist)
-                return;
-
-        sym_size = sym->end - sym->start;
-        offset = ip - sym->start;
-
-        if (verbose)
-                fprintf(stderr, "%s: ip=%Lx\n", __func__,
-                        he->map->unmap_ip(he->map, ip));
-
-        if (offset >= sym_size)
-                return;
-
-        h = priv->hist;
-        h->sum++;
-        h->ip[offset]++;
-
-        if (verbose >= 3)
-                printf("%p %s: count++ [ip: %p, %08Lx] => %Ld\n",
-                        (void *)(unsigned long)he->sym->start,
-                        he->sym->name,
-                        (void *)(unsigned long)ip, ip - he->sym->start,
-                        h->ip[offset]);
-}
-
-static int perf_session__add_hist_entry(struct perf_session *self,
-                                        struct addr_location *al, u64 count)
-{
-        bool hit;
-        struct hist_entry *he = __perf_session__add_hist_entry(self, al, NULL,
-                                                               count, &hit);
+        he = __hists__add_entry(self, al, NULL, 1);
         if (he == NULL)
                 return -ENOMEM;
-        hist_hit(he, al->addr);
-        return 0;
+
+        return hist_entry__inc_addr_samples(he, al->addr);
 }
 
 static int process_sample_event(event_t *event, struct perf_session *session)
 {
         struct addr_location al;
 
-        dump_printf("(IP, %d): %d: %p\n", event->header.misc,
-                    event->ip.pid, (void *)(long)event->ip.ip);
+        dump_printf("(IP, %d): %d: %#Lx\n", event->header.misc,
+                    event->ip.pid, event->ip.ip);
 
-        if (event__preprocess_sample(event, session, &al, symbol_filter) < 0) {
-                fprintf(stderr, "problem processing %d event, skipping it.\n",
-                        event->header.type);
+        if (event__preprocess_sample(event, session, &al, NULL) < 0) {
+                pr_warning("problem processing %d event, skipping it.\n",
+                           event->header.type);
                 return -1;
         }
 
-        if (!al.filtered && perf_session__add_hist_entry(session, &al, 1)) {
-                fprintf(stderr, "problem incrementing symbol count, "
-                                "skipping event\n");
+        if (!al.filtered && hists__add_entry(&session->hists, &al)) {
+                pr_warning("problem incrementing symbol count, "
+                           "skipping event\n");
                 return -1;
         }
 
         return 0;
 }
 
-static int parse_line(FILE *file, struct hist_entry *he, u64 len)
+static int objdump_line__print(struct objdump_line *self,
+                               struct list_head *head,
+                               struct hist_entry *he, u64 len)
 {
-        struct symbol *sym = he->sym;
-        char *line = NULL, *tmp, *tmp2;
+        struct symbol *sym = he->ms.sym;
         static const char *prev_line;
         static const char *prev_color;
-        unsigned int offset;
-        size_t line_len;
-        u64 start;
-        s64 line_ip;
-        int ret;
-        char *c;
-
-        if (getline(&line, &line_len, file) < 0)
-                return -1;
-        if (!line)
-                return -1;
 
-        c = strchr(line, '\n');
-        if (c)
-                *c = 0;
-
-        line_ip = -1;
-        offset = 0;
-        ret = -2;
-
-        /*
-         * Strip leading spaces:
-         */
-        tmp = line;
-        while (*tmp) {
-                if (*tmp != ' ')
-                        break;
-                tmp++;
-        }
-
-        if (*tmp) {
-                /*
-                 * Parse hexa addresses followed by ':'
-                 */
-                line_ip = strtoull(tmp, &tmp2, 16);
-                if (*tmp2 != ':')
-                        line_ip = -1;
-        }
-
-        start = he->map->unmap_ip(he->map, sym->start);
-
-        if (line_ip != -1) {
+        if (self->offset != -1) {
                 const char *path = NULL;
                 unsigned int hits = 0;
                 double percent = 0.0;
@@ -205,15 +96,22 @@ static int parse_line(FILE *file, struct hist_entry *he, u64 len)
                 struct sym_priv *priv = symbol__priv(sym);
                 struct sym_ext *sym_ext = priv->ext;
                 struct sym_hist *h = priv->hist;
+                s64 offset = self->offset;
+                struct objdump_line *next = objdump__get_next_ip_line(head, self);
+
+                while (offset < (s64)len &&
+                       (next == NULL || offset < next->offset)) {
+                        if (sym_ext) {
+                                if (path == NULL)
+                                        path = sym_ext[offset].path;
+                                percent += sym_ext[offset].percent;
+                        } else
+                                hits += h->ip[offset];
+
+                        ++offset;
+                }
 
-                offset = line_ip - start;
-                if (offset < len)
-                        hits = h->ip[offset];
-
-                if (offset < len && sym_ext) {
-                        path = sym_ext[offset].path;
-                        percent = sym_ext[offset].percent;
-                } else if (h->sum)
+                if (sym_ext == NULL && h->sum)
                         percent = 100.0 * hits / h->sum;
 
                 color = get_percent_color(percent);
@@ -234,12 +132,12 @@ static int parse_line(FILE *file, struct hist_entry *he, u64 len)
 
                 color_fprintf(stdout, color, " %7.2f", percent);
                 printf(" :      ");
-                color_fprintf(stdout, PERF_COLOR_BLUE, "%s\n", line);
+                color_fprintf(stdout, PERF_COLOR_BLUE, "%s\n", self->line);
         } else {
-                if (!*line)
+                if (!*self->line)
                         printf("         :\n");
                 else
-                        printf("         :      %s\n", line);
+                        printf("         :      %s\n", self->line);
         }
 
         return 0;
@@ -269,7 +167,7 @@ static void insert_source_line(struct sym_ext *sym_ext)
 
 static void free_source_line(struct hist_entry *he, int len)
 {
-        struct sym_priv *priv = symbol__priv(he->sym);
+        struct sym_priv *priv = symbol__priv(he->ms.sym);
         struct sym_ext *sym_ext = priv->ext;
         int i;
 
@@ -288,7 +186,7 @@ static void free_source_line(struct hist_entry *he, int len)
 static void
 get_source_line(struct hist_entry *he, int len, const char *filename)
 {
-        struct symbol *sym = he->sym;
+        struct symbol *sym = he->ms.sym;
         u64 start;
         int i;
         char cmd[PATH_MAX * 2];
@@ -303,7 +201,7 @@ get_source_line(struct hist_entry *he, int len, const char *filename)
         if (!priv->ext)
                 return;
 
-        start = he->map->unmap_ip(he->map, sym->start);
+        start = he->ms.map->unmap_ip(he->ms.map, sym->start);
 
         for (i = 0; i < len; i++) {
                 char *path = NULL;
@@ -365,24 +263,32 @@ static void print_summary(const char *filename)
         }
 }
 
-static void annotate_sym(struct hist_entry *he)
+static void hist_entry__print_hits(struct hist_entry *self)
 {
-        struct map *map = he->map;
+        struct symbol *sym = self->ms.sym;
+        struct sym_priv *priv = symbol__priv(sym);
+        struct sym_hist *h = priv->hist;
+        u64 len = sym->end - sym->start, offset;
+
+        for (offset = 0; offset < len; ++offset)
+                if (h->ip[offset] != 0)
+                        printf("%*Lx: %Lu\n", BITS_PER_LONG / 2,
+                               sym->start + offset, h->ip[offset]);
+        printf("%*s: %Lu\n", BITS_PER_LONG / 2, "h->sum", h->sum);
+}
+
+static int hist_entry__tty_annotate(struct hist_entry *he)
+{
+        struct map *map = he->ms.map;
         struct dso *dso = map->dso;
-        struct symbol *sym = he->sym;
+        struct symbol *sym = he->ms.sym;
         const char *filename = dso->long_name, *d_filename;
         u64 len;
-        char command[PATH_MAX*2];
-        FILE *file;
-
-        if (!filename)
-                return;
+        LIST_HEAD(head);
+        struct objdump_line *pos, *n;
 
-        if (verbose)
-                fprintf(stderr, "%s: filename=%s, sym=%s, start=%Lx, end=%Lx\n",
-                        __func__, filename, sym->name,
-                        map->unmap_ip(map, sym->start),
-                        map->unmap_ip(map, sym->end));
+        if (hist_entry__annotate(he, &head) < 0)
+                return -1;
 
         if (full_paths)
                 d_filename = filename;
@@ -400,61 +306,78 @@ static void annotate_sym(struct hist_entry *he)
         printf(" Percent |      Source code & Disassembly of %s\n", d_filename);
         printf("------------------------------------------------\n");
 
-        if (verbose >= 2)
-                printf("annotating [%p] %30s : [%p] %30s\n",
-                       dso, dso->long_name, sym, sym->name);
-
-        sprintf(command, "objdump --start-address=0x%016Lx --stop-address=0x%016Lx -dS %s|grep -v %s",
-                map->unmap_ip(map, sym->start), map->unmap_ip(map, sym->end),
-                filename, filename);
-
-        if (verbose >= 3)
-                printf("doing: %s\n", command);
-
-        file = popen(command, "r");
-        if (!file)
-                return;
+        if (verbose)
+                hist_entry__print_hits(he);
 
-        while (!feof(file)) {
-                if (parse_line(file, he, len) < 0)
-                        break;
+        list_for_each_entry_safe(pos, n, &head, node) {
+                objdump_line__print(pos, &head, he, len);
+                list_del(&pos->node);
+                objdump_line__free(pos);
         }
 
-        pclose(file);
         if (print_line)
                 free_source_line(he, len);
+
+        return 0;
 }
 
-static void perf_session__find_annotations(struct perf_session *self)
+static void hists__find_annotations(struct hists *self)
 {
-        struct rb_node *nd;
+        struct rb_node *first = rb_first(&self->entries), *nd = first;
+        int key = KEY_RIGHT;
 
-        for (nd = rb_first(&self->hists); nd; nd = rb_next(nd)) {
+        while (nd) {
                 struct hist_entry *he = rb_entry(nd, struct hist_entry, rb_node);
                 struct sym_priv *priv;
 
-                if (he->sym == NULL)
-                        continue;
+                if (he->ms.sym == NULL || he->ms.map->dso->annotate_warned)
+                        goto find_next;
 
-                priv = symbol__priv(he->sym);
-                if (priv->hist == NULL)
+                priv = symbol__priv(he->ms.sym);
+                if (priv->hist == NULL) {
+find_next:
+                        if (key == KEY_LEFT)
+                                nd = rb_prev(nd);
+                        else
+                                nd = rb_next(nd);
                         continue;
+                }
 
-                annotate_sym(he);
-                /*
-                 * Since we have a hist_entry per IP for the same symbol, free
-                 * he->sym->hist to signal we already processed this symbol.
-                 */
-                free(priv->hist);
-                priv->hist = NULL;
+                if (use_browser > 0) {
+                        key = hist_entry__tui_annotate(he);
+                        if (is_exit_key(key))
+                                break;
+                        switch (key) {
+                        case KEY_RIGHT:
+                        case '\t':
+                                nd = rb_next(nd);
+                                break;
+                        case KEY_LEFT:
+                                if (nd == first)
+                                        continue;
+                                nd = rb_prev(nd);
+                        default:
+                                break;
+                        }
+                } else {
+                        hist_entry__tty_annotate(he);
+                        nd = rb_next(nd);
+                        /*
+                         * Since we have a hist_entry per IP for the same
+                         * symbol, free he->ms.sym->hist to signal we already
+                         * processed this symbol.
+                         */
+                        free(priv->hist);
+                        priv->hist = NULL;
+                }
         }
 }
 
 static struct perf_event_ops event_ops = {
-        .process_sample_event   = process_sample_event,
-        .process_mmap_event     = event__process_mmap,
-        .process_comm_event     = event__process_comm,
-        .process_fork_event     = event__process_task,
+        .sample = process_sample_event,
+        .mmap   = event__process_mmap,
+        .comm   = event__process_comm,
+        .fork   = event__process_task,
 };
 
 static int __cmd_annotate(void)
@@ -462,7 +385,7 @@ static int __cmd_annotate(void)
         int ret;
         struct perf_session *session;
 
-        session = perf_session__new(input_name, O_RDONLY, force);
+        session = perf_session__new(input_name, O_RDONLY, force, false);
         if (session == NULL)
                 return -ENOMEM;
 
@@ -471,7 +394,7 @@ static int __cmd_annotate(void)
                 goto out_delete;
 
         if (dump_trace) {
-                event__print_totals();
+                perf_session__fprintf_nr_events(session, stdout);
                 goto out_delete;
         }
 
@@ -479,11 +402,11 @@ static int __cmd_annotate(void)
                 perf_session__fprintf(session, stdout);
 
         if (verbose > 2)
-                dsos__fprintf(stdout);
+                perf_session__fprintf_dsos(session, stdout);
 
-        perf_session__collapse_resort(session);
-        perf_session__output_resort(session, session->event_total[0]);
-        perf_session__find_annotations(session);
+        hists__collapse_resort(&session->hists);
+        hists__output_resort(&session->hists);
+        hists__find_annotations(&session->hists);
 out_delete:
         perf_session__delete(session);
 
@@ -498,10 +421,12 @@ static const char * const annotate_usage[] = {
 static const struct option options[] = {
         OPT_STRING('i', "input", &input_name, "file",
                     "input file name"),
+        OPT_STRING('d', "dsos", &symbol_conf.dso_list_str, "dso[,dso...]",
+                   "only consider symbols in these dsos"),
         OPT_STRING('s', "symbol", &sym_hist_filter, "symbol",
                     "symbol to annotate"),
         OPT_BOOLEAN('f', "force", &force, "don't complain, do it"),
-        OPT_BOOLEAN('v', "verbose", &verbose,
+        OPT_INCR('v', "verbose", &verbose,
                     "be more verbose (show symbol address, etc)"),
         OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
                     "dump raw trace in ASCII"),
@@ -520,6 +445,8 @@ int cmd_annotate(int argc, const char **argv, const char *prefix __used)
 {
         argc = parse_options(argc, argv, options, annotate_usage, 0);
 
+        setup_browser();
+
         symbol_conf.priv_size = sizeof(struct sym_priv);
         symbol_conf.try_vmlinux_path = true;
 
@@ -539,12 +466,9 @@ int cmd_annotate(int argc, const char **argv, const char *prefix __used)
                 sym_hist_filter = argv[0];
         }
 
-        setup_pager();
-
         if (field_sep && *field_sep == '.') {
-                fputs("'.' is the only non valid --field-separator argument\n",
-                                stderr);
-                exit(129);
+                pr_err("'.' is the only non valid --field-separator argument\n");
+                return -1;
         }
 
         return __cmd_annotate();