builtin-annotate.c 16.5 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0
2 3 4 5 6 7 8 9 10
/*
 * builtin-annotate.c
 *
 * Builtin annotate command: Analyze the perf.data input file,
 * look up and read DSOs and symbol information and display
 * a histogram of results, along various sorting keys.
 */
#include "builtin.h"

11
#include "util/util.h"
12
#include "util/color.h"
13
#include <linux/list.h>
14
#include "util/cache.h"
15
#include <linux/rbtree.h>
16 17 18
#include "util/symbol.h"

#include "perf.h"
19
#include "util/debug.h"
20

21 22
#include "util/evlist.h"
#include "util/evsel.h"
23
#include "util/annotate.h"
24
#include "util/event.h"
25
#include <subcmd/parse-options.h>
26
#include "util/parse-events.h"
27
#include "util/thread.h"
28
#include "util/sort.h"
29
#include "util/hist.h"
30
#include "util/session.h"
31
#include "util/tool.h"
32
#include "util/data.h"
33
#include "arch/common.h"
34
#include "util/block-range.h"
35

36
#include <dlfcn.h>
37
#include <errno.h>
38 39
#include <linux/bitmap.h>

40
struct perf_annotate {
41
	struct perf_tool tool;
42
	struct perf_session *session;
43
	struct annotation_options opts;
44
	bool	   use_tui, use_stdio, use_stdio2, use_gtk;
45
	bool	   skip_missing;
46
	bool	   has_br_stack;
47
	bool	   group_set;
48 49 50
	const char *sym_hist_filter;
	const char *cpu_list;
	DECLARE_BITMAP(cpu_bitmap, MAX_NR_CPUS);
51
};
52

53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149
/*
 * Given one basic block:
 *
 *	from	to		branch_i
 *	* ----> *
 *		|
 *		| block
 *		v
 *		* ----> *
 *		from	to	branch_i+1
 *
 * where the horizontal are the branches and the vertical is the executed
 * block of instructions.
 *
 * We count, for each 'instruction', the number of blocks that covered it as
 * well as count the ratio each branch is taken.
 *
 * We can do this without knowing the actual instruction stream by keeping
 * track of the address ranges. We break down ranges such that there is no
 * overlap and iterate from the start until the end.
 *
 * @acme: once we parse the objdump output _before_ processing the samples,
 * we can easily fold the branch.cycles IPC bits in.
 */
static void process_basic_block(struct addr_map_symbol *start,
				struct addr_map_symbol *end,
				struct branch_flags *flags)
{
	struct symbol *sym = start->sym;
	struct annotation *notes = sym ? symbol__annotation(sym) : NULL;
	struct block_range_iter iter;
	struct block_range *entry;

	/*
	 * Sanity; NULL isn't executable and the CPU cannot execute backwards
	 */
	if (!start->addr || start->addr > end->addr)
		return;

	iter = block_range__create(start->addr, end->addr);
	if (!block_range_iter__valid(&iter))
		return;

	/*
	 * First block in range is a branch target.
	 */
	entry = block_range_iter(&iter);
	assert(entry->is_target);
	entry->entry++;

	do {
		entry = block_range_iter(&iter);

		entry->coverage++;
		entry->sym = sym;

		if (notes)
			notes->max_coverage = max(notes->max_coverage, entry->coverage);

	} while (block_range_iter__next(&iter));

	/*
	 * Last block in rage is a branch.
	 */
	entry = block_range_iter(&iter);
	assert(entry->is_branch);
	entry->taken++;
	if (flags->predicted)
		entry->pred++;
}

static void process_branch_stack(struct branch_stack *bs, struct addr_location *al,
				 struct perf_sample *sample)
{
	struct addr_map_symbol *prev = NULL;
	struct branch_info *bi;
	int i;

	if (!bs || !bs->nr)
		return;

	bi = sample__resolve_bstack(sample, al);
	if (!bi)
		return;

	for (i = bs->nr - 1; i >= 0; i--) {
		/*
		 * XXX filter against symbol
		 */
		if (prev)
			process_basic_block(prev, &bi[i].from, &bi[i].flags);
		prev = &bi[i].to;
	}

	free(bi);
}

