projects / linux-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge tag 'pull-work.unaligned' of git://git.kernel.org/pub/scm/linux/kernel/git...
[linux-block.git] / tools / perf / util / sort.c
CommitLineData
b2441318 1// SPDX-License-Identifier: GPL-2.0
a43783ae 2#include <errno.h>
fd20e811 3#include <inttypes.h>
1eae20c1 4#include <regex.h>
f2a39fe8 5#include <stdlib.h>
6769e98d 6#include <linux/mman.h>
3723908d 7#include <linux/time64.h>
b4209025 8#include "debug.h"
4a3cec84 9#include "dso.h"
dd68ada2 10#include "sort.h"
8a6c5b26 11#include "hist.h"
12500902 12#include "cacheline.h"
4dfced35 13#include "comm.h"
1101f69a 14#include "map.h"
b629f3e9 15#include "maps.h"
08e71542 16#include "symbol.h"
d3300a3c
ACM		 17#include "map_symbol.h"
18#include "branch.h"
e7ff8920 19#include "thread.h"
8b536999 20#include "evsel.h"
40184c46 21#include "evlist.h"
97b9d866 22#include "srcline.h"
8ec20b17 23#include "strlist.h"
702fb9b4 24#include "strbuf.h"
0c877d75 25#include "mem-events.h"
ad3003a6 26#include "mem-info.h"
ec6ae74f 27#include "annotate.h"
2f2c41bd 28#include "annotate-data.h"
0a606822 29#include "event.h"
3723908d 30#include "time-utils.h"
b629f3e9
NK		 31#include "cgroup.h"
32#include "machine.h"
1784eeae 33#include "trace-event.h"
877a7a11 34#include <linux/kernel.h>
8520a98d 35#include <linux/string.h>
dd68ada2 36
378ef0f5
IR		 37#ifdef HAVE_LIBTRACEEVENT
38#include <traceevent/event-parse.h>
39#endif
40
dd68ada2 41regex_t parent_regex;
edb7c60e
ACM		 42const char default_parent_pattern[] = "^sys_|^do_page_fault";
43const char *parent_pattern = default_parent_pattern;
fa1f4565 44const char *default_sort_order = "comm,dso,symbol";
40997d6c 45const char default_branch_sort_order[] = "comm,dso_from,symbol_from,symbol_to,cycles";
e3304c21 46const char default_mem_sort_order[] = "local_weight,mem,sym,dso,symbol_daddr,dso_daddr,snoop,tlb,locked,blocked,local_ins_lat,local_p_stage_cyc";
512ae1bd
NK		 47const char default_top_sort_order[] = "dso,symbol";
48const char default_diff_sort_order[] = "dso,symbol";
d49dadea 49const char default_tracepoint_sort_order[] = "trace";
512ae1bd 50const char *sort_order;
a7d945bc 51const char *field_order;
b21484f1
GP		 52regex_t ignore_callees_regex;
53int have_ignore_callees = 0;
55369fc1 54enum sort_mode sort__mode = SORT_MODE__NORMAL;
e3304c21
AR		 55static const char *const dynamic_headers[] = {"local_ins_lat", "ins_lat", "local_p_stage_cyc", "p_stage_cyc"};
56static const char *const arch_specific_sort_keys[] = {"local_p_stage_cyc", "p_stage_cyc"};
a4fb581b 57
1470a108
FT		 58/*
59 * Some architectures have Adjacent Cacheline Prefetch feature, which
60 * behaves like the cacheline size is doubled. Enable this flag to
61 * check things in double cacheline granularity.
62 */
63bool chk_double_cl;
64
37d9bb58
ACM		 65/*
66 * Replaces all occurrences of a char used with the:
67 *
68 * -t, --field-separator
69 *
70 * option, that uses a special separator character and don't pad with spaces,
adba1634 71 * replacing all occurrences of this separator in symbol names (and other
37d9bb58
ACM		 72 * output) with a '.' character, that thus it's the only non valid separator.
73*/
a4e3b956 74static int repsep_snprintf(char *bf, size_t size, const char *fmt, ...)
dd68ada2
JK		 75{
76 int n;
77 va_list ap;
78
79 va_start(ap, fmt);
a4e3b956 80 n = vsnprintf(bf, size, fmt, ap);
0ca0c130 81 if (symbol_conf.field_sep && n > 0) {
a4e3b956
ACM		 82 char *sep = bf;
83
84 while (1) {
0ca0c130 85 sep = strchr(sep, *symbol_conf.field_sep);
a4e3b956
ACM		 86 if (sep == NULL)
87 break;
88 *sep = '.';
dd68ada2 89 }
dd68ada2
JK		 90 }
91 va_end(ap);
b832796c
AB		 92
93 if (n >= (int)size)
94 return size - 1;
dd68ada2
JK		 95 return n;
96}
97
b9c5143a 98static int64_t cmp_null(const void *l, const void *r)
872a878f
FW		 99{
100 if (!l && !r)
101 return 0;
102 else if (!l)
103 return -1;
104 else
105 return 1;
106}
107
108/* --sort pid */
109
110static int64_t
111sort__thread_cmp(struct hist_entry *left, struct hist_entry *right)
112{
ee84a303 113 return thread__tid(right->thread) - thread__tid(left->thread);
872a878f
FW		 114}
115
c824c433 116static int hist_entry__thread_snprintf(struct hist_entry *he, char *bf,
a4e3b956 117 size_t size, unsigned int width)
dd68ada2 118{
b9c5143a 119 const char *comm = thread__comm_str(he->thread);
5b591669 120
89c7cb2c 121 width = max(7U, width) - 8;
ee84a303 122 return repsep_snprintf(bf, size, "%7d:%-*.*s", thread__tid(he->thread),
5b591669 123 width, width, comm ?: "");
dd68ada2
JK		 124}
125
54430101
NK		 126static int hist_entry__thread_filter(struct hist_entry *he, int type, const void *arg)
127{
128 const struct thread *th = arg;
129
130 if (type != HIST_FILTER__THREAD)
131 return -1;
132
78c32f4c 133 return th && !RC_CHK_EQUAL(he->thread, th);
54430101
NK		 134}
135
872a878f 136struct sort_entry sort_thread = {
89c7cb2c 137 .se_header = " Pid:Command",
872a878f
FW		 138 .se_cmp = sort__thread_cmp,
139 .se_snprintf = hist_entry__thread_snprintf,
54430101 140 .se_filter = hist_entry__thread_filter,
872a878f
FW		 141 .se_width_idx = HISTC_THREAD,
142};
143
ea15483e
GG		 144/* --sort simd */
145
146static int64_t
147sort__simd_cmp(struct hist_entry *left, struct hist_entry *right)
148{
149 if (left->simd_flags.arch != right->simd_flags.arch)
150 return (int64_t) left->simd_flags.arch - right->simd_flags.arch;
151
152 return (int64_t) left->simd_flags.pred - right->simd_flags.pred;
153}
154
155static const char *hist_entry__get_simd_name(struct simd_flags *simd_flags)
156{
157 u64 arch = simd_flags->arch;
158
159 if (arch & SIMD_OP_FLAGS_ARCH_SVE)
160 return "SVE";
161 else
162 return "n/a";
163}
164
165static int hist_entry__simd_snprintf(struct hist_entry *he, char *bf,
166 size_t size, unsigned int width __maybe_unused)
167{
168 const char *name;
169
170 if (!he->simd_flags.arch)
171 return repsep_snprintf(bf, size, "");
172
173 name = hist_entry__get_simd_name(&he->simd_flags);
174
175 if (he->simd_flags.pred & SIMD_OP_FLAGS_PRED_EMPTY)
176 return repsep_snprintf(bf, size, "[e] %s", name);
177 else if (he->simd_flags.pred & SIMD_OP_FLAGS_PRED_PARTIAL)
178 return repsep_snprintf(bf, size, "[p] %s", name);
179
180 return repsep_snprintf(bf, size, "[.] %s", name);
181}
182
183struct sort_entry sort_simd = {
184 .se_header = "Simd ",
185 .se_cmp = sort__simd_cmp,
186 .se_snprintf = hist_entry__simd_snprintf,
187 .se_width_idx = HISTC_SIMD,
188};
189
872a878f
FW		 190/* --sort comm */
191
a7402c94
JO		 192/*
193 * We can't use pointer comparison in functions below,
194 * because it gives different results based on pointer
195 * values, which could break some sorting assumptions.
196 */
872a878f
FW		 197static int64_t
198sort__comm_cmp(struct hist_entry *left, struct hist_entry *right)
199{
2f15bd8c 200 return strcmp(comm__str(right->comm), comm__str(left->comm));
872a878f
FW		 201}
202
203static int64_t
204sort__comm_collapse(struct hist_entry *left, struct hist_entry *right)
205{
2f15bd8c 206 return strcmp(comm__str(right->comm), comm__str(left->comm));
872a878f
FW		 207}
208
202e7a6d
NK		 209static int64_t
210sort__comm_sort(struct hist_entry *left, struct hist_entry *right)
211{
212 return strcmp(comm__str(right->comm), comm__str(left->comm));
213}
214
c824c433 215static int hist_entry__comm_snprintf(struct hist_entry *he, char *bf,
a4e3b956 216 size_t size, unsigned int width)
dd68ada2 217{
5b591669 218 return repsep_snprintf(bf, size, "%-*.*s", width, width, comm__str(he->comm));
dd68ada2
JK		 219}
220
14d1ac74
NK		 221struct sort_entry sort_comm = {
222 .se_header = "Command",
223 .se_cmp = sort__comm_cmp,
224 .se_collapse = sort__comm_collapse,
202e7a6d 225 .se_sort = sort__comm_sort,
14d1ac74 226 .se_snprintf = hist_entry__comm_snprintf,
54430101 227 .se_filter = hist_entry__thread_filter,
14d1ac74
NK		 228 .se_width_idx = HISTC_COMM,
229};
230
231/* --sort dso */
232
b5387528
RAV		 233static int64_t _sort__dso_cmp(struct map *map_l, struct map *map_r)
234{
63df0e4b
IR		 235 struct dso *dso_l = map_l ? map__dso(map_l) : NULL;
236 struct dso *dso_r = map_r ? map__dso(map_r) : NULL;
b5387528
RAV		 237 const char *dso_name_l, *dso_name_r;
238
239 if (!dso_l || !dso_r)
202e7a6d 240 return cmp_null(dso_r, dso_l);
b5387528 241
bb963e16 242 if (verbose > 0) {
ee756ef7
IR		 243 dso_name_l = dso__long_name(dso_l);
244 dso_name_r = dso__long_name(dso_r);
b5387528 245 } else {
ee756ef7
IR		 246 dso_name_l = dso__short_name(dso_l);
247 dso_name_r = dso__short_name(dso_r);
b5387528
RAV		 248 }
249
250 return strcmp(dso_name_l, dso_name_r);
251}
252
872a878f 253static int64_t
dd68ada2
JK		 254sort__dso_cmp(struct hist_entry *left, struct hist_entry *right)
255{
202e7a6d 256 return _sort__dso_cmp(right->ms.map, left->ms.map);
b5387528 257}
dd68ada2 258
14d1ac74
NK		 259static int _hist_entry__dso_snprintf(struct map *map, char *bf,
260 size_t size, unsigned int width)
261{
63df0e4b
IR		 262 const struct dso *dso = map ? map__dso(map) : NULL;
263 const char *dso_name = "[unknown]";
264
265 if (dso)
ee756ef7 266 dso_name = verbose > 0 ? dso__long_name(dso) : dso__short_name(dso);
14d1ac74 267
63df0e4b 268 return repsep_snprintf(bf, size, "%-*.*s", width, width, dso_name);
14d1ac74
NK		 269}
270
c824c433 271static int hist_entry__dso_snprintf(struct hist_entry *he, char *bf,
14d1ac74
NK		 272 size_t size, unsigned int width)
273{
c824c433 274 return _hist_entry__dso_snprintf(he->ms.map, bf, size, width);
14d1ac74
NK		 275}
276
54430101
NK		 277static int hist_entry__dso_filter(struct hist_entry *he, int type, const void *arg)
278{
279 const struct dso *dso = arg;
280
281 if (type != HIST_FILTER__DSO)
282 return -1;
283
63df0e4b 284 return dso && (!he->ms.map || map__dso(he->ms.map) != dso);
54430101
NK		 285}
286
14d1ac74
NK		 287struct sort_entry sort_dso = {
288 .se_header = "Shared Object",
289 .se_cmp = sort__dso_cmp,
290 .se_snprintf = hist_entry__dso_snprintf,
54430101 291 .se_filter = hist_entry__dso_filter,
14d1ac74
NK		 292 .se_width_idx = HISTC_DSO,
293};
294
295/* --sort symbol */
dd68ada2 296
2037be53
NK		 297static int64_t _sort__addr_cmp(u64 left_ip, u64 right_ip)
298{
299 return (int64_t)(right_ip - left_ip);
300}
301
12e89e65 302int64_t _sort__sym_cmp(struct symbol *sym_l, struct symbol *sym_r)
b5387528
RAV		 303{
304 if (!sym_l || !sym_r)
305 return cmp_null(sym_l, sym_r);
306
307 if (sym_l == sym_r)
308 return 0;
309
7346195e
HK		 310 if (sym_l->inlined || sym_r->inlined) {
311 int ret = strcmp(sym_l->name, sym_r->name);
312
313 if (ret)
314 return ret;
315 if ((sym_l->start <= sym_r->end) && (sym_l->end >= sym_r->start))
316 return 0;
317 }
aa441895 318
c05676c0
YB		 319 if (sym_l->start != sym_r->start)
320 return (int64_t)(sym_r->start - sym_l->start);
b5387528 321
c05676c0 322 return (int64_t)(sym_r->end - sym_l->end);
b5387528
RAV		 323}
324
14d1ac74
NK		 325static int64_t
326sort__sym_cmp(struct hist_entry *left, struct hist_entry *right)
b5387528 327{
09600e0f
NK		 328 int64_t ret;
329
14d1ac74 330 if (!left->ms.sym && !right->ms.sym)
2037be53 331 return _sort__addr_cmp(left->ip, right->ip);
dd68ada2 332
09600e0f
NK		 333 /*
334 * comparing symbol address alone is not enough since it's a
335 * relative address within a dso.
336 */
cb39d05e 337 if (!hists__has(left->hists, dso)) {
68f6d022
NK		 338 ret = sort__dso_cmp(left, right);
339 if (ret != 0)
340 return ret;
341 }
09600e0f 342
51f27d14 343 return _sort__sym_cmp(left->ms.sym, right->ms.sym);
b5387528
RAV		 344}
345
202e7a6d
NK		 346static int64_t
347sort__sym_sort(struct hist_entry *left, struct hist_entry *right)
348{
349 if (!left->ms.sym || !right->ms.sym)
350 return cmp_null(left->ms.sym, right->ms.sym);
351
352 return strcmp(right->ms.sym->name, left->ms.sym->name);
353}
354
d46a4cdf 355static int _hist_entry__sym_snprintf(struct map_symbol *ms,
b5387528 356 u64 ip, char level, char *bf, size_t size,
43355522 357 unsigned int width)
b5387528 358{
d46a4cdf
ACM		 359 struct symbol *sym = ms->sym;
360 struct map *map = ms->map;
b5387528
RAV		 361 size_t ret = 0;
362
bb963e16 363 if (verbose > 0) {
63df0e4b
IR		 364 struct dso *dso = map ? map__dso(map) : NULL;
365 char o = dso ? dso__symtab_origin(dso) : '!';
51d96355
TR		 366 u64 rip = ip;
367
ee756ef7 368 if (dso && dso__kernel(dso) && dso__adjust_symbols(dso))
78a1f7cd 369 rip = map__unmap_ip(map, ip);
51d96355 370
b5387528 371 ret += repsep_snprintf(bf, size, "%-#*llx %c ",
51d96355 372 BITS_PER_LONG / 4 + 2, rip, o);
439d473b 373 }
dd68ada2 374
b5387528 375 ret += repsep_snprintf(bf + ret, size - ret, "[%c] ", level);
98a3b32c 376 if (sym && map) {
d1fd8d9e 377 if (sym->type == STT_OBJECT) {
98a3b32c
SE		 378 ret += repsep_snprintf(bf + ret, size - ret, "%s", sym->name);
379 ret += repsep_snprintf(bf + ret, size - ret, "+0x%llx",
78a1f7cd 380 ip - map__unmap_ip(map, sym->start));
98a3b32c 381 } else {
89fee709 382 ret += repsep_snprintf(bf + ret, size - ret, "%.*s",
98a3b32c
SE		 383 width - ret,
384 sym->name);
8932f807
MW		 385 if (sym->inlined)
386 ret += repsep_snprintf(bf + ret, size - ret,
387 " (inlined)");
98a3b32c
SE		 388 }
389 } else {
b5387528
RAV		 390 size_t len = BITS_PER_LONG / 4;
391 ret += repsep_snprintf(bf + ret, size - ret, "%-#.*llx",
392 len, ip);
b5387528
RAV		 393 }
394
89fee709 395 return ret;
dd68ada2
JK		 396}
397
bdc633fe 398int hist_entry__sym_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width)
b5387528 399{
d46a4cdf 400 return _hist_entry__sym_snprintf(&he->ms, he->ip,
c824c433 401 he->level, bf, size, width);
b5387528 402}
dd68ada2 403
54430101
NK		 404static int hist_entry__sym_filter(struct hist_entry *he, int type, const void *arg)
405{
406 const char *sym = arg;
407
408 if (type != HIST_FILTER__SYMBOL)
409 return -1;
410
411 return sym && (!he->ms.sym || !strstr(he->ms.sym->name, sym));
412}
413
872a878f
FW		 414struct sort_entry sort_sym = {
415 .se_header = "Symbol",
416 .se_cmp = sort__sym_cmp,
202e7a6d 417 .se_sort = sort__sym_sort,
872a878f 418 .se_snprintf = hist_entry__sym_snprintf,
54430101 419 .se_filter = hist_entry__sym_filter,
872a878f
FW		 420 .se_width_idx = HISTC_SYMBOL,
421};
dd68ada2 422
e2c1c8ff
NK		 423/* --sort symoff */
424
425static int64_t
426sort__symoff_cmp(struct hist_entry *left, struct hist_entry *right)
427{
428 int64_t ret;
429
430 ret = sort__sym_cmp(left, right);
431 if (ret)
432 return ret;
433
434 return left->ip - right->ip;
435}
436
437static int64_t
438sort__symoff_sort(struct hist_entry *left, struct hist_entry *right)
439{
440 int64_t ret;
441
442 ret = sort__sym_sort(left, right);
443 if (ret)
444 return ret;
445
446 return left->ip - right->ip;
447}
448
449static int
450hist_entry__symoff_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width)
451{
452 struct symbol *sym = he->ms.sym;
453
454 if (sym == NULL)
455 return repsep_snprintf(bf, size, "[%c] %-#.*llx", he->level, width - 4, he->ip);
456
457 return repsep_snprintf(bf, size, "[%c] %s+0x%llx", he->level, sym->name, he->ip - sym->start);
458}
459
460struct sort_entry sort_sym_offset = {
461 .se_header = "Symbol Offset",
462 .se_cmp = sort__symoff_cmp,
463 .se_sort = sort__symoff_sort,
464 .se_snprintf = hist_entry__symoff_snprintf,
465 .se_filter = hist_entry__sym_filter,
466 .se_width_idx = HISTC_SYMBOL_OFFSET,
467};
468
409a8be6
ACM		 469/* --sort srcline */
470
6a53da05 471char *hist_entry__srcline(struct hist_entry *he)
cecaec63 472{
e2d88aaa 473 return map__srcline(he->ms.map, he->ip, he->ms.sym);
cecaec63
NK		 474}
475
409a8be6
ACM		 476static int64_t
477sort__srcline_cmp(struct hist_entry *left, struct hist_entry *right)
ec222d7e
NK		 478{
479 int64_t ret;
480
481 ret = _sort__addr_cmp(left->ip, right->ip);
482 if (ret)
483 return ret;
484
485 return sort__dso_cmp(left, right);
486}
487
488static int64_t
489sort__srcline_collapse(struct hist_entry *left, struct hist_entry *right)
409a8be6 490{
cecaec63 491 if (!left->srcline)
6a53da05 492 left->srcline = hist_entry__srcline(left);
cecaec63 493 if (!right->srcline)
6a53da05 494 right->srcline = hist_entry__srcline(right);
cecaec63 495
202e7a6d 496 return strcmp(right->srcline, left->srcline);
409a8be6
ACM		 497}
498
ec222d7e
NK		 499static int64_t
500sort__srcline_sort(struct hist_entry *left, struct hist_entry *right)
501{
502 return sort__srcline_collapse(left, right);
503}
504
505static void
506sort__srcline_init(struct hist_entry *he)
409a8be6 507{
cecaec63 508 if (!he->srcline)
6a53da05 509 he->srcline = hist_entry__srcline(he);
ec222d7e 510}
cecaec63 511
ec222d7e
NK		 512static int hist_entry__srcline_snprintf(struct hist_entry *he, char *bf,
513 size_t size, unsigned int width)
514{
2960ed6f 515 return repsep_snprintf(bf, size, "%-.*s", width, he->srcline);
409a8be6
ACM		 516}
517
518struct sort_entry sort_srcline = {
519 .se_header = "Source:Line",
520 .se_cmp = sort__srcline_cmp,
ec222d7e
NK		 521 .se_collapse = sort__srcline_collapse,
522 .se_sort = sort__srcline_sort,
523 .se_init = sort__srcline_init,
409a8be6
ACM		 524 .se_snprintf = hist_entry__srcline_snprintf,
525 .se_width_idx = HISTC_SRCLINE,
526};
527
508be0df
AK		 528/* --sort srcline_from */
529
bfa63519
ACM		 530static char *addr_map_symbol__srcline(struct addr_map_symbol *ams)
531{
d46a4cdf 532 return map__srcline(ams->ms.map, ams->al_addr, ams->ms.sym);
bfa63519
ACM		 533}
534
508be0df
AK		 535static int64_t
536sort__srcline_from_cmp(struct hist_entry *left, struct hist_entry *right)
ad9ef9eb
NK		 537{
538 return left->branch_info->from.addr - right->branch_info->from.addr;
539}
540
541static int64_t
542sort__srcline_from_collapse(struct hist_entry *left, struct hist_entry *right)
508be0df 543{
bfa63519
ACM		 544 if (!left->branch_info->srcline_from)
545 left->branch_info->srcline_from = addr_map_symbol__srcline(&left->branch_info->from);
546
547 if (!right->branch_info->srcline_from)
548 right->branch_info->srcline_from = addr_map_symbol__srcline(&right->branch_info->from);
549
508be0df
AK		 550 return strcmp(right->branch_info->srcline_from, left->branch_info->srcline_from);
551}
552
ad9ef9eb
NK		 553static int64_t
554sort__srcline_from_sort(struct hist_entry *left, struct hist_entry *right)
555{
556 return sort__srcline_from_collapse(left, right);
557}
558
559static void sort__srcline_from_init(struct hist_entry *he)
560{
561 if (!he->branch_info->srcline_from)
562 he->branch_info->srcline_from = addr_map_symbol__srcline(&he->branch_info->from);
563}
564
508be0df
AK		 565static int hist_entry__srcline_from_snprintf(struct hist_entry *he, char *bf,
566 size_t size, unsigned int width)
567{
568 return repsep_snprintf(bf, size, "%-*.*s", width, width, he->branch_info->srcline_from);
569}
570
571struct sort_entry sort_srcline_from = {
572 .se_header = "From Source:Line",
573 .se_cmp = sort__srcline_from_cmp,
ad9ef9eb
NK		 574 .se_collapse = sort__srcline_from_collapse,
575 .se_sort = sort__srcline_from_sort,
576 .se_init = sort__srcline_from_init,
508be0df
AK		 577 .se_snprintf = hist_entry__srcline_from_snprintf,
578 .se_width_idx = HISTC_SRCLINE_FROM,
579};
580
581/* --sort srcline_to */
582
583static int64_t
584sort__srcline_to_cmp(struct hist_entry *left, struct hist_entry *right)
ad9ef9eb
NK		 585{
586 return left->branch_info->to.addr - right->branch_info->to.addr;
587}
588
589static int64_t
590sort__srcline_to_collapse(struct hist_entry *left, struct hist_entry *right)
508be0df 591{
bfa63519
ACM		 592 if (!left->branch_info->srcline_to)
593 left->branch_info->srcline_to = addr_map_symbol__srcline(&left->branch_info->to);
594
595 if (!right->branch_info->srcline_to)
596 right->branch_info->srcline_to = addr_map_symbol__srcline(&right->branch_info->to);
597
508be0df
AK		 598 return strcmp(right->branch_info->srcline_to, left->branch_info->srcline_to);
599}
600
ad9ef9eb
NK		 601static int64_t
602sort__srcline_to_sort(struct hist_entry *left, struct hist_entry *right)
603{
604 return sort__srcline_to_collapse(left, right);
605}
606
607static void sort__srcline_to_init(struct hist_entry *he)
608{
609 if (!he->branch_info->srcline_to)
610 he->branch_info->srcline_to = addr_map_symbol__srcline(&he->branch_info->to);
611}
612
508be0df
AK		 613static int hist_entry__srcline_to_snprintf(struct hist_entry *he, char *bf,
614 size_t size, unsigned int width)
615{
616 return repsep_snprintf(bf, size, "%-*.*s", width, width, he->branch_info->srcline_to);
617}
618
619struct sort_entry sort_srcline_to = {
620 .se_header = "To Source:Line",
621 .se_cmp = sort__srcline_to_cmp,
ad9ef9eb
NK		 622 .se_collapse = sort__srcline_to_collapse,
623 .se_sort = sort__srcline_to_sort,
624 .se_init = sort__srcline_to_init,
508be0df
AK		 625 .se_snprintf = hist_entry__srcline_to_snprintf,
626 .se_width_idx = HISTC_SRCLINE_TO,
627};
628
ec6ae74f
JY		 629static int hist_entry__sym_ipc_snprintf(struct hist_entry *he, char *bf,
630 size_t size, unsigned int width)
631{
632
633 struct symbol *sym = he->ms.sym;
b7f87e32 634 struct annotated_branch *branch;
ec6ae74f
JY		 635 double ipc = 0.0, coverage = 0.0;
636 char tmp[64];
637
638 if (!sym)
639 return repsep_snprintf(bf, size, "%-*s", width, "-");
640
b7f87e32 641 branch = symbol__annotation(sym)->branch;
ec6ae74f 642
b7f87e32
NK		 643 if (branch && branch->hit_cycles)
644 ipc = branch->hit_insn / ((double)branch->hit_cycles);
ec6ae74f 645
b7f87e32
NK		 646 if (branch && branch->total_insn) {
647 coverage = branch->cover_insn * 100.0 /
648 ((double)branch->total_insn);
ec6ae74f
JY		 649 }
650
651 snprintf(tmp, sizeof(tmp), "%-5.2f [%5.1f%%]", ipc, coverage);
652 return repsep_snprintf(bf, size, "%-*s", width, tmp);
653}
654
655struct sort_entry sort_sym_ipc = {
656 .se_header = "IPC [IPC Coverage]",
657 .se_cmp = sort__sym_cmp,
658 .se_snprintf = hist_entry__sym_ipc_snprintf,
659 .se_width_idx = HISTC_SYMBOL_IPC,
660};
661
662static int hist_entry__sym_ipc_null_snprintf(struct hist_entry *he
663 __maybe_unused,
664 char *bf, size_t size,
665 unsigned int width)
666{
667 char tmp[64];
668
669 snprintf(tmp, sizeof(tmp), "%-5s %2s", "-", "-");
670 return repsep_snprintf(bf, size, "%-*s", width, tmp);
671}
672
673struct sort_entry sort_sym_ipc_null = {
674 .se_header = "IPC [IPC Coverage]",
675 .se_cmp = sort__sym_cmp,
676 .se_snprintf = hist_entry__sym_ipc_null_snprintf,
677 .se_width_idx = HISTC_SYMBOL_IPC,
678};
679
31191a85
AK		 680/* --sort srcfile */
681
682static char no_srcfile[1];
683
cecaec63 684static char *hist_entry__get_srcfile(struct hist_entry *e)
31191a85
AK		 685{
686 char *sf, *p;
687 struct map *map = e->ms.map;
688
cecaec63
NK		 689 if (!map)
690 return no_srcfile;
691
63df0e4b 692 sf = __get_srcline(map__dso(map), map__rip_2objdump(map, e->ip),
935f5a9d 693 e->ms.sym, false, true, true, e->ip);
922db21d 694 if (sf == SRCLINE_UNKNOWN)
76b10655 695 return no_srcfile;
31191a85
AK		 696 p = strchr(sf, ':');
697 if (p && *sf) {
698 *p = 0;
699 return sf;
700 }
701 free(sf);
702 return no_srcfile;
703}
704
705static int64_t
706sort__srcfile_cmp(struct hist_entry *left, struct hist_entry *right)
707{
6094c774 708 return sort__srcline_cmp(left, right);
31191a85
AK		 709}
710
f0cdde28
NK		 711static int64_t
712sort__srcfile_collapse(struct hist_entry *left, struct hist_entry *right)
713{
714 if (!left->srcfile)
715 left->srcfile = hist_entry__get_srcfile(left);
716 if (!right->srcfile)
717 right->srcfile = hist_entry__get_srcfile(right);
718
719 return strcmp(right->srcfile, left->srcfile);
720}
721
722static int64_t
723sort__srcfile_sort(struct hist_entry *left, struct hist_entry *right)
724{
725 return sort__srcfile_collapse(left, right);
726}
727
728static void sort__srcfile_init(struct hist_entry *he)
31191a85 729{
cecaec63
NK		 730 if (!he->srcfile)
731 he->srcfile = hist_entry__get_srcfile(he);
f0cdde28 732}
cecaec63 733
f0cdde28
NK		 734static int hist_entry__srcfile_snprintf(struct hist_entry *he, char *bf,
735 size_t size, unsigned int width)
736{
2960ed6f 737 return repsep_snprintf(bf, size, "%-.*s", width, he->srcfile);
31191a85
AK		 738}
739
740struct sort_entry sort_srcfile = {
741 .se_header = "Source File",
742 .se_cmp = sort__srcfile_cmp,
f0cdde28
NK		 743 .se_collapse = sort__srcfile_collapse,
744 .se_sort = sort__srcfile_sort,
745 .se_init = sort__srcfile_init,
31191a85
AK		 746 .se_snprintf = hist_entry__srcfile_snprintf,
747 .se_width_idx = HISTC_SRCFILE,
748};
749
dd68ada2
JK		 750/* --sort parent */
751
872a878f 752static int64_t
dd68ada2
JK		 753sort__parent_cmp(struct hist_entry *left, struct hist_entry *right)
754{
755 struct symbol *sym_l = left->parent;
756 struct symbol *sym_r = right->parent;
757
758 if (!sym_l || !sym_r)
759 return cmp_null(sym_l, sym_r);
760
202e7a6d 761 return strcmp(sym_r->name, sym_l->name);
dd68ada2
JK		 762}
763
c824c433 764static int hist_entry__parent_snprintf(struct hist_entry *he, char *bf,
a4e3b956 765 size_t size, unsigned int width)
dd68ada2 766{
5b591669 767 return repsep_snprintf(bf, size, "%-*.*s", width, width,
c824c433 768 he->parent ? he->parent->name : "[other]");
dd68ada2
JK		 769}
770
872a878f
FW		 771struct sort_entry sort_parent = {
772 .se_header = "Parent symbol",
773 .se_cmp = sort__parent_cmp,
774 .se_snprintf = hist_entry__parent_snprintf,
775 .se_width_idx = HISTC_PARENT,
776};
777
f60f3593
AS		 778/* --sort cpu */
779
872a878f 780static int64_t
f60f3593
AS		 781sort__cpu_cmp(struct hist_entry *left, struct hist_entry *right)
782{
783 return right->cpu - left->cpu;
784}
785
c824c433
ACM		 786static int hist_entry__cpu_snprintf(struct hist_entry *he, char *bf,
787 size_t size, unsigned int width)
f60f3593 788{
5b591669 789 return repsep_snprintf(bf, size, "%*.*d", width, width, he->cpu);
f60f3593
AS		 790}
791
872a878f
FW		 792struct sort_entry sort_cpu = {
793 .se_header = "CPU",
794 .se_cmp = sort__cpu_cmp,
795 .se_snprintf = hist_entry__cpu_snprintf,
796 .se_width_idx = HISTC_CPU,
797};
798
d890a98c
HB		 799/* --sort cgroup_id */
800
801static int64_t _sort__cgroup_dev_cmp(u64 left_dev, u64 right_dev)
802{
803 return (int64_t)(right_dev - left_dev);
804}
805
806static int64_t _sort__cgroup_inode_cmp(u64 left_ino, u64 right_ino)
807{
808 return (int64_t)(right_ino - left_ino);
809}
810
811static int64_t
812sort__cgroup_id_cmp(struct hist_entry *left, struct hist_entry *right)
813{
814 int64_t ret;
815
816 ret = _sort__cgroup_dev_cmp(right->cgroup_id.dev, left->cgroup_id.dev);
817 if (ret != 0)
818 return ret;
819
820 return _sort__cgroup_inode_cmp(right->cgroup_id.ino,
821 left->cgroup_id.ino);
822}
823
824static int hist_entry__cgroup_id_snprintf(struct hist_entry *he,
825 char *bf, size_t size,
826 unsigned int width __maybe_unused)
827{
828 return repsep_snprintf(bf, size, "%lu/0x%lx", he->cgroup_id.dev,
829 he->cgroup_id.ino);
830}
831
832struct sort_entry sort_cgroup_id = {
833 .se_header = "cgroup id (dev/inode)",
834 .se_cmp = sort__cgroup_id_cmp,
835 .se_snprintf = hist_entry__cgroup_id_snprintf,
836 .se_width_idx = HISTC_CGROUP_ID,
837};
838
b629f3e9
NK		 839/* --sort cgroup */
840
841static int64_t
842sort__cgroup_cmp(struct hist_entry *left, struct hist_entry *right)
843{
844 return right->cgroup - left->cgroup;
845}
846
847static int hist_entry__cgroup_snprintf(struct hist_entry *he,
848 char *bf, size_t size,
849 unsigned int width __maybe_unused)
850{
851 const char *cgrp_name = "N/A";
852
853 if (he->cgroup) {
5ab6d715 854 struct cgroup *cgrp = cgroup__find(maps__machine(he->ms.maps)->env,
b629f3e9
NK		 855 he->cgroup);
856 if (cgrp != NULL)
857 cgrp_name = cgrp->name;
858 else
859 cgrp_name = "unknown";
860 }
861
862 return repsep_snprintf(bf, size, "%s", cgrp_name);
863}
864
865struct sort_entry sort_cgroup = {
866 .se_header = "Cgroup",
867 .se_cmp = sort__cgroup_cmp,
868 .se_snprintf = hist_entry__cgroup_snprintf,
869 .se_width_idx = HISTC_CGROUP,
870};
871
2e7ea3ab
KL		 872/* --sort socket */
873
874static int64_t
875sort__socket_cmp(struct hist_entry *left, struct hist_entry *right)
876{
877 return right->socket - left->socket;
878}
879
880static int hist_entry__socket_snprintf(struct hist_entry *he, char *bf,
881 size_t size, unsigned int width)
882{
883 return repsep_snprintf(bf, size, "%*.*d", width, width-3, he->socket);
884}
885
54430101
NK		 886static int hist_entry__socket_filter(struct hist_entry *he, int type, const void *arg)
887{
888 int sk = *(const int *)arg;
889
890 if (type != HIST_FILTER__SOCKET)
891 return -1;
892
893 return sk >= 0 && he->socket != sk;
894}
895
2e7ea3ab
KL		 896struct sort_entry sort_socket = {
897 .se_header = "Socket",
898 .se_cmp = sort__socket_cmp,
899 .se_snprintf = hist_entry__socket_snprintf,
54430101 900 .se_filter = hist_entry__socket_filter,
2e7ea3ab
KL		 901 .se_width_idx = HISTC_SOCKET,
902};
903
3723908d
AK		 904/* --sort time */
905
906static int64_t
907sort__time_cmp(struct hist_entry *left, struct hist_entry *right)
908{
909 return right->time - left->time;
910}
911
912static int hist_entry__time_snprintf(struct hist_entry *he, char *bf,
913 size_t size, unsigned int width)
914{
3723908d
AK		 915 char he_time[32];
916
3723908d 917 if (symbol_conf.nanosecs)
092804ae
AK		 918 timestamp__scnprintf_nsec(he->time, he_time,
919 sizeof(he_time));
3723908d
AK		 920 else
921 timestamp__scnprintf_usec(he->time, he_time,
922 sizeof(he_time));
923
924 return repsep_snprintf(bf, size, "%-.*s", width, he_time);
925}
926
927struct sort_entry sort_time = {
928 .se_header = "Time",
929 .se_cmp = sort__time_cmp,
930 .se_snprintf = hist_entry__time_snprintf,
931 .se_width_idx = HISTC_TIME,
932};
933
a34bb6a0
NK		 934/* --sort trace */
935
378ef0f5 936#ifdef HAVE_LIBTRACEEVENT
a34bb6a0
NK		 937static char *get_trace_output(struct hist_entry *he)
938{
939 struct trace_seq seq;
32dcd021 940 struct evsel *evsel;
cbc49b25 941 struct tep_record rec = {
a34bb6a0
NK		 942 .data = he->raw_data,
943 .size = he->raw_size,
944 };
945
946 evsel = hists_to_evsel(he->hists);
947
948 trace_seq_init(&seq);
053a3989 949 if (symbol_conf.raw_trace) {
6a48dc29
TSV		 950 tep_print_fields(&seq, he->raw_data, he->raw_size,
951 evsel->tp_format);
053a3989 952 } else {
38847db9
TS		 953 tep_print_event(evsel->tp_format->tep,
954 &seq, &rec, "%s", TEP_PRINT_INFO);
053a3989 955 }
887fa86d
ACM		 956 /*
957 * Trim the buffer, it starts at 4KB and we're not going to
958 * add anything more to this buffer.
959 */
960 return realloc(seq.buffer, seq.len + 1);
a34bb6a0
NK		 961}
962
963static int64_t
964sort__trace_cmp(struct hist_entry *left, struct hist_entry *right)
965{
32dcd021 966 struct evsel *evsel;
a34bb6a0
NK		 967
968 evsel = hists_to_evsel(left->hists);
1fc632ce 969 if (evsel->core.attr.type != PERF_TYPE_TRACEPOINT)
a34bb6a0
NK		 970 return 0;
971
972 if (left->trace_output == NULL)
973 left->trace_output = get_trace_output(left);
974 if (right->trace_output == NULL)
975 right->trace_output = get_trace_output(right);
976
a34bb6a0
NK		 977 return strcmp(right->trace_output, left->trace_output);
978}
979
980static int hist_entry__trace_snprintf(struct hist_entry *he, char *bf,
981 size_t size, unsigned int width)
982{
32dcd021 983 struct evsel *evsel;
a34bb6a0
NK		 984
985 evsel = hists_to_evsel(he->hists);
1fc632ce 986 if (evsel->core.attr.type != PERF_TYPE_TRACEPOINT)
2960ed6f 987 return scnprintf(bf, size, "%-.*s", width, "N/A");
a34bb6a0
NK		 988
989 if (he->trace_output == NULL)
990 he->trace_output = get_trace_output(he);
2960ed6f 991 return repsep_snprintf(bf, size, "%-.*s", width, he->trace_output);
a34bb6a0
NK		 992}
993
994struct sort_entry sort_trace = {
995 .se_header = "Trace output",
996 .se_cmp = sort__trace_cmp,
997 .se_snprintf = hist_entry__trace_snprintf,
998 .se_width_idx = HISTC_TRACE,
999};
378ef0f5 1000#endif /* HAVE_LIBTRACEEVENT */
a34bb6a0 1001
14d1ac74
NK		 1002/* sort keys for branch stacks */
1003
b5387528
RAV		 1004static int64_t
1005sort__dso_from_cmp(struct hist_entry *left, struct hist_entry *right)
1006{
288a4b91
JO		 1007 if (!left->branch_info || !right->branch_info)
1008 return cmp_null(left->branch_info, right->branch_info);
1009
d46a4cdf
ACM		 1010 return _sort__dso_cmp(left->branch_info->from.ms.map,
1011 right->branch_info->from.ms.map);
b5387528
RAV		 1012}
1013
c824c433 1014static int hist_entry__dso_from_snprintf(struct hist_entry *he, char *bf,
b5387528
RAV		 1015 size_t size, unsigned int width)
1016{
288a4b91 1017 if (he->branch_info)
d46a4cdf 1018 return _hist_entry__dso_snprintf(he->branch_info->from.ms.map,
288a4b91
JO		 1019 bf, size, width);
1020 else
1021 return repsep_snprintf(bf, size, "%-*.*s", width, width, "N/A");
b5387528
RAV		 1022}
1023
54430101
NK		 1024static int hist_entry__dso_from_filter(struct hist_entry *he, int type,
1025 const void *arg)
1026{
1027 const struct dso *dso = arg;
1028
1029 if (type != HIST_FILTER__DSO)
1030 return -1;
1031
d46a4cdf 1032 return dso && (!he->branch_info || !he->branch_info->from.ms.map ||
63df0e4b 1033 map__dso(he->branch_info->from.ms.map) != dso);
54430101
NK		 1034}
1035
b5387528
RAV		 1036static int64_t
1037sort__dso_to_cmp(struct hist_entry *left, struct hist_entry *right)
1038{
8b62fa59
JO		 1039 if (!left->branch_info || !right->branch_info)
1040 return cmp_null(left->branch_info, right->branch_info);
1041
d46a4cdf
ACM		 1042 return _sort__dso_cmp(left->branch_info->to.ms.map,
1043 right->branch_info->to.ms.map);
b5387528
RAV		 1044}
1045
c824c433 1046static int hist_entry__dso_to_snprintf(struct hist_entry *he, char *bf,
b5387528
RAV		 1047 size_t size, unsigned int width)
1048{
8b62fa59 1049 if (he->branch_info)
d46a4cdf 1050 return _hist_entry__dso_snprintf(he->branch_info->to.ms.map,
8b62fa59
JO		 1051 bf, size, width);
1052 else
1053 return repsep_snprintf(bf, size, "%-*.*s", width, width, "N/A");
b5387528
RAV		 1054}
1055
54430101
NK		 1056static int hist_entry__dso_to_filter(struct hist_entry *he, int type,
1057 const void *arg)
1058{
1059 const struct dso *dso = arg;
1060
1061 if (type != HIST_FILTER__DSO)
1062 return -1;
1063
d46a4cdf 1064 return dso && (!he->branch_info || !he->branch_info->to.ms.map ||
63df0e4b 1065 map__dso(he->branch_info->to.ms.map) != dso);
54430101
NK		 1066}
1067
b5387528
RAV		 1068static int64_t
1069sort__sym_from_cmp(struct hist_entry *left, struct hist_entry *right)
1070{
c160118a 1071 struct addr_map_symbol *from_l, *from_r;
b5387528 1072
1b9e97a2
JO		 1073 if (!left->branch_info || !right->branch_info)
1074 return cmp_null(left->branch_info, right->branch_info);
1075
1076 from_l = &left->branch_info->from;
1077 from_r = &right->branch_info->from;
1078
d46a4cdf 1079 if (!from_l->ms.sym && !from_r->ms.sym)
2037be53 1080 return _sort__addr_cmp(from_l->addr, from_r->addr);
b5387528 1081
d46a4cdf 1082 return _sort__sym_cmp(from_l->ms.sym, from_r->ms.sym);
b5387528
RAV		 1083}
1084
1085static int64_t
1086sort__sym_to_cmp(struct hist_entry *left, struct hist_entry *right)
1087{
38cdbd39
JO		 1088 struct addr_map_symbol *to_l, *to_r;
1089
1090 if (!left->branch_info || !right->branch_info)
1091 return cmp_null(left->branch_info, right->branch_info);
1092
1093 to_l = &left->branch_info->to;
1094 to_r = &right->branch_info->to;
b5387528 1095
d46a4cdf 1096 if (!to_l->ms.sym && !to_r->ms.sym)
2037be53 1097 return _sort__addr_cmp(to_l->addr, to_r->addr);
b5387528 1098
d46a4cdf 1099 return _sort__sym_cmp(to_l->ms.sym, to_r->ms.sym);
b5387528
RAV		 1100}
1101
c824c433 1102static int hist_entry__sym_from_snprintf(struct hist_entry *he, char *bf,
43355522 1103 size_t size, unsigned int width)
b5387528 1104{
1b9e97a2
JO		 1105 if (he->branch_info) {
1106 struct addr_map_symbol *from = &he->branch_info->from;
b5387528 1107
443bc639 1108 return _hist_entry__sym_snprintf(&from->ms, from->al_addr,
05b5a9d6 1109 from->al_level, bf, size, width);
1b9e97a2
JO		 1110 }
1111
1112 return repsep_snprintf(bf, size, "%-*.*s", width, width, "N/A");
b5387528
RAV		 1113}
1114
c824c433 1115static int hist_entry__sym_to_snprintf(struct hist_entry *he, char *bf,
43355522 1116 size_t size, unsigned int width)
b5387528 1117{
38cdbd39
JO		 1118 if (he->branch_info) {
1119 struct addr_map_symbol *to = &he->branch_info->to;
1120
443bc639 1121 return _hist_entry__sym_snprintf(&to->ms, to->al_addr,
05b5a9d6 1122 to->al_level, bf, size, width);
38cdbd39 1123 }
b5387528 1124
38cdbd39 1125 return repsep_snprintf(bf, size, "%-*.*s", width, width, "N/A");
b5387528
RAV		 1126}
1127
54430101
NK		 1128static int hist_entry__sym_from_filter(struct hist_entry *he, int type,
1129 const void *arg)
1130{
1131 const char *sym = arg;
1132
1133 if (type != HIST_FILTER__SYMBOL)
1134 return -1;
1135
d46a4cdf
ACM		 1136 return sym && !(he->branch_info && he->branch_info->from.ms.sym &&
1137 strstr(he->branch_info->from.ms.sym->name, sym));
54430101
NK		 1138}
1139
1140static int hist_entry__sym_to_filter(struct hist_entry *he, int type,
1141 const void *arg)
1142{
1143 const char *sym = arg;
1144
1145 if (type != HIST_FILTER__SYMBOL)
1146 return -1;
1147
d46a4cdf
ACM		 1148 return sym && !(he->branch_info && he->branch_info->to.ms.sym &&
1149 strstr(he->branch_info->to.ms.sym->name, sym));
54430101
NK		 1150}
1151
14d1ac74
NK		 1152struct sort_entry sort_dso_from = {
1153 .se_header = "Source Shared Object",
1154 .se_cmp = sort__dso_from_cmp,
1155 .se_snprintf = hist_entry__dso_from_snprintf,
54430101 1156 .se_filter = hist_entry__dso_from_filter,
14d1ac74
NK		 1157 .se_width_idx = HISTC_DSO_FROM,
1158};
1159
b5387528
RAV		 1160struct sort_entry sort_dso_to = {
1161 .se_header = "Target Shared Object",
1162 .se_cmp = sort__dso_to_cmp,
1163 .se_snprintf = hist_entry__dso_to_snprintf,
54430101 1164 .se_filter = hist_entry__dso_to_filter,
b5387528
RAV		 1165 .se_width_idx = HISTC_DSO_TO,
1166};
1167
1168struct sort_entry sort_sym_from = {
1169 .se_header = "Source Symbol",
1170 .se_cmp = sort__sym_from_cmp,
1171 .se_snprintf = hist_entry__sym_from_snprintf,
54430101 1172 .se_filter = hist_entry__sym_from_filter,
b5387528
RAV		 1173 .se_width_idx = HISTC_SYMBOL_FROM,
1174};
1175
1176struct sort_entry sort_sym_to = {
1177 .se_header = "Target Symbol",
1178 .se_cmp = sort__sym_to_cmp,
1179 .se_snprintf = hist_entry__sym_to_snprintf,
54430101 1180 .se_filter = hist_entry__sym_to_filter,
b5387528
RAV		 1181 .se_width_idx = HISTC_SYMBOL_TO,
1182};
1183
05274770
SE		 1184static int _hist_entry__addr_snprintf(struct map_symbol *ms,
1185 u64 ip, char level, char *bf, size_t size,
1186 unsigned int width)
1187{
1188 struct symbol *sym = ms->sym;
1189 struct map *map = ms->map;
1190 size_t ret = 0, offs;
1191
1192 ret += repsep_snprintf(bf + ret, size - ret, "[%c] ", level);
1193 if (sym && map) {
1194 if (sym->type == STT_OBJECT) {
1195 ret += repsep_snprintf(bf + ret, size - ret, "%s", sym->name);
1196 ret += repsep_snprintf(bf + ret, size - ret, "+0x%llx",
78a1f7cd 1197 ip - map__unmap_ip(map, sym->start));
05274770
SE		 1198 } else {
1199 ret += repsep_snprintf(bf + ret, size - ret, "%.*s",
1200 width - ret,
1201 sym->name);
1202 offs = ip - sym->start;
1203 if (offs)
1204 ret += repsep_snprintf(bf + ret, size - ret, "+0x%llx", offs);
1205 }
1206 } else {
1207 size_t len = BITS_PER_LONG / 4;
1208 ret += repsep_snprintf(bf + ret, size - ret, "%-#.*llx",
1209 len, ip);
1210 }
1211
1212 return ret;
1213}
1214
1215static int hist_entry__addr_from_snprintf(struct hist_entry *he, char *bf,
1216 size_t size, unsigned int width)
1217{
1218 if (he->branch_info) {
1219 struct addr_map_symbol *from = &he->branch_info->from;
1220
1221 return _hist_entry__addr_snprintf(&from->ms, from->al_addr,
1222 he->level, bf, size, width);
1223 }
1224
1225 return repsep_snprintf(bf, size, "%-*.*s", width, width, "N/A");
1226}
1227
1228static int hist_entry__addr_to_snprintf(struct hist_entry *he, char *bf,
1229 size_t size, unsigned int width)
1230{
1231 if (he->branch_info) {
1232 struct addr_map_symbol *to = &he->branch_info->to;
1233
1234 return _hist_entry__addr_snprintf(&to->ms, to->al_addr,
1235 he->level, bf, size, width);
1236 }
1237
1238 return repsep_snprintf(bf, size, "%-*.*s", width, width, "N/A");
1239}
1240
1241static int64_t
1242sort__addr_from_cmp(struct hist_entry *left, struct hist_entry *right)
1243{
1244 struct addr_map_symbol *from_l;
1245 struct addr_map_symbol *from_r;
1246 int64_t ret;
1247
1248 if (!left->branch_info || !right->branch_info)
1249 return cmp_null(left->branch_info, right->branch_info);
1250
1251 from_l = &left->branch_info->from;
1252 from_r = &right->branch_info->from;
1253
1254 /*
1255 * comparing symbol address alone is not enough since it's a
1256 * relative address within a dso.
1257 */
1258 ret = _sort__dso_cmp(from_l->ms.map, from_r->ms.map);
1259 if (ret != 0)
1260 return ret;
1261
1262 return _sort__addr_cmp(from_l->addr, from_r->addr);
1263}
1264
1265static int64_t
1266sort__addr_to_cmp(struct hist_entry *left, struct hist_entry *right)
1267{
1268 struct addr_map_symbol *to_l;
1269 struct addr_map_symbol *to_r;
1270 int64_t ret;
1271
1272 if (!left->branch_info || !right->branch_info)
1273 return cmp_null(left->branch_info, right->branch_info);
1274
1275 to_l = &left->branch_info->to;
1276 to_r = &right->branch_info->to;
1277
1278 /*
1279 * comparing symbol address alone is not enough since it's a
1280 * relative address within a dso.
1281 */
1282 ret = _sort__dso_cmp(to_l->ms.map, to_r->ms.map);
1283 if (ret != 0)
1284 return ret;
1285
1286 return _sort__addr_cmp(to_l->addr, to_r->addr);
1287}
1288
1289struct sort_entry sort_addr_from = {
1290 .se_header = "Source Address",
1291 .se_cmp = sort__addr_from_cmp,
1292 .se_snprintf = hist_entry__addr_from_snprintf,
1293 .se_filter = hist_entry__sym_from_filter, /* shared with sym_from */
1294 .se_width_idx = HISTC_ADDR_FROM,
1295};
1296
1297struct sort_entry sort_addr_to = {
1298 .se_header = "Target Address",
1299 .se_cmp = sort__addr_to_cmp,
1300 .se_snprintf = hist_entry__addr_to_snprintf,
1301 .se_filter = hist_entry__sym_to_filter, /* shared with sym_to */
1302 .se_width_idx = HISTC_ADDR_TO,
1303};
1304
1305
b5387528
RAV		 1306static int64_t
1307sort__mispredict_cmp(struct hist_entry *left, struct hist_entry *right)
1308{
428560e7 1309 unsigned char mp, p;
b5387528 1310
428560e7
JO		 1311 if (!left->branch_info || !right->branch_info)
1312 return cmp_null(left->branch_info, right->branch_info);
1313
1314 mp = left->branch_info->flags.mispred != right->branch_info->flags.mispred;
1315 p = left->branch_info->flags.predicted != right->branch_info->flags.predicted;
b5387528
RAV		 1316 return mp || p;
1317}
1318
c824c433 1319static int hist_entry__mispredict_snprintf(struct hist_entry *he, char *bf,
b5387528
RAV		 1320 size_t size, unsigned int width){
1321 static const char *out = "N/A";
1322
428560e7
JO		 1323 if (he->branch_info) {
1324 if (he->branch_info->flags.predicted)
1325 out = "N";
1326 else if (he->branch_info->flags.mispred)
1327 out = "Y";
1328 }
b5387528 1329
5b591669 1330 return repsep_snprintf(bf, size, "%-*.*s", width, width, out);
b5387528
RAV		 1331}
1332
0e332f03
AK		 1333static int64_t
1334sort__cycles_cmp(struct hist_entry *left, struct hist_entry *right)
1335{
4b0b3aa6
CD		 1336 if (!left->branch_info || !right->branch_info)
1337 return cmp_null(left->branch_info, right->branch_info);
1338
0e332f03
AK		 1339 return left->branch_info->flags.cycles -
1340 right->branch_info->flags.cycles;
1341}
1342
1343static int hist_entry__cycles_snprintf(struct hist_entry *he, char *bf,
1344 size_t size, unsigned int width)
1345{
4b0b3aa6
CD		 1346 if (!he->branch_info)
1347 return scnprintf(bf, size, "%-.*s", width, "N/A");
0e332f03
AK		 1348 if (he->branch_info->flags.cycles == 0)
1349 return repsep_snprintf(bf, size, "%-*s", width, "-");
1350 return repsep_snprintf(bf, size, "%-*hd", width,
1351 he->branch_info->flags.cycles);
1352}
1353
1354struct sort_entry sort_cycles = {
1355 .se_header = "Basic Block Cycles",
1356 .se_cmp = sort__cycles_cmp,
1357 .se_snprintf = hist_entry__cycles_snprintf,
1358 .se_width_idx = HISTC_CYCLES,
1359};
1360
98a3b32c 1361/* --sort daddr_sym */
5fe7b9b4 1362int64_t
98a3b32c
SE		 1363sort__daddr_cmp(struct hist_entry *left, struct hist_entry *right)
1364{
1365 uint64_t l = 0, r = 0;
1366
1367 if (left->mem_info)
1a8c2e01 1368 l = mem_info__daddr(left->mem_info)->addr;
98a3b32c 1369 if (right->mem_info)
1a8c2e01 1370 r = mem_info__daddr(right->mem_info)->addr;
98a3b32c
SE		 1371
1372 return (int64_t)(r - l);
1373}
1374
c824c433 1375static int hist_entry__daddr_snprintf(struct hist_entry *he, char *bf,
98a3b32c
SE		 1376 size_t size, unsigned int width)
1377{
1378 uint64_t addr = 0;
d46a4cdf 1379 struct map_symbol *ms = NULL;
98a3b32c 1380
c824c433 1381 if (he->mem_info) {
1a8c2e01
IR		 1382 addr = mem_info__daddr(he->mem_info)->addr;
1383 ms = &mem_info__daddr(he->mem_info)->ms;
98a3b32c 1384 }
d46a4cdf 1385 return _hist_entry__sym_snprintf(ms, addr, he->level, bf, size, width);
98a3b32c
SE		 1386}
1387
5fe7b9b4 1388int64_t
28e6db20
DZ		 1389sort__iaddr_cmp(struct hist_entry *left, struct hist_entry *right)
1390{
1391 uint64_t l = 0, r = 0;
1392
1393 if (left->mem_info)
1a8c2e01 1394 l = mem_info__iaddr(left->mem_info)->addr;
28e6db20 1395 if (right->mem_info)
1a8c2e01 1396 r = mem_info__iaddr(right->mem_info)->addr;
28e6db20
DZ		 1397
1398 return (int64_t)(r - l);
1399}
1400
1401static int hist_entry__iaddr_snprintf(struct hist_entry *he, char *bf,
1402 size_t size, unsigned int width)
1403{
1404 uint64_t addr = 0;
d46a4cdf 1405 struct map_symbol *ms = NULL;
28e6db20
DZ		 1406
1407 if (he->mem_info) {
1a8c2e01
IR		 1408 addr = mem_info__iaddr(he->mem_info)->addr;
1409 ms = &mem_info__iaddr(he->mem_info)->ms;
28e6db20 1410 }
d46a4cdf 1411 return _hist_entry__sym_snprintf(ms, addr, he->level, bf, size, width);
28e6db20
DZ		 1412}
1413
98a3b32c
SE		 1414static int64_t
1415sort__dso_daddr_cmp(struct hist_entry *left, struct hist_entry *right)
1416{
1417 struct map *map_l = NULL;
1418 struct map *map_r = NULL;
1419
1420 if (left->mem_info)
1a8c2e01 1421 map_l = mem_info__daddr(left->mem_info)->ms.map;
98a3b32c 1422 if (right->mem_info)
1a8c2e01 1423 map_r = mem_info__daddr(right->mem_info)->ms.map;
98a3b32c
SE		 1424
1425 return _sort__dso_cmp(map_l, map_r);
1426}
1427
c824c433 1428static int hist_entry__dso_daddr_snprintf(struct hist_entry *he, char *bf,
98a3b32c
SE		 1429 size_t size, unsigned int width)
1430{
1431 struct map *map = NULL;
1432
c824c433 1433 if (he->mem_info)
1a8c2e01 1434 map = mem_info__daddr(he->mem_info)->ms.map;
98a3b32c
SE		 1435
1436 return _hist_entry__dso_snprintf(map, bf, size, width);
1437}
1438
1439static int64_t
1440sort__locked_cmp(struct hist_entry *left, struct hist_entry *right)
1441{
1442 union perf_mem_data_src data_src_l;
1443 union perf_mem_data_src data_src_r;
1444
1445 if (left->mem_info)
1a8c2e01 1446 data_src_l = *mem_info__data_src(left->mem_info);
98a3b32c
SE		 1447 else
1448 data_src_l.mem_lock = PERF_MEM_LOCK_NA;
1449
1450 if (right->mem_info)
1a8c2e01 1451 data_src_r = *mem_info__data_src(right->mem_info);
98a3b32c
SE		 1452 else
1453 data_src_r.mem_lock = PERF_MEM_LOCK_NA;
1454
1455 return (int64_t)(data_src_r.mem_lock - data_src_l.mem_lock);
1456}
1457
c824c433 1458static int hist_entry__locked_snprintf(struct hist_entry *he, char *bf,
98a3b32c
SE		 1459 size_t size, unsigned int width)
1460{
69a77275 1461 char out[10];
98a3b32c 1462
69a77275 1463 perf_mem__lck_scnprintf(out, sizeof(out), he->mem_info);
89fee709 1464 return repsep_snprintf(bf, size, "%.*s", width, out);
98a3b32c
SE		 1465}
1466
1467static int64_t
1468sort__tlb_cmp(struct hist_entry *left, struct hist_entry *right)
1469{
1470 union perf_mem_data_src data_src_l;
1471 union perf_mem_data_src data_src_r;
1472
1473 if (left->mem_info)
1a8c2e01 1474 data_src_l = *mem_info__data_src(left->mem_info);
98a3b32c
SE		 1475 else
1476 data_src_l.mem_dtlb = PERF_MEM_TLB_NA;
1477
1478 if (right->mem_info)
1a8c2e01 1479 data_src_r = *mem_info__data_src(right->mem_info);
98a3b32c
SE		 1480 else
1481 data_src_r.mem_dtlb = PERF_MEM_TLB_NA;
1482
1483 return (int64_t)(data_src_r.mem_dtlb - data_src_l.mem_dtlb);
1484}
1485
c824c433 1486static int hist_entry__tlb_snprintf(struct hist_entry *he, char *bf,
98a3b32c
SE		 1487 size_t size, unsigned int width)
1488{
1489 char out[64];
98a3b32c 1490
0c877d75 1491 perf_mem__tlb_scnprintf(out, sizeof(out), he->mem_info);
98a3b32c
SE		 1492 return repsep_snprintf(bf, size, "%-*s", width, out);
1493}
1494
1495static int64_t
1496sort__lvl_cmp(struct hist_entry *left, struct hist_entry *right)
1497{
1498 union perf_mem_data_src data_src_l;
1499 union perf_mem_data_src data_src_r;
1500
1501 if (left->mem_info)
1a8c2e01 1502 data_src_l = *mem_info__data_src(left->mem_info);
98a3b32c
SE		 1503 else
1504 data_src_l.mem_lvl = PERF_MEM_LVL_NA;
1505
1506 if (right->mem_info)
1a8c2e01 1507 data_src_r = *mem_info__data_src(right->mem_info);
98a3b32c
SE		 1508 else
1509 data_src_r.mem_lvl = PERF_MEM_LVL_NA;
1510
1511 return (int64_t)(data_src_r.mem_lvl - data_src_l.mem_lvl);
1512}
1513
c824c433 1514static int hist_entry__lvl_snprintf(struct hist_entry *he, char *bf,
98a3b32c
SE		 1515 size_t size, unsigned int width)
1516{
1517 char out[64];
98a3b32c 1518
071e9a1e 1519 perf_mem__lvl_scnprintf(out, sizeof(out), he->mem_info);
98a3b32c
SE		 1520 return repsep_snprintf(bf, size, "%-*s", width, out);
1521}
1522
1523static int64_t
1524sort__snoop_cmp(struct hist_entry *left, struct hist_entry *right)
1525{
1526 union perf_mem_data_src data_src_l;
1527 union perf_mem_data_src data_src_r;
1528
1529 if (left->mem_info)
1a8c2e01 1530 data_src_l = *mem_info__data_src(left->mem_info);
98a3b32c
SE		 1531 else
1532 data_src_l.mem_snoop = PERF_MEM_SNOOP_NA;
1533
1534 if (right->mem_info)
1a8c2e01 1535 data_src_r = *mem_info__data_src(right->mem_info);
98a3b32c
SE		 1536 else
1537 data_src_r.mem_snoop = PERF_MEM_SNOOP_NA;
1538
1539 return (int64_t)(data_src_r.mem_snoop - data_src_l.mem_snoop);
1540}
1541
c824c433 1542static int hist_entry__snoop_snprintf(struct hist_entry *he, char *bf,
98a3b32c
SE		 1543 size_t size, unsigned int width)
1544{
1545 char out[64];
98a3b32c 1546
2c07af13 1547 perf_mem__snp_scnprintf(out, sizeof(out), he->mem_info);
98a3b32c
SE		 1548 return repsep_snprintf(bf, size, "%-*s", width, out);
1549}
1550
5fe7b9b4 1551int64_t
9b32ba71
DZ		 1552sort__dcacheline_cmp(struct hist_entry *left, struct hist_entry *right)
1553{
1554 u64 l, r;
1555 struct map *l_map, *r_map;
63df0e4b 1556 struct dso *l_dso, *r_dso;
7b59a824 1557 int rc;
9b32ba71
DZ		 1558
1559 if (!left->mem_info) return -1;
1560 if (!right->mem_info) return 1;
1561
1562 /* group event types together */
1563 if (left->cpumode > right->cpumode) return -1;
1564 if (left->cpumode < right->cpumode) return 1;
1565
1a8c2e01
IR		 1566 l_map = mem_info__daddr(left->mem_info)->ms.map;
1567 r_map = mem_info__daddr(right->mem_info)->ms.map;
9b32ba71
DZ		 1568
1569 /* if both are NULL, jump to sort on al_addr instead */
1570 if (!l_map && !r_map)
1571 goto addr;
1572
1573 if (!l_map) return -1;
1574 if (!r_map) return 1;
1575
63df0e4b
IR		 1576 l_dso = map__dso(l_map);
1577 r_dso = map__dso(r_map);
1578 rc = dso__cmp_id(l_dso, r_dso);
7b59a824
ACM		 1579 if (rc)
1580 return rc;
9b32ba71
DZ		 1581 /*
1582 * Addresses with no major/minor numbers are assumed to be
1583 * anonymous in userspace. Sort those on pid then address.
1584 *
1585 * The kernel and non-zero major/minor mapped areas are
1586 * assumed to be unity mapped. Sort those on address.
1587 */
1588
1589 if ((left->cpumode != PERF_RECORD_MISC_KERNEL) &&
ee756ef7
IR		 1590 (!(map__flags(l_map) & MAP_SHARED)) && !dso__id(l_dso)->maj && !dso__id(l_dso)->min &&
1591 !dso__id(l_dso)->ino && !dso__id(l_dso)->ino_generation) {
9b32ba71
DZ		 1592 /* userspace anonymous */
1593
ee84a303
IR		 1594 if (thread__pid(left->thread) > thread__pid(right->thread))
1595 return -1;
1596 if (thread__pid(left->thread) < thread__pid(right->thread))
1597 return 1;
9b32ba71
DZ		 1598 }
1599
1600addr:
1601 /* al_addr does all the right addr - start + offset calculations */
1a8c2e01
IR		 1602 l = cl_address(mem_info__daddr(left->mem_info)->al_addr, chk_double_cl);
1603 r = cl_address(mem_info__daddr(right->mem_info)->al_addr, chk_double_cl);
9b32ba71
DZ		 1604
1605 if (l > r) return -1;
1606 if (l < r) return 1;
1607
1608 return 0;
1609}
1610
1611static int hist_entry__dcacheline_snprintf(struct hist_entry *he, char *bf,
1612 size_t size, unsigned int width)
1613{
1614
1615 uint64_t addr = 0;
d46a4cdf 1616 struct map_symbol *ms = NULL;
9b32ba71
DZ		 1617 char level = he->level;
1618
1619 if (he->mem_info) {
1a8c2e01 1620 struct map *map = mem_info__daddr(he->mem_info)->ms.map;
3ad1be6f 1621 struct dso *dso = map ? map__dso(map) : NULL;
d46a4cdf 1622
1a8c2e01
IR		 1623 addr = cl_address(mem_info__daddr(he->mem_info)->al_addr, chk_double_cl);
1624 ms = &mem_info__daddr(he->mem_info)->ms;
9b32ba71
DZ		 1625
1626 /* print [s] for shared data mmaps */
1627 if ((he->cpumode != PERF_RECORD_MISC_KERNEL) &&
ddee3f2b
IR		 1628 map && !(map__prot(map) & PROT_EXEC) &&
1629 (map__flags(map) & MAP_SHARED) &&
ee756ef7
IR		 1630 (dso__id(dso)->maj || dso__id(dso)->min || dso__id(dso)->ino ||
1631 dso__id(dso)->ino_generation))
9b32ba71
DZ		 1632 level = 's';
1633 else if (!map)
1634 level = 'X';
1635 }
d46a4cdf 1636 return _hist_entry__sym_snprintf(ms, addr, level, bf, size, width);
9b32ba71
DZ		 1637}
1638
b5387528
RAV		 1639struct sort_entry sort_mispredict = {
1640 .se_header = "Branch Mispredicted",
1641 .se_cmp = sort__mispredict_cmp,
1642 .se_snprintf = hist_entry__mispredict_snprintf,
1643 .se_width_idx = HISTC_MISPREDICT,
1644};
1645
05484298 1646static int64_t
784e8add 1647sort__weight_cmp(struct hist_entry *left, struct hist_entry *right)
05484298 1648{
784e8add 1649 return left->weight - right->weight;
05484298
AK		 1650}
1651
c824c433 1652static int hist_entry__local_weight_snprintf(struct hist_entry *he, char *bf,
05484298
AK		 1653 size_t size, unsigned int width)
1654{
784e8add 1655 return repsep_snprintf(bf, size, "%-*llu", width, he->weight);
05484298
AK		 1656}
1657
1658struct sort_entry sort_local_weight = {
1659 .se_header = "Local Weight",
784e8add 1660 .se_cmp = sort__weight_cmp,
05484298
AK		 1661 .se_snprintf = hist_entry__local_weight_snprintf,
1662 .se_width_idx = HISTC_LOCAL_WEIGHT,
1663};
1664
c824c433 1665static int hist_entry__global_weight_snprintf(struct hist_entry *he, char *bf,
05484298
AK		 1666 size_t size, unsigned int width)
1667{
784e8add
NK		 1668 return repsep_snprintf(bf, size, "%-*llu", width,
1669 he->weight * he->stat.nr_events);
05484298
AK		 1670}
1671
1672struct sort_entry sort_global_weight = {
1673 .se_header = "Weight",
784e8add 1674 .se_cmp = sort__weight_cmp,
05484298
AK		 1675 .se_snprintf = hist_entry__global_weight_snprintf,
1676 .se_width_idx = HISTC_GLOBAL_WEIGHT,
1677};
1678
590db42d 1679static int64_t
4d03c753 1680sort__ins_lat_cmp(struct hist_entry *left, struct hist_entry *right)
590db42d 1681{
4d03c753 1682 return left->ins_lat - right->ins_lat;
590db42d
KL		 1683}
1684
1685static int hist_entry__local_ins_lat_snprintf(struct hist_entry *he, char *bf,
1686 size_t size, unsigned int width)
1687{
4d03c753 1688 return repsep_snprintf(bf, size, "%-*u", width, he->ins_lat);
590db42d
KL		 1689}
1690
1691struct sort_entry sort_local_ins_lat = {
1692 .se_header = "Local INSTR Latency",
4d03c753 1693 .se_cmp = sort__ins_lat_cmp,
590db42d
KL		 1694 .se_snprintf = hist_entry__local_ins_lat_snprintf,
1695 .se_width_idx = HISTC_LOCAL_INS_LAT,
1696};
1697
590db42d
KL		 1698static int hist_entry__global_ins_lat_snprintf(struct hist_entry *he, char *bf,
1699 size_t size, unsigned int width)
1700{
4d03c753
NK		 1701 return repsep_snprintf(bf, size, "%-*u", width,
1702 he->ins_lat * he->stat.nr_events);
590db42d
KL		 1703}
1704
1705struct sort_entry sort_global_ins_lat = {
1706 .se_header = "INSTR Latency",
4d03c753 1707 .se_cmp = sort__ins_lat_cmp,
590db42d
KL		 1708 .se_snprintf = hist_entry__global_ins_lat_snprintf,
1709 .se_width_idx = HISTC_GLOBAL_INS_LAT,
1710};
1711
06e5ca74 1712static int64_t
e3304c21 1713sort__p_stage_cyc_cmp(struct hist_entry *left, struct hist_entry *right)
06e5ca74 1714{
db4b2840 1715 return left->p_stage_cyc - right->p_stage_cyc;
06e5ca74
AR		 1716}
1717
e3304c21
AR		 1718static int hist_entry__global_p_stage_cyc_snprintf(struct hist_entry *he, char *bf,
1719 size_t size, unsigned int width)
1720{
1721 return repsep_snprintf(bf, size, "%-*u", width,
1722 he->p_stage_cyc * he->stat.nr_events);
1723}
1724
1725
06e5ca74
AR		 1726static int hist_entry__p_stage_cyc_snprintf(struct hist_entry *he, char *bf,
1727 size_t size, unsigned int width)
1728{
db4b2840 1729 return repsep_snprintf(bf, size, "%-*u", width, he->p_stage_cyc);
06e5ca74
AR		 1730}
1731
e3304c21
AR		 1732struct sort_entry sort_local_p_stage_cyc = {
1733 .se_header = "Local Pipeline Stage Cycle",
1734 .se_cmp = sort__p_stage_cyc_cmp,
06e5ca74 1735 .se_snprintf = hist_entry__p_stage_cyc_snprintf,
e3304c21
AR		 1736 .se_width_idx = HISTC_LOCAL_P_STAGE_CYC,
1737};
1738
1739struct sort_entry sort_global_p_stage_cyc = {
1740 .se_header = "Pipeline Stage Cycle",
1741 .se_cmp = sort__p_stage_cyc_cmp,
1742 .se_snprintf = hist_entry__global_p_stage_cyc_snprintf,
1743 .se_width_idx = HISTC_GLOBAL_P_STAGE_CYC,
06e5ca74
AR		 1744};
1745
98a3b32c
SE		 1746struct sort_entry sort_mem_daddr_sym = {
1747 .se_header = "Data Symbol",
1748 .se_cmp = sort__daddr_cmp,
1749 .se_snprintf = hist_entry__daddr_snprintf,
1750 .se_width_idx = HISTC_MEM_DADDR_SYMBOL,
1751};
1752
28e6db20
DZ		 1753struct sort_entry sort_mem_iaddr_sym = {
1754 .se_header = "Code Symbol",
1755 .se_cmp = sort__iaddr_cmp,
1756 .se_snprintf = hist_entry__iaddr_snprintf,
1757 .se_width_idx = HISTC_MEM_IADDR_SYMBOL,
1758};
1759
98a3b32c
SE		 1760struct sort_entry sort_mem_daddr_dso = {
1761 .se_header = "Data Object",
1762 .se_cmp = sort__dso_daddr_cmp,
1763 .se_snprintf = hist_entry__dso_daddr_snprintf,
94c39988 1764 .se_width_idx = HISTC_MEM_DADDR_DSO,
98a3b32c
SE		 1765};
1766
1767struct sort_entry sort_mem_locked = {
1768 .se_header = "Locked",
1769 .se_cmp = sort__locked_cmp,
1770 .se_snprintf = hist_entry__locked_snprintf,
1771 .se_width_idx = HISTC_MEM_LOCKED,
1772};
1773
1774struct sort_entry sort_mem_tlb = {
1775 .se_header = "TLB access",
1776 .se_cmp = sort__tlb_cmp,
1777 .se_snprintf = hist_entry__tlb_snprintf,
1778 .se_width_idx = HISTC_MEM_TLB,
1779};
1780
1781struct sort_entry sort_mem_lvl = {
1782 .se_header = "Memory access",
1783 .se_cmp = sort__lvl_cmp,
1784 .se_snprintf = hist_entry__lvl_snprintf,
1785 .se_width_idx = HISTC_MEM_LVL,
1786};
1787
1788struct sort_entry sort_mem_snoop = {
1789 .se_header = "Snoop",
1790 .se_cmp = sort__snoop_cmp,
1791 .se_snprintf = hist_entry__snoop_snprintf,
1792 .se_width_idx = HISTC_MEM_SNOOP,
1793};
1794
9b32ba71
DZ		 1795struct sort_entry sort_mem_dcacheline = {
1796 .se_header = "Data Cacheline",
1797 .se_cmp = sort__dcacheline_cmp,
1798 .se_snprintf = hist_entry__dcacheline_snprintf,
1799 .se_width_idx = HISTC_MEM_DCACHELINE,
1800};
1801
a054c298
KL		 1802static int64_t
1803sort__blocked_cmp(struct hist_entry *left, struct hist_entry *right)
1804{
1805 union perf_mem_data_src data_src_l;
1806 union perf_mem_data_src data_src_r;
1807
1808 if (left->mem_info)
1a8c2e01 1809 data_src_l = *mem_info__data_src(left->mem_info);
a054c298
KL		 1810 else
1811 data_src_l.mem_blk = PERF_MEM_BLK_NA;
1812
1813 if (right->mem_info)
1a8c2e01 1814 data_src_r = *mem_info__data_src(right->mem_info);
a054c298
KL		 1815 else
1816 data_src_r.mem_blk = PERF_MEM_BLK_NA;
1817
1818 return (int64_t)(data_src_r.mem_blk - data_src_l.mem_blk);
1819}
1820
1821static int hist_entry__blocked_snprintf(struct hist_entry *he, char *bf,
1822 size_t size, unsigned int width)
1823{
1824 char out[16];
1825
1826 perf_mem__blk_scnprintf(out, sizeof(out), he->mem_info);
1827 return repsep_snprintf(bf, size, "%.*s", width, out);
1828}
1829
1830struct sort_entry sort_mem_blocked = {
1831 .se_header = "Blocked",
1832 .se_cmp = sort__blocked_cmp,
1833 .se_snprintf = hist_entry__blocked_snprintf,
1834 .se_width_idx = HISTC_MEM_BLOCKED,
1835};
1836
8780fb25
KL		 1837static int64_t
1838sort__phys_daddr_cmp(struct hist_entry *left, struct hist_entry *right)
1839{
1840 uint64_t l = 0, r = 0;
1841
1842 if (left->mem_info)
1a8c2e01 1843 l = mem_info__daddr(left->mem_info)->phys_addr;
8780fb25 1844 if (right->mem_info)
1a8c2e01 1845 r = mem_info__daddr(right->mem_info)->phys_addr;
8780fb25
KL		 1846
1847 return (int64_t)(r - l);
1848}
1849
1850static int hist_entry__phys_daddr_snprintf(struct hist_entry *he, char *bf,
1851 size_t size, unsigned int width)
1852{
1853 uint64_t addr = 0;
1854 size_t ret = 0;
1855 size_t len = BITS_PER_LONG / 4;
1856
1a8c2e01 1857 addr = mem_info__daddr(he->mem_info)->phys_addr;
8780fb25
KL		 1858
1859 ret += repsep_snprintf(bf + ret, size - ret, "[%c] ", he->level);
1860
1861 ret += repsep_snprintf(bf + ret, size - ret, "%-#.*llx", len, addr);
1862
1863 ret += repsep_snprintf(bf + ret, size - ret, "%-*s", width - ret, "");
1864
1865 if (ret > width)
1866 bf[width] = '\0';
1867
1868 return width;
1869}
1870
1871struct sort_entry sort_mem_phys_daddr = {
1872 .se_header = "Data Physical Address",
1873 .se_cmp = sort__phys_daddr_cmp,
1874 .se_snprintf = hist_entry__phys_daddr_snprintf,
1875 .se_width_idx = HISTC_MEM_PHYS_DADDR,
1876};
1877
a50d03e3
KL		 1878static int64_t
1879sort__data_page_size_cmp(struct hist_entry *left, struct hist_entry *right)
1880{
1881 uint64_t l = 0, r = 0;
1882
1883 if (left->mem_info)
1a8c2e01 1884 l = mem_info__daddr(left->mem_info)->data_page_size;
a50d03e3 1885 if (right->mem_info)
1a8c2e01 1886 r = mem_info__daddr(right->mem_info)->data_page_size;
a50d03e3
KL		 1887
1888 return (int64_t)(r - l);
1889}
1890
1891static int hist_entry__data_page_size_snprintf(struct hist_entry *he, char *bf,
1892 size_t size, unsigned int width)
1893{
1894 char str[PAGE_SIZE_NAME_LEN];
1895
1896 return repsep_snprintf(bf, size, "%-*s", width,
1a8c2e01 1897 get_page_size_name(mem_info__daddr(he->mem_info)->data_page_size, str));
a50d03e3
KL		 1898}
1899
1900struct sort_entry sort_mem_data_page_size = {
1901 .se_header = "Data Page Size",
1902 .se_cmp = sort__data_page_size_cmp,
1903 .se_snprintf = hist_entry__data_page_size_snprintf,
1904 .se_width_idx = HISTC_MEM_DATA_PAGE_SIZE,
1905};
1906
9fd74f20
SE		 1907static int64_t
1908sort__code_page_size_cmp(struct hist_entry *left, struct hist_entry *right)
1909{
1910 uint64_t l = left->code_page_size;
1911 uint64_t r = right->code_page_size;
1912
1913 return (int64_t)(r - l);
1914}
1915
1916static int hist_entry__code_page_size_snprintf(struct hist_entry *he, char *bf,
1917 size_t size, unsigned int width)
1918{
1919 char str[PAGE_SIZE_NAME_LEN];
1920
1921 return repsep_snprintf(bf, size, "%-*s", width,
1922 get_page_size_name(he->code_page_size, str));
1923}
1924
1925struct sort_entry sort_code_page_size = {
1926 .se_header = "Code Page Size",
1927 .se_cmp = sort__code_page_size_cmp,
1928 .se_snprintf = hist_entry__code_page_size_snprintf,
1929 .se_width_idx = HISTC_CODE_PAGE_SIZE,
1930};
1931
f5d05bce
AK		 1932static int64_t
1933sort__abort_cmp(struct hist_entry *left, struct hist_entry *right)
1934{
49f47443
JO		 1935 if (!left->branch_info || !right->branch_info)
1936 return cmp_null(left->branch_info, right->branch_info);
1937
f5d05bce
AK		 1938 return left->branch_info->flags.abort !=
1939 right->branch_info->flags.abort;
1940}
1941
c824c433 1942static int hist_entry__abort_snprintf(struct hist_entry *he, char *bf,
f5d05bce
AK		 1943 size_t size, unsigned int width)
1944{
49f47443
JO		 1945 static const char *out = "N/A";
1946
1947 if (he->branch_info) {
1948 if (he->branch_info->flags.abort)
1949 out = "A";
1950 else
1951 out = ".";
1952 }
f5d05bce 1953
f5d05bce
AK		 1954 return repsep_snprintf(bf, size, "%-*s", width, out);
1955}
1956
1957struct sort_entry sort_abort = {
1958 .se_header = "Transaction abort",
1959 .se_cmp = sort__abort_cmp,
1960 .se_snprintf = hist_entry__abort_snprintf,
1961 .se_width_idx = HISTC_ABORT,
1962};
1963
1964static int64_t
1965sort__in_tx_cmp(struct hist_entry *left, struct hist_entry *right)
1966{
0199d244
JO		 1967 if (!left->branch_info || !right->branch_info)
1968 return cmp_null(left->branch_info, right->branch_info);
1969
f5d05bce
AK		 1970 return left->branch_info->flags.in_tx !=
1971 right->branch_info->flags.in_tx;
1972}
1973
c824c433 1974static int hist_entry__in_tx_snprintf(struct hist_entry *he, char *bf,
f5d05bce
AK		 1975 size_t size, unsigned int width)
1976{
0199d244 1977 static const char *out = "N/A";
f5d05bce 1978
0199d244
JO		 1979 if (he->branch_info) {
1980 if (he->branch_info->flags.in_tx)
1981 out = "T";
1982 else
1983 out = ".";
1984 }
f5d05bce
AK		 1985
1986 return repsep_snprintf(bf, size, "%-*s", width, out);
1987}
1988
1989struct sort_entry sort_in_tx = {
1990 .se_header = "Branch in transaction",
1991 .se_cmp = sort__in_tx_cmp,
1992 .se_snprintf = hist_entry__in_tx_snprintf,
1993 .se_width_idx = HISTC_IN_TX,
1994};
1995
475eeab9
AK		 1996static int64_t
1997sort__transaction_cmp(struct hist_entry *left, struct hist_entry *right)
1998{
1999 return left->transaction - right->transaction;
2000}
2001
2002static inline char *add_str(char *p, const char *str)
2003{
2004 strcpy(p, str);
2005 return p + strlen(str);
2006}
2007
2008static struct txbit {
2009 unsigned flag;
2010 const char *name;
2011 int skip_for_len;
2012} txbits[] = {
2013 { PERF_TXN_ELISION, "EL ", 0 },
2014 { PERF_TXN_TRANSACTION, "TX ", 1 },
2015 { PERF_TXN_SYNC, "SYNC ", 1 },
2016 { PERF_TXN_ASYNC, "ASYNC ", 0 },
2017 { PERF_TXN_RETRY, "RETRY ", 0 },
2018 { PERF_TXN_CONFLICT, "CON ", 0 },
2019 { PERF_TXN_CAPACITY_WRITE, "CAP-WRITE ", 1 },
2020 { PERF_TXN_CAPACITY_READ, "CAP-READ ", 0 },
2021 { 0, NULL, 0 }
2022};
2023
2024int hist_entry__transaction_len(void)
2025{
2026 int i;
2027 int len = 0;
2028
2029 for (i = 0; txbits[i].name; i++) {
2030 if (!txbits[i].skip_for_len)
2031 len += strlen(txbits[i].name);
2032 }
2033 len += 4; /* :XX<space> */
2034 return len;
2035}
2036
c824c433 2037static int hist_entry__transaction_snprintf(struct hist_entry *he, char *bf,
475eeab9
AK		 2038 size_t size, unsigned int width)
2039{
c824c433 2040 u64 t = he->transaction;
475eeab9
AK		 2041 char buf[128];
2042 char *p = buf;
2043 int i;
2044
2045 buf[0] = 0;
2046 for (i = 0; txbits[i].name; i++)
2047 if (txbits[i].flag & t)
2048 p = add_str(p, txbits[i].name);
2049 if (t && !(t & (PERF_TXN_SYNC|PERF_TXN_ASYNC)))
2050 p = add_str(p, "NEITHER ");
2051 if (t & PERF_TXN_ABORT_MASK) {
2052 sprintf(p, ":%" PRIx64,
2053 (t & PERF_TXN_ABORT_MASK) >>
2054 PERF_TXN_ABORT_SHIFT);
2055 p += strlen(p);
2056 }
2057
2058 return repsep_snprintf(bf, size, "%-*s", width, buf);
2059}
2060
2061struct sort_entry sort_transaction = {
2062 .se_header = "Transaction ",
2063 .se_cmp = sort__transaction_cmp,
2064 .se_snprintf = hist_entry__transaction_snprintf,
2065 .se_width_idx = HISTC_TRANSACTION,
2066};
2067
7768f8da
CB		 2068/* --sort symbol_size */
2069
2070static int64_t _sort__sym_size_cmp(struct symbol *sym_l, struct symbol *sym_r)
2071{
2072 int64_t size_l = sym_l != NULL ? symbol__size(sym_l) : 0;
2073 int64_t size_r = sym_r != NULL ? symbol__size(sym_r) : 0;
2074
2075 return size_l < size_r ? -1 :
2076 size_l == size_r ? 0 : 1;
2077}
2078
2079static int64_t
2080sort__sym_size_cmp(struct hist_entry *left, struct hist_entry *right)
2081{
2082 return _sort__sym_size_cmp(right->ms.sym, left->ms.sym);
2083}
2084
2085static int _hist_entry__sym_size_snprintf(struct symbol *sym, char *bf,
2086 size_t bf_size, unsigned int width)
2087{
2088 if (sym)
2089 return repsep_snprintf(bf, bf_size, "%*d", width, symbol__size(sym));
2090
2091 return repsep_snprintf(bf, bf_size, "%*s", width, "unknown");
2092}
2093
2094static int hist_entry__sym_size_snprintf(struct hist_entry *he, char *bf,
2095 size_t size, unsigned int width)
2096{
2097 return _hist_entry__sym_size_snprintf(he->ms.sym, bf, size, width);
2098}
2099
2100struct sort_entry sort_sym_size = {
2101 .se_header = "Symbol size",
2102 .se_cmp = sort__sym_size_cmp,
2103 .se_snprintf = hist_entry__sym_size_snprintf,
2104 .se_width_idx = HISTC_SYM_SIZE,
2105};
2106
b74d12d5
KP		 2107/* --sort dso_size */
2108
2109static int64_t _sort__dso_size_cmp(struct map *map_l, struct map *map_r)
2110{
2111 int64_t size_l = map_l != NULL ? map__size(map_l) : 0;
2112 int64_t size_r = map_r != NULL ? map__size(map_r) : 0;
2113
2114 return size_l < size_r ? -1 :
2115 size_l == size_r ? 0 : 1;
2116}
2117
2118static int64_t
2119sort__dso_size_cmp(struct hist_entry *left, struct hist_entry *right)
2120{
2121 return _sort__dso_size_cmp(right->ms.map, left->ms.map);
2122}
2123
2124static int _hist_entry__dso_size_snprintf(struct map *map, char *bf,
2125 size_t bf_size, unsigned int width)
2126{
63df0e4b
IR		 2127 if (map && map__dso(map))
2128 return repsep_snprintf(bf, bf_size, "%*d", width, map__size(map));
b74d12d5
KP		 2129
2130 return repsep_snprintf(bf, bf_size, "%*s", width, "unknown");
2131}
2132
2133static int hist_entry__dso_size_snprintf(struct hist_entry *he, char *bf,
2134 size_t size, unsigned int width)
2135{
2136 return _hist_entry__dso_size_snprintf(he->ms.map, bf, size, width);
2137}
2138
2139struct sort_entry sort_dso_size = {
2140 .se_header = "DSO size",
2141 .se_cmp = sort__dso_size_cmp,
2142 .se_snprintf = hist_entry__dso_size_snprintf,
2143 .se_width_idx = HISTC_DSO_SIZE,
2144};
2145
2f2c41bd 2146/* --sort addr */
762461f1
NK		 2147
2148static int64_t
2149sort__addr_cmp(struct hist_entry *left, struct hist_entry *right)
2150{
2151 u64 left_ip = left->ip;
2152 u64 right_ip = right->ip;
2153 struct map *left_map = left->ms.map;
2154 struct map *right_map = right->ms.map;
2155
2156 if (left_map)
78a1f7cd 2157 left_ip = map__unmap_ip(left_map, left_ip);
762461f1 2158 if (right_map)
78a1f7cd 2159 right_ip = map__unmap_ip(right_map, right_ip);
762461f1
NK		 2160
2161 return _sort__addr_cmp(left_ip, right_ip);
2162}
2163
2164static int hist_entry__addr_snprintf(struct hist_entry *he, char *bf,
2165 size_t size, unsigned int width)
2166{
2167 u64 ip = he->ip;
2168 struct map *map = he->ms.map;
2169
2170 if (map)
78a1f7cd 2171 ip = map__unmap_ip(map, ip);
762461f1
NK		 2172
2173 return repsep_snprintf(bf, size, "%-#*llx", width, ip);
2174}
2175
2176struct sort_entry sort_addr = {
2177 .se_header = "Address",
2178 .se_cmp = sort__addr_cmp,
2179 .se_snprintf = hist_entry__addr_snprintf,
2180 .se_width_idx = HISTC_ADDR,
2181};
2182
2f2c41bd
NK		 2183/* --sort type */
2184
2185struct annotated_data_type unknown_type = {
4a111cad
NK		 2186 .self = {
2187 .type_name = (char *)"(unknown)",
2188 .children = LIST_HEAD_INIT(unknown_type.self.children),
2189 },
2f2c41bd
NK		 2190};
2191
2192static int64_t
2193sort__type_cmp(struct hist_entry *left, struct hist_entry *right)
2194{
2195 return sort__addr_cmp(left, right);
2196}
2197
2198static void sort__type_init(struct hist_entry *he)
2199{
2200 if (he->mem_type)
2201 return;
2202
2203 he->mem_type = hist_entry__get_data_type(he);
871304a7 2204 if (he->mem_type == NULL) {
2f2c41bd 2205 he->mem_type = &unknown_type;
871304a7
NK		 2206 he->mem_type_off = 0;
2207 }
2f2c41bd
NK		 2208}
2209
2210static int64_t
2211sort__type_collapse(struct hist_entry *left, struct hist_entry *right)
2212{
2213 struct annotated_data_type *left_type = left->mem_type;
2214 struct annotated_data_type *right_type = right->mem_type;
2215
2216 if (!left_type) {
2217 sort__type_init(left);
2218 left_type = left->mem_type;
2219 }
2220
2221 if (!right_type) {
2222 sort__type_init(right);
2223 right_type = right->mem_type;
2224 }
2225
4a111cad 2226 return strcmp(left_type->self.type_name, right_type->self.type_name);
2f2c41bd
NK		 2227}
2228
2229static int64_t
2230sort__type_sort(struct hist_entry *left, struct hist_entry *right)
2231{
2232 return sort__type_collapse(left, right);
2233}
2234
2235static int hist_entry__type_snprintf(struct hist_entry *he, char *bf,
2236 size_t size, unsigned int width)
2237{
4a111cad 2238 return repsep_snprintf(bf, size, "%-*s", width, he->mem_type->self.type_name);
2f2c41bd
NK		 2239}
2240
2241struct sort_entry sort_type = {
2242 .se_header = "Data Type",
2243 .se_cmp = sort__type_cmp,
2244 .se_collapse = sort__type_collapse,
2245 .se_sort = sort__type_sort,
2246 .se_init = sort__type_init,
2247 .se_snprintf = hist_entry__type_snprintf,
2248 .se_width_idx = HISTC_TYPE,
2249};
2250
871304a7
NK		 2251/* --sort typeoff */
2252
2253static int64_t
2254sort__typeoff_sort(struct hist_entry *left, struct hist_entry *right)
2255{
2256 struct annotated_data_type *left_type = left->mem_type;
2257 struct annotated_data_type *right_type = right->mem_type;
2258 int64_t ret;
2259
2260 if (!left_type) {
2261 sort__type_init(left);
2262 left_type = left->mem_type;
2263 }
2264
2265 if (!right_type) {
2266 sort__type_init(right);
2267 right_type = right->mem_type;
2268 }
2269
2270 ret = strcmp(left_type->self.type_name, right_type->self.type_name);
2271 if (ret)
2272 return ret;
2273 return left->mem_type_off - right->mem_type_off;
2274}
2275
2276static void fill_member_name(char *buf, size_t sz, struct annotated_member *m,
2277 int offset, bool first)
2278{
2279 struct annotated_member *child;
2280
2281 if (list_empty(&m->children))
2282 return;
2283
2284 list_for_each_entry(child, &m->children, node) {
2285 if (child->offset <= offset && offset < child->offset + child->size) {
2286 int len = 0;
2287
2288 /* It can have anonymous struct/union members */
2289 if (child->var_name) {
2290 len = scnprintf(buf, sz, "%s%s",
2291 first ? "" : ".", child->var_name);
2292 first = false;
2293 }
2294
2295 fill_member_name(buf + len, sz - len, child, offset, first);
2296 return;
2297 }
2298 }
2299}
2300
2301static int hist_entry__typeoff_snprintf(struct hist_entry *he, char *bf,
2302 size_t size, unsigned int width __maybe_unused)
2303{
2304 struct annotated_data_type *he_type = he->mem_type;
2305 char buf[4096];
2306
2307 buf[0] = '\0';
2308 if (list_empty(&he_type->self.children))
2309 snprintf(buf, sizeof(buf), "no field");
2310 else
2311 fill_member_name(buf, sizeof(buf), &he_type->self,
2312 he->mem_type_off, true);
2313 buf[4095] = '\0';
2314
7a5c2170 2315 return repsep_snprintf(bf, size, "%s +%#x (%s)", he_type->self.type_name,
871304a7
NK		 2316 he->mem_type_off, buf);
2317}
2318
2319struct sort_entry sort_type_offset = {
2320 .se_header = "Data Type Offset",
2321 .se_cmp = sort__type_cmp,
2322 .se_collapse = sort__typeoff_sort,
2323 .se_sort = sort__typeoff_sort,
2324 .se_init = sort__type_init,
2325 .se_snprintf = hist_entry__typeoff_snprintf,
2326 .se_width_idx = HISTC_TYPE_OFFSET,
2327};
2328
fd45d52e
NK		 2329/* --sort typecln */
2330
2331/* TODO: use actual value in the system */
2332#define TYPE_CACHELINE_SIZE 64
2333
2334static int64_t
2335sort__typecln_sort(struct hist_entry *left, struct hist_entry *right)
2336{
2337 struct annotated_data_type *left_type = left->mem_type;
2338 struct annotated_data_type *right_type = right->mem_type;
2339 int64_t left_cln, right_cln;
2340 int64_t ret;
2341
2342 if (!left_type) {
2343 sort__type_init(left);
2344 left_type = left->mem_type;
2345 }
2346
2347 if (!right_type) {
2348 sort__type_init(right);
2349 right_type = right->mem_type;
2350 }
2351
2352 ret = strcmp(left_type->self.type_name, right_type->self.type_name);
2353 if (ret)
2354 return ret;
2355
2356 left_cln = left->mem_type_off / TYPE_CACHELINE_SIZE;
2357 right_cln = right->mem_type_off / TYPE_CACHELINE_SIZE;
2358 return left_cln - right_cln;
2359}
2360
2361static int hist_entry__typecln_snprintf(struct hist_entry *he, char *bf,
2362 size_t size, unsigned int width __maybe_unused)
2363{
2364 struct annotated_data_type *he_type = he->mem_type;
2365
2366 return repsep_snprintf(bf, size, "%s: cache-line %d", he_type->self.type_name,
2367 he->mem_type_off / TYPE_CACHELINE_SIZE);
2368}
2369
2370struct sort_entry sort_type_cacheline = {
2371 .se_header = "Data Type Cacheline",
2372 .se_cmp = sort__type_cmp,
2373 .se_collapse = sort__typecln_sort,
2374 .se_sort = sort__typecln_sort,
2375 .se_init = sort__type_init,
2376 .se_snprintf = hist_entry__typecln_snprintf,
2377 .se_width_idx = HISTC_TYPE_CACHELINE,
2378};
2379
7768f8da 2380
872a878f
FW		 2381struct sort_dimension {
2382 const char *name;
2383 struct sort_entry *entry;
2384 int taken;
2385};
2386
50fa3a53
AR		 2387int __weak arch_support_sort_key(const char *sort_key __maybe_unused)
2388{
2389 return 0;
2390}
2391
0a606822
AR		 2392const char * __weak arch_perf_header_entry(const char *se_header)
2393{
2394 return se_header;
2395}
2396
2397static void sort_dimension_add_dynamic_header(struct sort_dimension *sd)
2398{
2399 sd->entry->se_header = arch_perf_header_entry(sd->entry->se_header);
2400}
2401
b5387528
RAV		 2402#define DIM(d, n, func) [d] = { .name = n, .entry = &(func) }
2403
fc5871ed 2404static struct sort_dimension common_sort_dimensions[] = {
b5387528
RAV		 2405 DIM(SORT_PID, "pid", sort_thread),
2406 DIM(SORT_COMM, "comm", sort_comm),
2407 DIM(SORT_DSO, "dso", sort_dso),
b5387528 2408 DIM(SORT_SYM, "symbol", sort_sym),
b5387528
RAV		 2409 DIM(SORT_PARENT, "parent", sort_parent),
2410 DIM(SORT_CPU, "cpu", sort_cpu),
2e7ea3ab 2411 DIM(SORT_SOCKET, "socket", sort_socket),
409a8be6 2412 DIM(SORT_SRCLINE, "srcline", sort_srcline),
31191a85 2413 DIM(SORT_SRCFILE, "srcfile", sort_srcfile),
f9ea55d0
AK		 2414 DIM(SORT_LOCAL_WEIGHT, "local_weight", sort_local_weight),
2415 DIM(SORT_GLOBAL_WEIGHT, "weight", sort_global_weight),
475eeab9 2416 DIM(SORT_TRANSACTION, "transaction", sort_transaction),
378ef0f5 2417#ifdef HAVE_LIBTRACEEVENT
a34bb6a0 2418 DIM(SORT_TRACE, "trace", sort_trace),
378ef0f5 2419#endif
7768f8da 2420 DIM(SORT_SYM_SIZE, "symbol_size", sort_sym_size),
b74d12d5 2421 DIM(SORT_DSO_SIZE, "dso_size", sort_dso_size),
b629f3e9 2422 DIM(SORT_CGROUP, "cgroup", sort_cgroup),
d890a98c 2423 DIM(SORT_CGROUP_ID, "cgroup_id", sort_cgroup_id),
ec6ae74f 2424 DIM(SORT_SYM_IPC_NULL, "ipc_null", sort_sym_ipc_null),
3723908d 2425 DIM(SORT_TIME, "time", sort_time),
9fd74f20 2426 DIM(SORT_CODE_PAGE_SIZE, "code_page_size", sort_code_page_size),
590db42d
KL		 2427 DIM(SORT_LOCAL_INS_LAT, "local_ins_lat", sort_local_ins_lat),
2428 DIM(SORT_GLOBAL_INS_LAT, "ins_lat", sort_global_ins_lat),
e3304c21
AR		 2429 DIM(SORT_LOCAL_PIPELINE_STAGE_CYC, "local_p_stage_cyc", sort_local_p_stage_cyc),
2430 DIM(SORT_GLOBAL_PIPELINE_STAGE_CYC, "p_stage_cyc", sort_global_p_stage_cyc),
762461f1 2431 DIM(SORT_ADDR, "addr", sort_addr),
d7d213e0
KL		 2432 DIM(SORT_LOCAL_RETIRE_LAT, "local_retire_lat", sort_local_p_stage_cyc),
2433 DIM(SORT_GLOBAL_RETIRE_LAT, "retire_lat", sort_global_p_stage_cyc),
2f2c41bd
NK		 2434 DIM(SORT_SIMD, "simd", sort_simd),
2435 DIM(SORT_ANNOTATE_DATA_TYPE, "type", sort_type),
871304a7 2436 DIM(SORT_ANNOTATE_DATA_TYPE_OFFSET, "typeoff", sort_type_offset),
e2c1c8ff 2437 DIM(SORT_SYM_OFFSET, "symoff", sort_sym_offset),
fd45d52e 2438 DIM(SORT_ANNOTATE_DATA_TYPE_CACHELINE, "typecln", sort_type_cacheline),
872a878f
FW		 2439};
2440
fc5871ed
NK		 2441#undef DIM
2442
2443#define DIM(d, n, func) [d - __SORT_BRANCH_STACK] = { .name = n, .entry = &(func) }
2444
2445static struct sort_dimension bstack_sort_dimensions[] = {
2446 DIM(SORT_DSO_FROM, "dso_from", sort_dso_from),
2447 DIM(SORT_DSO_TO, "dso_to", sort_dso_to),
2448 DIM(SORT_SYM_FROM, "symbol_from", sort_sym_from),
2449 DIM(SORT_SYM_TO, "symbol_to", sort_sym_to),
2450 DIM(SORT_MISPREDICT, "mispredict", sort_mispredict),
f5d05bce
AK		 2451 DIM(SORT_IN_TX, "in_tx", sort_in_tx),
2452 DIM(SORT_ABORT, "abort", sort_abort),
0e332f03 2453 DIM(SORT_CYCLES, "cycles", sort_cycles),
508be0df
AK		 2454 DIM(SORT_SRCLINE_FROM, "srcline_from", sort_srcline_from),
2455 DIM(SORT_SRCLINE_TO, "srcline_to", sort_srcline_to),
ec6ae74f 2456 DIM(SORT_SYM_IPC, "ipc_lbr", sort_sym_ipc),
05274770
SE		 2457 DIM(SORT_ADDR_FROM, "addr_from", sort_addr_from),
2458 DIM(SORT_ADDR_TO, "addr_to", sort_addr_to),
fc5871ed
NK		 2459};
2460
2461#undef DIM
2462
afab87b9
NK		 2463#define DIM(d, n, func) [d - __SORT_MEMORY_MODE] = { .name = n, .entry = &(func) }
2464
2465static struct sort_dimension memory_sort_dimensions[] = {
afab87b9 2466 DIM(SORT_MEM_DADDR_SYMBOL, "symbol_daddr", sort_mem_daddr_sym),
28e6db20 2467 DIM(SORT_MEM_IADDR_SYMBOL, "symbol_iaddr", sort_mem_iaddr_sym),
afab87b9
NK		 2468 DIM(SORT_MEM_DADDR_DSO, "dso_daddr", sort_mem_daddr_dso),
2469 DIM(SORT_MEM_LOCKED, "locked", sort_mem_locked),
2470 DIM(SORT_MEM_TLB, "tlb", sort_mem_tlb),
2471 DIM(SORT_MEM_LVL, "mem", sort_mem_lvl),
2472 DIM(SORT_MEM_SNOOP, "snoop", sort_mem_snoop),
9b32ba71 2473 DIM(SORT_MEM_DCACHELINE, "dcacheline", sort_mem_dcacheline),
8780fb25 2474 DIM(SORT_MEM_PHYS_DADDR, "phys_daddr", sort_mem_phys_daddr),
a50d03e3 2475 DIM(SORT_MEM_DATA_PAGE_SIZE, "data_page_size", sort_mem_data_page_size),
a054c298 2476 DIM(SORT_MEM_BLOCKED, "blocked", sort_mem_blocked),
afab87b9
NK		 2477};
2478
2479#undef DIM
2480
a2ce067e
NK		 2481struct hpp_dimension {
2482 const char *name;
2483 struct perf_hpp_fmt *fmt;
2484 int taken;
2485};
2486
2487#define DIM(d, n) { .name = n, .fmt = &perf_hpp__format[d], }
2488
2489static struct hpp_dimension hpp_sort_dimensions[] = {
2490 DIM(PERF_HPP__OVERHEAD, "overhead"),
2491 DIM(PERF_HPP__OVERHEAD_SYS, "overhead_sys"),
2492 DIM(PERF_HPP__OVERHEAD_US, "overhead_us"),
2493 DIM(PERF_HPP__OVERHEAD_GUEST_SYS, "overhead_guest_sys"),
2494 DIM(PERF_HPP__OVERHEAD_GUEST_US, "overhead_guest_us"),
594dcbf3 2495 DIM(PERF_HPP__OVERHEAD_ACC, "overhead_children"),
a2ce067e
NK		 2496 DIM(PERF_HPP__SAMPLES, "sample"),
2497 DIM(PERF_HPP__PERIOD, "period"),
7043dc52
NK		 2498 DIM(PERF_HPP__WEIGHT1, "weight1"),
2499 DIM(PERF_HPP__WEIGHT2, "weight2"),
2500 DIM(PERF_HPP__WEIGHT3, "weight3"),
2501 /* aliases for weight_struct */
2502 DIM(PERF_HPP__WEIGHT2, "ins_lat"),
2503 DIM(PERF_HPP__WEIGHT3, "retire_lat"),
2504 DIM(PERF_HPP__WEIGHT3, "p_stage_cyc"),
a2ce067e
NK		 2505};
2506
2507#undef DIM
2508
8b536999
NK		 2509struct hpp_sort_entry {
2510 struct perf_hpp_fmt hpp;
2511 struct sort_entry *se;
2512};
2513
e0d66c74 2514void perf_hpp__reset_sort_width(struct perf_hpp_fmt *fmt, struct hists *hists)
678a500d
NK		 2515{
2516 struct hpp_sort_entry *hse;
2517
2518 if (!perf_hpp__is_sort_entry(fmt))
2519 return;
2520
2521 hse = container_of(fmt, struct hpp_sort_entry, hpp);
1ecd4453 2522 hists__new_col_len(hists, hse->se->se_width_idx, strlen(fmt->name));
678a500d
NK		 2523}
2524
8b536999 2525static int __sort__hpp_header(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
29659ab4
JO		 2526 struct hists *hists, int line __maybe_unused,
2527 int *span __maybe_unused)
8b536999
NK		 2528{
2529 struct hpp_sort_entry *hse;
5b591669 2530 size_t len = fmt->user_len;
8b536999
NK		 2531
2532 hse = container_of(fmt, struct hpp_sort_entry, hpp);
8b536999 2533
5b591669 2534 if (!len)
05372173 2535 len = hists__col_len(hists, hse->se->se_width_idx);
5b591669 2536
1ecd4453 2537 return scnprintf(hpp->buf, hpp->size, "%-*.*s", len, len, fmt->name);
8b536999
NK		 2538}
2539
2540static int __sort__hpp_width(struct perf_hpp_fmt *fmt,
2541 struct perf_hpp *hpp __maybe_unused,
da1b0407 2542 struct hists *hists)
8b536999
NK		 2543{
2544 struct hpp_sort_entry *hse;
5b591669 2545 size_t len = fmt->user_len;
8b536999
NK		 2546
2547 hse = container_of(fmt, struct hpp_sort_entry, hpp);
2548
5b591669 2549 if (!len)
da1b0407 2550 len = hists__col_len(hists, hse->se->se_width_idx);
5b591669
NK		 2551
2552 return len;
8b536999
NK		 2553}
2554
2555static int __sort__hpp_entry(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
2556 struct hist_entry *he)
2557{
2558 struct hpp_sort_entry *hse;
5b591669 2559 size_t len = fmt->user_len;
8b536999
NK		 2560
2561 hse = container_of(fmt, struct hpp_sort_entry, hpp);
5b591669
NK		 2562
2563 if (!len)
2564 len = hists__col_len(he->hists, hse->se->se_width_idx);
8b536999
NK		 2565
2566 return hse->se->se_snprintf(he, hpp->buf, hpp->size, len);
2567}
2568
87bbdf76
NK		 2569static int64_t __sort__hpp_cmp(struct perf_hpp_fmt *fmt,
2570 struct hist_entry *a, struct hist_entry *b)
2571{
2572 struct hpp_sort_entry *hse;
2573
2574 hse = container_of(fmt, struct hpp_sort_entry, hpp);
2575 return hse->se->se_cmp(a, b);
2576}
2577
2578static int64_t __sort__hpp_collapse(struct perf_hpp_fmt *fmt,
2579 struct hist_entry *a, struct hist_entry *b)
2580{
2581 struct hpp_sort_entry *hse;
2582 int64_t (*collapse_fn)(struct hist_entry *, struct hist_entry *);
2583
2584 hse = container_of(fmt, struct hpp_sort_entry, hpp);
2585 collapse_fn = hse->se->se_collapse ?: hse->se->se_cmp;
2586 return collapse_fn(a, b);
2587}
2588
2589static int64_t __sort__hpp_sort(struct perf_hpp_fmt *fmt,
2590 struct hist_entry *a, struct hist_entry *b)
2591{
2592 struct hpp_sort_entry *hse;
2593 int64_t (*sort_fn)(struct hist_entry *, struct hist_entry *);
2594
2595 hse = container_of(fmt, struct hpp_sort_entry, hpp);
2596 sort_fn = hse->se->se_sort ?: hse->se->se_cmp;
2597 return sort_fn(a, b);
2598}
2599
97358084
JO		 2600bool perf_hpp__is_sort_entry(struct perf_hpp_fmt *format)
2601{
2602 return format->header == __sort__hpp_header;
2603}
2604
4945cf2a
NK		 2605#define MK_SORT_ENTRY_CHK(key) \
2606bool perf_hpp__is_ ## key ## _entry(struct perf_hpp_fmt *fmt) \
2607{ \
2608 struct hpp_sort_entry *hse; \
2609 \
2610 if (!perf_hpp__is_sort_entry(fmt)) \
2611 return false; \
2612 \
2613 hse = container_of(fmt, struct hpp_sort_entry, hpp); \
2614 return hse->se == &sort_ ## key ; \
2615}
2616
378ef0f5 2617#ifdef HAVE_LIBTRACEEVENT
4945cf2a 2618MK_SORT_ENTRY_CHK(trace)
378ef0f5
IR		 2619#else
2620bool perf_hpp__is_trace_entry(struct perf_hpp_fmt *fmt __maybe_unused)
2621{
2622 return false;
2623}
2624#endif
4945cf2a
NK		 2625MK_SORT_ENTRY_CHK(srcline)
2626MK_SORT_ENTRY_CHK(srcfile)
2627MK_SORT_ENTRY_CHK(thread)
2628MK_SORT_ENTRY_CHK(comm)
2629MK_SORT_ENTRY_CHK(dso)
2630MK_SORT_ENTRY_CHK(sym)
a9c6e46c 2631
a9c6e46c 2632
97358084
JO		 2633static bool __sort__hpp_equal(struct perf_hpp_fmt *a, struct perf_hpp_fmt *b)
2634{
2635 struct hpp_sort_entry *hse_a;
2636 struct hpp_sort_entry *hse_b;
2637
2638 if (!perf_hpp__is_sort_entry(a) || !perf_hpp__is_sort_entry(b))
2639 return false;
2640
2641 hse_a = container_of(a, struct hpp_sort_entry, hpp);
2642 hse_b = container_of(b, struct hpp_sort_entry, hpp);
2643
2644 return hse_a->se == hse_b->se;
2645}
2646
564132f3
JO		 2647static void hse_free(struct perf_hpp_fmt *fmt)
2648{
2649 struct hpp_sort_entry *hse;
2650
2651 hse = container_of(fmt, struct hpp_sort_entry, hpp);
2652 free(hse);
2653}
2654
cb6e92c7
NK		 2655static void hse_init(struct perf_hpp_fmt *fmt, struct hist_entry *he)
2656{
2657 struct hpp_sort_entry *hse;
2658
2659 if (!perf_hpp__is_sort_entry(fmt))
2660 return;
2661
2662 hse = container_of(fmt, struct hpp_sort_entry, hpp);
2663
2664 if (hse->se->se_init)
2665 hse->se->se_init(he);
2666}
2667
a7d945bc 2668static struct hpp_sort_entry *
4b633eba 2669__sort_dimension__alloc_hpp(struct sort_dimension *sd, int level)
8b536999
NK		 2670{
2671 struct hpp_sort_entry *hse;
2672
2673 hse = malloc(sizeof(*hse));
2674 if (hse == NULL) {
2675 pr_err("Memory allocation failed\n");
a7d945bc 2676 return NULL;
8b536999
NK		 2677 }
2678
2679 hse->se = sd->entry;
1ecd4453 2680 hse->hpp.name = sd->entry->se_header;
8b536999
NK		 2681 hse->hpp.header = __sort__hpp_header;
2682 hse->hpp.width = __sort__hpp_width;
2683 hse->hpp.entry = __sort__hpp_entry;
2684 hse->hpp.color = NULL;
2685
87bbdf76
NK		 2686 hse->hpp.cmp = __sort__hpp_cmp;
2687 hse->hpp.collapse = __sort__hpp_collapse;
2688 hse->hpp.sort = __sort__hpp_sort;
97358084 2689 hse->hpp.equal = __sort__hpp_equal;
564132f3 2690 hse->hpp.free = hse_free;
cb6e92c7 2691 hse->hpp.init = hse_init;
8b536999
NK		 2692
2693 INIT_LIST_HEAD(&hse->hpp.list);
2694 INIT_LIST_HEAD(&hse->hpp.sort_list);
f2998422 2695 hse->hpp.elide = false;
e0d66c74 2696 hse->hpp.len = 0;
5b591669 2697 hse->hpp.user_len = 0;
4b633eba 2698 hse->hpp.level = level;
8b536999 2699
a7d945bc
NK		 2700 return hse;
2701}
2702
564132f3
JO		 2703static void hpp_free(struct perf_hpp_fmt *fmt)
2704{
2705 free(fmt);
2706}
2707
4b633eba
NK		 2708static struct perf_hpp_fmt *__hpp_dimension__alloc_hpp(struct hpp_dimension *hd,
2709 int level)
1945c3e7
JO		 2710{
2711 struct perf_hpp_fmt *fmt;
2712
2713 fmt = memdup(hd->fmt, sizeof(*fmt));
2714 if (fmt) {
2715 INIT_LIST_HEAD(&fmt->list);
2716 INIT_LIST_HEAD(&fmt->sort_list);
564132f3 2717 fmt->free = hpp_free;
4b633eba 2718 fmt->level = level;
1945c3e7
JO		 2719 }
2720
2721 return fmt;
2722}
2723
54430101
NK		 2724int hist_entry__filter(struct hist_entry *he, int type, const void *arg)
2725{
2726 struct perf_hpp_fmt *fmt;
2727 struct hpp_sort_entry *hse;
f4954cfb
NK		 2728 int ret = -1;
2729 int r;
2730
2731 perf_hpp_list__for_each_format(he->hpp_list, fmt) {
2732 if (!perf_hpp__is_sort_entry(fmt))
2733 continue;
2734
2735 hse = container_of(fmt, struct hpp_sort_entry, hpp);
2736 if (hse->se->se_filter == NULL)
2737 continue;
2738
2739 /*
2740 * hist entry is filtered if any of sort key in the hpp list
2741 * is applied. But it should skip non-matched filter types.
2742 */
2743 r = hse->se->se_filter(he, type, arg);
2744 if (r >= 0) {
2745 if (ret < 0)
2746 ret = 0;
2747 ret |= r;
2748 }
2749 }
54430101 2750
f4954cfb 2751 return ret;
54430101
NK		 2752}
2753
d7b617f5
JO		 2754static int __sort_dimension__add_hpp_sort(struct sort_dimension *sd,
2755 struct perf_hpp_list *list,
2756 int level)
a7d945bc 2757{
4b633eba 2758 struct hpp_sort_entry *hse = __sort_dimension__alloc_hpp(sd, level);
a7d945bc
NK		 2759
2760 if (hse == NULL)
2761 return -1;
2762
d7b617f5 2763 perf_hpp_list__register_sort_field(list, &hse->hpp);
8b536999
NK		 2764 return 0;
2765}
2766
d7b617f5
JO		 2767static int __sort_dimension__add_hpp_output(struct sort_dimension *sd,
2768 struct perf_hpp_list *list)
a7d945bc 2769{
4b633eba 2770 struct hpp_sort_entry *hse = __sort_dimension__alloc_hpp(sd, 0);
a7d945bc
NK		 2771
2772 if (hse == NULL)
2773 return -1;
2774
07600027 2775 perf_hpp_list__column_register(list, &hse->hpp);
a7d945bc
NK		 2776 return 0;
2777}
2778
378ef0f5
IR		 2779#ifndef HAVE_LIBTRACEEVENT
2780bool perf_hpp__is_dynamic_entry(struct perf_hpp_fmt *fmt __maybe_unused)
2781{
2782 return false;
2783}
2784bool perf_hpp__defined_dynamic_entry(struct perf_hpp_fmt *fmt __maybe_unused,
2785 struct hists *hists __maybe_unused)
2786{
2787 return false;
2788}
2789#else
c7c2a5e4
NK		 2790struct hpp_dynamic_entry {
2791 struct perf_hpp_fmt hpp;
32dcd021 2792 struct evsel *evsel;
2c92f982 2793 struct tep_format_field *field;
c7c2a5e4 2794 unsigned dynamic_len;
053a3989 2795 bool raw_trace;
c7c2a5e4
NK		 2796};
2797
2798static int hde_width(struct hpp_dynamic_entry *hde)
2799{
2800 if (!hde->hpp.len) {
2801 int len = hde->dynamic_len;
2802 int namelen = strlen(hde->field->name);
2803 int fieldlen = hde->field->size;
2804
2805 if (namelen > len)
2806 len = namelen;
2807
bb39ccb2 2808 if (!(hde->field->flags & TEP_FIELD_IS_STRING)) {
c7c2a5e4
NK		 2809 /* length for print hex numbers */
2810 fieldlen = hde->field->size * 2 + 2;
2811 }
2812 if (fieldlen > len)
2813 len = fieldlen;
2814
2815 hde->hpp.len = len;
2816 }
2817 return hde->hpp.len;
2818}
2819
60517d28
NK		 2820static void update_dynamic_len(struct hpp_dynamic_entry *hde,
2821 struct hist_entry *he)
2822{
2823 char *str, *pos;
2c92f982 2824 struct tep_format_field *field = hde->field;
60517d28
NK		 2825 size_t namelen;
2826 bool last = false;
2827
053a3989
NK		 2828 if (hde->raw_trace)
2829 return;
2830
60517d28
NK		 2831 /* parse pretty print result and update max length */
2832 if (!he->trace_output)
2833 he->trace_output = get_trace_output(he);
2834
2835 namelen = strlen(field->name);
2836 str = he->trace_output;
2837
2838 while (str) {
2839 pos = strchr(str, ' ');
2840 if (pos == NULL) {
2841 last = true;
2842 pos = str + strlen(str);
2843 }
2844
2845 if (!strncmp(str, field->name, namelen)) {
2846 size_t len;
2847
2848 str += namelen + 1;
2849 len = pos - str;
2850
2851 if (len > hde->dynamic_len)
2852 hde->dynamic_len = len;
2853 break;
2854 }
2855
2856 if (last)
2857 str = NULL;
2858 else
2859 str = pos + 1;
2860 }
2861}
2862
c7c2a5e4 2863static int __sort__hde_header(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
74bb43f2 2864 struct hists *hists __maybe_unused,
29659ab4
JO		 2865 int line __maybe_unused,
2866 int *span __maybe_unused)
c7c2a5e4
NK		 2867{
2868 struct hpp_dynamic_entry *hde;
2869 size_t len = fmt->user_len;
2870
2871 hde = container_of(fmt, struct hpp_dynamic_entry, hpp);
2872
2873 if (!len)
2874 len = hde_width(hde);
2875
2876 return scnprintf(hpp->buf, hpp->size, "%*.*s", len, len, hde->field->name);
2877}
2878
2879static int __sort__hde_width(struct perf_hpp_fmt *fmt,
2880 struct perf_hpp *hpp __maybe_unused,
da1b0407 2881 struct hists *hists __maybe_unused)
c7c2a5e4
NK		 2882{
2883 struct hpp_dynamic_entry *hde;
2884 size_t len = fmt->user_len;
2885
2886 hde = container_of(fmt, struct hpp_dynamic_entry, hpp);
2887
2888 if (!len)
2889 len = hde_width(hde);
2890
2891 return len;
2892}
2893
361459f1
NK		 2894bool perf_hpp__defined_dynamic_entry(struct perf_hpp_fmt *fmt, struct hists *hists)
2895{
2896 struct hpp_dynamic_entry *hde;
2897
2898 hde = container_of(fmt, struct hpp_dynamic_entry, hpp);
2899
2900 return hists_to_evsel(hists) == hde->evsel;
2901}
2902
c7c2a5e4
NK		 2903static int __sort__hde_entry(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
2904 struct hist_entry *he)
2905{
2906 struct hpp_dynamic_entry *hde;
2907 size_t len = fmt->user_len;
60517d28 2908 char *str, *pos;
2c92f982 2909 struct tep_format_field *field;
60517d28
NK		 2910 size_t namelen;
2911 bool last = false;
c7c2a5e4
NK		 2912 int ret;
2913
2914 hde = container_of(fmt, struct hpp_dynamic_entry, hpp);
2915
2916 if (!len)
2917 len = hde_width(hde);
2918
053a3989
NK		 2919 if (hde->raw_trace)
2920 goto raw_field;
60517d28 2921
e049d4a3
NK		 2922 if (!he->trace_output)
2923 he->trace_output = get_trace_output(he);
2924
053a3989 2925 field = hde->field;
60517d28
NK		 2926 namelen = strlen(field->name);
2927 str = he->trace_output;
2928
2929 while (str) {
2930 pos = strchr(str, ' ');
2931 if (pos == NULL) {
2932 last = true;
2933 pos = str + strlen(str);
2934 }
2935
2936 if (!strncmp(str, field->name, namelen)) {
2937 str += namelen + 1;
2938 str = strndup(str, pos - str);
2939
2940 if (str == NULL)
2941 return scnprintf(hpp->buf, hpp->size,
2942 "%*.*s", len, len, "ERROR");
2943 break;
2944 }
2945
2946 if (last)
2947 str = NULL;
2948 else
2949 str = pos + 1;
2950 }
2951
2952 if (str == NULL) {
2953 struct trace_seq seq;
053a3989 2954raw_field:
60517d28 2955 trace_seq_init(&seq);
6a48dc29 2956 tep_print_field(&seq, he->raw_data, hde->field);
60517d28
NK		 2957 str = seq.buffer;
2958 }
2959
2960 ret = scnprintf(hpp->buf, hpp->size, "%*.*s", len, len, str);
2961 free(str);
c7c2a5e4
NK		 2962 return ret;
2963}
2964
2965static int64_t __sort__hde_cmp(struct perf_hpp_fmt *fmt,
2966 struct hist_entry *a, struct hist_entry *b)
2967{
2968 struct hpp_dynamic_entry *hde;
2c92f982 2969 struct tep_format_field *field;
c7c2a5e4
NK		 2970 unsigned offset, size;
2971
2972 hde = container_of(fmt, struct hpp_dynamic_entry, hpp);
2973
c7c2a5e4 2974 field = hde->field;
bb39ccb2 2975 if (field->flags & TEP_FIELD_IS_DYNAMIC) {
c7c2a5e4
NK		 2976 unsigned long long dyn;
2977
59c1baee 2978 tep_read_number_field(field, a->raw_data, &dyn);
c7c2a5e4
NK		 2979 offset = dyn & 0xffff;
2980 size = (dyn >> 16) & 0xffff;
1634bad3 2981 if (tep_field_is_relative(field->flags))
7c689c83 2982 offset += field->offset + field->size;
c7c2a5e4
NK		 2983 /* record max width for output */
2984 if (size > hde->dynamic_len)
2985 hde->dynamic_len = size;
2986 } else {
2987 offset = field->offset;
2988 size = field->size;
2989 }
2990
2991 return memcmp(a->raw_data + offset, b->raw_data + offset, size);
2992}
2993
361459f1
NK		 2994bool perf_hpp__is_dynamic_entry(struct perf_hpp_fmt *fmt)
2995{
2996 return fmt->cmp == __sort__hde_cmp;
2997}
2998
665aa757
NK		 2999static bool __sort__hde_equal(struct perf_hpp_fmt *a, struct perf_hpp_fmt *b)
3000{
3001 struct hpp_dynamic_entry *hde_a;
3002 struct hpp_dynamic_entry *hde_b;
3003
3004 if (!perf_hpp__is_dynamic_entry(a) || !perf_hpp__is_dynamic_entry(b))
3005 return false;
3006
3007 hde_a = container_of(a, struct hpp_dynamic_entry, hpp);
3008 hde_b = container_of(b, struct hpp_dynamic_entry, hpp);
3009
3010 return hde_a->field == hde_b->field;
3011}
3012
564132f3
JO		 3013static void hde_free(struct perf_hpp_fmt *fmt)
3014{
3015 struct hpp_dynamic_entry *hde;
3016
3017 hde = container_of(fmt, struct hpp_dynamic_entry, hpp);
3018 free(hde);
3019}
3020
cb6e92c7
NK		 3021static void __sort__hde_init(struct perf_hpp_fmt *fmt, struct hist_entry *he)
3022{
3023 struct hpp_dynamic_entry *hde;
3024
3025 if (!perf_hpp__is_dynamic_entry(fmt))
3026 return;
3027
3028 hde = container_of(fmt, struct hpp_dynamic_entry, hpp);
3029 update_dynamic_len(hde, he);
3030}
3031
c7c2a5e4 3032static struct hpp_dynamic_entry *
32dcd021 3033__alloc_dynamic_entry(struct evsel *evsel, struct tep_format_field *field,
4b633eba 3034 int level)
c7c2a5e4
NK		 3035{
3036 struct hpp_dynamic_entry *hde;
3037
3038 hde = malloc(sizeof(*hde));
3039 if (hde == NULL) {
3040 pr_debug("Memory allocation failed\n");
3041 return NULL;
3042 }
3043
3044 hde->evsel = evsel;
3045 hde->field = field;
3046 hde->dynamic_len = 0;
3047
3048 hde->hpp.name = field->name;
3049 hde->hpp.header = __sort__hde_header;
3050 hde->hpp.width = __sort__hde_width;
3051 hde->hpp.entry = __sort__hde_entry;
3052 hde->hpp.color = NULL;
3053
cb6e92c7 3054 hde->hpp.init = __sort__hde_init;
c7c2a5e4
NK		 3055 hde->hpp.cmp = __sort__hde_cmp;
3056 hde->hpp.collapse = __sort__hde_cmp;
3057 hde->hpp.sort = __sort__hde_cmp;
665aa757 3058 hde->hpp.equal = __sort__hde_equal;
564132f3 3059 hde->hpp.free = hde_free;
c7c2a5e4
NK		 3060
3061 INIT_LIST_HEAD(&hde->hpp.list);
3062 INIT_LIST_HEAD(&hde->hpp.sort_list);
3063 hde->hpp.elide = false;
3064 hde->hpp.len = 0;
3065 hde->hpp.user_len = 0;
4b633eba 3066 hde->hpp.level = level;
c7c2a5e4
NK		 3067
3068 return hde;
3069}
378ef0f5 3070#endif /* HAVE_LIBTRACEEVENT */
c7c2a5e4 3071
c3bc0c43
NK		 3072struct perf_hpp_fmt *perf_hpp_fmt__dup(struct perf_hpp_fmt *fmt)
3073{
3074 struct perf_hpp_fmt *new_fmt = NULL;
3075
3076 if (perf_hpp__is_sort_entry(fmt)) {
3077 struct hpp_sort_entry *hse, *new_hse;
3078
3079 hse = container_of(fmt, struct hpp_sort_entry, hpp);
3080 new_hse = memdup(hse, sizeof(*hse));
3081 if (new_hse)
3082 new_fmt = &new_hse->hpp;
378ef0f5 3083#ifdef HAVE_LIBTRACEEVENT
c3bc0c43
NK		 3084 } else if (perf_hpp__is_dynamic_entry(fmt)) {
3085 struct hpp_dynamic_entry *hde, *new_hde;
3086
3087 hde = container_of(fmt, struct hpp_dynamic_entry, hpp);
3088 new_hde = memdup(hde, sizeof(*hde));
3089 if (new_hde)
3090 new_fmt = &new_hde->hpp;
378ef0f5 3091#endif
c3bc0c43
NK		 3092 } else {
3093 new_fmt = memdup(fmt, sizeof(*fmt));
3094 }
3095
3096 INIT_LIST_HEAD(&new_fmt->list);
3097 INIT_LIST_HEAD(&new_fmt->sort_list);
3098
3099 return new_fmt;
3100}
3101
5d0cff93
NK		 3102static int parse_field_name(char *str, char **event, char **field, char **opt)
3103{
3104 char *event_name, *field_name, *opt_name;
3105
3106 event_name = str;
3107 field_name = strchr(str, '.');
3108
3109 if (field_name) {
3110 *field_name++ = '\0';
3111 } else {
3112 event_name = NULL;
3113 field_name = str;
3114 }
3115
3116 opt_name = strchr(field_name, '/');
3117 if (opt_name)
3118 *opt_name++ = '\0';
3119
3120 *event = event_name;
3121 *field = field_name;
3122 *opt = opt_name;
3123
3124 return 0;
3125}
3126
3127/* find match evsel using a given event name. The event name can be:
9735be24
NK		 3128 * 1. '%' + event index (e.g. '%1' for first event)
3129 * 2. full event name (e.g. sched:sched_switch)
3130 * 3. partial event name (should not contain ':')
5d0cff93 3131 */
63503dba 3132static struct evsel *find_evsel(struct evlist *evlist, char *event_name)
5d0cff93 3133{
32dcd021
JO		 3134 struct evsel *evsel = NULL;
3135 struct evsel *pos;
5d0cff93
NK		 3136 bool full_name;
3137
3138 /* case 1 */
5d0cff93
NK		 3139 if (event_name[0] == '%') {
3140 int nr = strtol(event_name+1, NULL, 0);
3141
6484d2f9 3142 if (nr > evlist->core.nr_entries)
5d0cff93
NK		 3143 return NULL;
3144
515dbe48 3145 evsel = evlist__first(evlist);
5d0cff93 3146 while (--nr > 0)
e470daea 3147 evsel = evsel__next(evsel);
5d0cff93
NK		 3148
3149 return evsel;
3150 }
3151
3152 full_name = !!strchr(event_name, ':');
e5cadb93 3153 evlist__for_each_entry(evlist, pos) {
9735be24 3154 /* case 2 */
ce1d3bc2 3155 if (full_name && evsel__name_is(pos, event_name))
5d0cff93 3156 return pos;
9735be24 3157 /* case 3 */
5d0cff93
NK		 3158 if (!full_name && strstr(pos->name, event_name)) {
3159 if (evsel) {
3160 pr_debug("'%s' event is ambiguous: it can be %s or %s\n",
3161 event_name, evsel->name, pos->name);
3162 return NULL;
3163 }
3164 evsel = pos;
3165 }
3166 }
3167
3168 return evsel;
3169}
3170
378ef0f5 3171#ifdef HAVE_LIBTRACEEVENT
32dcd021 3172static int __dynamic_dimension__add(struct evsel *evsel,
2c92f982 3173 struct tep_format_field *field,
4b633eba 3174 bool raw_trace, int level)
3b099bf5
NK		 3175{
3176 struct hpp_dynamic_entry *hde;
3177
4b633eba 3178 hde = __alloc_dynamic_entry(evsel, field, level);
3b099bf5
NK		 3179 if (hde == NULL)
3180 return -ENOMEM;
3181
3182 hde->raw_trace = raw_trace;
3183
3184 perf_hpp__register_sort_field(&hde->hpp);
3185 return 0;
3186}
3187
32dcd021 3188static int add_evsel_fields(struct evsel *evsel, bool raw_trace, int level)
2e422fd1
NK		 3189{
3190 int ret;
2c92f982 3191 struct tep_format_field *field;
2e422fd1
NK		 3192
3193 field = evsel->tp_format->format.fields;
3194 while (field) {
4b633eba 3195 ret = __dynamic_dimension__add(evsel, field, raw_trace, level);
2e422fd1
NK		 3196 if (ret < 0)
3197 return ret;
3198
3199 field = field->next;
3200 }
3201 return 0;
3202}
3203
63503dba 3204static int add_all_dynamic_fields(struct evlist *evlist, bool raw_trace,
4b633eba 3205 int level)
2e422fd1
NK		 3206{
3207 int ret;
32dcd021 3208 struct evsel *evsel;
2e422fd1 3209
e5cadb93 3210 evlist__for_each_entry(evlist, evsel) {
1fc632ce 3211 if (evsel->core.attr.type != PERF_TYPE_TRACEPOINT)
2e422fd1
NK		 3212 continue;
3213
4b633eba 3214 ret = add_evsel_fields(evsel, raw_trace, level);
2e422fd1
NK		 3215 if (ret < 0)
3216 return ret;
3217 }
3218 return 0;
3219}
3220
63503dba 3221static int add_all_matching_fields(struct evlist *evlist,
4b633eba 3222 char *field_name, bool raw_trace, int level)
9735be24
NK		 3223{
3224 int ret = -ESRCH;
32dcd021 3225 struct evsel *evsel;
2c92f982 3226 struct tep_format_field *field;
9735be24 3227
e5cadb93 3228 evlist__for_each_entry(evlist, evsel) {
1fc632ce 3229 if (evsel->core.attr.type != PERF_TYPE_TRACEPOINT)
9735be24
NK		 3230 continue;
3231
af85cd19 3232 field = tep_find_any_field(evsel->tp_format, field_name);
9735be24
NK		 3233 if (field == NULL)
3234 continue;
3235
4b633eba 3236 ret = __dynamic_dimension__add(evsel, field, raw_trace, level);
9735be24
NK		 3237 if (ret < 0)
3238 break;
3239 }
3240 return ret;
3241}
378ef0f5 3242#endif /* HAVE_LIBTRACEEVENT */
9735be24 3243
63503dba 3244static int add_dynamic_entry(struct evlist *evlist, const char *tok,
4b633eba 3245 int level)
c7c2a5e4 3246{
5d0cff93 3247 char *str, *event_name, *field_name, *opt_name;
32dcd021 3248 struct evsel *evsel;
053a3989 3249 bool raw_trace = symbol_conf.raw_trace;
c7c2a5e4
NK		 3250 int ret = 0;
3251
3252 if (evlist == NULL)
3253 return -ENOENT;
3254
3255 str = strdup(tok);
3256 if (str == NULL)
3257 return -ENOMEM;
3258
5d0cff93 3259 if (parse_field_name(str, &event_name, &field_name, &opt_name) < 0) {
c7c2a5e4
NK		 3260 ret = -EINVAL;
3261 goto out;
3262 }
c7c2a5e4 3263
5d0cff93
NK		 3264 if (opt_name) {
3265 if (strcmp(opt_name, "raw")) {
3266 pr_debug("unsupported field option %s\n", opt_name);
053a3989
NK		 3267 ret = -EINVAL;
3268 goto out;
3269 }
3270 raw_trace = true;
3271 }
3272
378ef0f5 3273#ifdef HAVE_LIBTRACEEVENT
2e422fd1 3274 if (!strcmp(field_name, "trace_fields")) {
4b633eba 3275 ret = add_all_dynamic_fields(evlist, raw_trace, level);
2e422fd1
NK		 3276 goto out;
3277 }
3278
9735be24 3279 if (event_name == NULL) {
4b633eba 3280 ret = add_all_matching_fields(evlist, field_name, raw_trace, level);
9735be24
NK		 3281 goto out;
3282 }
77fe30fe
ACM		 3283#else
3284 evlist__for_each_entry(evlist, evsel) {
3285 if (evsel->core.attr.type == PERF_TYPE_TRACEPOINT) {
3286 pr_err("%s %s", ret ? "," : "This perf binary isn't linked with libtraceevent, can't process", evsel__name(evsel));
3287 ret = -ENOTSUP;
3288 }
3289 }
3290
3291 if (ret) {
3292 pr_err("\n");
3293 goto out;
3294 }
378ef0f5 3295#endif
9735be24 3296
5d0cff93 3297 evsel = find_evsel(evlist, event_name);
c7c2a5e4
NK		 3298 if (evsel == NULL) {
3299 pr_debug("Cannot find event: %s\n", event_name);
3300 ret = -ENOENT;
3301 goto out;
3302 }
3303
1fc632ce 3304 if (evsel->core.attr.type != PERF_TYPE_TRACEPOINT) {
c7c2a5e4
NK		 3305 pr_debug("%s is not a tracepoint event\n", event_name);
3306 ret = -EINVAL;
3307 goto out;
3308 }
3309
378ef0f5 3310#ifdef HAVE_LIBTRACEEVENT
3b099bf5 3311 if (!strcmp(field_name, "*")) {
4b633eba 3312 ret = add_evsel_fields(evsel, raw_trace, level);
3b099bf5 3313 } else {
378ef0f5
IR		 3314 struct tep_format_field *field = tep_find_any_field(evsel->tp_format, field_name);
3315
3b099bf5
NK		 3316 if (field == NULL) {
3317 pr_debug("Cannot find event field for %s.%s\n",
3318 event_name, field_name);
3319 return -ENOENT;
3320 }
3321
4b633eba 3322 ret = __dynamic_dimension__add(evsel, field, raw_trace, level);
3b099bf5 3323 }
378ef0f5
IR		 3324#else
3325 (void)level;
3326 (void)raw_trace;
3327#endif /* HAVE_LIBTRACEEVENT */
c7c2a5e4
NK		 3328
3329out:
3330 free(str);
3331 return ret;
3332}
3333
d7b617f5
JO		 3334static int __sort_dimension__add(struct sort_dimension *sd,
3335 struct perf_hpp_list *list,
3336 int level)
2f532d09
NK		 3337{
3338 if (sd->taken)
8b536999
NK		 3339 return 0;
3340
d7b617f5 3341 if (__sort_dimension__add_hpp_sort(sd, list, level) < 0)
8b536999 3342 return -1;
2f532d09
NK		 3343
3344 if (sd->entry->se_collapse)
52225036 3345 list->need_collapse = 1;
2f532d09 3346
2f532d09 3347 sd->taken = 1;
8b536999
NK		 3348
3349 return 0;
2f532d09
NK		 3350}
3351
d7b617f5
JO		 3352static int __hpp_dimension__add(struct hpp_dimension *hd,
3353 struct perf_hpp_list *list,
3354 int level)
a2ce067e 3355{
1945c3e7 3356 struct perf_hpp_fmt *fmt;
a2ce067e 3357
1945c3e7
JO		 3358 if (hd->taken)
3359 return 0;
3360
4b633eba 3361 fmt = __hpp_dimension__alloc_hpp(hd, level);
1945c3e7
JO		 3362 if (!fmt)
3363 return -1;
3364
3365 hd->taken = 1;
d7b617f5 3366 perf_hpp_list__register_sort_field(list, fmt);
a2ce067e
NK		 3367 return 0;
3368}
3369
07600027
JO		 3370static int __sort_dimension__add_output(struct perf_hpp_list *list,
3371 struct sort_dimension *sd)
a7d945bc
NK		 3372{
3373 if (sd->taken)
3374 return 0;
3375
d7b617f5 3376 if (__sort_dimension__add_hpp_output(sd, list) < 0)
a7d945bc
NK		 3377 return -1;
3378
3379 sd->taken = 1;
3380 return 0;
3381}
3382
07600027
JO		 3383static int __hpp_dimension__add_output(struct perf_hpp_list *list,
3384 struct hpp_dimension *hd)
a7d945bc 3385{
1945c3e7 3386 struct perf_hpp_fmt *fmt;
a7d945bc 3387
1945c3e7
JO		 3388 if (hd->taken)
3389 return 0;
3390
4b633eba 3391 fmt = __hpp_dimension__alloc_hpp(hd, 0);
1945c3e7
JO		 3392 if (!fmt)
3393 return -1;
3394
3395 hd->taken = 1;
07600027 3396 perf_hpp_list__column_register(list, fmt);
a7d945bc
NK		 3397 return 0;
3398}
3399
beeaaeb3
JO		 3400int hpp_dimension__add_output(unsigned col)
3401{
3402 BUG_ON(col >= PERF_HPP__MAX_INDEX);
07600027 3403 return __hpp_dimension__add_output(&perf_hpp_list, &hpp_sort_dimensions[col]);
beeaaeb3
JO		 3404}
3405
a76490e4 3406int sort_dimension__add(struct perf_hpp_list *list, const char *tok,
63503dba 3407 struct evlist *evlist,
a76490e4 3408 int level)
dd68ada2 3409{
0a606822 3410 unsigned int i, j;
dd68ada2 3411
50fa3a53
AR		 3412 /*
3413 * Check to see if there are any arch specific
3414 * sort dimensions not applicable for the current
3415 * architecture. If so, Skip that sort key since
3416 * we don't want to display it in the output fields.
3417 */
3418 for (j = 0; j < ARRAY_SIZE(arch_specific_sort_keys); j++) {
3419 if (!strcmp(arch_specific_sort_keys[j], tok) &&
3420 !arch_support_sort_key(tok)) {
3421 return 0;
3422 }
3423 }
3424
fc5871ed
NK		 3425 for (i = 0; i < ARRAY_SIZE(common_sort_dimensions); i++) {
3426 struct sort_dimension *sd = &common_sort_dimensions[i];
dd68ada2 3427
378ef0f5 3428 if (!sd->name || strncasecmp(tok, sd->name, strlen(tok)))
dd68ada2 3429 continue;
fc5871ed 3430
0a606822 3431 for (j = 0; j < ARRAY_SIZE(dynamic_headers); j++) {
378ef0f5 3432 if (sd->name && !strcmp(dynamic_headers[j], sd->name))
0a606822
AR		 3433 sort_dimension_add_dynamic_header(sd);
3434 }
3435
1c84b47f 3436 if (sd->entry == &sort_parent && parent_pattern) {
dd68ada2
JK		 3437 int ret = regcomp(&parent_regex, parent_pattern, REG_EXTENDED);
3438 if (ret) {
3439 char err[BUFSIZ];
3440
3441 regerror(ret, &parent_regex, err, sizeof(err));
2aefa4f7
ACM		 3442 pr_err("Invalid regex: %s\n%s", parent_pattern, err);
3443 return -EINVAL;
dd68ada2 3444 }
de7e6a7c 3445 list->parent = 1;
930477bd 3446 } else if (sd->entry == &sort_sym) {
2e0453af 3447 list->sym = 1;
94ba462d
KL		 3448 /*
3449 * perf diff displays the performance difference amongst
3450 * two or more perf.data files. Those files could come
3451 * from different binaries. So we should not compare
3452 * their ips, but the name of symbol.
3453 */
3454 if (sort__mode == SORT_MODE__DIFF)
3455 sd->entry->se_collapse = sort__sym_sort;
3456
68f6d022 3457 } else if (sd->entry == &sort_dso) {
69849fc5 3458 list->dso = 1;
2e7ea3ab 3459 } else if (sd->entry == &sort_socket) {
35a634f7 3460 list->socket = 1;
cfd92dad 3461 } else if (sd->entry == &sort_thread) {
fa82911a 3462 list->thread = 1;
078b8d4a 3463 } else if (sd->entry == &sort_comm) {
7cecb7fe 3464 list->comm = 1;
263925bf
NK		 3465 } else if (sd->entry == &sort_type_offset) {
3466 symbol_conf.annotate_data_member = true;
dd68ada2
JK		 3467 }
3468
d7b617f5 3469 return __sort_dimension__add(sd, list, level);
dd68ada2 3470 }
fc5871ed 3471
a2ce067e
NK		 3472 for (i = 0; i < ARRAY_SIZE(hpp_sort_dimensions); i++) {
3473 struct hpp_dimension *hd = &hpp_sort_dimensions[i];
3474
3475 if (strncasecmp(tok, hd->name, strlen(tok)))
3476 continue;
3477
d7b617f5 3478 return __hpp_dimension__add(hd, list, level);
a2ce067e
NK		 3479 }
3480
fc5871ed
NK		 3481 for (i = 0; i < ARRAY_SIZE(bstack_sort_dimensions); i++) {
3482 struct sort_dimension *sd = &bstack_sort_dimensions[i];
3483
378ef0f5 3484 if (!sd->name || strncasecmp(tok, sd->name, strlen(tok)))
fc5871ed
NK		 3485 continue;
3486
55369fc1 3487 if (sort__mode != SORT_MODE__BRANCH)
fc5871ed
NK		 3488 return -EINVAL;
3489
3490 if (sd->entry == &sort_sym_from || sd->entry == &sort_sym_to)
2e0453af 3491 list->sym = 1;
fc5871ed 3492
d7b617f5 3493 __sort_dimension__add(sd, list, level);
fc5871ed
NK		 3494 return 0;
3495 }
3496
afab87b9
NK		 3497 for (i = 0; i < ARRAY_SIZE(memory_sort_dimensions); i++) {
3498 struct sort_dimension *sd = &memory_sort_dimensions[i];
3499
378ef0f5 3500 if (!sd->name || strncasecmp(tok, sd->name, strlen(tok)))
afab87b9
NK		 3501 continue;
3502
3503 if (sort__mode != SORT_MODE__MEMORY)
3504 return -EINVAL;
3505
9ac94e31 3506 if (sd->entry == &sort_mem_dcacheline && cacheline_size() == 0)
0d203166
ACM		 3507 return -EINVAL;
3508
afab87b9 3509 if (sd->entry == &sort_mem_daddr_sym)
2e0453af 3510 list->sym = 1;
afab87b9 3511
d7b617f5 3512 __sort_dimension__add(sd, list, level);
afab87b9
NK		 3513 return 0;
3514 }
3515
4b633eba 3516 if (!add_dynamic_entry(evlist, tok, level))
c7c2a5e4
NK		 3517 return 0;
3518
dd68ada2
JK		 3519 return -ESRCH;
3520}
c8829c7a 3521
d7b617f5 3522static int setup_sort_list(struct perf_hpp_list *list, char *str,
63503dba 3523 struct evlist *evlist)
2fbaa390
JO		 3524{
3525 char *tmp, *tok;
3526 int ret = 0;
4b633eba 3527 int level = 0;
a23f37e8
NK		 3528 int next_level = 1;
3529 bool in_group = false;
3530
3531 do {
3532 tok = str;
3533 tmp = strpbrk(str, "{}, ");
3534 if (tmp) {
3535 if (in_group)
3536 next_level = level;
3537 else
3538 next_level = level + 1;
3539
3540 if (*tmp == '{')
3541 in_group = true;
3542 else if (*tmp == '}')
3543 in_group = false;
3544
3545 *tmp = '\0';
3546 str = tmp + 1;
3547 }
2fbaa390 3548
a23f37e8 3549 if (*tok) {
d7b617f5 3550 ret = sort_dimension__add(list, tok, evlist, level);
a23f37e8 3551 if (ret == -EINVAL) {
9ac94e31 3552 if (!cacheline_size() && !strncasecmp(tok, "dcacheline", strlen(tok)))
ae87405f 3553 ui__error("The \"dcacheline\" --sort key needs to know the cacheline size and it couldn't be determined on this system");
0d203166 3554 else
ae87405f 3555 ui__error("Invalid --sort key: `%s'", tok);
a23f37e8
NK		 3556 break;
3557 } else if (ret == -ESRCH) {
ae87405f 3558 ui__error("Unknown --sort key: `%s'", tok);
a23f37e8
NK		 3559 break;
3560 }
2fbaa390 3561 }
a23f37e8
NK		 3562
3563 level = next_level;
3564 } while (tmp);
2fbaa390
JO		 3565
3566 return ret;
3567}
3568
63503dba 3569static const char *get_default_sort_order(struct evlist *evlist)
512ae1bd
NK		 3570{
3571 const char *default_sort_orders[] = {
3572 default_sort_order,
3573 default_branch_sort_order,
3574 default_mem_sort_order,
3575 default_top_sort_order,
3576 default_diff_sort_order,
d49dadea 3577 default_tracepoint_sort_order,
512ae1bd 3578 };
d49dadea 3579 bool use_trace = true;
32dcd021 3580 struct evsel *evsel;
512ae1bd
NK		 3581
3582 BUG_ON(sort__mode >= ARRAY_SIZE(default_sort_orders));
3583
e414fd1a 3584 if (evlist == NULL || evlist__empty(evlist))
d49dadea
NK		 3585 goto out_no_evlist;
3586
e5cadb93 3587 evlist__for_each_entry(evlist, evsel) {
1fc632ce 3588 if (evsel->core.attr.type != PERF_TYPE_TRACEPOINT) {
d49dadea
NK		 3589 use_trace = false;
3590 break;
3591 }
3592 }
3593
3594 if (use_trace) {
3595 sort__mode = SORT_MODE__TRACEPOINT;
3596 if (symbol_conf.raw_trace)
3597 return "trace_fields";
3598 }
3599out_no_evlist:
512ae1bd
NK		 3600 return default_sort_orders[sort__mode];
3601}
3602
63503dba 3603static int setup_sort_order(struct evlist *evlist)
1a1c0ffb
JO		 3604{
3605 char *new_sort_order;
3606
3607 /*
3608 * Append '+'-prefixed sort order to the default sort
3609 * order string.
3610 */
3611 if (!sort_order || is_strict_order(sort_order))
3612 return 0;
3613
3614 if (sort_order[1] == '\0') {
ae87405f 3615 ui__error("Invalid --sort key: `+'");
1a1c0ffb
JO		 3616 return -EINVAL;
3617 }
3618
3619 /*
3620 * We allocate new sort_order string, but we never free it,
3621 * because it's checked over the rest of the code.
3622 */
3623 if (asprintf(&new_sort_order, "%s,%s",
d49dadea 3624 get_default_sort_order(evlist), sort_order + 1) < 0) {
62d94b00 3625 pr_err("Not enough memory to set up --sort");
1a1c0ffb
JO		 3626 return -ENOMEM;
3627 }
3628
3629 sort_order = new_sort_order;
3630 return 0;
3631}
3632
b97511c5
JO		 3633/*
3634 * Adds 'pre,' prefix into 'str' is 'pre' is
3635 * not already part of 'str'.
3636 */
3637static char *prefix_if_not_in(const char *pre, char *str)
3638{
3639 char *n;
3640
3641 if (!str || strstr(str, pre))
3642 return str;
3643
3644 if (asprintf(&n, "%s,%s", pre, str) < 0)
07e9a6f5 3645 n = NULL;
b97511c5
JO		 3646
3647 free(str);
3648 return n;
3649}
3650
3651static char *setup_overhead(char *keys)
3652{
e9d848cb
NK		 3653 if (sort__mode == SORT_MODE__DIFF)
3654 return keys;
3655
b97511c5
JO		 3656 keys = prefix_if_not_in("overhead", keys);
3657
3658 if (symbol_conf.cumulate_callchain)
3659 keys = prefix_if_not_in("overhead_children", keys);
3660
3661 return keys;
3662}
3663
63503dba 3664static int __setup_sorting(struct evlist *evlist)
c8829c7a 3665{
2fbaa390 3666 char *str;
1a1c0ffb 3667 const char *sort_keys;
55309985 3668 int ret = 0;
c8829c7a 3669
d49dadea 3670 ret = setup_sort_order(evlist);
1a1c0ffb
JO		 3671 if (ret)
3672 return ret;
3673
3674 sort_keys = sort_order;
a7d945bc 3675 if (sort_keys == NULL) {
2f3f9bcf 3676 if (is_strict_order(field_order)) {
a7d945bc
NK		 3677 /*
3678 * If user specified field order but no sort order,
3679 * we'll honor it and not add default sort orders.
3680 */
3681 return 0;
3682 }
3683
d49dadea 3684 sort_keys = get_default_sort_order(evlist);
a7d945bc 3685 }
512ae1bd
NK		 3686
3687 str = strdup(sort_keys);
5936f54d 3688 if (str == NULL) {
62d94b00 3689 pr_err("Not enough memory to setup sort keys");
5936f54d
NK		 3690 return -ENOMEM;
3691 }
3692
b97511c5
JO		 3693 /*
3694 * Prepend overhead fields for backward compatibility.
3695 */
3696 if (!is_strict_order(field_order)) {
3697 str = setup_overhead(str);
3698 if (str == NULL) {
62d94b00 3699 pr_err("Not enough memory to setup overhead keys");
b97511c5
JO		 3700 return -ENOMEM;
3701 }
3702 }
3703
d7b617f5 3704 ret = setup_sort_list(&perf_hpp_list, str, evlist);
c8829c7a
ACM		 3705
3706 free(str);
55309985 3707 return ret;
c8829c7a 3708}
c351c281 3709
f2998422 3710void perf_hpp__set_elide(int idx, bool elide)
e67d49a7 3711{
f2998422
JO		 3712 struct perf_hpp_fmt *fmt;
3713 struct hpp_sort_entry *hse;
e67d49a7 3714
cf094045 3715 perf_hpp_list__for_each_format(&perf_hpp_list, fmt) {
f2998422
JO		 3716 if (!perf_hpp__is_sort_entry(fmt))
3717 continue;
3718
3719 hse = container_of(fmt, struct hpp_sort_entry, hpp);
3720 if (hse->se->se_width_idx == idx) {
3721 fmt->elide = elide;
3722 break;
3723 }
e67d49a7 3724 }
e67d49a7
NK		 3725}
3726
f2998422 3727static bool __get_elide(struct strlist *list, const char *list_name, FILE *fp)
c351c281
ACM		 3728{
3729 if (list && strlist__nr_entries(list) == 1) {
3730 if (fp != NULL)
3731 fprintf(fp, "# %s: %s\n", list_name,
3732 strlist__entry(list, 0)->s);
f2998422
JO		 3733 return true;
3734 }
3735 return false;
3736}
3737
3738static bool get_elide(int idx, FILE *output)
3739{
3740 switch (idx) {
3741 case HISTC_SYMBOL:
3742 return __get_elide(symbol_conf.sym_list, "symbol", output);
3743 case HISTC_DSO:
3744 return __get_elide(symbol_conf.dso_list, "dso", output);
3745 case HISTC_COMM:
3746 return __get_elide(symbol_conf.comm_list, "comm", output);
3747 default:
3748 break;
c351c281 3749 }
f2998422
JO		 3750
3751 if (sort__mode != SORT_MODE__BRANCH)
3752 return false;
3753
3754 switch (idx) {
3755 case HISTC_SYMBOL_FROM:
3756 return __get_elide(symbol_conf.sym_from_list, "sym_from", output);
3757 case HISTC_SYMBOL_TO:
3758 return __get_elide(symbol_conf.sym_to_list, "sym_to", output);
3759 case HISTC_DSO_FROM:
3760 return __get_elide(symbol_conf.dso_from_list, "dso_from", output);
3761 case HISTC_DSO_TO:
3762 return __get_elide(symbol_conf.dso_to_list, "dso_to", output);
05274770
SE		 3763 case HISTC_ADDR_FROM:
3764 return __get_elide(symbol_conf.sym_from_list, "addr_from", output);
3765 case HISTC_ADDR_TO:
3766 return __get_elide(symbol_conf.sym_to_list, "addr_to", output);
f2998422
JO		 3767 default:
3768 break;
3769 }
3770
3771 return false;
c351c281 3772}
08e71542
NK		 3773
3774void sort__setup_elide(FILE *output)
3775{
cfaa154b
NK		 3776 struct perf_hpp_fmt *fmt;
3777 struct hpp_sort_entry *hse;
7524f63b 3778
cf094045 3779 perf_hpp_list__for_each_format(&perf_hpp_list, fmt) {
f2998422
JO		 3780 if (!perf_hpp__is_sort_entry(fmt))
3781 continue;
3782
3783 hse = container_of(fmt, struct hpp_sort_entry, hpp);
3784 fmt->elide = get_elide(hse->se->se_width_idx, output);
08e71542
NK		 3785 }
3786
7524f63b
NK		 3787 /*
3788 * It makes no sense to elide all of sort entries.
3789 * Just revert them to show up again.
3790 */
cf094045 3791 perf_hpp_list__for_each_format(&perf_hpp_list, fmt) {
cfaa154b
NK		 3792 if (!perf_hpp__is_sort_entry(fmt))
3793 continue;
3794
f2998422 3795 if (!fmt->elide)
7524f63b
NK		 3796 return;
3797 }
3798
cf094045 3799 perf_hpp_list__for_each_format(&perf_hpp_list, fmt) {
cfaa154b
NK		 3800 if (!perf_hpp__is_sort_entry(fmt))
3801 continue;
3802
f2998422 3803 fmt->elide = false;
cfaa154b 3804 }
08e71542 3805}
a7d945bc 3806
7043dc52 3807int output_field_add(struct perf_hpp_list *list, const char *tok)
a7d945bc
NK		 3808{
3809 unsigned int i;
3810
7043dc52
NK		 3811 for (i = 0; i < ARRAY_SIZE(hpp_sort_dimensions); i++) {
3812 struct hpp_dimension *hd = &hpp_sort_dimensions[i];
a7d945bc 3813
7043dc52 3814 if (strncasecmp(tok, hd->name, strlen(tok)))
a7d945bc
NK		 3815 continue;
3816
7043dc52
NK		 3817 if (!strcasecmp(tok, "weight"))
3818 ui__warning("--fields weight shows the average value unlike in the --sort key.\n");
3819
3820 return __hpp_dimension__add_output(list, hd);
a7d945bc
NK		 3821 }
3822
7043dc52
NK		 3823 for (i = 0; i < ARRAY_SIZE(common_sort_dimensions); i++) {
3824 struct sort_dimension *sd = &common_sort_dimensions[i];
a7d945bc 3825
7043dc52 3826 if (!sd->name || strncasecmp(tok, sd->name, strlen(tok)))
a7d945bc
NK		 3827 continue;
3828
7043dc52 3829 return __sort_dimension__add_output(list, sd);
a7d945bc
NK		 3830 }
3831
3832 for (i = 0; i < ARRAY_SIZE(bstack_sort_dimensions); i++) {
3833 struct sort_dimension *sd = &bstack_sort_dimensions[i];
3834
378ef0f5 3835 if (!sd->name || strncasecmp(tok, sd->name, strlen(tok)))
a7d945bc
NK		 3836 continue;
3837
6740a4e7 3838 if (sort__mode != SORT_MODE__BRANCH)
aa6b3c99
RB		 3839 return -EINVAL;
3840
07600027 3841 return __sort_dimension__add_output(list, sd);
a7d945bc
NK		 3842 }
3843
3844 for (i = 0; i < ARRAY_SIZE(memory_sort_dimensions); i++) {
3845 struct sort_dimension *sd = &memory_sort_dimensions[i];
3846
378ef0f5 3847 if (!sd->name || strncasecmp(tok, sd->name, strlen(tok)))
a7d945bc
NK		 3848 continue;
3849
6740a4e7 3850 if (sort__mode != SORT_MODE__MEMORY)
aa6b3c99
RB		 3851 return -EINVAL;
3852
07600027 3853 return __sort_dimension__add_output(list, sd);
a7d945bc
NK		 3854 }
3855
3856 return -ESRCH;
3857}
3858
07600027 3859static int setup_output_list(struct perf_hpp_list *list, char *str)
6d3375ef
JO		 3860{
3861 char *tmp, *tok;
3862 int ret = 0;
3863
3864 for (tok = strtok_r(str, ", ", &tmp);
3865 tok; tok = strtok_r(NULL, ", ", &tmp)) {
07600027 3866 ret = output_field_add(list, tok);
6d3375ef 3867 if (ret == -EINVAL) {
56271170 3868 ui__error("Invalid --fields key: `%s'", tok);
6d3375ef
JO		 3869 break;
3870 } else if (ret == -ESRCH) {
56271170 3871 ui__error("Unknown --fields key: `%s'", tok);
6d3375ef
JO		 3872 break;
3873 }
3874 }
3875
3876 return ret;
3877}
3878
bcf98740 3879void reset_dimensions(void)
a7d945bc
NK		 3880{
3881 unsigned int i;
3882
3883 for (i = 0; i < ARRAY_SIZE(common_sort_dimensions); i++)
3884 common_sort_dimensions[i].taken = 0;
3885
3886 for (i = 0; i < ARRAY_SIZE(hpp_sort_dimensions); i++)
3887 hpp_sort_dimensions[i].taken = 0;
3888
3889 for (i = 0; i < ARRAY_SIZE(bstack_sort_dimensions); i++)
3890 bstack_sort_dimensions[i].taken = 0;
3891
3892 for (i = 0; i < ARRAY_SIZE(memory_sort_dimensions); i++)
3893 memory_sort_dimensions[i].taken = 0;
3894}
3895
2f3f9bcf
JO		 3896bool is_strict_order(const char *order)
3897{
3898 return order && (*order != '+');
3899}
3900
a7d945bc
NK		 3901static int __setup_output_field(void)
3902{
6d3375ef 3903 char *str, *strp;
2f3f9bcf 3904 int ret = -EINVAL;
a7d945bc
NK		 3905
3906 if (field_order == NULL)
3907 return 0;
3908
2f3f9bcf 3909 strp = str = strdup(field_order);
a7d945bc 3910 if (str == NULL) {
62d94b00 3911 pr_err("Not enough memory to setup output fields");
a7d945bc
NK		 3912 return -ENOMEM;
3913 }
3914
2f3f9bcf
JO		 3915 if (!is_strict_order(field_order))
3916 strp++;
3917
3918 if (!strlen(strp)) {
ae87405f 3919 ui__error("Invalid --fields key: `+'");
2f3f9bcf
JO		 3920 goto out;
3921 }
3922
07600027 3923 ret = setup_output_list(&perf_hpp_list, strp);
a7d945bc 3924
2f3f9bcf 3925out:
a7d945bc
NK		 3926 free(str);
3927 return ret;
3928}
3929
63503dba 3930int setup_sorting(struct evlist *evlist)
9b240637
ACM		 3931{
3932 int err;
3933
3934 err = __setup_sorting(evlist);
3935 if (err < 0)
3936 return err;
3937
3938 if (parent_pattern != default_parent_pattern) {
d7b617f5 3939 err = sort_dimension__add(&perf_hpp_list, "parent", evlist, -1);
9b240637
ACM		 3940 if (err < 0)
3941 return err;
3942 }
3943
a7d945bc
NK		 3944 reset_dimensions();
3945
3946 /*
3947 * perf diff doesn't use default hpp output fields.
3948 */
3949 if (sort__mode != SORT_MODE__DIFF)
3950 perf_hpp__init();
3951
3952 err = __setup_output_field();
3953 if (err < 0)
3954 return err;
3955
3956 /* copy sort keys to output fields */
43e0a68f 3957 perf_hpp__setup_output_field(&perf_hpp_list);
a7d945bc 3958 /* and then copy output fields to sort keys */
43e0a68f 3959 perf_hpp__append_sort_keys(&perf_hpp_list);
a7d945bc 3960
c3bc0c43
NK		 3961 /* setup hists-specific output fields */
3962 if (perf_hpp__setup_hists_formats(&perf_hpp_list, evlist) < 0)
3963 return -1;
3964
a7d945bc
NK		 3965 return 0;
3966}
1c89fe9b
NK		 3967
3968void reset_output_field(void)
3969{
52225036 3970 perf_hpp_list.need_collapse = 0;
de7e6a7c 3971 perf_hpp_list.parent = 0;
2e0453af 3972 perf_hpp_list.sym = 0;
69849fc5 3973 perf_hpp_list.dso = 0;
1c89fe9b 3974
d69b2962
NK		 3975 field_order = NULL;
3976 sort_order = NULL;
3977
1c89fe9b 3978 reset_dimensions();
43e0a68f 3979 perf_hpp__reset_output_field(&perf_hpp_list);
1c89fe9b 3980}
702fb9b4
AK		 3981
3982#define INDENT (3*8 + 1)
3983
3984static void add_key(struct strbuf *sb, const char *str, int *llen)
3985{
378ef0f5
IR		 3986 if (!str)
3987 return;
3988
702fb9b4
AK		 3989 if (*llen >= 75) {
3990 strbuf_addstr(sb, "\n\t\t\t ");
3991 *llen = INDENT;
3992 }
3993 strbuf_addf(sb, " %s", str);
3994 *llen += strlen(str) + 1;
3995}
3996
3997static void add_sort_string(struct strbuf *sb, struct sort_dimension *s, int n,
3998 int *llen)
3999{
4000 int i;
4001
4002 for (i = 0; i < n; i++)
4003 add_key(sb, s[i].name, llen);
4004}
4005
4006static void add_hpp_sort_string(struct strbuf *sb, struct hpp_dimension *s, int n,
4007 int *llen)
4008{
4009 int i;
4010
4011 for (i = 0; i < n; i++)
4012 add_key(sb, s[i].name, llen);
4013}
4014
871893d7 4015char *sort_help(const char *prefix, enum sort_mode mode)
702fb9b4
AK		 4016{
4017 struct strbuf sb;
4018 char *s;
4019 int len = strlen(prefix) + INDENT;
4020
4021 strbuf_init(&sb, 300);
4022 strbuf_addstr(&sb, prefix);
4023 add_hpp_sort_string(&sb, hpp_sort_dimensions,
4024 ARRAY_SIZE(hpp_sort_dimensions), &len);
4025 add_sort_string(&sb, common_sort_dimensions,
4026 ARRAY_SIZE(common_sort_dimensions), &len);
871893d7
NK		 4027 if (mode == SORT_MODE__NORMAL || mode == SORT_MODE__BRANCH)
4028 add_sort_string(&sb, bstack_sort_dimensions,
4029 ARRAY_SIZE(bstack_sort_dimensions), &len);
4030 if (mode == SORT_MODE__NORMAL || mode == SORT_MODE__MEMORY)
4031 add_sort_string(&sb, memory_sort_dimensions,
4032 ARRAY_SIZE(memory_sort_dimensions), &len);
702fb9b4
AK		 4033 s = strbuf_detach(&sb, NULL);
4034 strbuf_release(&sb);
4035 return s;
4036}
Linux 6.x block layer and io_uring tree(s)