xref: /linux/tools/perf/util/sort.c (revision fd45d52e)
1 // SPDX-License-Identifier: GPL-2.0
2 #include <errno.h>
3 #include <inttypes.h>
4 #include <regex.h>
5 #include <stdlib.h>
6 #include <linux/mman.h>
7 #include <linux/time64.h>
8 #include "debug.h"
9 #include "dso.h"
10 #include "sort.h"
11 #include "hist.h"
12 #include "cacheline.h"
13 #include "comm.h"
14 #include "map.h"
15 #include "maps.h"
16 #include "symbol.h"
17 #include "map_symbol.h"
18 #include "branch.h"
19 #include "thread.h"
20 #include "evsel.h"
21 #include "evlist.h"
22 #include "srcline.h"
23 #include "strlist.h"
24 #include "strbuf.h"
25 #include "mem-events.h"
26 #include "mem-info.h"
27 #include "annotate.h"
28 #include "annotate-data.h"
29 #include "event.h"
30 #include "time-utils.h"
31 #include "cgroup.h"
32 #include "machine.h"
33 #include "trace-event.h"
34 #include <linux/kernel.h>
35 #include <linux/string.h>
36 
37 #ifdef HAVE_LIBTRACEEVENT
38 #include <traceevent/event-parse.h>
39 #endif
40 
41 regex_t		parent_regex;
42 const char	default_parent_pattern[] = "^sys_|^do_page_fault";
43 const char	*parent_pattern = default_parent_pattern;
44 const char	*default_sort_order = "comm,dso,symbol";
45 const char	default_branch_sort_order[] = "comm,dso_from,symbol_from,symbol_to,cycles";
46 const 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";
47 const char	default_top_sort_order[] = "dso,symbol";
48 const char	default_diff_sort_order[] = "dso,symbol";
49 const char	default_tracepoint_sort_order[] = "trace";
50 const char	*sort_order;
51 const char	*field_order;
52 regex_t		ignore_callees_regex;
53 int		have_ignore_callees = 0;
54 enum sort_mode	sort__mode = SORT_MODE__NORMAL;
55 static const char *const dynamic_headers[] = {"local_ins_lat", "ins_lat", "local_p_stage_cyc", "p_stage_cyc"};
56 static const char *const arch_specific_sort_keys[] = {"local_p_stage_cyc", "p_stage_cyc"};
57 
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  */
63 bool chk_double_cl;
64 
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,
71  * replacing all occurrences of this separator in symbol names (and other
72  * output) with a '.' character, that thus it's the only non valid separator.
73 */
repsep_snprintf(char * bf,size_t size,const char * fmt,...)74 static int repsep_snprintf(char *bf, size_t size, const char *fmt, ...)
75 {
76 	int n;
77 	va_list ap;
78 
79 	va_start(ap, fmt);
80 	n = vsnprintf(bf, size, fmt, ap);
81 	if (symbol_conf.field_sep && n > 0) {
82 		char *sep = bf;
83 
84 		while (1) {
85 			sep = strchr(sep, *symbol_conf.field_sep);
86 			if (sep == NULL)
87 				break;
88 			*sep = '.';
89 		}
90 	}
91 	va_end(ap);
92 
93 	if (n >= (int)size)
94 		return size - 1;
95 	return n;
96 }
97 
cmp_null(const void * l,const void * r)98 static int64_t cmp_null(const void *l, const void *r)
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 
110 static int64_t
sort__thread_cmp(struct hist_entry * left,struct hist_entry * right)111 sort__thread_cmp(struct hist_entry *left, struct hist_entry *right)
112 {
113 	return thread__tid(right->thread) - thread__tid(left->thread);
114 }
115 
hist_entry__thread_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)116 static int hist_entry__thread_snprintf(struct hist_entry *he, char *bf,
117 				       size_t size, unsigned int width)
118 {
119 	const char *comm = thread__comm_str(he->thread);
120 
121 	width = max(7U, width) - 8;
122 	return repsep_snprintf(bf, size, "%7d:%-*.*s", thread__tid(he->thread),
123 			       width, width, comm ?: "");
124 }
125 
hist_entry__thread_filter(struct hist_entry * he,int type,const void * arg)126 static 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 
133 	return th && !RC_CHK_EQUAL(he->thread, th);
134 }
135 
136 struct sort_entry sort_thread = {
137 	.se_header	= "    Pid:Command",
138 	.se_cmp		= sort__thread_cmp,
139 	.se_snprintf	= hist_entry__thread_snprintf,
140 	.se_filter	= hist_entry__thread_filter,
141 	.se_width_idx	= HISTC_THREAD,
142 };
143 
144 /* --sort simd */
145 
146 static int64_t
sort__simd_cmp(struct hist_entry * left,struct hist_entry * right)147 sort__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 
hist_entry__get_simd_name(struct simd_flags * simd_flags)155 static 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 
hist_entry__simd_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width __maybe_unused)165 static 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 
183 struct 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 
190 /* --sort comm */
191 
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  */
197 static int64_t
sort__comm_cmp(struct hist_entry * left,struct hist_entry * right)198 sort__comm_cmp(struct hist_entry *left, struct hist_entry *right)
199 {
200 	return strcmp(comm__str(right->comm), comm__str(left->comm));
201 }
202 
203 static int64_t
sort__comm_collapse(struct hist_entry * left,struct hist_entry * right)204 sort__comm_collapse(struct hist_entry *left, struct hist_entry *right)
205 {
206 	return strcmp(comm__str(right->comm), comm__str(left->comm));
207 }
208 
209 static int64_t
sort__comm_sort(struct hist_entry * left,struct hist_entry * right)210 sort__comm_sort(struct hist_entry *left, struct hist_entry *right)
211 {
212 	return strcmp(comm__str(right->comm), comm__str(left->comm));
213 }
214 
hist_entry__comm_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)215 static int hist_entry__comm_snprintf(struct hist_entry *he, char *bf,
216 				     size_t size, unsigned int width)
217 {
218 	return repsep_snprintf(bf, size, "%-*.*s", width, width, comm__str(he->comm));
219 }
220 
221 struct sort_entry sort_comm = {
222 	.se_header	= "Command",
223 	.se_cmp		= sort__comm_cmp,
224 	.se_collapse	= sort__comm_collapse,
225 	.se_sort	= sort__comm_sort,
226 	.se_snprintf	= hist_entry__comm_snprintf,
227 	.se_filter	= hist_entry__thread_filter,
228 	.se_width_idx	= HISTC_COMM,
229 };
230 
231 /* --sort dso */
232 
_sort__dso_cmp(struct map * map_l,struct map * map_r)233 static int64_t _sort__dso_cmp(struct map *map_l, struct map *map_r)
234 {
235 	struct dso *dso_l = map_l ? map__dso(map_l) : NULL;
236 	struct dso *dso_r = map_r ? map__dso(map_r) : NULL;
237 	const char *dso_name_l, *dso_name_r;
238 
239 	if (!dso_l || !dso_r)
240 		return cmp_null(dso_r, dso_l);
241 
242 	if (verbose > 0) {
243 		dso_name_l = dso__long_name(dso_l);
244 		dso_name_r = dso__long_name(dso_r);
245 	} else {
246 		dso_name_l = dso__short_name(dso_l);
247 		dso_name_r = dso__short_name(dso_r);
248 	}
249 
250 	return strcmp(dso_name_l, dso_name_r);
251 }
252 
253 static int64_t
sort__dso_cmp(struct hist_entry * left,struct hist_entry * right)254 sort__dso_cmp(struct hist_entry *left, struct hist_entry *right)
255 {
256 	return _sort__dso_cmp(right->ms.map, left->ms.map);
257 }
258 
_hist_entry__dso_snprintf(struct map * map,char * bf,size_t size,unsigned int width)259 static int _hist_entry__dso_snprintf(struct map *map, char *bf,
260 				     size_t size, unsigned int width)
261 {
262 	const struct dso *dso = map ? map__dso(map) : NULL;
263 	const char *dso_name = "[unknown]";
264 
265 	if (dso)
266 		dso_name = verbose > 0 ? dso__long_name(dso) : dso__short_name(dso);
267 
268 	return repsep_snprintf(bf, size, "%-*.*s", width, width, dso_name);
269 }
270 
hist_entry__dso_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)271 static int hist_entry__dso_snprintf(struct hist_entry *he, char *bf,
272 				    size_t size, unsigned int width)
273 {
274 	return _hist_entry__dso_snprintf(he->ms.map, bf, size, width);
275 }
276 
hist_entry__dso_filter(struct hist_entry * he,int type,const void * arg)277 static 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 
284 	return dso && (!he->ms.map || map__dso(he->ms.map) != dso);
285 }
286 
287 struct sort_entry sort_dso = {
288 	.se_header	= "Shared Object",
289 	.se_cmp		= sort__dso_cmp,
290 	.se_snprintf	= hist_entry__dso_snprintf,
291 	.se_filter	= hist_entry__dso_filter,
292 	.se_width_idx	= HISTC_DSO,
293 };
294 
295 /* --sort symbol */
296 
_sort__addr_cmp(u64 left_ip,u64 right_ip)297 static int64_t _sort__addr_cmp(u64 left_ip, u64 right_ip)
298 {
299 	return (int64_t)(right_ip - left_ip);
300 }
301 
_sort__sym_cmp(struct symbol * sym_l,struct symbol * sym_r)302 int64_t _sort__sym_cmp(struct symbol *sym_l, struct symbol *sym_r)
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 
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 	}
318 
319 	if (sym_l->start != sym_r->start)
320 		return (int64_t)(sym_r->start - sym_l->start);
321 
322 	return (int64_t)(sym_r->end - sym_l->end);
323 }
324 
325 static int64_t
sort__sym_cmp(struct hist_entry * left,struct hist_entry * right)326 sort__sym_cmp(struct hist_entry *left, struct hist_entry *right)
327 {
328 	int64_t ret;
329 
330 	if (!left->ms.sym && !right->ms.sym)
331 		return _sort__addr_cmp(left->ip, right->ip);
332 
333 	/*
334 	 * comparing symbol address alone is not enough since it's a
335 	 * relative address within a dso.
336 	 */
337 	if (!hists__has(left->hists, dso)) {
338 		ret = sort__dso_cmp(left, right);
339 		if (ret != 0)
340 			return ret;
341 	}
342 
343 	return _sort__sym_cmp(left->ms.sym, right->ms.sym);
344 }
345 
346 static int64_t
sort__sym_sort(struct hist_entry * left,struct hist_entry * right)347 sort__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 
_hist_entry__sym_snprintf(struct map_symbol * ms,u64 ip,char level,char * bf,size_t size,unsigned int width)355 static int _hist_entry__sym_snprintf(struct map_symbol *ms,
356 				     u64 ip, char level, char *bf, size_t size,
357 				     unsigned int width)
358 {
359 	struct symbol *sym = ms->sym;
360 	struct map *map = ms->map;
361 	size_t ret = 0;
362 
363 	if (verbose > 0) {
364 		struct dso *dso = map ? map__dso(map) : NULL;
365 		char o = dso ? dso__symtab_origin(dso) : '!';
366 		u64 rip = ip;
367 
368 		if (dso && dso__kernel(dso) && dso__adjust_symbols(dso))
369 			rip = map__unmap_ip(map, ip);
370 
371 		ret += repsep_snprintf(bf, size, "%-#*llx %c ",
372 				       BITS_PER_LONG / 4 + 2, rip, o);
373 	}
374 
375 	ret += repsep_snprintf(bf + ret, size - ret, "[%c] ", level);
376 	if (sym && map) {
377 		if (sym->type == STT_OBJECT) {
378 			ret += repsep_snprintf(bf + ret, size - ret, "%s", sym->name);
379 			ret += repsep_snprintf(bf + ret, size - ret, "+0x%llx",
380 					ip - map__unmap_ip(map, sym->start));
381 		} else {
382 			ret += repsep_snprintf(bf + ret, size - ret, "%.*s",
383 					       width - ret,
384 					       sym->name);
385 			if (sym->inlined)
386 				ret += repsep_snprintf(bf + ret, size - ret,
387 						       " (inlined)");
388 		}
389 	} else {
390 		size_t len = BITS_PER_LONG / 4;
391 		ret += repsep_snprintf(bf + ret, size - ret, "%-#.*llx",
392 				       len, ip);
393 	}
394 
395 	return ret;
396 }
397 
hist_entry__sym_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)398 int hist_entry__sym_snprintf(struct hist_entry *he, char *bf, size_t size, unsigned int width)
399 {
400 	return _hist_entry__sym_snprintf(&he->ms, he->ip,
401 					 he->level, bf, size, width);
402 }
403 
hist_entry__sym_filter(struct hist_entry * he,int type,const void * arg)404 static 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 
414 struct sort_entry sort_sym = {
415 	.se_header	= "Symbol",
416 	.se_cmp		= sort__sym_cmp,
417 	.se_sort	= sort__sym_sort,
418 	.se_snprintf	= hist_entry__sym_snprintf,
419 	.se_filter	= hist_entry__sym_filter,
420 	.se_width_idx	= HISTC_SYMBOL,
421 };
422 
423 /* --sort symoff */
424 
425 static int64_t
sort__symoff_cmp(struct hist_entry * left,struct hist_entry * right)426 sort__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 
437 static int64_t
sort__symoff_sort(struct hist_entry * left,struct hist_entry * right)438 sort__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 
449 static int
hist_entry__symoff_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)450 hist_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 
460 struct 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 
469 /* --sort srcline */
470 
hist_entry__srcline(struct hist_entry * he)471 char *hist_entry__srcline(struct hist_entry *he)
472 {
473 	return map__srcline(he->ms.map, he->ip, he->ms.sym);
474 }
475 
476 static int64_t
sort__srcline_cmp(struct hist_entry * left,struct hist_entry * right)477 sort__srcline_cmp(struct hist_entry *left, struct hist_entry *right)
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 
488 static int64_t
sort__srcline_collapse(struct hist_entry * left,struct hist_entry * right)489 sort__srcline_collapse(struct hist_entry *left, struct hist_entry *right)
490 {
491 	if (!left->srcline)
492 		left->srcline = hist_entry__srcline(left);
493 	if (!right->srcline)
494 		right->srcline = hist_entry__srcline(right);
495 
496 	return strcmp(right->srcline, left->srcline);
497 }
498 
499 static int64_t
sort__srcline_sort(struct hist_entry * left,struct hist_entry * right)500 sort__srcline_sort(struct hist_entry *left, struct hist_entry *right)
501 {
502 	return sort__srcline_collapse(left, right);
503 }
504 
505 static void
sort__srcline_init(struct hist_entry * he)506 sort__srcline_init(struct hist_entry *he)
507 {
508 	if (!he->srcline)
509 		he->srcline = hist_entry__srcline(he);
510 }
511 
hist_entry__srcline_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)512 static int hist_entry__srcline_snprintf(struct hist_entry *he, char *bf,
513 					size_t size, unsigned int width)
514 {
515 	return repsep_snprintf(bf, size, "%-.*s", width, he->srcline);
516 }
517 
518 struct sort_entry sort_srcline = {
519 	.se_header	= "Source:Line",
520 	.se_cmp		= sort__srcline_cmp,
521 	.se_collapse	= sort__srcline_collapse,
522 	.se_sort	= sort__srcline_sort,
523 	.se_init	= sort__srcline_init,
524 	.se_snprintf	= hist_entry__srcline_snprintf,
525 	.se_width_idx	= HISTC_SRCLINE,
526 };
527 
528 /* --sort srcline_from */
529 
addr_map_symbol__srcline(struct addr_map_symbol * ams)530 static char *addr_map_symbol__srcline(struct addr_map_symbol *ams)
531 {
532 	return map__srcline(ams->ms.map, ams->al_addr, ams->ms.sym);
533 }
534 
535 static int64_t
sort__srcline_from_cmp(struct hist_entry * left,struct hist_entry * right)536 sort__srcline_from_cmp(struct hist_entry *left, struct hist_entry *right)
537 {
538 	return left->branch_info->from.addr - right->branch_info->from.addr;
539 }
540 
541 static int64_t
sort__srcline_from_collapse(struct hist_entry * left,struct hist_entry * right)542 sort__srcline_from_collapse(struct hist_entry *left, struct hist_entry *right)
543 {
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 
550 	return strcmp(right->branch_info->srcline_from, left->branch_info->srcline_from);
551 }
552 
553 static int64_t
sort__srcline_from_sort(struct hist_entry * left,struct hist_entry * right)554 sort__srcline_from_sort(struct hist_entry *left, struct hist_entry *right)
555 {
556 	return sort__srcline_from_collapse(left, right);
557 }
558 
sort__srcline_from_init(struct hist_entry * he)559 static 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 
hist_entry__srcline_from_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)565 static 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 
571 struct sort_entry sort_srcline_from = {
572 	.se_header	= "From Source:Line",
573 	.se_cmp		= sort__srcline_from_cmp,
574 	.se_collapse	= sort__srcline_from_collapse,
575 	.se_sort	= sort__srcline_from_sort,
576 	.se_init	= sort__srcline_from_init,
577 	.se_snprintf	= hist_entry__srcline_from_snprintf,
578 	.se_width_idx	= HISTC_SRCLINE_FROM,
579 };
580 
581 /* --sort srcline_to */
582 
583 static int64_t
sort__srcline_to_cmp(struct hist_entry * left,struct hist_entry * right)584 sort__srcline_to_cmp(struct hist_entry *left, struct hist_entry *right)
585 {
586 	return left->branch_info->to.addr - right->branch_info->to.addr;
587 }
588 
589 static int64_t
sort__srcline_to_collapse(struct hist_entry * left,struct hist_entry * right)590 sort__srcline_to_collapse(struct hist_entry *left, struct hist_entry *right)
591 {
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 
598 	return strcmp(right->branch_info->srcline_to, left->branch_info->srcline_to);
599 }
600 
601 static int64_t
sort__srcline_to_sort(struct hist_entry * left,struct hist_entry * right)602 sort__srcline_to_sort(struct hist_entry *left, struct hist_entry *right)
603 {
604 	return sort__srcline_to_collapse(left, right);
605 }
606 
sort__srcline_to_init(struct hist_entry * he)607 static 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 
hist_entry__srcline_to_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)613 static 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 
619 struct sort_entry sort_srcline_to = {
620 	.se_header	= "To Source:Line",
621 	.se_cmp		= sort__srcline_to_cmp,
622 	.se_collapse	= sort__srcline_to_collapse,
623 	.se_sort	= sort__srcline_to_sort,
624 	.se_init	= sort__srcline_to_init,
625 	.se_snprintf	= hist_entry__srcline_to_snprintf,
626 	.se_width_idx	= HISTC_SRCLINE_TO,
627 };
628 
hist_entry__sym_ipc_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)629 static 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;
634 	struct annotated_branch *branch;
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 
641 	branch = symbol__annotation(sym)->branch;
642 
643 	if (branch && branch->hit_cycles)
644 		ipc = branch->hit_insn / ((double)branch->hit_cycles);
645 
646 	if (branch && branch->total_insn) {
647 		coverage = branch->cover_insn * 100.0 /
648 			((double)branch->total_insn);
649 	}
650 
651 	snprintf(tmp, sizeof(tmp), "%-5.2f [%5.1f%%]", ipc, coverage);
652 	return repsep_snprintf(bf, size, "%-*s", width, tmp);
653 }
654 
655 struct 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 
hist_entry__sym_ipc_null_snprintf(struct hist_entry * he __maybe_unused,char * bf,size_t size,unsigned int width)662 static 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 
673 struct 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 
680 /* --sort srcfile */
681 
682 static char no_srcfile[1];
683 
hist_entry__get_srcfile(struct hist_entry * e)684 static char *hist_entry__get_srcfile(struct hist_entry *e)
685 {
686 	char *sf, *p;
687 	struct map *map = e->ms.map;
688 
689 	if (!map)
690 		return no_srcfile;
691 
692 	sf = __get_srcline(map__dso(map), map__rip_2objdump(map, e->ip),
693 			 e->ms.sym, false, true, true, e->ip);
694 	if (sf == SRCLINE_UNKNOWN)
695 		return no_srcfile;
696 	p = strchr(sf, ':');
697 	if (p && *sf) {
698 		*p = 0;
699 		return sf;
700 	}
701 	free(sf);
702 	return no_srcfile;
703 }
704 
705 static int64_t
sort__srcfile_cmp(struct hist_entry * left,struct hist_entry * right)706 sort__srcfile_cmp(struct hist_entry *left, struct hist_entry *right)
707 {
708 	return sort__srcline_cmp(left, right);
709 }
710 
711 static int64_t
sort__srcfile_collapse(struct hist_entry * left,struct hist_entry * right)712 sort__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 
722 static int64_t
sort__srcfile_sort(struct hist_entry * left,struct hist_entry * right)723 sort__srcfile_sort(struct hist_entry *left, struct hist_entry *right)
724 {
725 	return sort__srcfile_collapse(left, right);
726 }
727 
sort__srcfile_init(struct hist_entry * he)728 static void sort__srcfile_init(struct hist_entry *he)
729 {
730 	if (!he->srcfile)
731 		he->srcfile = hist_entry__get_srcfile(he);
732 }
733 
hist_entry__srcfile_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)734 static int hist_entry__srcfile_snprintf(struct hist_entry *he, char *bf,
735 					size_t size, unsigned int width)
736 {
737 	return repsep_snprintf(bf, size, "%-.*s", width, he->srcfile);
738 }
739 
740 struct sort_entry sort_srcfile = {
741 	.se_header	= "Source File",
742 	.se_cmp		= sort__srcfile_cmp,
743 	.se_collapse	= sort__srcfile_collapse,
744 	.se_sort	= sort__srcfile_sort,
745 	.se_init	= sort__srcfile_init,
746 	.se_snprintf	= hist_entry__srcfile_snprintf,
747 	.se_width_idx	= HISTC_SRCFILE,
748 };
749 
750 /* --sort parent */
751 
752 static int64_t
sort__parent_cmp(struct hist_entry * left,struct hist_entry * right)753 sort__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 
761 	return strcmp(sym_r->name, sym_l->name);
762 }
763 
hist_entry__parent_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)764 static int hist_entry__parent_snprintf(struct hist_entry *he, char *bf,
765 				       size_t size, unsigned int width)
766 {
767 	return repsep_snprintf(bf, size, "%-*.*s", width, width,
768 			      he->parent ? he->parent->name : "[other]");
769 }
770 
771 struct 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 
778 /* --sort cpu */
779 
780 static int64_t
sort__cpu_cmp(struct hist_entry * left,struct hist_entry * right)781 sort__cpu_cmp(struct hist_entry *left, struct hist_entry *right)
782 {
783 	return right->cpu - left->cpu;
784 }
785 
hist_entry__cpu_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)786 static int hist_entry__cpu_snprintf(struct hist_entry *he, char *bf,
787 				    size_t size, unsigned int width)
788 {
789 	return repsep_snprintf(bf, size, "%*.*d", width, width, he->cpu);
790 }
791 
792 struct 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 
799 /* --sort cgroup_id */
800 
_sort__cgroup_dev_cmp(u64 left_dev,u64 right_dev)801 static int64_t _sort__cgroup_dev_cmp(u64 left_dev, u64 right_dev)
802 {
803 	return (int64_t)(right_dev - left_dev);
804 }
805 
_sort__cgroup_inode_cmp(u64 left_ino,u64 right_ino)806 static int64_t _sort__cgroup_inode_cmp(u64 left_ino, u64 right_ino)
807 {
808 	return (int64_t)(right_ino - left_ino);
809 }
810 
811 static int64_t
sort__cgroup_id_cmp(struct hist_entry * left,struct hist_entry * right)812 sort__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 
hist_entry__cgroup_id_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width __maybe_unused)824 static 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 
832 struct 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 
839 /* --sort cgroup */
840 
841 static int64_t
sort__cgroup_cmp(struct hist_entry * left,struct hist_entry * right)842 sort__cgroup_cmp(struct hist_entry *left, struct hist_entry *right)
843 {
844 	return right->cgroup - left->cgroup;
845 }
846 
hist_entry__cgroup_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width __maybe_unused)847 static 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) {
854 		struct cgroup *cgrp = cgroup__find(maps__machine(he->ms.maps)->env,
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 
865 struct 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 
872 /* --sort socket */
873 
874 static int64_t
sort__socket_cmp(struct hist_entry * left,struct hist_entry * right)875 sort__socket_cmp(struct hist_entry *left, struct hist_entry *right)
876 {
877 	return right->socket - left->socket;
878 }
879 
hist_entry__socket_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)880 static 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 
hist_entry__socket_filter(struct hist_entry * he,int type,const void * arg)886 static 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 
896 struct sort_entry sort_socket = {
897 	.se_header      = "Socket",
898 	.se_cmp	        = sort__socket_cmp,
899 	.se_snprintf    = hist_entry__socket_snprintf,
900 	.se_filter      = hist_entry__socket_filter,
901 	.se_width_idx	= HISTC_SOCKET,
902 };
903 
904 /* --sort time */
905 
906 static int64_t
sort__time_cmp(struct hist_entry * left,struct hist_entry * right)907 sort__time_cmp(struct hist_entry *left, struct hist_entry *right)
908 {
909 	return right->time - left->time;
910 }
911 
hist_entry__time_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)912 static int hist_entry__time_snprintf(struct hist_entry *he, char *bf,
913 				    size_t size, unsigned int width)
914 {
915 	char he_time[32];
916 
917 	if (symbol_conf.nanosecs)
918 		timestamp__scnprintf_nsec(he->time, he_time,
919 					  sizeof(he_time));
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 
927 struct 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 
934 /* --sort trace */
935 
936 #ifdef HAVE_LIBTRACEEVENT
get_trace_output(struct hist_entry * he)937 static char *get_trace_output(struct hist_entry *he)
938 {
939 	struct trace_seq seq;
940 	struct evsel *evsel;
941 	struct tep_record rec = {
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);
949 	if (symbol_conf.raw_trace) {
950 		tep_print_fields(&seq, he->raw_data, he->raw_size,
951 				 evsel->tp_format);
952 	} else {
953 		tep_print_event(evsel->tp_format->tep,
954 				&seq, &rec, "%s", TEP_PRINT_INFO);
955 	}
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);
961 }
962 
963 static int64_t
sort__trace_cmp(struct hist_entry * left,struct hist_entry * right)964 sort__trace_cmp(struct hist_entry *left, struct hist_entry *right)
965 {
966 	struct evsel *evsel;
967 
968 	evsel = hists_to_evsel(left->hists);
969 	if (evsel->core.attr.type != PERF_TYPE_TRACEPOINT)
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 
977 	return strcmp(right->trace_output, left->trace_output);
978 }
979 
hist_entry__trace_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)980 static int hist_entry__trace_snprintf(struct hist_entry *he, char *bf,
981 				    size_t size, unsigned int width)
982 {
983 	struct evsel *evsel;
984 
985 	evsel = hists_to_evsel(he->hists);
986 	if (evsel->core.attr.type != PERF_TYPE_TRACEPOINT)
987 		return scnprintf(bf, size, "%-.*s", width, "N/A");
988 
989 	if (he->trace_output == NULL)
990 		he->trace_output = get_trace_output(he);
991 	return repsep_snprintf(bf, size, "%-.*s", width, he->trace_output);
992 }
993 
994 struct 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 };
1000 #endif /* HAVE_LIBTRACEEVENT */
1001 
1002 /* sort keys for branch stacks */
1003 
1004 static int64_t
sort__dso_from_cmp(struct hist_entry * left,struct hist_entry * right)1005 sort__dso_from_cmp(struct hist_entry *left, struct hist_entry *right)
1006 {
1007 	if (!left->branch_info || !right->branch_info)
1008 		return cmp_null(left->branch_info, right->branch_info);
1009 
1010 	return _sort__dso_cmp(left->branch_info->from.ms.map,
1011 			      right->branch_info->from.ms.map);
1012 }
1013 
hist_entry__dso_from_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1014 static int hist_entry__dso_from_snprintf(struct hist_entry *he, char *bf,
1015 				    size_t size, unsigned int width)
1016 {
1017 	if (he->branch_info)
1018 		return _hist_entry__dso_snprintf(he->branch_info->from.ms.map,
1019 						 bf, size, width);
1020 	else
1021 		return repsep_snprintf(bf, size, "%-*.*s", width, width, "N/A");
1022 }
1023 
hist_entry__dso_from_filter(struct hist_entry * he,int type,const void * arg)1024 static 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 
1032 	return dso && (!he->branch_info || !he->branch_info->from.ms.map ||
1033 		map__dso(he->branch_info->from.ms.map) != dso);
1034 }
1035 
1036 static int64_t
sort__dso_to_cmp(struct hist_entry * left,struct hist_entry * right)1037 sort__dso_to_cmp(struct hist_entry *left, struct hist_entry *right)
1038 {
1039 	if (!left->branch_info || !right->branch_info)
1040 		return cmp_null(left->branch_info, right->branch_info);
1041 
1042 	return _sort__dso_cmp(left->branch_info->to.ms.map,
1043 			      right->branch_info->to.ms.map);
1044 }
1045 
hist_entry__dso_to_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1046 static int hist_entry__dso_to_snprintf(struct hist_entry *he, char *bf,
1047 				       size_t size, unsigned int width)
1048 {
1049 	if (he->branch_info)
1050 		return _hist_entry__dso_snprintf(he->branch_info->to.ms.map,
1051 						 bf, size, width);
1052 	else
1053 		return repsep_snprintf(bf, size, "%-*.*s", width, width, "N/A");
1054 }
1055 
hist_entry__dso_to_filter(struct hist_entry * he,int type,const void * arg)1056 static 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 
1064 	return dso && (!he->branch_info || !he->branch_info->to.ms.map ||
1065 		map__dso(he->branch_info->to.ms.map) != dso);
1066 }
1067 
1068 static int64_t
sort__sym_from_cmp(struct hist_entry * left,struct hist_entry * right)1069 sort__sym_from_cmp(struct hist_entry *left, struct hist_entry *right)
1070 {
1071 	struct addr_map_symbol *from_l, *from_r;
1072 
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 
1079 	if (!from_l->ms.sym && !from_r->ms.sym)
1080 		return _sort__addr_cmp(from_l->addr, from_r->addr);
1081 
1082 	return _sort__sym_cmp(from_l->ms.sym, from_r->ms.sym);
1083 }
1084 
1085 static int64_t
sort__sym_to_cmp(struct hist_entry * left,struct hist_entry * right)1086 sort__sym_to_cmp(struct hist_entry *left, struct hist_entry *right)
1087 {
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;
1095 
1096 	if (!to_l->ms.sym && !to_r->ms.sym)
1097 		return _sort__addr_cmp(to_l->addr, to_r->addr);
1098 
1099 	return _sort__sym_cmp(to_l->ms.sym, to_r->ms.sym);
1100 }
1101 
hist_entry__sym_from_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1102 static int hist_entry__sym_from_snprintf(struct hist_entry *he, char *bf,
1103 					 size_t size, unsigned int width)
1104 {
1105 	if (he->branch_info) {
1106 		struct addr_map_symbol *from = &he->branch_info->from;
1107 
1108 		return _hist_entry__sym_snprintf(&from->ms, from->al_addr,
1109 						 from->al_level, bf, size, width);
1110 	}
1111 
1112 	return repsep_snprintf(bf, size, "%-*.*s", width, width, "N/A");
1113 }
1114 
hist_entry__sym_to_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1115 static int hist_entry__sym_to_snprintf(struct hist_entry *he, char *bf,
1116 				       size_t size, unsigned int width)
1117 {
1118 	if (he->branch_info) {
1119 		struct addr_map_symbol *to = &he->branch_info->to;
1120 
1121 		return _hist_entry__sym_snprintf(&to->ms, to->al_addr,
1122 						 to->al_level, bf, size, width);
1123 	}
1124 
1125 	return repsep_snprintf(bf, size, "%-*.*s", width, width, "N/A");
1126 }
1127 
hist_entry__sym_from_filter(struct hist_entry * he,int type,const void * arg)1128 static 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 
1136 	return sym && !(he->branch_info && he->branch_info->from.ms.sym &&
1137 			strstr(he->branch_info->from.ms.sym->name, sym));
1138 }
1139 
hist_entry__sym_to_filter(struct hist_entry * he,int type,const void * arg)1140 static 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 
1148 	return sym && !(he->branch_info && he->branch_info->to.ms.sym &&
1149 		        strstr(he->branch_info->to.ms.sym->name, sym));
1150 }
1151 
1152 struct 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,
1156 	.se_filter	= hist_entry__dso_from_filter,
1157 	.se_width_idx	= HISTC_DSO_FROM,
1158 };
1159 
1160 struct 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,
1164 	.se_filter	= hist_entry__dso_to_filter,
1165 	.se_width_idx	= HISTC_DSO_TO,
1166 };
1167 
1168 struct 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,
1172 	.se_filter	= hist_entry__sym_from_filter,
1173 	.se_width_idx	= HISTC_SYMBOL_FROM,
1174 };
1175 
1176 struct 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,
1180 	.se_filter	= hist_entry__sym_to_filter,
1181 	.se_width_idx	= HISTC_SYMBOL_TO,
1182 };
1183 
_hist_entry__addr_snprintf(struct map_symbol * ms,u64 ip,char level,char * bf,size_t size,unsigned int width)1184 static 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",
1197 					ip - map__unmap_ip(map, sym->start));
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 
hist_entry__addr_from_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1215 static 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 
hist_entry__addr_to_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1228 static 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 
1241 static int64_t
sort__addr_from_cmp(struct hist_entry * left,struct hist_entry * right)1242 sort__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 
1265 static int64_t
sort__addr_to_cmp(struct hist_entry * left,struct hist_entry * right)1266 sort__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 
1289 struct 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 
1297 struct 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 
1306 static int64_t
sort__mispredict_cmp(struct hist_entry * left,struct hist_entry * right)1307 sort__mispredict_cmp(struct hist_entry *left, struct hist_entry *right)
1308 {
1309 	unsigned char mp, p;
1310 
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;
1316 	return mp || p;
1317 }
1318 
hist_entry__mispredict_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1319 static int hist_entry__mispredict_snprintf(struct hist_entry *he, char *bf,
1320 				    size_t size, unsigned int width){
1321 	static const char *out = "N/A";
1322 
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 	}
1329 
1330 	return repsep_snprintf(bf, size, "%-*.*s", width, width, out);
1331 }
1332 
1333 static int64_t
sort__cycles_cmp(struct hist_entry * left,struct hist_entry * right)1334 sort__cycles_cmp(struct hist_entry *left, struct hist_entry *right)
1335 {
1336 	if (!left->branch_info || !right->branch_info)
1337 		return cmp_null(left->branch_info, right->branch_info);
1338 
1339 	return left->branch_info->flags.cycles -
1340 		right->branch_info->flags.cycles;
1341 }
1342 
hist_entry__cycles_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1343 static int hist_entry__cycles_snprintf(struct hist_entry *he, char *bf,
1344 				    size_t size, unsigned int width)
1345 {
1346 	if (!he->branch_info)
1347 		return scnprintf(bf, size, "%-.*s", width, "N/A");
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 
1354 struct 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 
1361 /* --sort daddr_sym */
1362 int64_t
sort__daddr_cmp(struct hist_entry * left,struct hist_entry * right)1363 sort__daddr_cmp(struct hist_entry *left, struct hist_entry *right)
1364 {
1365 	uint64_t l = 0, r = 0;
1366 
1367 	if (left->mem_info)
1368 		l = mem_info__daddr(left->mem_info)->addr;
1369 	if (right->mem_info)
1370 		r = mem_info__daddr(right->mem_info)->addr;
1371 
1372 	return (int64_t)(r - l);
1373 }
1374 
hist_entry__daddr_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1375 static int hist_entry__daddr_snprintf(struct hist_entry *he, char *bf,
1376 				    size_t size, unsigned int width)
1377 {
1378 	uint64_t addr = 0;
1379 	struct map_symbol *ms = NULL;
1380 
1381 	if (he->mem_info) {
1382 		addr = mem_info__daddr(he->mem_info)->addr;
1383 		ms = &mem_info__daddr(he->mem_info)->ms;
1384 	}
1385 	return _hist_entry__sym_snprintf(ms, addr, he->level, bf, size, width);
1386 }
1387 
1388 int64_t
sort__iaddr_cmp(struct hist_entry * left,struct hist_entry * right)1389 sort__iaddr_cmp(struct hist_entry *left, struct hist_entry *right)
1390 {
1391 	uint64_t l = 0, r = 0;
1392 
1393 	if (left->mem_info)
1394 		l = mem_info__iaddr(left->mem_info)->addr;
1395 	if (right->mem_info)
1396 		r = mem_info__iaddr(right->mem_info)->addr;
1397 
1398 	return (int64_t)(r - l);
1399 }
1400 
hist_entry__iaddr_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1401 static int hist_entry__iaddr_snprintf(struct hist_entry *he, char *bf,
1402 				    size_t size, unsigned int width)
1403 {
1404 	uint64_t addr = 0;
1405 	struct map_symbol *ms = NULL;
1406 
1407 	if (he->mem_info) {
1408 		addr = mem_info__iaddr(he->mem_info)->addr;
1409 		ms   = &mem_info__iaddr(he->mem_info)->ms;
1410 	}
1411 	return _hist_entry__sym_snprintf(ms, addr, he->level, bf, size, width);
1412 }
1413 
1414 static int64_t
sort__dso_daddr_cmp(struct hist_entry * left,struct hist_entry * right)1415 sort__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)
1421 		map_l = mem_info__daddr(left->mem_info)->ms.map;
1422 	if (right->mem_info)
1423 		map_r = mem_info__daddr(right->mem_info)->ms.map;
1424 
1425 	return _sort__dso_cmp(map_l, map_r);
1426 }
1427 
hist_entry__dso_daddr_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1428 static int hist_entry__dso_daddr_snprintf(struct hist_entry *he, char *bf,
1429 				    size_t size, unsigned int width)
1430 {
1431 	struct map *map = NULL;
1432 
1433 	if (he->mem_info)
1434 		map = mem_info__daddr(he->mem_info)->ms.map;
1435 
1436 	return _hist_entry__dso_snprintf(map, bf, size, width);
1437 }
1438 
1439 static int64_t
sort__locked_cmp(struct hist_entry * left,struct hist_entry * right)1440 sort__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)
1446 		data_src_l = *mem_info__data_src(left->mem_info);
1447 	else
1448 		data_src_l.mem_lock = PERF_MEM_LOCK_NA;
1449 
1450 	if (right->mem_info)
1451 		data_src_r = *mem_info__data_src(right->mem_info);
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 
hist_entry__locked_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1458 static int hist_entry__locked_snprintf(struct hist_entry *he, char *bf,
1459 				    size_t size, unsigned int width)
1460 {
1461 	char out[10];
1462 
1463 	perf_mem__lck_scnprintf(out, sizeof(out), he->mem_info);
1464 	return repsep_snprintf(bf, size, "%.*s", width, out);
1465 }
1466 
1467 static int64_t
sort__tlb_cmp(struct hist_entry * left,struct hist_entry * right)1468 sort__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)
1474 		data_src_l = *mem_info__data_src(left->mem_info);
1475 	else
1476 		data_src_l.mem_dtlb = PERF_MEM_TLB_NA;
1477 
1478 	if (right->mem_info)
1479 		data_src_r = *mem_info__data_src(right->mem_info);
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 
hist_entry__tlb_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1486 static int hist_entry__tlb_snprintf(struct hist_entry *he, char *bf,
1487 				    size_t size, unsigned int width)
1488 {
1489 	char out[64];
1490 
1491 	perf_mem__tlb_scnprintf(out, sizeof(out), he->mem_info);
1492 	return repsep_snprintf(bf, size, "%-*s", width, out);
1493 }
1494 
1495 static int64_t
sort__lvl_cmp(struct hist_entry * left,struct hist_entry * right)1496 sort__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)
1502 		data_src_l = *mem_info__data_src(left->mem_info);
1503 	else
1504 		data_src_l.mem_lvl = PERF_MEM_LVL_NA;
1505 
1506 	if (right->mem_info)
1507 		data_src_r = *mem_info__data_src(right->mem_info);
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 
hist_entry__lvl_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1514 static int hist_entry__lvl_snprintf(struct hist_entry *he, char *bf,
1515 				    size_t size, unsigned int width)
1516 {
1517 	char out[64];
1518 
1519 	perf_mem__lvl_scnprintf(out, sizeof(out), he->mem_info);
1520 	return repsep_snprintf(bf, size, "%-*s", width, out);
1521 }
1522 
1523 static int64_t
sort__snoop_cmp(struct hist_entry * left,struct hist_entry * right)1524 sort__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)
1530 		data_src_l = *mem_info__data_src(left->mem_info);
1531 	else
1532 		data_src_l.mem_snoop = PERF_MEM_SNOOP_NA;
1533 
1534 	if (right->mem_info)
1535 		data_src_r = *mem_info__data_src(right->mem_info);
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 
hist_entry__snoop_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1542 static int hist_entry__snoop_snprintf(struct hist_entry *he, char *bf,
1543 				    size_t size, unsigned int width)
1544 {
1545 	char out[64];
1546 
1547 	perf_mem__snp_scnprintf(out, sizeof(out), he->mem_info);
1548 	return repsep_snprintf(bf, size, "%-*s", width, out);
1549 }
1550 
1551 int64_t
sort__dcacheline_cmp(struct hist_entry * left,struct hist_entry * right)1552 sort__dcacheline_cmp(struct hist_entry *left, struct hist_entry *right)
1553 {
1554 	u64 l, r;
1555 	struct map *l_map, *r_map;
1556 	struct dso *l_dso, *r_dso;
1557 	int rc;
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 
1566 	l_map = mem_info__daddr(left->mem_info)->ms.map;
1567 	r_map = mem_info__daddr(right->mem_info)->ms.map;
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 
1576 	l_dso = map__dso(l_map);
1577 	r_dso = map__dso(r_map);
1578 	rc = dso__cmp_id(l_dso, r_dso);
1579 	if (rc)
1580 		return rc;
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) &&
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) {
1592 		/* userspace anonymous */
1593 
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;
1598 	}
1599 
1600 addr:
1601 	/* al_addr does all the right addr - start + offset calculations */
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);
1604 
1605 	if (l > r) return -1;
1606 	if (l < r) return 1;
1607 
1608 	return 0;
1609 }
1610 
hist_entry__dcacheline_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1611 static 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;
1616 	struct map_symbol *ms = NULL;
1617 	char level = he->level;
1618 
1619 	if (he->mem_info) {
1620 		struct map *map = mem_info__daddr(he->mem_info)->ms.map;
1621 		struct dso *dso = map ? map__dso(map) : NULL;
1622 
1623 		addr = cl_address(mem_info__daddr(he->mem_info)->al_addr, chk_double_cl);
1624 		ms = &mem_info__daddr(he->mem_info)->ms;
1625 
1626 		/* print [s] for shared data mmaps */
1627 		if ((he->cpumode != PERF_RECORD_MISC_KERNEL) &&
1628 		     map && !(map__prot(map) & PROT_EXEC) &&
1629 		     (map__flags(map) & MAP_SHARED) &&
1630 		     (dso__id(dso)->maj || dso__id(dso)->min || dso__id(dso)->ino ||
1631 		      dso__id(dso)->ino_generation))
1632 			level = 's';
1633 		else if (!map)
1634 			level = 'X';
1635 	}
1636 	return _hist_entry__sym_snprintf(ms, addr, level, bf, size, width);
1637 }
1638 
1639 struct 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 
1646 static int64_t
sort__weight_cmp(struct hist_entry * left,struct hist_entry * right)1647 sort__weight_cmp(struct hist_entry *left, struct hist_entry *right)
1648 {
1649 	return left->weight - right->weight;
1650 }
1651 
hist_entry__local_weight_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1652 static int hist_entry__local_weight_snprintf(struct hist_entry *he, char *bf,
1653 				    size_t size, unsigned int width)
1654 {
1655 	return repsep_snprintf(bf, size, "%-*llu", width, he->weight);
1656 }
1657 
1658 struct sort_entry sort_local_weight = {
1659 	.se_header	= "Local Weight",
1660 	.se_cmp		= sort__weight_cmp,
1661 	.se_snprintf	= hist_entry__local_weight_snprintf,
1662 	.se_width_idx	= HISTC_LOCAL_WEIGHT,
1663 };
1664 
hist_entry__global_weight_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1665 static int hist_entry__global_weight_snprintf(struct hist_entry *he, char *bf,
1666 					      size_t size, unsigned int width)
1667 {
1668 	return repsep_snprintf(bf, size, "%-*llu", width,
1669 			       he->weight * he->stat.nr_events);
1670 }
1671 
1672 struct sort_entry sort_global_weight = {
1673 	.se_header	= "Weight",
1674 	.se_cmp		= sort__weight_cmp,
1675 	.se_snprintf	= hist_entry__global_weight_snprintf,
1676 	.se_width_idx	= HISTC_GLOBAL_WEIGHT,
1677 };
1678 
1679 static int64_t
sort__ins_lat_cmp(struct hist_entry * left,struct hist_entry * right)1680 sort__ins_lat_cmp(struct hist_entry *left, struct hist_entry *right)
1681 {
1682 	return left->ins_lat - right->ins_lat;
1683 }
1684 
hist_entry__local_ins_lat_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1685 static int hist_entry__local_ins_lat_snprintf(struct hist_entry *he, char *bf,
1686 					      size_t size, unsigned int width)
1687 {
1688 	return repsep_snprintf(bf, size, "%-*u", width, he->ins_lat);
1689 }
1690 
1691 struct sort_entry sort_local_ins_lat = {
1692 	.se_header	= "Local INSTR Latency",
1693 	.se_cmp		= sort__ins_lat_cmp,
1694 	.se_snprintf	= hist_entry__local_ins_lat_snprintf,
1695 	.se_width_idx	= HISTC_LOCAL_INS_LAT,
1696 };
1697 
hist_entry__global_ins_lat_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1698 static int hist_entry__global_ins_lat_snprintf(struct hist_entry *he, char *bf,
1699 					       size_t size, unsigned int width)
1700 {
1701 	return repsep_snprintf(bf, size, "%-*u", width,
1702 			       he->ins_lat * he->stat.nr_events);
1703 }
1704 
1705 struct sort_entry sort_global_ins_lat = {
1706 	.se_header	= "INSTR Latency",
1707 	.se_cmp		= sort__ins_lat_cmp,
1708 	.se_snprintf	= hist_entry__global_ins_lat_snprintf,
1709 	.se_width_idx	= HISTC_GLOBAL_INS_LAT,
1710 };
1711 
1712 static int64_t
sort__p_stage_cyc_cmp(struct hist_entry * left,struct hist_entry * right)1713 sort__p_stage_cyc_cmp(struct hist_entry *left, struct hist_entry *right)
1714 {
1715 	return left->p_stage_cyc - right->p_stage_cyc;
1716 }
1717 
hist_entry__global_p_stage_cyc_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1718 static 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 
hist_entry__p_stage_cyc_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1726 static int hist_entry__p_stage_cyc_snprintf(struct hist_entry *he, char *bf,
1727 					size_t size, unsigned int width)
1728 {
1729 	return repsep_snprintf(bf, size, "%-*u", width, he->p_stage_cyc);
1730 }
1731 
1732 struct sort_entry sort_local_p_stage_cyc = {
1733 	.se_header      = "Local Pipeline Stage Cycle",
1734 	.se_cmp         = sort__p_stage_cyc_cmp,
1735 	.se_snprintf	= hist_entry__p_stage_cyc_snprintf,
1736 	.se_width_idx	= HISTC_LOCAL_P_STAGE_CYC,
1737 };
1738 
1739 struct 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,
1744 };
1745 
1746 struct 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 
1753 struct 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 
1760 struct 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,
1764 	.se_width_idx	= HISTC_MEM_DADDR_DSO,
1765 };
1766 
1767 struct 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 
1774 struct 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 
1781 struct 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 
1788 struct 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 
1795 struct 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 
1802 static int64_t
sort__blocked_cmp(struct hist_entry * left,struct hist_entry * right)1803 sort__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)
1809 		data_src_l = *mem_info__data_src(left->mem_info);
1810 	else
1811 		data_src_l.mem_blk = PERF_MEM_BLK_NA;
1812 
1813 	if (right->mem_info)
1814 		data_src_r = *mem_info__data_src(right->mem_info);
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 
hist_entry__blocked_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1821 static 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 
1830 struct 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 
1837 static int64_t
sort__phys_daddr_cmp(struct hist_entry * left,struct hist_entry * right)1838 sort__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)
1843 		l = mem_info__daddr(left->mem_info)->phys_addr;
1844 	if (right->mem_info)
1845 		r = mem_info__daddr(right->mem_info)->phys_addr;
1846 
1847 	return (int64_t)(r - l);
1848 }
1849 
hist_entry__phys_daddr_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1850 static 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 
1857 	addr = mem_info__daddr(he->mem_info)->phys_addr;
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 
1871 struct 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 
1878 static int64_t
sort__data_page_size_cmp(struct hist_entry * left,struct hist_entry * right)1879 sort__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)
1884 		l = mem_info__daddr(left->mem_info)->data_page_size;
1885 	if (right->mem_info)
1886 		r = mem_info__daddr(right->mem_info)->data_page_size;
1887 
1888 	return (int64_t)(r - l);
1889 }
1890 
hist_entry__data_page_size_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1891 static 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,
1897 			get_page_size_name(mem_info__daddr(he->mem_info)->data_page_size, str));
1898 }
1899 
1900 struct 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 
1907 static int64_t
sort__code_page_size_cmp(struct hist_entry * left,struct hist_entry * right)1908 sort__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 
hist_entry__code_page_size_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1916 static 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 
1925 struct 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 
1932 static int64_t
sort__abort_cmp(struct hist_entry * left,struct hist_entry * right)1933 sort__abort_cmp(struct hist_entry *left, struct hist_entry *right)
1934 {
1935 	if (!left->branch_info || !right->branch_info)
1936 		return cmp_null(left->branch_info, right->branch_info);
1937 
1938 	return left->branch_info->flags.abort !=
1939 		right->branch_info->flags.abort;
1940 }
1941 
hist_entry__abort_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1942 static int hist_entry__abort_snprintf(struct hist_entry *he, char *bf,
1943 				    size_t size, unsigned int width)
1944 {
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 	}
1953 
1954 	return repsep_snprintf(bf, size, "%-*s", width, out);
1955 }
1956 
1957 struct 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 
1964 static int64_t
sort__in_tx_cmp(struct hist_entry * left,struct hist_entry * right)1965 sort__in_tx_cmp(struct hist_entry *left, struct hist_entry *right)
1966 {
1967 	if (!left->branch_info || !right->branch_info)
1968 		return cmp_null(left->branch_info, right->branch_info);
1969 
1970 	return left->branch_info->flags.in_tx !=
1971 		right->branch_info->flags.in_tx;
1972 }
1973 
hist_entry__in_tx_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)1974 static int hist_entry__in_tx_snprintf(struct hist_entry *he, char *bf,
1975 				    size_t size, unsigned int width)
1976 {
1977 	static const char *out = "N/A";
1978 
1979 	if (he->branch_info) {
1980 		if (he->branch_info->flags.in_tx)
1981 			out = "T";
1982 		else
1983 			out = ".";
1984 	}
1985 
1986 	return repsep_snprintf(bf, size, "%-*s", width, out);
1987 }
1988 
1989 struct 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 
1996 static int64_t
sort__transaction_cmp(struct hist_entry * left,struct hist_entry * right)1997 sort__transaction_cmp(struct hist_entry *left, struct hist_entry *right)
1998 {
1999 	return left->transaction - right->transaction;
2000 }
2001 
add_str(char * p,const char * str)2002 static inline char *add_str(char *p, const char *str)
2003 {
2004 	strcpy(p, str);
2005 	return p + strlen(str);
2006 }
2007 
2008 static 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 
hist_entry__transaction_len(void)2024 int 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 
hist_entry__transaction_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)2037 static int hist_entry__transaction_snprintf(struct hist_entry *he, char *bf,
2038 					    size_t size, unsigned int width)
2039 {
2040 	u64 t = he->transaction;
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 
2061 struct 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 
2068 /* --sort symbol_size */
2069 
_sort__sym_size_cmp(struct symbol * sym_l,struct symbol * sym_r)2070 static 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 
2079 static int64_t
sort__sym_size_cmp(struct hist_entry * left,struct hist_entry * right)2080 sort__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 
_hist_entry__sym_size_snprintf(struct symbol * sym,char * bf,size_t bf_size,unsigned int width)2085 static 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 
hist_entry__sym_size_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)2094 static 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 
2100 struct 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 
2107 /* --sort dso_size */
2108 
_sort__dso_size_cmp(struct map * map_l,struct map * map_r)2109 static 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 
2118 static int64_t
sort__dso_size_cmp(struct hist_entry * left,struct hist_entry * right)2119 sort__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 
_hist_entry__dso_size_snprintf(struct map * map,char * bf,size_t bf_size,unsigned int width)2124 static int _hist_entry__dso_size_snprintf(struct map *map, char *bf,
2125 					  size_t bf_size, unsigned int width)
2126 {
2127 	if (map && map__dso(map))
2128 		return repsep_snprintf(bf, bf_size, "%*d", width, map__size(map));
2129 
2130 	return repsep_snprintf(bf, bf_size, "%*s", width, "unknown");
2131 }
2132 
hist_entry__dso_size_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)2133 static 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 
2139 struct 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 
2146 /* --sort addr */
2147 
2148 static int64_t
sort__addr_cmp(struct hist_entry * left,struct hist_entry * right)2149 sort__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)
2157 		left_ip = map__unmap_ip(left_map, left_ip);
2158 	if (right_map)
2159 		right_ip = map__unmap_ip(right_map, right_ip);
2160 
2161 	return _sort__addr_cmp(left_ip, right_ip);
2162 }
2163 
hist_entry__addr_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)2164 static 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)
2171 		ip = map__unmap_ip(map, ip);
2172 
2173 	return repsep_snprintf(bf, size, "%-#*llx", width, ip);
2174 }
2175 
2176 struct 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 
2183 /* --sort type */
2184 
2185 struct annotated_data_type unknown_type = {
2186 	.self = {
2187 		.type_name = (char *)"(unknown)",
2188 		.children = LIST_HEAD_INIT(unknown_type.self.children),
2189 	},
2190 };
2191 
2192 static int64_t
sort__type_cmp(struct hist_entry * left,struct hist_entry * right)2193 sort__type_cmp(struct hist_entry *left, struct hist_entry *right)
2194 {
2195 	return sort__addr_cmp(left, right);
2196 }
2197 
sort__type_init(struct hist_entry * he)2198 static 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);
2204 	if (he->mem_type == NULL) {
2205 		he->mem_type = &unknown_type;
2206 		he->mem_type_off = 0;
2207 	}
2208 }
2209 
2210 static int64_t
sort__type_collapse(struct hist_entry * left,struct hist_entry * right)2211 sort__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 
2226 	return strcmp(left_type->self.type_name, right_type->self.type_name);
2227 }
2228 
2229 static int64_t
sort__type_sort(struct hist_entry * left,struct hist_entry * right)2230 sort__type_sort(struct hist_entry *left, struct hist_entry *right)
2231 {
2232 	return sort__type_collapse(left, right);
2233 }
2234 
hist_entry__type_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width)2235 static int hist_entry__type_snprintf(struct hist_entry *he, char *bf,
2236 				     size_t size, unsigned int width)
2237 {
2238 	return repsep_snprintf(bf, size, "%-*s", width, he->mem_type->self.type_name);
2239 }
2240 
2241 struct 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 
2251 /* --sort typeoff */
2252 
2253 static int64_t
sort__typeoff_sort(struct hist_entry * left,struct hist_entry * right)2254 sort__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 
fill_member_name(char * buf,size_t sz,struct annotated_member * m,int offset,bool first)2276 static 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 
hist_entry__typeoff_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width __maybe_unused)2301 static 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 
2315 	return repsep_snprintf(bf, size, "%s +%#x (%s)", he_type->self.type_name,
2316 			       he->mem_type_off, buf);
2317 }
2318 
2319 struct 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 
2329 /* --sort typecln */
2330 
2331 /* TODO: use actual value in the system */
2332 #define TYPE_CACHELINE_SIZE  64
2333 
2334 static int64_t
sort__typecln_sort(struct hist_entry * left,struct hist_entry * right)2335 sort__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 
hist_entry__typecln_snprintf(struct hist_entry * he,char * bf,size_t size,unsigned int width __maybe_unused)2361 static 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 
2370 struct 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 
2380 
2381 struct sort_dimension {
2382 	const char		*name;
2383 	struct sort_entry	*entry;
2384 	int			taken;
2385 };
2386 
arch_support_sort_key(const char * sort_key __maybe_unused)2387 int __weak arch_support_sort_key(const char *sort_key __maybe_unused)
2388 {
2389 	return 0;
2390 }
2391 
arch_perf_header_entry(const char * se_header)2392 const char * __weak arch_perf_header_entry(const char *se_header)
2393 {
2394 	return se_header;
2395 }
2396 
sort_dimension_add_dynamic_header(struct sort_dimension * sd)2397 static 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 
2402 #define DIM(d, n, func) [d] = { .name = n, .entry = &(func) }
2403 
2404 static struct sort_dimension common_sort_dimensions[] = {
2405 	DIM(SORT_PID, "pid", sort_thread),
2406 	DIM(SORT_COMM, "comm", sort_comm),
2407 	DIM(SORT_DSO, "dso", sort_dso),
2408 	DIM(SORT_SYM, "symbol", sort_sym),
2409 	DIM(SORT_PARENT, "parent", sort_parent),
2410 	DIM(SORT_CPU, "cpu", sort_cpu),
2411 	DIM(SORT_SOCKET, "socket", sort_socket),
2412 	DIM(SORT_SRCLINE, "srcline", sort_srcline),
2413 	DIM(SORT_SRCFILE, "srcfile", sort_srcfile),
2414 	DIM(SORT_LOCAL_WEIGHT, "local_weight", sort_local_weight),
2415 	DIM(SORT_GLOBAL_WEIGHT, "weight", sort_global_weight),
2416 	DIM(SORT_TRANSACTION, "transaction", sort_transaction),
2417 #ifdef HAVE_LIBTRACEEVENT
2418 	DIM(SORT_TRACE, "trace", sort_trace),
2419 #endif
2420 	DIM(SORT_SYM_SIZE, "symbol_size", sort_sym_size),
2421 	DIM(SORT_DSO_SIZE, "dso_size", sort_dso_size),
2422 	DIM(SORT_CGROUP, "cgroup", sort_cgroup),
2423 	DIM(SORT_CGROUP_ID, "cgroup_id", sort_cgroup_id),
2424 	DIM(SORT_SYM_IPC_NULL, "ipc_null", sort_sym_ipc_null),
2425 	DIM(SORT_TIME, "time", sort_time),
2426 	DIM(SORT_CODE_PAGE_SIZE, "code_page_size", sort_code_page_size),
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),
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),
2431 	DIM(SORT_ADDR, "addr", sort_addr),
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),
2434 	DIM(SORT_SIMD, "simd", sort_simd),
2435 	DIM(SORT_ANNOTATE_DATA_TYPE, "type", sort_type),
2436 	DIM(SORT_ANNOTATE_DATA_TYPE_OFFSET, "typeoff", sort_type_offset),
2437 	DIM(SORT_SYM_OFFSET, "symoff", sort_sym_offset),
2438 	DIM(SORT_ANNOTATE_DATA_TYPE_CACHELINE, "typecln", sort_type_cacheline),
2439 };
2440 
2441 #undef DIM
2442 
2443 #define DIM(d, n, func) [d - __SORT_BRANCH_STACK] = { .name = n, .entry = &(func) }
2444 
2445 static 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),
2451 	DIM(SORT_IN_TX, "in_tx", sort_in_tx),
2452 	DIM(SORT_ABORT, "abort", sort_abort),
2453 	DIM(SORT_CYCLES, "cycles", sort_cycles),
2454 	DIM(SORT_SRCLINE_FROM, "srcline_from", sort_srcline_from),
2455 	DIM(SORT_SRCLINE_TO, "srcline_to", sort_srcline_to),
2456 	DIM(SORT_SYM_IPC, "ipc_lbr", sort_sym_ipc),
2457 	DIM(SORT_ADDR_FROM, "addr_from", sort_addr_from),
2458 	DIM(SORT_ADDR_TO, "addr_to", sort_addr_to),
2459 };
2460 
2461 #undef DIM
2462 
2463 #define DIM(d, n, func) [d - __SORT_MEMORY_MODE] = { .name = n, .entry = &(func) }
2464 
2465 static struct sort_dimension memory_sort_dimensions[] = {
2466 	DIM(SORT_MEM_DADDR_SYMBOL, "symbol_daddr", sort_mem_daddr_sym),
2467 	DIM(SORT_MEM_IADDR_SYMBOL, "symbol_iaddr", sort_mem_iaddr_sym),
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),
2473 	DIM(SORT_MEM_DCACHELINE, "dcacheline", sort_mem_dcacheline),
2474 	DIM(SORT_MEM_PHYS_DADDR, "phys_daddr", sort_mem_phys_daddr),
2475 	DIM(SORT_MEM_DATA_PAGE_SIZE, "data_page_size", sort_mem_data_page_size),
2476 	DIM(SORT_MEM_BLOCKED, "blocked", sort_mem_blocked),
2477 };
2478 
2479 #undef DIM
2480 
2481 struct 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 
2489 static 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"),
2495 	DIM(PERF_HPP__OVERHEAD_ACC, "overhead_children"),
2496 	DIM(PERF_HPP__SAMPLES, "sample"),
2497 	DIM(PERF_HPP__PERIOD, "period"),
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"),
2505 };
2506 
2507 #undef DIM
2508 
2509 struct hpp_sort_entry {
2510 	struct perf_hpp_fmt hpp;
2511 	struct sort_entry *se;
2512 };
2513 
perf_hpp__reset_sort_width(struct perf_hpp_fmt * fmt,struct hists * hists)2514 void perf_hpp__reset_sort_width(struct perf_hpp_fmt *fmt, struct hists *hists)
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);
2522 	hists__new_col_len(hists, hse->se->se_width_idx, strlen(fmt->name));
2523 }
2524 
__sort__hpp_header(struct perf_hpp_fmt * fmt,struct perf_hpp * hpp,struct hists * hists,int line __maybe_unused,int * span __maybe_unused)2525 static int __sort__hpp_header(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
2526 			      struct hists *hists, int line __maybe_unused,
2527 			      int *span __maybe_unused)
2528 {
2529 	struct hpp_sort_entry *hse;
2530 	size_t len = fmt->user_len;
2531 
2532 	hse = container_of(fmt, struct hpp_sort_entry, hpp);
2533 
2534 	if (!len)
2535 		len = hists__col_len(hists, hse->se->se_width_idx);
2536 
2537 	return scnprintf(hpp->buf, hpp->size, "%-*.*s", len, len, fmt->name);
2538 }
2539 
__sort__hpp_width(struct perf_hpp_fmt * fmt,struct perf_hpp * hpp __maybe_unused,struct hists * hists)2540 static int __sort__hpp_width(struct perf_hpp_fmt *fmt,
2541 			     struct perf_hpp *hpp __maybe_unused,
2542 			     struct hists *hists)
2543 {
2544 	struct hpp_sort_entry *hse;
2545 	size_t len = fmt->user_len;
2546 
2547 	hse = container_of(fmt, struct hpp_sort_entry, hpp);
2548 
2549 	if (!len)
2550 		len = hists__col_len(hists, hse->se->se_width_idx);
2551 
2552 	return len;
2553 }
2554 
__sort__hpp_entry(struct perf_hpp_fmt * fmt,struct perf_hpp * hpp,struct hist_entry * he)2555 static 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;
2559 	size_t len = fmt->user_len;
2560 
2561 	hse = container_of(fmt, struct hpp_sort_entry, hpp);
2562 
2563 	if (!len)
2564 		len = hists__col_len(he->hists, hse->se->se_width_idx);
2565 
2566 	return hse->se->se_snprintf(he, hpp->buf, hpp->size, len);
2567 }
2568 
__sort__hpp_cmp(struct perf_hpp_fmt * fmt,struct hist_entry * a,struct hist_entry * b)2569 static 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 
__sort__hpp_collapse(struct perf_hpp_fmt * fmt,struct hist_entry * a,struct hist_entry * b)2578 static 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 
__sort__hpp_sort(struct perf_hpp_fmt * fmt,struct hist_entry * a,struct hist_entry * b)2589 static 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 
perf_hpp__is_sort_entry(struct perf_hpp_fmt * format)2600 bool perf_hpp__is_sort_entry(struct perf_hpp_fmt *format)
2601 {
2602 	return format->header == __sort__hpp_header;
2603 }
2604 
2605 #define MK_SORT_ENTRY_CHK(key)					\
2606 bool 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 
2617 #ifdef HAVE_LIBTRACEEVENT
2618 MK_SORT_ENTRY_CHK(trace)
2619 #else
2620 bool perf_hpp__is_trace_entry(struct perf_hpp_fmt *fmt __maybe_unused)
2621 {
2622 	return false;
2623 }
2624 #endif
MK_SORT_ENTRY_CHK(srcline)2625 MK_SORT_ENTRY_CHK(srcline)
2626 MK_SORT_ENTRY_CHK(srcfile)
2627 MK_SORT_ENTRY_CHK(thread)
2628 MK_SORT_ENTRY_CHK(comm)
2629 MK_SORT_ENTRY_CHK(dso)
2630 MK_SORT_ENTRY_CHK(sym)
2631 
2632 
2633 static 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 
hse_free(struct perf_hpp_fmt * fmt)2647 static 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 
hse_init(struct perf_hpp_fmt * fmt,struct hist_entry * he)2655 static 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 
2668 static struct hpp_sort_entry *
__sort_dimension__alloc_hpp(struct sort_dimension * sd,int level)2669 __sort_dimension__alloc_hpp(struct sort_dimension *sd, int level)
2670 {
2671 	struct hpp_sort_entry *hse;
2672 
2673 	hse = malloc(sizeof(*hse));
2674 	if (hse == NULL) {
2675 		pr_err("Memory allocation failed\n");
2676 		return NULL;
2677 	}
2678 
2679 	hse->se = sd->entry;
2680 	hse->hpp.name = sd->entry->se_header;
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 
2686 	hse->hpp.cmp = __sort__hpp_cmp;
2687 	hse->hpp.collapse = __sort__hpp_collapse;
2688 	hse->hpp.sort = __sort__hpp_sort;
2689 	hse->hpp.equal = __sort__hpp_equal;
2690 	hse->hpp.free = hse_free;
2691 	hse->hpp.init = hse_init;
2692 
2693 	INIT_LIST_HEAD(&hse->hpp.list);
2694 	INIT_LIST_HEAD(&hse->hpp.sort_list);
2695 	hse->hpp.elide = false;
2696 	hse->hpp.len = 0;
2697 	hse->hpp.user_len = 0;
2698 	hse->hpp.level = level;
2699 
2700 	return hse;
2701 }
2702 
hpp_free(struct perf_hpp_fmt * fmt)2703 static void hpp_free(struct perf_hpp_fmt *fmt)
2704 {
2705 	free(fmt);
2706 }
2707 
__hpp_dimension__alloc_hpp(struct hpp_dimension * hd,int level)2708 static struct perf_hpp_fmt *__hpp_dimension__alloc_hpp(struct hpp_dimension *hd,
2709 						       int level)
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);
2717 		fmt->free = hpp_free;
2718 		fmt->level = level;
2719 	}
2720 
2721 	return fmt;
2722 }
2723 
hist_entry__filter(struct hist_entry * he,int type,const void * arg)2724 int 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;
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 	}
2750 
2751 	return ret;
2752 }
2753 
__sort_dimension__add_hpp_sort(struct sort_dimension * sd,struct perf_hpp_list * list,int level)2754 static int __sort_dimension__add_hpp_sort(struct sort_dimension *sd,
2755 					  struct perf_hpp_list *list,
2756 					  int level)
2757 {
2758 	struct hpp_sort_entry *hse = __sort_dimension__alloc_hpp(sd, level);
2759 
2760 	if (hse == NULL)
2761 		return -1;
2762 
2763 	perf_hpp_list__register_sort_field(list, &hse->hpp);
2764 	return 0;
2765 }
2766 
__sort_dimension__add_hpp_output(struct sort_dimension * sd,struct perf_hpp_list * list)2767 static int __sort_dimension__add_hpp_output(struct sort_dimension *sd,
2768 					    struct perf_hpp_list *list)
2769 {
2770 	struct hpp_sort_entry *hse = __sort_dimension__alloc_hpp(sd, 0);
2771 
2772 	if (hse == NULL)
2773 		return -1;
2774 
2775 	perf_hpp_list__column_register(list, &hse->hpp);
2776 	return 0;
2777 }
2778 
2779 #ifndef HAVE_LIBTRACEEVENT
perf_hpp__is_dynamic_entry(struct perf_hpp_fmt * fmt __maybe_unused)2780 bool perf_hpp__is_dynamic_entry(struct perf_hpp_fmt *fmt __maybe_unused)
2781 {
2782 	return false;
2783 }
perf_hpp__defined_dynamic_entry(struct perf_hpp_fmt * fmt __maybe_unused,struct hists * hists __maybe_unused)2784 bool 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
2790 struct hpp_dynamic_entry {
2791 	struct perf_hpp_fmt hpp;
2792 	struct evsel *evsel;
2793 	struct tep_format_field *field;
2794 	unsigned dynamic_len;
2795 	bool raw_trace;
2796 };
2797 
hde_width(struct hpp_dynamic_entry * hde)2798 static 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 
2808 		if (!(hde->field->flags & TEP_FIELD_IS_STRING)) {
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 
update_dynamic_len(struct hpp_dynamic_entry * hde,struct hist_entry * he)2820 static void update_dynamic_len(struct hpp_dynamic_entry *hde,
2821 			       struct hist_entry *he)
2822 {
2823 	char *str, *pos;
2824 	struct tep_format_field *field = hde->field;
2825 	size_t namelen;
2826 	bool last = false;
2827 
2828 	if (hde->raw_trace)
2829 		return;
2830 
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 
__sort__hde_header(struct perf_hpp_fmt * fmt,struct perf_hpp * hpp,struct hists * hists __maybe_unused,int line __maybe_unused,int * span __maybe_unused)2863 static int __sort__hde_header(struct perf_hpp_fmt *fmt, struct perf_hpp *hpp,
2864 			      struct hists *hists __maybe_unused,
2865 			      int line __maybe_unused,
2866 			      int *span __maybe_unused)
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 
__sort__hde_width(struct perf_hpp_fmt * fmt,struct perf_hpp * hpp __maybe_unused,struct hists * hists __maybe_unused)2879 static int __sort__hde_width(struct perf_hpp_fmt *fmt,
2880 			     struct perf_hpp *hpp __maybe_unused,
2881 			     struct hists *hists __maybe_unused)
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 
perf_hpp__defined_dynamic_entry(struct perf_hpp_fmt * fmt,struct hists * hists)2894 bool 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 
__sort__hde_entry(struct perf_hpp_fmt * fmt,struct perf_hpp * hpp,struct hist_entry * he)2903 static 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;
2908 	char *str, *pos;
2909 	struct tep_format_field *field;
2910 	size_t namelen;
2911 	bool last = false;
2912 	int ret;
2913 
2914 	hde = container_of(fmt, struct hpp_dynamic_entry, hpp);
2915 
2916 	if (!len)
2917 		len = hde_width(hde);
2918 
2919 	if (hde->raw_trace)
2920 		goto raw_field;
2921 
2922 	if (!he->trace_output)
2923 		he->trace_output = get_trace_output(he);
2924 
2925 	field = hde->field;
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;
2954 raw_field:
2955 		trace_seq_init(&seq);
2956 		tep_print_field(&seq, he->raw_data, hde->field);
2957 		str = seq.buffer;
2958 	}
2959 
2960 	ret = scnprintf(hpp->buf, hpp->size, "%*.*s", len, len, str);
2961 	free(str);
2962 	return ret;
2963 }
2964 
__sort__hde_cmp(struct perf_hpp_fmt * fmt,struct hist_entry * a,struct hist_entry * b)2965 static 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;
2969 	struct tep_format_field *field;
2970 	unsigned offset, size;
2971 
2972 	hde = container_of(fmt, struct hpp_dynamic_entry, hpp);
2973 
2974 	field = hde->field;
2975 	if (field->flags & TEP_FIELD_IS_DYNAMIC) {
2976 		unsigned long long dyn;
2977 
2978 		tep_read_number_field(field, a->raw_data, &dyn);
2979 		offset = dyn & 0xffff;
2980 		size = (dyn >> 16) & 0xffff;
2981 		if (tep_field_is_relative(field->flags))
2982 			offset += field->offset + field->size;
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 
perf_hpp__is_dynamic_entry(struct perf_hpp_fmt * fmt)2994 bool perf_hpp__is_dynamic_entry(struct perf_hpp_fmt *fmt)
2995 {
2996 	return fmt->cmp == __sort__hde_cmp;
2997 }
2998 
__sort__hde_equal(struct perf_hpp_fmt * a,struct perf_hpp_fmt * b)2999 static 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 
hde_free(struct perf_hpp_fmt * fmt)3013 static 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 
__sort__hde_init(struct perf_hpp_fmt * fmt,struct hist_entry * he)3021 static 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 
3032 static struct hpp_dynamic_entry *
__alloc_dynamic_entry(struct evsel * evsel,struct tep_format_field * field,int level)3033 __alloc_dynamic_entry(struct evsel *evsel, struct tep_format_field *field,
3034 		      int level)
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 
3054 	hde->hpp.init = __sort__hde_init;
3055 	hde->hpp.cmp = __sort__hde_cmp;
3056 	hde->hpp.collapse = __sort__hde_cmp;
3057 	hde->hpp.sort = __sort__hde_cmp;
3058 	hde->hpp.equal = __sort__hde_equal;
3059 	hde->hpp.free = hde_free;
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;
3066 	hde->hpp.level = level;
3067 
3068 	return hde;
3069 }
3070 #endif /* HAVE_LIBTRACEEVENT */
3071 
perf_hpp_fmt__dup(struct perf_hpp_fmt * fmt)3072 struct 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;
3083 #ifdef HAVE_LIBTRACEEVENT
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;
3091 #endif
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 
parse_field_name(char * str,char ** event,char ** field,char ** opt)3102 static 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:
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 ':')
3131  */
find_evsel(struct evlist * evlist,char * event_name)3132 static struct evsel *find_evsel(struct evlist *evlist, char *event_name)
3133 {
3134 	struct evsel *evsel = NULL;
3135 	struct evsel *pos;
3136 	bool full_name;
3137 
3138 	/* case 1 */
3139 	if (event_name[0] == '%') {
3140 		int nr = strtol(event_name+1, NULL, 0);
3141 
3142 		if (nr > evlist->core.nr_entries)
3143 			return NULL;
3144 
3145 		evsel = evlist__first(evlist);
3146 		while (--nr > 0)
3147 			evsel = evsel__next(evsel);
3148 
3149 		return evsel;
3150 	}
3151 
3152 	full_name = !!strchr(event_name, ':');
3153 	evlist__for_each_entry(evlist, pos) {
3154 		/* case 2 */
3155 		if (full_name && evsel__name_is(pos, event_name))
3156 			return pos;
3157 		/* case 3 */
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 
3171 #ifdef HAVE_LIBTRACEEVENT
__dynamic_dimension__add(struct evsel * evsel,struct tep_format_field * field,bool raw_trace,int level)3172 static int __dynamic_dimension__add(struct evsel *evsel,
3173 				    struct tep_format_field *field,
3174 				    bool raw_trace, int level)
3175 {
3176 	struct hpp_dynamic_entry *hde;
3177 
3178 	hde = __alloc_dynamic_entry(evsel, field, level);
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 
add_evsel_fields(struct evsel * evsel,bool raw_trace,int level)3188 static int add_evsel_fields(struct evsel *evsel, bool raw_trace, int level)
3189 {
3190 	int ret;
3191 	struct tep_format_field *field;
3192 
3193 	field = evsel->tp_format->format.fields;
3194 	while (field) {
3195 		ret = __dynamic_dimension__add(evsel, field, raw_trace, level);
3196 		if (ret < 0)
3197 			return ret;
3198 
3199 		field = field->next;
3200 	}
3201 	return 0;
3202 }
3203 
add_all_dynamic_fields(struct evlist * evlist,bool raw_trace,int level)3204 static int add_all_dynamic_fields(struct evlist *evlist, bool raw_trace,
3205 				  int level)
3206 {
3207 	int ret;
3208 	struct evsel *evsel;
3209 
3210 	evlist__for_each_entry(evlist, evsel) {
3211 		if (evsel->core.attr.type != PERF_TYPE_TRACEPOINT)
3212 			continue;
3213 
3214 		ret = add_evsel_fields(evsel, raw_trace, level);
3215 		if (ret < 0)
3216 			return ret;
3217 	}
3218 	return 0;
3219 }
3220 
add_all_matching_fields(struct evlist * evlist,char * field_name,bool raw_trace,int level)3221 static int add_all_matching_fields(struct evlist *evlist,
3222 				   char *field_name, bool raw_trace, int level)
3223 {
3224 	int ret = -ESRCH;
3225 	struct evsel *evsel;
3226 	struct tep_format_field *field;
3227 
3228 	evlist__for_each_entry(evlist, evsel) {
3229 		if (evsel->core.attr.type != PERF_TYPE_TRACEPOINT)
3230 			continue;
3231 
3232 		field = tep_find_any_field(evsel->tp_format, field_name);
3233 		if (field == NULL)
3234 			continue;
3235 
3236 		ret = __dynamic_dimension__add(evsel, field, raw_trace, level);
3237 		if (ret < 0)
3238 			break;
3239 	}
3240 	return ret;
3241 }
3242 #endif /* HAVE_LIBTRACEEVENT */
3243 
add_dynamic_entry(struct evlist * evlist,const char * tok,int level)3244 static int add_dynamic_entry(struct evlist *evlist, const char *tok,
3245 			     int level)
3246 {
3247 	char *str, *event_name, *field_name, *opt_name;
3248 	struct evsel *evsel;
3249 	bool raw_trace = symbol_conf.raw_trace;
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 
3259 	if (parse_field_name(str, &event_name, &field_name, &opt_name) < 0) {
3260 		ret = -EINVAL;
3261 		goto out;
3262 	}
3263 
3264 	if (opt_name) {
3265 		if (strcmp(opt_name, "raw")) {
3266 			pr_debug("unsupported field option %s\n", opt_name);
3267 			ret = -EINVAL;
3268 			goto out;
3269 		}
3270 		raw_trace = true;
3271 	}
3272 
3273 #ifdef HAVE_LIBTRACEEVENT
3274 	if (!strcmp(field_name, "trace_fields")) {
3275 		ret = add_all_dynamic_fields(evlist, raw_trace, level);
3276 		goto out;
3277 	}
3278 
3279 	if (event_name == NULL) {
3280 		ret = add_all_matching_fields(evlist, field_name, raw_trace, level);
3281 		goto out;
3282 	}
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 	}
3295 #endif
3296 
3297 	evsel = find_evsel(evlist, event_name);
3298 	if (evsel == NULL) {
3299 		pr_debug("Cannot find event: %s\n", event_name);
3300 		ret = -ENOENT;
3301 		goto out;
3302 	}
3303 
3304 	if (evsel->core.attr.type != PERF_TYPE_TRACEPOINT) {
3305 		pr_debug("%s is not a tracepoint event\n", event_name);
3306 		ret = -EINVAL;
3307 		goto out;
3308 	}
3309 
3310 #ifdef HAVE_LIBTRACEEVENT
3311 	if (!strcmp(field_name, "*")) {
3312 		ret = add_evsel_fields(evsel, raw_trace, level);
3313 	} else {
3314 		struct tep_format_field *field = tep_find_any_field(evsel->tp_format, field_name);
3315 
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 
3322 		ret = __dynamic_dimension__add(evsel, field, raw_trace, level);
3323 	}
3324 #else
3325 	(void)level;
3326 	(void)raw_trace;
3327 #endif /* HAVE_LIBTRACEEVENT */
3328 
3329 out:
3330 	free(str);
3331 	return ret;
3332 }
3333 
__sort_dimension__add(struct sort_dimension * sd,struct perf_hpp_list * list,int level)3334 static int __sort_dimension__add(struct sort_dimension *sd,
3335 				 struct perf_hpp_list *list,
3336 				 int level)
3337 {
3338 	if (sd->taken)
3339 		return 0;
3340 
3341 	if (__sort_dimension__add_hpp_sort(sd, list, level) < 0)
3342 		return -1;
3343 
3344 	if (sd->entry->se_collapse)
3345 		list->need_collapse = 1;
3346 
3347 	sd->taken = 1;
3348 
3349 	return 0;
3350 }
3351 
__hpp_dimension__add(struct hpp_dimension * hd,struct perf_hpp_list * list,int level)3352 static int __hpp_dimension__add(struct hpp_dimension *hd,
3353 				struct perf_hpp_list *list,
3354 				int level)
3355 {
3356 	struct perf_hpp_fmt *fmt;
3357 
3358 	if (hd->taken)
3359 		return 0;
3360 
3361 	fmt = __hpp_dimension__alloc_hpp(hd, level);
3362 	if (!fmt)
3363 		return -1;
3364 
3365 	hd->taken = 1;
3366 	perf_hpp_list__register_sort_field(list, fmt);
3367 	return 0;
3368 }
3369 
__sort_dimension__add_output(struct perf_hpp_list * list,struct sort_dimension * sd)3370 static int __sort_dimension__add_output(struct perf_hpp_list *list,
3371 					struct sort_dimension *sd)
3372 {
3373 	if (sd->taken)
3374 		return 0;
3375 
3376 	if (__sort_dimension__add_hpp_output(sd, list) < 0)
3377 		return -1;
3378 
3379 	sd->taken = 1;
3380 	return 0;
3381 }
3382 
__hpp_dimension__add_output(struct perf_hpp_list * list,struct hpp_dimension * hd)3383 static int __hpp_dimension__add_output(struct perf_hpp_list *list,
3384 				       struct hpp_dimension *hd)
3385 {
3386 	struct perf_hpp_fmt *fmt;
3387 
3388 	if (hd->taken)
3389 		return 0;
3390 
3391 	fmt = __hpp_dimension__alloc_hpp(hd, 0);
3392 	if (!fmt)
3393 		return -1;
3394 
3395 	hd->taken = 1;
3396 	perf_hpp_list__column_register(list, fmt);
3397 	return 0;
3398 }
3399 
hpp_dimension__add_output(unsigned col)3400 int hpp_dimension__add_output(unsigned col)
3401 {
3402 	BUG_ON(col >= PERF_HPP__MAX_INDEX);
3403 	return __hpp_dimension__add_output(&perf_hpp_list, &hpp_sort_dimensions[col]);
3404 }
3405 
sort_dimension__add(struct perf_hpp_list * list,const char * tok,struct evlist * evlist,int level)3406 int sort_dimension__add(struct perf_hpp_list *list, const char *tok,
3407 			struct evlist *evlist,
3408 			int level)
3409 {
3410 	unsigned int i, j;
3411 
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 
3425 	for (i = 0; i < ARRAY_SIZE(common_sort_dimensions); i++) {
3426 		struct sort_dimension *sd = &common_sort_dimensions[i];
3427 
3428 		if (!sd->name || strncasecmp(tok, sd->name, strlen(tok)))
3429 			continue;
3430 
3431 		for (j = 0; j < ARRAY_SIZE(dynamic_headers); j++) {
3432 			if (sd->name && !strcmp(dynamic_headers[j], sd->name))
3433 				sort_dimension_add_dynamic_header(sd);
3434 		}
3435 
3436 		if (sd->entry == &sort_parent && parent_pattern) {
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));
3442 				pr_err("Invalid regex: %s\n%s", parent_pattern, err);
3443 				return -EINVAL;
3444 			}
3445 			list->parent = 1;
3446 		} else if (sd->entry == &sort_sym) {
3447 			list->sym = 1;
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 
3457 		} else if (sd->entry == &sort_dso) {
3458 			list->dso = 1;
3459 		} else if (sd->entry == &sort_socket) {
3460 			list->socket = 1;
3461 		} else if (sd->entry == &sort_thread) {
3462 			list->thread = 1;
3463 		} else if (sd->entry == &sort_comm) {
3464 			list->comm = 1;
3465 		} else if (sd->entry == &sort_type_offset) {
3466 			symbol_conf.annotate_data_member = true;
3467 		}
3468 
3469 		return __sort_dimension__add(sd, list, level);
3470 	}
3471 
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 
3478 		return __hpp_dimension__add(hd, list, level);
3479 	}
3480 
3481 	for (i = 0; i < ARRAY_SIZE(bstack_sort_dimensions); i++) {
3482 		struct sort_dimension *sd = &bstack_sort_dimensions[i];
3483 
3484 		if (!sd->name || strncasecmp(tok, sd->name, strlen(tok)))
3485 			continue;
3486 
3487 		if (sort__mode != SORT_MODE__BRANCH)
3488 			return -EINVAL;
3489 
3490 		if (sd->entry == &sort_sym_from || sd->entry == &sort_sym_to)
3491 			list->sym = 1;
3492 
3493 		__sort_dimension__add(sd, list, level);
3494 		return 0;
3495 	}
3496 
3497 	for (i = 0; i < ARRAY_SIZE(memory_sort_dimensions); i++) {
3498 		struct sort_dimension *sd = &memory_sort_dimensions[i];
3499 
3500 		if (!sd->name || strncasecmp(tok, sd->name, strlen(tok)))
3501 			continue;
3502 
3503 		if (sort__mode != SORT_MODE__MEMORY)
3504 			return -EINVAL;
3505 
3506 		if (sd->entry == &sort_mem_dcacheline && cacheline_size() == 0)
3507 			return -EINVAL;
3508 
3509 		if (sd->entry == &sort_mem_daddr_sym)
3510 			list->sym = 1;
3511 
3512 		__sort_dimension__add(sd, list, level);
3513 		return 0;
3514 	}
3515 
3516 	if (!add_dynamic_entry(evlist, tok, level))
3517 		return 0;
3518 
3519 	return -ESRCH;
3520 }
3521 
setup_sort_list(struct perf_hpp_list * list,char * str,struct evlist * evlist)3522 static int setup_sort_list(struct perf_hpp_list *list, char *str,
3523 			   struct evlist *evlist)
3524 {
3525 	char *tmp, *tok;
3526 	int ret = 0;
3527 	int level = 0;
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 		}
3548 
3549 		if (*tok) {
3550 			ret = sort_dimension__add(list, tok, evlist, level);
3551 			if (ret == -EINVAL) {
3552 				if (!cacheline_size() && !strncasecmp(tok, "dcacheline", strlen(tok)))
3553 					ui__error("The \"dcacheline\" --sort key needs to know the cacheline size and it couldn't be determined on this system");
3554 				else
3555 					ui__error("Invalid --sort key: `%s'", tok);
3556 				break;
3557 			} else if (ret == -ESRCH) {
3558 				ui__error("Unknown --sort key: `%s'", tok);
3559 				break;
3560 			}
3561 		}
3562 
3563 		level = next_level;
3564 	} while (tmp);
3565 
3566 	return ret;
3567 }
3568 
get_default_sort_order(struct evlist * evlist)3569 static const char *get_default_sort_order(struct evlist *evlist)
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,
3577 		default_tracepoint_sort_order,
3578 	};
3579 	bool use_trace = true;
3580 	struct evsel *evsel;
3581 
3582 	BUG_ON(sort__mode >= ARRAY_SIZE(default_sort_orders));
3583 
3584 	if (evlist == NULL || evlist__empty(evlist))
3585 		goto out_no_evlist;
3586 
3587 	evlist__for_each_entry(evlist, evsel) {
3588 		if (evsel->core.attr.type != PERF_TYPE_TRACEPOINT) {
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 	}
3599 out_no_evlist:
3600 	return default_sort_orders[sort__mode];
3601 }
3602 
setup_sort_order(struct evlist * evlist)3603 static int setup_sort_order(struct evlist *evlist)
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') {
3615 		ui__error("Invalid --sort key: `+'");
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",
3624 		     get_default_sort_order(evlist), sort_order + 1) < 0) {
3625 		pr_err("Not enough memory to set up --sort");
3626 		return -ENOMEM;
3627 	}
3628 
3629 	sort_order = new_sort_order;
3630 	return 0;
3631 }
3632 
3633 /*
3634  * Adds 'pre,' prefix into 'str' is 'pre' is
3635  * not already part of 'str'.
3636  */
prefix_if_not_in(const char * pre,char * str)3637 static 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)
3645 		n = NULL;
3646 
3647 	free(str);
3648 	return n;
3649 }
3650 
setup_overhead(char * keys)3651 static char *setup_overhead(char *keys)
3652 {
3653 	if (sort__mode == SORT_MODE__DIFF)
3654 		return keys;
3655 
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 
__setup_sorting(struct evlist * evlist)3664 static int __setup_sorting(struct evlist *evlist)
3665 {
3666 	char *str;
3667 	const char *sort_keys;
3668 	int ret = 0;
3669 
3670 	ret = setup_sort_order(evlist);
3671 	if (ret)
3672 		return ret;
3673 
3674 	sort_keys = sort_order;
3675 	if (sort_keys == NULL) {
3676 		if (is_strict_order(field_order)) {
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 
3684 		sort_keys = get_default_sort_order(evlist);
3685 	}
3686 
3687 	str = strdup(sort_keys);
3688 	if (str == NULL) {
3689 		pr_err("Not enough memory to setup sort keys");
3690 		return -ENOMEM;
3691 	}
3692 
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) {
3699 			pr_err("Not enough memory to setup overhead keys");
3700 			return -ENOMEM;
3701 		}
3702 	}
3703 
3704 	ret = setup_sort_list(&perf_hpp_list, str, evlist);
3705 
3706 	free(str);
3707 	return ret;
3708 }
3709 
perf_hpp__set_elide(int idx,bool elide)3710 void perf_hpp__set_elide(int idx, bool elide)
3711 {
3712 	struct perf_hpp_fmt *fmt;
3713 	struct hpp_sort_entry *hse;
3714 
3715 	perf_hpp_list__for_each_format(&perf_hpp_list, fmt) {
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 		}
3724 	}
3725 }
3726 
__get_elide(struct strlist * list,const char * list_name,FILE * fp)3727 static bool __get_elide(struct strlist *list, const char *list_name, FILE *fp)
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);
3733 		return true;
3734 	}
3735 	return false;
3736 }
3737 
get_elide(int idx,FILE * output)3738 static 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;
3749 	}
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);
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);
3767 	default:
3768 		break;
3769 	}
3770 
3771 	return false;
3772 }
3773 
sort__setup_elide(FILE * output)3774 void sort__setup_elide(FILE *output)
3775 {
3776 	struct perf_hpp_fmt *fmt;
3777 	struct hpp_sort_entry *hse;
3778 
3779 	perf_hpp_list__for_each_format(&perf_hpp_list, fmt) {
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);
3785 	}
3786 
3787 	/*
3788 	 * It makes no sense to elide all of sort entries.
3789 	 * Just revert them to show up again.
3790 	 */
3791 	perf_hpp_list__for_each_format(&perf_hpp_list, fmt) {
3792 		if (!perf_hpp__is_sort_entry(fmt))
3793 			continue;
3794 
3795 		if (!fmt->elide)
3796 			return;
3797 	}
3798 
3799 	perf_hpp_list__for_each_format(&perf_hpp_list, fmt) {
3800 		if (!perf_hpp__is_sort_entry(fmt))
3801 			continue;
3802 
3803 		fmt->elide = false;
3804 	}
3805 }
3806 
output_field_add(struct perf_hpp_list * list,const char * tok)3807 int output_field_add(struct perf_hpp_list *list, const char *tok)
3808 {
3809 	unsigned int i;
3810 
3811 	for (i = 0; i < ARRAY_SIZE(hpp_sort_dimensions); i++) {
3812 		struct hpp_dimension *hd = &hpp_sort_dimensions[i];
3813 
3814 		if (strncasecmp(tok, hd->name, strlen(tok)))
3815 			continue;
3816 
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);
3821 	}
3822 
3823 	for (i = 0; i < ARRAY_SIZE(common_sort_dimensions); i++) {
3824 		struct sort_dimension *sd = &common_sort_dimensions[i];
3825 
3826 		if (!sd->name || strncasecmp(tok, sd->name, strlen(tok)))
3827 			continue;
3828 
3829 		return __sort_dimension__add_output(list, sd);
3830 	}
3831 
3832 	for (i = 0; i < ARRAY_SIZE(bstack_sort_dimensions); i++) {
3833 		struct sort_dimension *sd = &bstack_sort_dimensions[i];
3834 
3835 		if (!sd->name || strncasecmp(tok, sd->name, strlen(tok)))
3836 			continue;
3837 
3838 		if (sort__mode != SORT_MODE__BRANCH)
3839 			return -EINVAL;
3840 
3841 		return __sort_dimension__add_output(list, sd);
3842 	}
3843 
3844 	for (i = 0; i < ARRAY_SIZE(memory_sort_dimensions); i++) {
3845 		struct sort_dimension *sd = &memory_sort_dimensions[i];
3846 
3847 		if (!sd->name || strncasecmp(tok, sd->name, strlen(tok)))
3848 			continue;
3849 
3850 		if (sort__mode != SORT_MODE__MEMORY)
3851 			return -EINVAL;
3852 
3853 		return __sort_dimension__add_output(list, sd);
3854 	}
3855 
3856 	return -ESRCH;
3857 }
3858 
setup_output_list(struct perf_hpp_list * list,char * str)3859 static int setup_output_list(struct perf_hpp_list *list, char *str)
3860 {
3861 	char *tmp, *tok;
3862 	int ret = 0;
3863 
3864 	for (tok = strtok_r(str, ", ", &tmp);
3865 			tok; tok = strtok_r(NULL, ", ", &tmp)) {
3866 		ret = output_field_add(list, tok);
3867 		if (ret == -EINVAL) {
3868 			ui__error("Invalid --fields key: `%s'", tok);
3869 			break;
3870 		} else if (ret == -ESRCH) {
3871 			ui__error("Unknown --fields key: `%s'", tok);
3872 			break;
3873 		}
3874 	}
3875 
3876 	return ret;
3877 }
3878 
reset_dimensions(void)3879 void reset_dimensions(void)
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 
is_strict_order(const char * order)3896 bool is_strict_order(const char *order)
3897 {
3898 	return order && (*order != '+');
3899 }
3900 
__setup_output_field(void)3901 static int __setup_output_field(void)
3902 {
3903 	char *str, *strp;
3904 	int ret = -EINVAL;
3905 
3906 	if (field_order == NULL)
3907 		return 0;
3908 
3909 	strp = str = strdup(field_order);
3910 	if (str == NULL) {
3911 		pr_err("Not enough memory to setup output fields");
3912 		return -ENOMEM;
3913 	}
3914 
3915 	if (!is_strict_order(field_order))
3916 		strp++;
3917 
3918 	if (!strlen(strp)) {
3919 		ui__error("Invalid --fields key: `+'");
3920 		goto out;
3921 	}
3922 
3923 	ret = setup_output_list(&perf_hpp_list, strp);
3924 
3925 out:
3926 	free(str);
3927 	return ret;
3928 }
3929 
setup_sorting(struct evlist * evlist)3930 int setup_sorting(struct evlist *evlist)
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) {
3939 		err = sort_dimension__add(&perf_hpp_list, "parent", evlist, -1);
3940 		if (err < 0)
3941 			return err;
3942 	}
3943 
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 */
3957 	perf_hpp__setup_output_field(&perf_hpp_list);
3958 	/* and then copy output fields to sort keys */
3959 	perf_hpp__append_sort_keys(&perf_hpp_list);
3960 
3961 	/* setup hists-specific output fields */
3962 	if (perf_hpp__setup_hists_formats(&perf_hpp_list, evlist) < 0)
3963 		return -1;
3964 
3965 	return 0;
3966 }
3967 
reset_output_field(void)3968 void reset_output_field(void)
3969 {
3970 	perf_hpp_list.need_collapse = 0;
3971 	perf_hpp_list.parent = 0;
3972 	perf_hpp_list.sym = 0;
3973 	perf_hpp_list.dso = 0;
3974 
3975 	field_order = NULL;
3976 	sort_order = NULL;
3977 
3978 	reset_dimensions();
3979 	perf_hpp__reset_output_field(&perf_hpp_list);
3980 }
3981 
3982 #define INDENT (3*8 + 1)
3983 
add_key(struct strbuf * sb,const char * str,int * llen)3984 static void add_key(struct strbuf *sb, const char *str, int *llen)
3985 {
3986 	if (!str)
3987 		return;
3988 
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 
add_sort_string(struct strbuf * sb,struct sort_dimension * s,int n,int * llen)3997 static 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 
add_hpp_sort_string(struct strbuf * sb,struct hpp_dimension * s,int n,int * llen)4006 static 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 
sort_help(const char * prefix,enum sort_mode mode)4015 char *sort_help(const char *prefix, enum sort_mode mode)
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);
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);
4033 	s = strbuf_detach(&sb, NULL);
4034 	strbuf_release(&sb);
4035 	return s;
4036 }
4037