150 151 152 153 154 155 156 157 158 159 160 161 162 163
static int hist_iter__branch_callback(struct hist_entry_iter *iter,
				      struct addr_location *al __maybe_unused,
				      bool single __maybe_unused,
				      void *arg __maybe_unused)
{
	struct hist_entry *he = iter->he;
	struct branch_info *bi;
	struct perf_sample *sample = iter->sample;
	struct perf_evsel *evsel = iter->evsel;
	int err;

	hist__account_cycles(sample->branch_stack, al, sample, false);

	bi = he->branch_info;
164
	err = addr_map_symbol__inc_samples(&bi->from, sample, evsel);
165 166 167 168

	if (err)
		goto out;

169
	err = addr_map_symbol__inc_samples(&bi->to, sample, evsel);
170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204

out:
	return err;
}

static int process_branch_callback(struct perf_evsel *evsel,
				   struct perf_sample *sample,
				   struct addr_location *al __maybe_unused,
				   struct perf_annotate *ann,
				   struct machine *machine)
{
	struct hist_entry_iter iter = {
		.evsel		= evsel,
		.sample		= sample,
		.add_entry_cb	= hist_iter__branch_callback,
		.hide_unresolved	= symbol_conf.hide_unresolved,
		.ops		= &hist_iter_branch,
	};

	struct addr_location a;
	int ret;

	if (machine__resolve(machine, &a, sample) < 0)
		return -1;

	if (a.sym == NULL)
		return 0;

	if (a.map != NULL)
		a.map->dso->hit = 1;

	ret = hist_entry_iter__add(&iter, &a, PERF_MAX_STACK_DEPTH, ann);
	return ret;
}

205 206 207 208 209
static bool has_annotation(struct perf_annotate *ann)
{
	return ui__has_annotation() || ann->use_stdio2;
}

210
static int perf_evsel__add_sample(struct perf_evsel *evsel,
211
				  struct perf_sample *sample,
212
				  struct addr_location *al,
213 214
				  struct perf_annotate *ann,
				  struct machine *machine)
215
{
216
	struct hists *hists = evsel__hists(evsel);
217
	struct hist_entry *he;
218
	int ret;
219

220
	if ((!ann->has_br_stack || !has_annotation(ann)) &&
221
	    ann->sym_hist_filter != NULL &&
222 223
	    (al->sym == NULL ||
	     strcmp(ann->sym_hist_filter, al->sym->name) != 0)) {
224
		/* We're only interested in a symbol named sym_hist_filter */
225 226 227 228
		/*
		 * FIXME: why isn't this done in the symbol_filter when loading
		 * the DSO?
		 */
229 230
		if (al->sym != NULL) {
			rb_erase(&al->sym->rb_node,
231
				 &al->map->dso->symbols);
232
			symbol__delete(al->sym);
233
			dso__reset_find_symbol_cache(al->map->dso);
234 235 236 237
		}
		return 0;
	}

238 239 240 241 242 243
	/*
	 * XXX filtered samples can still have branch entires pointing into our
	 * symbol and are missed.
	 */
	process_branch_stack(sample->branch_stack, al, sample);

244
	if (ann->has_br_stack && has_annotation(ann))
245 246
		return process_branch_callback(evsel, sample, al, ann, machine);

247
	he = hists__add_entry(hists, al, NULL, NULL, NULL, sample, true);
248
	if (he == NULL)
249
		return -ENOMEM;
250

251
	ret = hist_entry__inc_addr_samples(he, sample, evsel, al->addr);
252
	hists__inc_nr_samples(hists, true);
253
	return ret;
254 255
}

256
static int process_sample_event(struct perf_tool *tool,
257
				union perf_event *event,
258
				struct perf_sample *sample,
259
				struct perf_evsel *evsel,
260
				struct machine *machine)
261
{
262
	struct perf_annotate *ann = container_of(tool, struct perf_annotate, tool);
263
	struct addr_location al;
264
	int ret = 0;
265

266
	if (machine__resolve(machine, &al, sample) < 0) {
267 268
		pr_warning("problem processing %d event, skipping it.\n",
			   event->header.type);
269 270 271
		return -1;
	}

272
	if (ann->cpu_list && !test_bit(sample->cpu, ann->cpu_bitmap))
273
		goto out_put;
274

275 276
	if (!al.filtered &&
	    perf_evsel__add_sample(evsel, sample, &al, ann, machine)) {
277 278
		pr_warning("problem incrementing symbol count, "
			   "skipping event\n");
279
		ret = -1;
280
	}
281 282 283
out_put:
	addr_location__put(&al);
	return ret;
284 285
}

286 287
static int process_feature_event(struct perf_session *session,
				 union perf_event *event)
288 289
{
	if (event->feat.feat_id < HEADER_LAST_FEATURE)
290
		return perf_event__process_feature(session, event);
291 292 293
	return 0;
}

