xref: /linux/tools/perf/ui/stdio/hist.c (revision c411ed854584a71b0e86ac3019b60e4789d88086)
1 #include <stdio.h>
2 
3 #include "../../util/util.h"
4 #include "../../util/hist.h"
5 #include "../../util/sort.h"
6 #include "../../util/evsel.h"
7 #include "../../util/srcline.h"
8 #include "../../util/string2.h"
9 #include "../../util/thread.h"
10 #include "../../util/sane_ctype.h"
11 
12 static size_t callchain__fprintf_left_margin(FILE *fp, int left_margin)
13 {
14 	int i;
15 	int ret = fprintf(fp, "            ");
16 
17 	for (i = 0; i < left_margin; i++)
18 		ret += fprintf(fp, " ");
19 
20 	return ret;
21 }
22 
23 static size_t inline__fprintf(struct map *map, u64 ip, int left_margin,
24 			      int depth, int depth_mask, FILE *fp)
25 {
26 	struct dso *dso;
27 	struct inline_node *node;
28 	struct inline_list *ilist;
29 	int ret = 0, i;
30 
31 	if (map == NULL)
32 		return 0;
33 
34 	dso = map->dso;
35 	if (dso == NULL)
36 		return 0;
37 
38 	if (dso->kernel != DSO_TYPE_USER)
39 		return 0;
40 
41 	node = dso__parse_addr_inlines(dso,
42 				       map__rip_2objdump(map, ip));
43 	if (node == NULL)
44 		return 0;
45 
46 	list_for_each_entry(ilist, &node->val, list) {
47 		if ((ilist->filename != NULL) || (ilist->funcname != NULL)) {
48 			ret += callchain__fprintf_left_margin(fp, left_margin);
49 
50 			for (i = 0; i < depth; i++) {
51 				if (depth_mask & (1 << i))
52 					ret += fprintf(fp, "|");
53 				else
54 					ret += fprintf(fp, " ");
55 				ret += fprintf(fp, "          ");
56 			}
57 
58 			if (callchain_param.key == CCKEY_ADDRESS ||
59 			    callchain_param.key == CCKEY_SRCLINE) {
60 				if (ilist->filename != NULL)
61 					ret += fprintf(fp, "%s:%d (inline)",
62 						       ilist->filename,
63 						       ilist->line_nr);
64 				else
65 					ret += fprintf(fp, "??");
66 			} else if (ilist->funcname != NULL)
67 				ret += fprintf(fp, "%s (inline)",
68 					       ilist->funcname);
69 			else if (ilist->filename != NULL)
70 				ret += fprintf(fp, "%s:%d (inline)",
71 					       ilist->filename,
72 					       ilist->line_nr);
73 			else
74 				ret += fprintf(fp, "??");
75 
76 			ret += fprintf(fp, "\n");
77 		}
78 	}
79 
80 	inline_node__delete(node);
81 	return ret;
82 }
83 
84 static size_t ipchain__fprintf_graph_line(FILE *fp, int depth, int depth_mask,
85 					  int left_margin)
86 {
87 	int i;
88 	size_t ret = callchain__fprintf_left_margin(fp, left_margin);
89 
90 	for (i = 0; i < depth; i++)
91 		if (depth_mask & (1 << i))
92 			ret += fprintf(fp, "|          ");
93 		else
94 			ret += fprintf(fp, "           ");
95 
96 	ret += fprintf(fp, "\n");
97 
98 	return ret;
99 }
100 
101 static size_t ipchain__fprintf_graph(FILE *fp, struct callchain_node *node,
102 				     struct callchain_list *chain,
103 				     int depth, int depth_mask, int period,
104 				     u64 total_samples, int left_margin)
105 {
106 	int i;
107 	size_t ret = 0;
108 	char bf[1024], *alloc_str = NULL;
109 	char buf[64];
110 	const char *str;
111 
112 	ret += callchain__fprintf_left_margin(fp, left_margin);
113 	for (i = 0; i < depth; i++) {
114 		if (depth_mask & (1 << i))
115 			ret += fprintf(fp, "|");
116 		else
117 			ret += fprintf(fp, " ");
118 		if (!period && i == depth - 1) {
119 			ret += fprintf(fp, "--");
120 			ret += callchain_node__fprintf_value(node, fp, total_samples);
121 			ret += fprintf(fp, "--");
122 		} else
123 			ret += fprintf(fp, "%s", "          ");
124 	}
125 
126 	str = callchain_list__sym_name(chain, bf, sizeof(bf), false);
127 
128 	if (symbol_conf.show_branchflag_count) {
129 		if (!period)
130 			callchain_list_counts__printf_value(node, chain, NULL,
131 							    buf, sizeof(buf));
132 		else
133 			callchain_list_counts__printf_value(NULL, chain, NULL,
134 							    buf, sizeof(buf));
135 
136 		if (asprintf(&alloc_str, "%s%s", str, buf) < 0)
137 			str = "Not enough memory!";
138 		else
139 			str = alloc_str;
140 	}
141 
142 	fputs(str, fp);
143 	fputc('\n', fp);
144 	free(alloc_str);
145 
146 	if (symbol_conf.inline_name)
147 		ret += inline__fprintf(chain->ms.map, chain->ip,
148 				       left_margin, depth, depth_mask, fp);
149 	return ret;
150 }
151 
152 static struct symbol *rem_sq_bracket;
153 static struct callchain_list rem_hits;
154 
155 static void init_rem_hits(void)
156 {
157 	rem_sq_bracket = malloc(sizeof(*rem_sq_bracket) + 6);
158 	if (!rem_sq_bracket) {
159 		fprintf(stderr, "Not enough memory to display remaining hits\n");
160 		return;
161 	}
162 
163 	strcpy(rem_sq_bracket->name, "[...]");
164 	rem_hits.ms.sym = rem_sq_bracket;
165 }
166 
167 static size_t __callchain__fprintf_graph(FILE *fp, struct rb_root *root,
168 					 u64 total_samples, int depth,
169 					 int depth_mask, int left_margin)
170 {
171 	struct rb_node *node, *next;
172 	struct callchain_node *child = NULL;
173 	struct callchain_list *chain;
174 	int new_depth_mask = depth_mask;
175 	u64 remaining;
176 	size_t ret = 0;
177 	int i;
178 	uint entries_printed = 0;
179 	int cumul_count = 0;
180 
181 	remaining = total_samples;
182 
183 	node = rb_first(root);
184 	while (node) {
185 		u64 new_total;
186 		u64 cumul;
187 
188 		child = rb_entry(node, struct callchain_node, rb_node);
189 		cumul = callchain_cumul_hits(child);
190 		remaining -= cumul;
191 		cumul_count += callchain_cumul_counts(child);
192 
193 		/*
194 		 * The depth mask manages the output of pipes that show
195 		 * the depth. We don't want to keep the pipes of the current
196 		 * level for the last child of this depth.
197 		 * Except if we have remaining filtered hits. They will
198 		 * supersede the last child
199 		 */
200 		next = rb_next(node);
201 		if (!next && (callchain_param.mode != CHAIN_GRAPH_REL || !remaining))
202 			new_depth_mask &= ~(1 << (depth - 1));
203 
204 		/*
205 		 * But we keep the older depth mask for the line separator
206 		 * to keep the level link until we reach the last child
207 		 */
208 		ret += ipchain__fprintf_graph_line(fp, depth, depth_mask,
209 						   left_margin);
210 		i = 0;
211 		list_for_each_entry(chain, &child->val, list) {
212 			ret += ipchain__fprintf_graph(fp, child, chain, depth,
213 						      new_depth_mask, i++,
214 						      total_samples,
215 						      left_margin);
216 		}
217 
218 		if (callchain_param.mode == CHAIN_GRAPH_REL)
219 			new_total = child->children_hit;
220 		else
221 			new_total = total_samples;
222 
223 		ret += __callchain__fprintf_graph(fp, &child->rb_root, new_total,
224 						  depth + 1,
225 						  new_depth_mask | (1 << depth),
226 						  left_margin);
227 		node = next;
228 		if (++entries_printed == callchain_param.print_limit)
229 			break;
230 	}
231 
232 	if (callchain_param.mode == CHAIN_GRAPH_REL &&
233 		remaining && remaining != total_samples) {
234 		struct callchain_node rem_node = {
235 			.hit = remaining,
236 		};
237 
238 		if (!rem_sq_bracket)
239 			return ret;
240 
241 		if (callchain_param.value == CCVAL_COUNT && child && child->parent) {
242 			rem_node.count = child->parent->children_count - cumul_count;
243 			if (rem_node.count <= 0)
244 				return ret;
245 		}
246 
247 		new_depth_mask &= ~(1 << (depth - 1));
248 		ret += ipchain__fprintf_graph(fp, &rem_node, &rem_hits, depth,
249 					      new_depth_mask, 0, total_samples,
250 					      left_margin);
251 	}
252 
253 	return ret;
254 }
255 
256 /*
257  * If have one single callchain root, don't bother printing
258  * its percentage (100 % in fractal mode and the same percentage
259  * than the hist in graph mode). This also avoid one level of column.
260  *
261  * However when percent-limit applied, it's possible that single callchain
262  * node have different (non-100% in fractal mode) percentage.
263  */
264 static bool need_percent_display(struct rb_node *node, u64 parent_samples)
265 {
266 	struct callchain_node *cnode;
267 
268 	if (rb_next(node))
269 		return true;
270 
271 	cnode = rb_entry(node, struct callchain_node, rb_node);
272 	return callchain_cumul_hits(cnode) != parent_samples;
273 }
274 
275 static size_t callchain__fprintf_graph(FILE *fp, struct rb_root *root,
276 				       u64 total_samples, u64 parent_samples,
277 				       int left_margin)
278 {
279 	struct callchain_node *cnode;
280 	struct callchain_list *chain;
281 	u32 entries_printed = 0;
282 	bool printed = false;
283 	struct rb_node *node;
284 	int i = 0;
285 	int ret = 0;
286 	char bf[1024];
287 
288 	node = rb_first(root);
289 	if (node && !need_percent_display(node, parent_samples)) {
290 		cnode = rb_entry(node, struct callchain_node, rb_node);
291 		list_for_each_entry(chain, &cnode->val, list) {
292 			/*
293 			 * If we sort by symbol, the first entry is the same than
294 			 * the symbol. No need to print it otherwise it appears as
295 			 * displayed twice.
296 			 */
297 			if (!i++ && field_order == NULL &&
298 			    sort_order && !prefixcmp(sort_order, "sym"))
299 				continue;
300 
301 			if (!printed) {
302 				ret += callchain__fprintf_left_margin(fp, left_margin);
303 				ret += fprintf(fp, "|\n");
304 				ret += callchain__fprintf_left_margin(fp, left_margin);
305 				ret += fprintf(fp, "---");
306 				left_margin += 3;
307 				printed = true;
308 			} else
309 				ret += callchain__fprintf_left_margin(fp, left_margin);
310 
311 			ret += fprintf(fp, "%s",
312 				       callchain_list__sym_name(chain, bf,
313 								sizeof(bf),
314 								false));
315 
316 			if (symbol_conf.show_branchflag_count)
317 				ret += callchain_list_counts__printf_value(
318 						NULL, chain, fp, NULL, 0);
319 			ret += fprintf(fp, "\n");
320 
321 			if (++entries_printed == callchain_param.print_limit)
322 				break;
323 
324 			if (symbol_conf.inline_name)
325 				ret += inline__fprintf(chain->ms.map,
326 						       chain->ip,
327 						       left_margin,
328 						       0, 0,
329 						       fp);
330 		}
331 		root = &cnode->rb_root;
332 	}
333 
334 	if (callchain_param.mode == CHAIN_GRAPH_REL)
335 		total_samples = parent_samples;
336 
337 	ret += __callchain__fprintf_graph(fp, root, total_samples,
338 					  1, 1, left_margin);
339 	if (ret) {
340 		/* do not add a blank line if it printed nothing */
341 		ret += fprintf(fp, "\n");
342 	}
343 
344 	return ret;
345 }
346 
347 static size_t __callchain__fprintf_flat(FILE *fp, struct callchain_node *node,
348 					u64 total_samples)
349 {
350 	struct callchain_list *chain;
351 	size_t ret = 0;
352 	char bf[1024];
353 
354 	if (!node)
355 		return 0;
356 
357 	ret += __callchain__fprintf_flat(fp, node->parent, total_samples);
358 
359 
360 	list_for_each_entry(chain, &node->val, list) {
361 		if (chain->ip >= PERF_CONTEXT_MAX)
362 			continue;
363 		ret += fprintf(fp, "                %s\n", callchain_list__sym_name(chain,
364 					bf, sizeof(bf), false));
365 	}
366 
367 	return ret;
368 }
369 
370 static size_t callchain__fprintf_flat(FILE *fp, struct rb_root *tree,
371 				      u64 total_samples)
372 {
373 	size_t ret = 0;
374 	u32 entries_printed = 0;
375 	struct callchain_node *chain;
376 	struct rb_node *rb_node = rb_first(tree);
377 
378 	while (rb_node) {
379 		chain = rb_entry(rb_node, struct callchain_node, rb_node);
380 
381 		ret += fprintf(fp, "           ");
382 		ret += callchain_node__fprintf_value(chain, fp, total_samples);
383 		ret += fprintf(fp, "\n");
384 		ret += __callchain__fprintf_flat(fp, chain, total_samples);
385 		ret += fprintf(fp, "\n");
386 		if (++entries_printed == callchain_param.print_limit)
387 			break;
388 
389 		rb_node = rb_next(rb_node);
390 	}
391 
392 	return ret;
393 }
394 
395 static size_t __callchain__fprintf_folded(FILE *fp, struct callchain_node *node)
396 {
397 	const char *sep = symbol_conf.field_sep ?: ";";
398 	struct callchain_list *chain;
399 	size_t ret = 0;
400 	char bf[1024];
401 	bool first;
402 
403 	if (!node)
404 		return 0;
405 
406 	ret += __callchain__fprintf_folded(fp, node->parent);
407 
408 	first = (ret == 0);
409 	list_for_each_entry(chain, &node->val, list) {
410 		if (chain->ip >= PERF_CONTEXT_MAX)
411 			continue;
412 		ret += fprintf(fp, "%s%s", first ? "" : sep,
413 			       callchain_list__sym_name(chain,
414 						bf, sizeof(bf), false));
415 		first = false;
416 	}
417 
418 	return ret;
419 }
420 
421 static size_t callchain__fprintf_folded(FILE *fp, struct rb_root *tree,
422 					u64 total_samples)
423 {
424 	size_t ret = 0;
425 	u32 entries_printed = 0;
426 	struct callchain_node *chain;
427 	struct rb_node *rb_node = rb_first(tree);
428 
429 	while (rb_node) {
430 
431 		chain = rb_entry(rb_node, struct callchain_node, rb_node);
432 
433 		ret += callchain_node__fprintf_value(chain, fp, total_samples);
434 		ret += fprintf(fp, " ");
435 		ret += __callchain__fprintf_folded(fp, chain);
436 		ret += fprintf(fp, "\n");
437 		if (++entries_printed == callchain_param.print_limit)
438 			break;
439 
440 		rb_node = rb_next(rb_node);
441 	}
442 
443 	return ret;
444 }
445 
446 static size_t hist_entry_callchain__fprintf(struct hist_entry *he,
447 					    u64 total_samples, int left_margin,
448 					    FILE *fp)
449 {
450 	u64 parent_samples = he->stat.period;
451 
452 	if (symbol_conf.cumulate_callchain)
453 		parent_samples = he->stat_acc->period;
454 
455 	switch (callchain_param.mode) {
456 	case CHAIN_GRAPH_REL:
457 		return callchain__fprintf_graph(fp, &he->sorted_chain, total_samples,
458 						parent_samples, left_margin);
459 		break;
460 	case CHAIN_GRAPH_ABS:
461 		return callchain__fprintf_graph(fp, &he->sorted_chain, total_samples,
462 						parent_samples, left_margin);
463 		break;
464 	case CHAIN_FLAT:
465 		return callchain__fprintf_flat(fp, &he->sorted_chain, total_samples);
466 		break;
467 	case CHAIN_FOLDED:
468 		return callchain__fprintf_folded(fp, &he->sorted_chain, total_samples);
469 		break;
470 	case CHAIN_NONE:
471 		break;
472 	default:
473 		pr_err("Bad callchain mode\n");
474 	}
475 
476 	return 0;
477 }
478 
479 int __hist_entry__snprintf(struct hist_entry *he, struct perf_hpp *hpp,
480 			   struct perf_hpp_list *hpp_list)
481 {
482 	const char *sep = symbol_conf.field_sep;
483 	struct perf_hpp_fmt *fmt;
484 	char *start = hpp->buf;
485 	int ret;
486 	bool first = true;
487 
488 	if (symbol_conf.exclude_other && !he->parent)
489 		return 0;
490 
491 	perf_hpp_list__for_each_format(hpp_list, fmt) {
492 		if (perf_hpp__should_skip(fmt, he->hists))
493 			continue;
494 
495 		/*
496 		 * If there's no field_sep, we still need
497 		 * to display initial '  '.
498 		 */
499 		if (!sep || !first) {
500 			ret = scnprintf(hpp->buf, hpp->size, "%s", sep ?: "  ");
501 			advance_hpp(hpp, ret);
502 		} else
503 			first = false;
504 
505 		if (perf_hpp__use_color() && fmt->color)
506 			ret = fmt->color(fmt, hpp, he);
507 		else
508 			ret = fmt->entry(fmt, hpp, he);
509 
510 		ret = hist_entry__snprintf_alignment(he, hpp, fmt, ret);
511 		advance_hpp(hpp, ret);
512 	}
513 
514 	return hpp->buf - start;
515 }
516 
517 static int hist_entry__snprintf(struct hist_entry *he, struct perf_hpp *hpp)
518 {
519 	return __hist_entry__snprintf(he, hpp, he->hists->hpp_list);
520 }
521 
522 static int hist_entry__hierarchy_fprintf(struct hist_entry *he,
523 					 struct perf_hpp *hpp,
524 					 struct hists *hists,
525 					 FILE *fp)
526 {
527 	const char *sep = symbol_conf.field_sep;
528 	struct perf_hpp_fmt *fmt;
529 	struct perf_hpp_list_node *fmt_node;
530 	char *buf = hpp->buf;
531 	size_t size = hpp->size;
532 	int ret, printed = 0;
533 	bool first = true;
534 
535 	if (symbol_conf.exclude_other && !he->parent)
536 		return 0;
537 
538 	ret = scnprintf(hpp->buf, hpp->size, "%*s", he->depth * HIERARCHY_INDENT, "");
539 	advance_hpp(hpp, ret);
540 
541 	/* the first hpp_list_node is for overhead columns */
542 	fmt_node = list_first_entry(&hists->hpp_formats,
543 				    struct perf_hpp_list_node, list);
544 	perf_hpp_list__for_each_format(&fmt_node->hpp, fmt) {
545 		/*
546 		 * If there's no field_sep, we still need
547 		 * to display initial '  '.
548 		 */
549 		if (!sep || !first) {
550 			ret = scnprintf(hpp->buf, hpp->size, "%s", sep ?: "  ");
551 			advance_hpp(hpp, ret);
552 		} else
553 			first = false;
554 
555 		if (perf_hpp__use_color() && fmt->color)
556 			ret = fmt->color(fmt, hpp, he);
557 		else
558 			ret = fmt->entry(fmt, hpp, he);
559 
560 		ret = hist_entry__snprintf_alignment(he, hpp, fmt, ret);
561 		advance_hpp(hpp, ret);
562 	}
563 
564 	if (!sep)
565 		ret = scnprintf(hpp->buf, hpp->size, "%*s",
566 				(hists->nr_hpp_node - 2) * HIERARCHY_INDENT, "");
567 	advance_hpp(hpp, ret);
568 
569 	printed += fprintf(fp, "%s", buf);
570 
571 	perf_hpp_list__for_each_format(he->hpp_list, fmt) {
572 		hpp->buf  = buf;
573 		hpp->size = size;
574 
575 		/*
576 		 * No need to call hist_entry__snprintf_alignment() since this
577 		 * fmt is always the last column in the hierarchy mode.
578 		 */
579 		if (perf_hpp__use_color() && fmt->color)
580 			fmt->color(fmt, hpp, he);
581 		else
582 			fmt->entry(fmt, hpp, he);
583 
584 		/*
585 		 * dynamic entries are right-aligned but we want left-aligned
586 		 * in the hierarchy mode
587 		 */
588 		printed += fprintf(fp, "%s%s", sep ?: "  ", ltrim(buf));
589 	}
590 	printed += putc('\n', fp);
591 
592 	if (symbol_conf.use_callchain && he->leaf) {
593 		u64 total = hists__total_period(hists);
594 
595 		printed += hist_entry_callchain__fprintf(he, total, 0, fp);
596 		goto out;
597 	}
598 
599 out:
600 	return printed;
601 }
602 
603 static int hist_entry__fprintf(struct hist_entry *he, size_t size,
604 			       char *bf, size_t bfsz, FILE *fp,
605 			       bool use_callchain)
606 {
607 	int ret;
608 	int callchain_ret = 0;
609 	int inline_ret = 0;
610 	struct perf_hpp hpp = {
611 		.buf		= bf,
612 		.size		= size,
613 	};
614 	struct hists *hists = he->hists;
615 	u64 total_period = hists->stats.total_period;
616 
617 	if (size == 0 || size > bfsz)
618 		size = hpp.size = bfsz;
619 
620 	if (symbol_conf.report_hierarchy)
621 		return hist_entry__hierarchy_fprintf(he, &hpp, hists, fp);
622 
623 	hist_entry__snprintf(he, &hpp);
624 
625 	ret = fprintf(fp, "%s\n", bf);
626 
627 	if (use_callchain)
628 		callchain_ret = hist_entry_callchain__fprintf(he, total_period,
629 							      0, fp);
630 
631 	if (callchain_ret == 0 && symbol_conf.inline_name) {
632 		inline_ret = inline__fprintf(he->ms.map, he->ip, 0, 0, 0, fp);
633 		ret += inline_ret;
634 		if (inline_ret > 0)
635 			ret += fprintf(fp, "\n");
636 	} else
637 		ret += callchain_ret;
638 
639 	return ret;
640 }
641 
642 static int print_hierarchy_indent(const char *sep, int indent,
643 				  const char *line, FILE *fp)
644 {
645 	if (sep != NULL || indent < 2)
646 		return 0;
647 
648 	return fprintf(fp, "%-.*s", (indent - 2) * HIERARCHY_INDENT, line);
649 }
650 
651 static int hists__fprintf_hierarchy_headers(struct hists *hists,
652 					    struct perf_hpp *hpp, FILE *fp)
653 {
654 	bool first_node, first_col;
655 	int indent;
656 	int depth;
657 	unsigned width = 0;
658 	unsigned header_width = 0;
659 	struct perf_hpp_fmt *fmt;
660 	struct perf_hpp_list_node *fmt_node;
661 	const char *sep = symbol_conf.field_sep;
662 
663 	indent = hists->nr_hpp_node;
664 
665 	/* preserve max indent depth for column headers */
666 	print_hierarchy_indent(sep, indent, spaces, fp);
667 
668 	/* the first hpp_list_node is for overhead columns */
669 	fmt_node = list_first_entry(&hists->hpp_formats,
670 				    struct perf_hpp_list_node, list);
671 
672 	perf_hpp_list__for_each_format(&fmt_node->hpp, fmt) {
673 		fmt->header(fmt, hpp, hists, 0, NULL);
674 		fprintf(fp, "%s%s", hpp->buf, sep ?: "  ");
675 	}
676 
677 	/* combine sort headers with ' / ' */
678 	first_node = true;
679 	list_for_each_entry_continue(fmt_node, &hists->hpp_formats, list) {
680 		if (!first_node)
681 			header_width += fprintf(fp, " / ");
682 		first_node = false;
683 
684 		first_col = true;
685 		perf_hpp_list__for_each_format(&fmt_node->hpp, fmt) {
686 			if (perf_hpp__should_skip(fmt, hists))
687 				continue;
688 
689 			if (!first_col)
690 				header_width += fprintf(fp, "+");
691 			first_col = false;
692 
693 			fmt->header(fmt, hpp, hists, 0, NULL);
694 
695 			header_width += fprintf(fp, "%s", trim(hpp->buf));
696 		}
697 	}
698 
699 	fprintf(fp, "\n# ");
700 
701 	/* preserve max indent depth for initial dots */
702 	print_hierarchy_indent(sep, indent, dots, fp);
703 
704 	/* the first hpp_list_node is for overhead columns */
705 	fmt_node = list_first_entry(&hists->hpp_formats,
706 				    struct perf_hpp_list_node, list);
707 
708 	first_col = true;
709 	perf_hpp_list__for_each_format(&fmt_node->hpp, fmt) {
710 		if (!first_col)
711 			fprintf(fp, "%s", sep ?: "..");
712 		first_col = false;
713 
714 		width = fmt->width(fmt, hpp, hists);
715 		fprintf(fp, "%.*s", width, dots);
716 	}
717 
718 	depth = 0;
719 	list_for_each_entry_continue(fmt_node, &hists->hpp_formats, list) {
720 		first_col = true;
721 		width = depth * HIERARCHY_INDENT;
722 
723 		perf_hpp_list__for_each_format(&fmt_node->hpp, fmt) {
724 			if (perf_hpp__should_skip(fmt, hists))
725 				continue;
726 
727 			if (!first_col)
728 				width++;  /* for '+' sign between column header */
729 			first_col = false;
730 
731 			width += fmt->width(fmt, hpp, hists);
732 		}
733 
734 		if (width > header_width)
735 			header_width = width;
736 
737 		depth++;
738 	}
739 
740 	fprintf(fp, "%s%-.*s", sep ?: "  ", header_width, dots);
741 
742 	fprintf(fp, "\n#\n");
743 
744 	return 2;
745 }
746 
747 static void fprintf_line(struct hists *hists, struct perf_hpp *hpp,
748 			 int line, FILE *fp)
749 {
750 	struct perf_hpp_fmt *fmt;
751 	const char *sep = symbol_conf.field_sep;
752 	bool first = true;
753 	int span = 0;
754 
755 	hists__for_each_format(hists, fmt) {
756 		if (perf_hpp__should_skip(fmt, hists))
757 			continue;
758 
759 		if (!first && !span)
760 			fprintf(fp, "%s", sep ?: "  ");
761 		else
762 			first = false;
763 
764 		fmt->header(fmt, hpp, hists, line, &span);
765 
766 		if (!span)
767 			fprintf(fp, "%s", hpp->buf);
768 	}
769 }
770 
771 static int
772 hists__fprintf_standard_headers(struct hists *hists,
773 				struct perf_hpp *hpp,
774 				FILE *fp)
775 {
776 	struct perf_hpp_list *hpp_list = hists->hpp_list;
777 	struct perf_hpp_fmt *fmt;
778 	unsigned int width;
779 	const char *sep = symbol_conf.field_sep;
780 	bool first = true;
781 	int line;
782 
783 	for (line = 0; line < hpp_list->nr_header_lines; line++) {
784 		/* first # is displayed one level up */
785 		if (line)
786 			fprintf(fp, "# ");
787 		fprintf_line(hists, hpp, line, fp);
788 		fprintf(fp, "\n");
789 	}
790 
791 	if (sep)
792 		return hpp_list->nr_header_lines;
793 
794 	first = true;
795 
796 	fprintf(fp, "# ");
797 
798 	hists__for_each_format(hists, fmt) {
799 		unsigned int i;
800 
801 		if (perf_hpp__should_skip(fmt, hists))
802 			continue;
803 
804 		if (!first)
805 			fprintf(fp, "%s", sep ?: "  ");
806 		else
807 			first = false;
808 
809 		width = fmt->width(fmt, hpp, hists);
810 		for (i = 0; i < width; i++)
811 			fprintf(fp, ".");
812 	}
813 
814 	fprintf(fp, "\n");
815 	fprintf(fp, "#\n");
816 	return hpp_list->nr_header_lines + 2;
817 }
818 
819 int hists__fprintf_headers(struct hists *hists, FILE *fp)
820 {
821 	char bf[1024];
822 	struct perf_hpp dummy_hpp = {
823 		.buf	= bf,
824 		.size	= sizeof(bf),
825 	};
826 
827 	fprintf(fp, "# ");
828 
829 	if (symbol_conf.report_hierarchy)
830 		return hists__fprintf_hierarchy_headers(hists, &dummy_hpp, fp);
831 	else
832 		return hists__fprintf_standard_headers(hists, &dummy_hpp, fp);
833 
834 }
835 
836 size_t hists__fprintf(struct hists *hists, bool show_header, int max_rows,
837 		      int max_cols, float min_pcnt, FILE *fp,
838 		      bool use_callchain)
839 {
840 	struct rb_node *nd;
841 	size_t ret = 0;
842 	const char *sep = symbol_conf.field_sep;
843 	int nr_rows = 0;
844 	size_t linesz;
845 	char *line = NULL;
846 	unsigned indent;
847 
848 	init_rem_hits();
849 
850 	hists__reset_column_width(hists);
851 
852 	if (symbol_conf.col_width_list_str)
853 		perf_hpp__set_user_width(symbol_conf.col_width_list_str);
854 
855 	if (show_header)
856 		nr_rows += hists__fprintf_headers(hists, fp);
857 
858 	if (max_rows && nr_rows >= max_rows)
859 		goto out;
860 
861 	linesz = hists__sort_list_width(hists) + 3 + 1;
862 	linesz += perf_hpp__color_overhead();
863 	line = malloc(linesz);
864 	if (line == NULL) {
865 		ret = -1;
866 		goto out;
867 	}
868 
869 	indent = hists__overhead_width(hists) + 4;
870 
871 	for (nd = rb_first(&hists->entries); nd; nd = __rb_hierarchy_next(nd, HMD_FORCE_CHILD)) {
872 		struct hist_entry *h = rb_entry(nd, struct hist_entry, rb_node);
873 		float percent;
874 
875 		if (h->filtered)
876 			continue;
877 
878 		percent = hist_entry__get_percent_limit(h);
879 		if (percent < min_pcnt)
880 			continue;
881 
882 		ret += hist_entry__fprintf(h, max_cols, line, linesz, fp, use_callchain);
883 
884 		if (max_rows && ++nr_rows >= max_rows)
885 			break;
886 
887 		/*
888 		 * If all children are filtered out or percent-limited,
889 		 * display "no entry >= x.xx%" message.
890 		 */
891 		if (!h->leaf && !hist_entry__has_hierarchy_children(h, min_pcnt)) {
892 			int depth = hists->nr_hpp_node + h->depth + 1;
893 
894 			print_hierarchy_indent(sep, depth, spaces, fp);
895 			fprintf(fp, "%*sno entry >= %.2f%%\n", indent, "", min_pcnt);
896 
897 			if (max_rows && ++nr_rows >= max_rows)
898 				break;
899 		}
900 
901 		if (h->ms.map == NULL && verbose > 1) {
902 			__map_groups__fprintf_maps(h->thread->mg,
903 						   MAP__FUNCTION, fp);
904 			fprintf(fp, "%.10s end\n", graph_dotted_line);
905 		}
906 	}
907 
908 	free(line);
909 out:
910 	zfree(&rem_sq_bracket);
911 
912 	return ret;
913 }
914 
915 size_t events_stats__fprintf(struct events_stats *stats, FILE *fp)
916 {
917 	int i;
918 	size_t ret = 0;
919 
920 	for (i = 0; i < PERF_RECORD_HEADER_MAX; ++i) {
921 		const char *name;
922 
923 		if (stats->nr_events[i] == 0)
924 			continue;
925 
926 		name = perf_event__name(i);
927 		if (!strcmp(name, "UNKNOWN"))
928 			continue;
929 
930 		ret += fprintf(fp, "%16s events: %10d\n", name,
931 			       stats->nr_events[i]);
932 	}
933 
934 	return ret;
935 }
936