powerpc/vdso64: Fix CLOCK_MONOTONIC inconsistencies across Y2038

[linux.git] / tools / perf / util / annotate.c

diff --git a/tools/perf/util/annotate.c b/tools/perf/util/annotate.c
index 70de8f6b3aee7870db595120da775353103acd8f..5f6dbbf5d74931dd3379e57717bc92acf93e5472 100644 (file)
--- a/tools/perf/util/annotate.c
+++ b/tools/perf/util/annotate.c
@@ -9,6 +9,7 @@
 
 #include <errno.h>
 #include <inttypes.h>
+#include <libgen.h>
 #include "util.h"
 #include "ui/ui.h"
 #include "sort.h"
@@ -16,6 +17,7 @@
 #include "color.h"
 #include "config.h"
 #include "cache.h"
+#include "map.h"
 #include "symbol.h"
 #include "units.h"
 #include "debug.h"
@@ -196,18 +198,18 @@ static void ins__delete(struct ins_operands *ops)
 }
 
 static int ins__raw_scnprintf(struct ins *ins, char *bf, size_t size,
-                             struct ins_operands *ops)
+                             struct ins_operands *ops, int max_ins_name)
 {
-       return scnprintf(bf, size, "%-6s %s", ins->name, ops->raw);
+       return scnprintf(bf, size, "%-*s %s", max_ins_name, ins->name, ops->raw);
 }
 
 int ins__scnprintf(struct ins *ins, char *bf, size_t size,
-                 struct ins_operands *ops)
+                  struct ins_operands *ops, int max_ins_name)
 {
        if (ins->ops->scnprintf)
-               return ins->ops->scnprintf(ins, bf, size, ops);
+               return ins->ops->scnprintf(ins, bf, size, ops, max_ins_name);
 
-       return ins__raw_scnprintf(ins, bf, size, ops);
+       return ins__raw_scnprintf(ins, bf, size, ops, max_ins_name);
 }
 
 bool ins__is_fused(struct arch *arch, const char *ins1, const char *ins2)
@@ -271,18 +273,18 @@ indirect_call:
 }
 
 static int call__scnprintf(struct ins *ins, char *bf, size_t size,
-                          struct ins_operands *ops)
+                          struct ins_operands *ops, int max_ins_name)
 {
        if (ops->target.sym)
-               return scnprintf(bf, size, "%-6s %s", ins->name, ops->target.sym->name);
+               return scnprintf(bf, size, "%-*s %s", max_ins_name, ins->name, ops->target.sym->name);
 
        if (ops->target.addr == 0)
-               return ins__raw_scnprintf(ins, bf, size, ops);
+               return ins__raw_scnprintf(ins, bf, size, ops, max_ins_name);
 
        if (ops->target.name)
-               return scnprintf(bf, size, "%-6s %s", ins->name, ops->target.name);
+               return scnprintf(bf, size, "%-*s %s", max_ins_name, ins->name, ops->target.name);
 
-       return scnprintf(bf, size, "%-6s *%" PRIx64, ins->name, ops->target.addr);
+       return scnprintf(bf, size, "%-*s *%" PRIx64, max_ins_name, ins->name, ops->target.addr);
 }
 
 static struct ins_ops call_ops = {
@@ -386,15 +388,15 @@ static int jump__parse(struct arch *arch, struct ins_operands *ops, struct map_s
 }
 
 static int jump__scnprintf(struct ins *ins, char *bf, size_t size,
-                          struct ins_operands *ops)
+                          struct ins_operands *ops, int max_ins_name)
 {
        const char *c;
 
        if (!ops->target.addr || ops->target.offset < 0)
-               return ins__raw_scnprintf(ins, bf, size, ops);
+               return ins__raw_scnprintf(ins, bf, size, ops, max_ins_name);
 
        if (ops->target.outside && ops->target.sym != NULL)
-               return scnprintf(bf, size, "%-6s %s", ins->name, ops->target.sym->name);
+               return scnprintf(bf, size, "%-*s %s", max_ins_name, ins->name, ops->target.sym->name);
 
        c = strchr(ops->raw, ',');
        c = validate_comma(c, ops);
@@ -413,7 +415,7 @@ static int jump__scnprintf(struct ins *ins, char *bf, size_t size,
                        c++;
        }
 
-       return scnprintf(bf, size, "%-6s %.*s%" PRIx64,
+       return scnprintf(bf, size, "%-*s %.*s%" PRIx64, max_ins_name,
                         ins->name, c ? c - ops->raw : 0, ops->raw,
                         ops->target.offset);
 }
@@ -481,16 +483,16 @@ out_free_ops:
 }
 
 static int lock__scnprintf(struct ins *ins, char *bf, size_t size,
-                          struct ins_operands *ops)
+                          struct ins_operands *ops, int max_ins_name)
 {
        int printed;
 
        if (ops->locked.ins.ops == NULL)
-               return ins__raw_scnprintf(ins, bf, size, ops);
+               return ins__raw_scnprintf(ins, bf, size, ops, max_ins_name);
 
-       printed = scnprintf(bf, size, "%-6s ", ins->name);
+       printed = scnprintf(bf, size, "%-*s ", max_ins_name, ins->name);
        return printed + ins__scnprintf(&ops->locked.ins, bf + printed,
-                                       size - printed, ops->locked.ops);
+                                       size - printed, ops->locked.ops, max_ins_name);
 }
 
 static void lock__delete(struct ins_operands *ops)