294 295
static int hist_entry__tty_annotate(struct hist_entry *he,
				    struct perf_evsel *evsel,
296
				    struct perf_annotate *ann)
297
{
298
	if (!ann->use_stdio2)
299 300 301
		return symbol__tty_annotate(he->ms.sym, he->ms.map, evsel, &ann->opts);

	return symbol__tty_annotate2(he->ms.sym, he->ms.map, evsel, &ann->opts);
302 303
}

304
static void hists__find_annotations(struct hists *hists,
305
				    struct perf_evsel *evsel,
306
				    struct perf_annotate *ann)
307
{
308
	struct rb_node *nd = rb_first(&hists->entries), *next;
309
	int key = K_RIGHT;
310

311
	while (nd) {
312
		struct hist_entry *he = rb_entry(nd, struct hist_entry, rb_node);
313
		struct annotation *notes;
314

315 316
		if (he->ms.sym == NULL || he->ms.map->dso->annotate_warned)
			goto find_next;
317

318 319 320 321
		if (ann->sym_hist_filter &&
		    (strcmp(he->ms.sym->name, ann->sym_hist_filter) != 0))
			goto find_next;

322
		notes = symbol__annotation(he->ms.sym);
323
		if (notes->src == NULL) {
324
find_next:
325
			if (key == K_LEFT)
326 327 328
				nd = rb_prev(nd);
			else
				nd = rb_next(nd);
329
			continue;
330
		}
331

332
		if (use_browser == 2) {
333
			int ret;
334 335 336 337 338 339 340 341 342 343
			int (*annotate)(struct hist_entry *he,
					struct perf_evsel *evsel,
					struct hist_browser_timer *hbt);

			annotate = dlsym(perf_gtk_handle,
					 "hist_entry__gtk_annotate");
			if (annotate == NULL) {
				ui__error("GTK browser not found!\n");
				return;
			}
344

345
			ret = annotate(he, evsel, NULL);
346 347 348 349 350
			if (!ret || !ann->skip_missing)
				return;

			/* skip missing symbols */
			nd = rb_next(nd);
351
		} else if (use_browser == 1) {
352
			key = hist_entry__tui_annotate(he, evsel, NULL, &ann->opts);
353

354
			switch (key) {
355 356 357 358
			case -1:
				if (!ann->skip_missing)
					return;
				/* fall through */
359
			case K_RIGHT:
360
				next = rb_next(nd);
361
				break;
362
			case K_LEFT:
363
				next = rb_prev(nd);
364
				break;
365 366
			default:
				return;
367
			}
368 369 370

			if (next != NULL)
				nd = next;
371
		} else {
372
			hist_entry__tty_annotate(he, evsel, ann);
373 374 375
			nd = rb_next(nd);
			/*
			 * Since we have a hist_entry per IP for the same
376
			 * symbol, free he->ms.sym->src to signal we already
377 378
			 * processed this symbol.
			 */
379
			zfree(&notes->src->cycles_hist);
380
			zfree(&notes->src);
381
		}
382 383 384
	}
}

385
static int __cmd_annotate(struct perf_annotate *ann)
386
{
387
	int ret;
388
	struct perf_session *session = ann->session;
389 390
	struct perf_evsel *pos;
	u64 total_nr_samples;
391

392 393 394
	if (ann->cpu_list) {
		ret = perf_session__cpu_bitmap(session, ann->cpu_list,
					       ann->cpu_bitmap);
395
		if (ret)
396
			goto out;
397 398
	}

399 400 401
	if (!ann->opts.objdump_path) {
		ret = perf_env__lookup_objdump(&session->header.env,
					       &ann->opts.objdump_path);
402
		if (ret)
403
			goto out;
404 405
	}

406
	ret = perf_session__process_events(session);
407
	if (ret)
408
		goto out;
409

410
	if (dump_trace) {
411
		perf_session__fprintf_nr_events(session, stdout);
412
		perf_evlist__fprintf_nr_events(session->evlist, stdout);
413
		goto out;
414
	}
415

416
	if (verbose > 3)
417
		perf_session__fprintf(session, stdout);
418

419
	if (verbose > 2)
420
		perf_session__fprintf_dsos(session, stdout);
421

422
	total_nr_samples = 0;
423
	evlist__for_each_entry(session->evlist, pos) {
424
		struct hists *hists = evsel__hists(pos);
425 426 427 428
		u32 nr_samples = hists->stats.nr_events[PERF_RECORD_SAMPLE];

		if (nr_samples > 0) {
			total_nr_samples += nr_samples;
429
			hists__collapse_resort(hists, NULL);
430 431
			/* Don't sort callchain */
			perf_evsel__reset_sample_bit(pos, CALLCHAIN);
432
			perf_evsel__output_resort(pos, NULL);
433 434 435 436 437

			if (symbol_conf.event_group &&
			    !perf_evsel__is_group_leader(pos))
				continue;

438
			hists__find_annotations(hists, pos, ann);
439 440
		}
	}
441

442
	if (total_nr_samples == 0) {
443
		ui__error("The %s file has no samples!\n", session->data->file.path);
444
		goto out;
445
	}
446

447 448 449 450 451 452 453
	if (use_browser == 2) {
		void (*show_annotations)(void);

		show_annotations = dlsym(perf_gtk_handle,
					 "perf_gtk__show_annotations");
		if (show_annotations == NULL) {
			ui__error("GTK browser not found!\n");
454
			goto out;
455 456 457
		}
		show_annotations();
	}
458

459
out:
460
	return ret;
461 462 463
}

static const char * const annotate_usage[] = {
464
	"perf annotate [<options>]",
465 466 467
	NULL
};

468
int cmd_annotate(int argc, const char **argv)
469 470
{
	struct perf_annotate annotate = {
471
		.tool = {
472 473
			.sample	= process_sample_event,
			.mmap	= perf_event__process_mmap,
474
			.mmap2	= perf_event__process_mmap2,
475
			.comm	= perf_event__process_comm,
476
			.exit	= perf_event__process_exit,
477
			.fork	= perf_event__process_fork,
478
			.namespaces = perf_event__process_namespaces,
479 480
			.attr	= perf_event__process_attr,
			.build_id = perf_event__process_build_id,
481
			.tracing_data   = perf_event__process_tracing_data,
482
			.feature	= process_feature_event,
483
			.ordered_events = true,
484 485
			.ordering_requires_timestamps = true,
		},
486
		.opts = annotation__default_options,
487
	};
488
	struct perf_data data = {
489 490
		.mode  = PERF_DATA_MODE_READ,
	};
491
	struct option options[] = {
492
	OPT_STRING('i', "input", &input_name, "file",
493
		    "input file name"),
494 495
	OPT_STRING('d', "dsos", &symbol_conf.dso_list_str, "dso[,dso...]",
		   "only consider symbols in these dsos"),
496
	OPT_STRING('s', "symbol", &annotate.sym_hist_filter, "symbol",
497
		    "symbol to annotate"),
498
	OPT_BOOLEAN('f', "force", &data.force, "don't complain, do it"),
499
	OPT_INCR('v', "verbose", &verbose,
500
		    "be more verbose (show symbol address, etc)"),
501
	OPT_BOOLEAN('q', "quiet", &quiet, "do now show any message"),
502 503
	OPT_BOOLEAN('D', "dump-raw-trace", &dump_trace,
		    "dump raw trace in ASCII"),
504
	OPT_BOOLEAN(0, "gtk", &annotate.use_gtk, "Use the GTK interface"),
505 506
	OPT_BOOLEAN(0, "tui", &annotate.use_tui, "Use the TUI interface"),
	OPT_BOOLEAN(0, "stdio", &annotate.use_stdio, "Use the stdio interface"),
507
	OPT_BOOLEAN(0, "stdio2", &annotate.use_stdio2, "Use the stdio interface"),
508 509
	OPT_BOOLEAN(0, "ignore-vmlinux", &symbol_conf.ignore_vmlinux,
                    "don't load vmlinux even if found"),
510 511 512
	OPT_STRING('k', "vmlinux", &symbol_conf.vmlinux_name,
		   "file", "vmlinux pathname"),
	OPT_BOOLEAN('m', "modules", &symbol_conf.use_modules,
513
		    "load module symbols - WARNING: use only with -k and LIVE kernel"),
514
	OPT_BOOLEAN('l', "print-line", &annotate.opts.print_lines,
515
		    "print matching source lines (may be slow)"),
516
	OPT_BOOLEAN('P', "full-paths", &annotate.opts.full_path,
517
		    "Don't shorten the displayed pathnames"),
518 519
	OPT_BOOLEAN(0, "skip-missing", &annotate.skip_missing,
		    "Skip symbols that cannot be annotated"),
520 521 522
	OPT_BOOLEAN_SET(0, "group", &symbol_conf.event_group,
			&annotate.group_set,
			"Show event group information together"),
523
	OPT_STRING('C', "cpu", &annotate.cpu_list, "cpu", "list of cpus to profile"),
524 525 526
	OPT_CALLBACK(0, "symfs", NULL, "directory",
		     "Look for files with symbols relative to this directory",
		     symbol__config_symfs),
527
	OPT_BOOLEAN(0, "source", &annotate.opts.annotate_src,
528
		    "Interleave source code with assembly code (default)"),
529
	OPT_BOOLEAN(0, "asm-raw", &annotate.opts.show_asm_raw,
530
		    "Display raw encoding of assembly instructions (default)"),
531
	OPT_STRING('M', "disassembler-style", &annotate.opts.disassembler_style, "disassembler style",
532
		   "Specify disassembler style (e.g. -M intel for intel syntax)"),
533
	OPT_STRING(0, "objdump", &annotate.opts.objdump_path, "path",
534
		   "objdump binary to use for disassembly and annotations"),
535 536
	OPT_BOOLEAN(0, "group", &symbol_conf.event_group,
		    "Show event group information together"),
537 538
	OPT_BOOLEAN(0, "show-total-period", &symbol_conf.show_total_period,
		    "Show a column with the sum of periods"),
539 540
	OPT_BOOLEAN('n', "show-nr-samples", &symbol_conf.show_nr_samples,
		    "Show a column with the number of samples"),
541 542 543
	OPT_CALLBACK_DEFAULT(0, "stdio-color", NULL, "mode",
			     "'always' (default), 'never' or 'auto' only applicable to --stdio mode",
			     stdio__config_color, "always"),
544 545 546 547
	OPT_CALLBACK(0, "percent-type", &annotate.opts, "local-period",
		     "Set percent type local/global-period/hits",
		     annotate_parse_percent_type),

548
	OPT_END()
549
	};
550 551 552 553 554
	int ret;

	set_option_flag(options, 0, "show-total-period", PARSE_OPT_EXCLUSIVE);
	set_option_flag(options, 0, "show-nr-samples", PARSE_OPT_EXCLUSIVE);

555

556
	ret = hists__init();
557 558
	if (ret < 0)
		return ret;
559

560
	argc = parse_options(argc, argv, options, annotate_usage, 0);
561 562 563 564 565 566 567 568 569 570
	if (argc) {
		/*
		 * Special case: if there's an argument left then assume that
		 * it's a symbol filter:
		 */
		if (argc > 1)
			usage_with_options(annotate_usage, options);

		annotate.sym_hist_filter = argv[0];
	}
571

572 573
	if (symbol_conf.show_nr_samples && annotate.use_gtk) {
		pr_err("--show-nr-samples is not available in --gtk mode at this time\n");
574 575 576
		return ret;
	}

577 578 579
	if (quiet)
		perf_quiet_option();

580
	data.file.path = input_name;
581

582
	annotate.session = perf_session__new(&data, false, &annotate.tool);
583
	if (annotate.session == NULL)
584
		return -1;
585

586 587 588
	annotate.has_br_stack = perf_header__has_feat(&annotate.session->header,
						      HEADER_BRANCH_STACK);

589 590 591
	if (annotate.group_set)
		perf_evlist__force_leader(annotate.session->evlist);

592 593 594 595
	ret = symbol__annotation_init();
	if (ret < 0)
		goto out_delete;

596 597
	annotation_config__init();

598 599
	symbol_conf.try_vmlinux_path = true;

600
	ret = symbol__init(&annotate.session->header.env);
601 602
	if (ret < 0)
		goto out_delete;
603

604
	if (annotate.use_stdio || annotate.use_stdio2)
605 606 607 608 609 610 611 612
		use_browser = 0;
	else if (annotate.use_tui)
		use_browser = 1;
	else if (annotate.use_gtk)
		use_browser = 2;

	setup_browser(true);

613
	if ((use_browser == 1 || annotate.use_stdio2) && annotate.has_br_stack) {
614 615 616 617 618 619 620 621
		sort__mode = SORT_MODE__BRANCH;
		if (setup_sorting(annotate.session->evlist) < 0)
			usage_with_options(annotate_usage, options);
	} else {
		if (setup_sorting(NULL) < 0)
			usage_with_options(annotate_usage, options);
	}

622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637
	ret = __cmd_annotate(&annotate);

out_delete:
	/*
	 * Speed up the exit process, for large files this can
	 * take quite a while.
	 *
	 * XXX Enable this when using valgrind or if we ever
	 * librarize this command.
	 *
	 * Also experiment with obstacks to see how much speed
	 * up we'll get here.
	 *
	 * perf_session__delete(session);
	 */
	return ret;
638
}