@@ -562,9 +564,9 @@ out_free_source:
 }
 
 static int mov__scnprintf(struct ins *ins, char *bf, size_t size,
-                          struct ins_operands *ops)
+                          struct ins_operands *ops, int max_ins_name)
 {
-       return scnprintf(bf, size, "%-6s %s,%s", ins->name,
+       return scnprintf(bf, size, "%-*s %s,%s", max_ins_name, ins->name,
                         ops->source.name ?: ops->source.raw,
                         ops->target.name ?: ops->target.raw);
 }
@@ -602,9 +604,9 @@ static int dec__parse(struct arch *arch __maybe_unused, struct ins_operands *ops
 }
 
 static int dec__scnprintf(struct ins *ins, char *bf, size_t size,
-                          struct ins_operands *ops)
+                          struct ins_operands *ops, int max_ins_name)
 {
-       return scnprintf(bf, size, "%-6s %s", ins->name,
+       return scnprintf(bf, size, "%-*s %s", max_ins_name, ins->name,
                         ops->target.name ?: ops->target.raw);
 }
 
@@ -614,9 +616,9 @@ static struct ins_ops dec_ops = {
 };
 
 static int nop__scnprintf(struct ins *ins __maybe_unused, char *bf, size_t size,
-                         struct ins_operands *ops __maybe_unused)
+                         struct ins_operands *ops __maybe_unused, int max_ins_name)
 {
-       return scnprintf(bf, size, "%-6s", "nop");
+       return scnprintf(bf, size, "%-*s", max_ins_name, "nop");
 }
 
 static struct ins_ops nop_ops = {
@@ -1230,12 +1232,12 @@ void disasm_line__free(struct disasm_line *dl)
        annotation_line__delete(&dl->al);
 }
 
-int disasm_line__scnprintf(struct disasm_line *dl, char *bf, size_t size, bool raw)
+int disasm_line__scnprintf(struct disasm_line *dl, char *bf, size_t size, bool raw, int max_ins_name)
 {
        if (raw || !dl->ins.ops)
-               return scnprintf(bf, size, "%-6s %s", dl->ins.name, dl->ops.raw);
+               return scnprintf(bf, size, "%-*s %s", max_ins_name, dl->ins.name, dl->ops.raw);
 
-       return ins__scnprintf(&dl->ins, bf, size, &dl->ops);
+       return ins__scnprintf(&dl->ins, bf, size, &dl->ops, max_ins_name);
 }
 
 static void annotation_line__add(struct annotation_line *al, struct list_head *head)
@@ -1889,6 +1891,7 @@ int symbol__annotate(struct symbol *sym, struct map *map,
                     struct annotation_options *options,
                     struct arch **parch)
 {
+       struct annotation *notes = symbol__annotation(sym);
        struct annotate_args args = {
                .privsize       = privsize,
                .evsel          = evsel,
@@ -1919,6 +1922,7 @@ int symbol__annotate(struct symbol *sym, struct map *map,
 
        args.ms.map = map;
        args.ms.sym = sym;
+       notes->start = map__rip_2objdump(map, sym->start);
 
        return symbol__disassemble(sym, &args);
 }
@@ -2410,12 +2414,30 @@ static inline int width_jumps(int n)
        return 1;
 }
 
+static int annotation__max_ins_name(struct annotation *notes)
+{
+       int max_name = 0, len;
+       struct annotation_line *al;
+
+        list_for_each_entry(al, &notes->src->source, node) {
+               if (al->offset == -1)
+                       continue;
+
+               len = strlen(disasm_line(al)->ins.name);
+               if (max_name < len)
+                       max_name = len;
+       }
+
+       return max_name;
+}
+
 void annotation__init_column_widths(struct annotation *notes, struct symbol *sym)
 {
        notes->widths.addr = notes->widths.target =
                notes->widths.min_addr = hex_width(symbol__size(sym));
        notes->widths.max_addr = hex_width(sym->end);
        notes->widths.jumps = width_jumps(notes->max_jump_sources);
+       notes->widths.max_ins_name = annotation__max_ins_name(notes);
 }
 
 void annotation__update_column_widths(struct annotation *notes)
@@ -2579,7 +2601,7 @@ call_like:
                obj__printf(obj, "  ");
        }
 
-       disasm_line__scnprintf(dl, bf, size, !notes->options->use_offset);
+       disasm_line__scnprintf(dl, bf, size, !notes->options->use_offset, notes->widths.max_ins_name);
 }
 
 static void ipc_coverage_string(char *bf, int size, struct annotation *notes)
@@ -2794,8 +2816,6 @@ int symbol__annotate2(struct symbol *sym, struct map *map, struct perf_evsel *ev
 
        symbol__calc_percent(sym, evsel);
 
-       notes->start = map__rip_2objdump(map, sym->start);
-
        annotation__set_offsets(notes, size);
        annotation__mark_jump_targets(notes, sym);
        annotation__compute_ipc(notes, size);