1/*
   2 * Copyright (C) 2011, Red Hat Inc, Arnaldo Carvalho de Melo <acme@redhat.com>
   3 *
   4 * Parts came from builtin-annotate.c, see those files for further
   5 * copyright notes.
   6 *
   7 * Released under the GPL v2. (and only v2, not any later version)
   8 */
   9
  10#include "util.h"
  11#include "ui/ui.h"
  12#include "sort.h"
  13#include "build-id.h"
  14#include "color.h"
  15#include "cache.h"
  16#include "symbol.h"
  17#include "debug.h"
  18#include "annotate.h"
  19#include "evsel.h"
  20#include <regex.h>
  21#include <pthread.h>
  22#include <linux/bitops.h>
  23
  24const char 	*disassembler_style;
  25const char	*objdump_path;
  26static regex_t	 file_lineno;
  27
  28static struct ins *ins__find(const char *name);
  29static int disasm_line__parse(char *line, char **namep, char **rawp);
  30
  31static void ins__delete(struct ins_operands *ops)
  32{
  33	if (ops == NULL)
  34		return;
  35	zfree(&ops->source.raw);
  36	zfree(&ops->source.name);
  37	zfree(&ops->target.raw);
  38	zfree(&ops->target.name);
  39}
  40
  41static int ins__raw_scnprintf(struct ins *ins, char *bf, size_t size,
  42			      struct ins_operands *ops)
  43{
  44	return scnprintf(bf, size, "%-6.6s %s", ins->name, ops->raw);
  45}
  46
  47int ins__scnprintf(struct ins *ins, char *bf, size_t size,
  48		  struct ins_operands *ops)
  49{
  50	if (ins->ops->scnprintf)
  51		return ins->ops->scnprintf(ins, bf, size, ops);
  52
  53	return ins__raw_scnprintf(ins, bf, size, ops);
  54}
  55
  56static int call__parse(struct ins_operands *ops)
  57{
  58	char *endptr, *tok, *name;
  59
  60	ops->target.addr = strtoull(ops->raw, &endptr, 16);
  61
  62	name = strchr(endptr, '<');
  63	if (name == NULL)
  64		goto indirect_call;
  65
  66	name++;
  67
  68#ifdef __arm__
  69	if (strchr(name, '+'))
  70		return -1;
  71#endif
  72
  73	tok = strchr(name, '>');
  74	if (tok == NULL)
  75		return -1;
  76
  77	*tok = '\0';
  78	ops->target.name = strdup(name);
  79	*tok = '>';
  80
  81	return ops->target.name == NULL ? -1 : 0;
  82
  83indirect_call:
  84	tok = strchr(endptr, '(');
  85	if (tok != NULL) {
  86		ops->target.addr = 0;
  87		return 0;
  88	}
  89
  90	tok = strchr(endptr, '*');
  91	if (tok == NULL)
  92		return -1;
  93
  94	ops->target.addr = strtoull(tok + 1, NULL, 16);
  95	return 0;
  96}
  97
  98static int call__scnprintf(struct ins *ins, char *bf, size_t size,
  99			   struct ins_operands *ops)
 100{
 101	if (ops->target.name)
 102		return scnprintf(bf, size, "%-6.6s %s", ins->name, ops->target.name);
 103
 104	if (ops->target.addr == 0)
 105		return ins__raw_scnprintf(ins, bf, size, ops);
 106
 107	return scnprintf(bf, size, "%-6.6s *%" PRIx64, ins->name, ops->target.addr);
 108}
 109
 110static struct ins_ops call_ops = {
 111	.parse	   = call__parse,
 112	.scnprintf = call__scnprintf,
 113};
 114
 115bool ins__is_call(const struct ins *ins)
 116{
 117	return ins->ops == &call_ops;
 118}
 119
 120static int jump__parse(struct ins_operands *ops)
 121{
 122	const char *s = strchr(ops->raw, '+');
 123
 124	ops->target.addr = strtoull(ops->raw, NULL, 16);
 125
 126	if (s++ != NULL)
 127		ops->target.offset = strtoull(s, NULL, 16);
 128	else
 129		ops->target.offset = UINT64_MAX;
 130
 131	return 0;
 132}
 133
 134static int jump__scnprintf(struct ins *ins, char *bf, size_t size,
 135			   struct ins_operands *ops)
 136{
 137	return scnprintf(bf, size, "%-6.6s %" PRIx64, ins->name, ops->target.offset);
 138}
 139
 140static struct ins_ops jump_ops = {
 141	.parse	   = jump__parse,
 142	.scnprintf = jump__scnprintf,
 143};
 144
 145bool ins__is_jump(const struct ins *ins)
 146{
 147	return ins->ops == &jump_ops;
 148}
 149
 150static int comment__symbol(char *raw, char *comment, u64 *addrp, char **namep)
 151{
 152	char *endptr, *name, *t;
 153
 154	if (strstr(raw, "(%rip)") == NULL)
 155		return 0;
 156
 157	*addrp = strtoull(comment, &endptr, 16);
 158	name = strchr(endptr, '<');
 159	if (name == NULL)
 160		return -1;
 161
 162	name++;
 163
 164	t = strchr(name, '>');
 165	if (t == NULL)
 166		return 0;
 167
 168	*t = '\0';
 169	*namep = strdup(name);
 170	*t = '>';
 171
 172	return 0;
 173}
 174
 175static int lock__parse(struct ins_operands *ops)
 176{
 177	char *name;
 178
 179	ops->locked.ops = zalloc(sizeof(*ops->locked.ops));
 180	if (ops->locked.ops == NULL)
 181		return 0;
 182
 183	if (disasm_line__parse(ops->raw, &name, &ops->locked.ops->raw) < 0)
 184		goto out_free_ops;
 185
 186	ops->locked.ins = ins__find(name);
 187	free(name);
 188
 189	if (ops->locked.ins == NULL)
 190		goto out_free_ops;
 191
 192	if (!ops->locked.ins->ops)
 193		return 0;
 194
 195	if (ops->locked.ins->ops->parse &&
 196	    ops->locked.ins->ops->parse(ops->locked.ops) < 0)
 197		goto out_free_ops;
 198
 199	return 0;
 200
 201out_free_ops:
 202	zfree(&ops->locked.ops);
 203	return 0;
 204}
 205
 206static int lock__scnprintf(struct ins *ins, char *bf, size_t size,
 207			   struct ins_operands *ops)
 208{
 209	int printed;
 210
 211	if (ops->locked.ins == NULL)
 212		return ins__raw_scnprintf(ins, bf, size, ops);
 213
 214	printed = scnprintf(bf, size, "%-6.6s ", ins->name);
 215	return printed + ins__scnprintf(ops->locked.ins, bf + printed,
 216					size - printed, ops->locked.ops);
 217}
 218
 219static void lock__delete(struct ins_operands *ops)
 220{
 221	struct ins *ins = ops->locked.ins;
 222
 223	if (ins && ins->ops->free)
 224		ins->ops->free(ops->locked.ops);
 225	else
 226		ins__delete(ops->locked.ops);
 227
 228	zfree(&ops->locked.ops);
 229	zfree(&ops->target.raw);
 230	zfree(&ops->target.name);
 231}
 232
 233static struct ins_ops lock_ops = {
 234	.free	   = lock__delete,
 235	.parse	   = lock__parse,
 236	.scnprintf = lock__scnprintf,
 237};
 238
 239static int mov__parse(struct ins_operands *ops)
 240{
 241	char *s = strchr(ops->raw, ','), *target, *comment, prev;
 242
 243	if (s == NULL)
 244		return -1;
 245
 246	*s = '\0';
 247	ops->source.raw = strdup(ops->raw);
 248	*s = ',';
 249
 250	if (ops->source.raw == NULL)
 251		return -1;
 252
 253	target = ++s;
 254#ifdef __arm__
 255	comment = strchr(s, ';');
 256#else
 257	comment = strchr(s, '#');
 258#endif
 259
 260	if (comment != NULL)
 261		s = comment - 1;
 262	else
 263		s = strchr(s, '\0') - 1;
 264
 265	while (s > target && isspace(s[0]))
 266		--s;
 267	s++;
 268	prev = *s;
 269	*s = '\0';
 270
 271	ops->target.raw = strdup(target);
 272	*s = prev;
 273
 274	if (ops->target.raw == NULL)
 275		goto out_free_source;
 276
 277	if (comment == NULL)
 278		return 0;
 279
 280	while (comment[0] != '\0' && isspace(comment[0]))
 281		++comment;
 282
 283	comment__symbol(ops->source.raw, comment, &ops->source.addr, &ops->source.name);
 284	comment__symbol(ops->target.raw, comment, &ops->target.addr, &ops->target.name);
 285
 286	return 0;
 287
 288out_free_source:
 289	zfree(&ops->source.raw);
 290	return -1;
 291}
 292
 293static int mov__scnprintf(struct ins *ins, char *bf, size_t size,
 294			   struct ins_operands *ops)
 295{
 296	return scnprintf(bf, size, "%-6.6s %s,%s", ins->name,
 297			 ops->source.name ?: ops->source.raw,
 298			 ops->target.name ?: ops->target.raw);
 299}
 300
 301static struct ins_ops mov_ops = {
 302	.parse	   = mov__parse,
 303	.scnprintf = mov__scnprintf,
 304};
 305
 306static int dec__parse(struct ins_operands *ops)
 307{
 308	char *target, *comment, *s, prev;
 309
 310	target = s = ops->raw;
 311
 312	while (s[0] != '\0' && !isspace(s[0]))
 313		++s;
 314	prev = *s;
 315	*s = '\0';
 316
 317	ops->target.raw = strdup(target);
 318	*s = prev;
 319
 320	if (ops->target.raw == NULL)
 321		return -1;
 322
 323	comment = strchr(s, '#');
 324	if (comment == NULL)
 325		return 0;
 326
 327	while (comment[0] != '\0' && isspace(comment[0]))
 328		++comment;
 329
 330	comment__symbol(ops->target.raw, comment, &ops->target.addr, &ops->target.name);
 331
 332	return 0;
 333}
 334
 335static int dec__scnprintf(struct ins *ins, char *bf, size_t size,
 336			   struct ins_operands *ops)
 337{
 338	return scnprintf(bf, size, "%-6.6s %s", ins->name,
 339			 ops->target.name ?: ops->target.raw);
 340}
 341
 342static struct ins_ops dec_ops = {
 343	.parse	   = dec__parse,
 344	.scnprintf = dec__scnprintf,
 345};
 346
 347static int nop__scnprintf(struct ins *ins __maybe_unused, char *bf, size_t size,
 348			  struct ins_operands *ops __maybe_unused)
 349{
 350	return scnprintf(bf, size, "%-6.6s", "nop");
 351}
 352
 353static struct ins_ops nop_ops = {
 354	.scnprintf = nop__scnprintf,
 355};
 356
 357/*
 358 * Must be sorted by name!
 359 */
 360static struct ins instructions[] = {
 361	{ .name = "add",   .ops  = &mov_ops, },
 362	{ .name = "addl",  .ops  = &mov_ops, },
 363	{ .name = "addq",  .ops  = &mov_ops, },
 364	{ .name = "addw",  .ops  = &mov_ops, },
 365	{ .name = "and",   .ops  = &mov_ops, },
 366#ifdef __arm__
 367	{ .name = "b",     .ops  = &jump_ops, }, // might also be a call
 368	{ .name = "bcc",   .ops  = &jump_ops, },
 369	{ .name = "bcs",   .ops  = &jump_ops, },
 370	{ .name = "beq",   .ops  = &jump_ops, },
 371	{ .name = "bge",   .ops  = &jump_ops, },
 372	{ .name = "bgt",   .ops  = &jump_ops, },
 373	{ .name = "bhi",   .ops  = &jump_ops, },
 374	{ .name = "bl",    .ops  = &call_ops, },
 375	{ .name = "blt",   .ops  = &jump_ops, },
 376	{ .name = "bls",   .ops  = &jump_ops, },
 377	{ .name = "blx",   .ops  = &call_ops, },
 378	{ .name = "bne",   .ops  = &jump_ops, },
 379#endif
 380	{ .name = "bts",   .ops  = &mov_ops, },
 381	{ .name = "call",  .ops  = &call_ops, },
 382	{ .name = "callq", .ops  = &call_ops, },
 383	{ .name = "cmp",   .ops  = &mov_ops, },
 384	{ .name = "cmpb",  .ops  = &mov_ops, },
 385	{ .name = "cmpl",  .ops  = &mov_ops, },
 386	{ .name = "cmpq",  .ops  = &mov_ops, },
 387	{ .name = "cmpw",  .ops  = &mov_ops, },
 388	{ .name = "cmpxch", .ops  = &mov_ops, },
 389	{ .name = "dec",   .ops  = &dec_ops, },
 390	{ .name = "decl",  .ops  = &dec_ops, },
 391	{ .name = "imul",  .ops  = &mov_ops, },
 392	{ .name = "inc",   .ops  = &dec_ops, },
 393	{ .name = "incl",  .ops  = &dec_ops, },
 394	{ .name = "ja",	   .ops  = &jump_ops, },
 395	{ .name = "jae",   .ops  = &jump_ops, },
 396	{ .name = "jb",	   .ops  = &jump_ops, },
 397	{ .name = "jbe",   .ops  = &jump_ops, },
 398	{ .name = "jc",	   .ops  = &jump_ops, },
 399	{ .name = "jcxz",  .ops  = &jump_ops, },
 400	{ .name = "je",	   .ops  = &jump_ops, },
 401	{ .name = "jecxz", .ops  = &jump_ops, },
 402	{ .name = "jg",	   .ops  = &jump_ops, },
 403	{ .name = "jge",   .ops  = &jump_ops, },
 404	{ .name = "jl",    .ops  = &jump_ops, },
 405	{ .name = "jle",   .ops  = &jump_ops, },
 406	{ .name = "jmp",   .ops  = &jump_ops, },
 407	{ .name = "jmpq",  .ops  = &jump_ops, },
 408	{ .name = "jna",   .ops  = &jump_ops, },
 409	{ .name = "jnae",  .ops  = &jump_ops, },
 410	{ .name = "jnb",   .ops  = &jump_ops, },
 411	{ .name = "jnbe",  .ops  = &jump_ops, },
 412	{ .name = "jnc",   .ops  = &jump_ops, },
 413	{ .name = "jne",   .ops  = &jump_ops, },
 414	{ .name = "jng",   .ops  = &jump_ops, },
 415	{ .name = "jnge",  .ops  = &jump_ops, },
 416	{ .name = "jnl",   .ops  = &jump_ops, },
 417	{ .name = "jnle",  .ops  = &jump_ops, },
 418	{ .name = "jno",   .ops  = &jump_ops, },
 419	{ .name = "jnp",   .ops  = &jump_ops, },
 420	{ .name = "jns",   .ops  = &jump_ops, },
 421	{ .name = "jnz",   .ops  = &jump_ops, },
 422	{ .name = "jo",	   .ops  = &jump_ops, },
 423	{ .name = "jp",	   .ops  = &jump_ops, },
 424	{ .name = "jpe",   .ops  = &jump_ops, },
 425	{ .name = "jpo",   .ops  = &jump_ops, },
 426	{ .name = "jrcxz", .ops  = &jump_ops, },
 427	{ .name = "js",	   .ops  = &jump_ops, },
 428	{ .name = "jz",	   .ops  = &jump_ops, },
 429	{ .name = "lea",   .ops  = &mov_ops, },
 430	{ .name = "lock",  .ops  = &lock_ops, },
 431	{ .name = "mov",   .ops  = &mov_ops, },
 432	{ .name = "movb",  .ops  = &mov_ops, },
 433	{ .name = "movdqa",.ops  = &mov_ops, },
 434	{ .name = "movl",  .ops  = &mov_ops, },
 435	{ .name = "movq",  .ops  = &mov_ops, },
 436	{ .name = "movslq", .ops  = &mov_ops, },
 437	{ .name = "movzbl", .ops  = &mov_ops, },
 438	{ .name = "movzwl", .ops  = &mov_ops, },
 439	{ .name = "nop",   .ops  = &nop_ops, },
 440	{ .name = "nopl",  .ops  = &nop_ops, },
 441	{ .name = "nopw",  .ops  = &nop_ops, },
 442	{ .name = "or",    .ops  = &mov_ops, },
 443	{ .name = "orl",   .ops  = &mov_ops, },
 444	{ .name = "test",  .ops  = &mov_ops, },
 445	{ .name = "testb", .ops  = &mov_ops, },
 446	{ .name = "testl", .ops  = &mov_ops, },
 447	{ .name = "xadd",  .ops  = &mov_ops, },
 448	{ .name = "xbeginl", .ops  = &jump_ops, },
 449	{ .name = "xbeginq", .ops  = &jump_ops, },
 450};
 451
 452static int ins__cmp(const void *name, const void *insp)
 453{
 454	const struct ins *ins = insp;
 455
 456	return strcmp(name, ins->name);
 457}
 458
 459static struct ins *ins__find(const char *name)
 460{
 461	const int nmemb = ARRAY_SIZE(instructions);
 462
 463	return bsearch(name, instructions, nmemb, sizeof(struct ins), ins__cmp);
 464}
 465
 466int symbol__annotate_init(struct map *map __maybe_unused, struct symbol *sym)
 467{
 468	struct annotation *notes = symbol__annotation(sym);
 469	pthread_mutex_init(&notes->lock, NULL);
 470	return 0;
 471}
 472
 473int symbol__alloc_hist(struct symbol *sym)
 474{
 475	struct annotation *notes = symbol__annotation(sym);
 476	const size_t size = symbol__size(sym);
 477	size_t sizeof_sym_hist;
 478
 479	/* Check for overflow when calculating sizeof_sym_hist */
 480	if (size > (SIZE_MAX - sizeof(struct sym_hist)) / sizeof(u64))
 481		return -1;
 482
 483	sizeof_sym_hist = (sizeof(struct sym_hist) + size * sizeof(u64));
 484
 485	/* Check for overflow in zalloc argument */
 486	if (sizeof_sym_hist > (SIZE_MAX - sizeof(*notes->src))
 487				/ symbol_conf.nr_events)
 488		return -1;
 489
 490	notes->src = zalloc(sizeof(*notes->src) + symbol_conf.nr_events * sizeof_sym_hist);
 491	if (notes->src == NULL)
 492		return -1;
 493	notes->src->sizeof_sym_hist = sizeof_sym_hist;
 494	notes->src->nr_histograms   = symbol_conf.nr_events;
 495	INIT_LIST_HEAD(&notes->src->source);
 496	return 0;
 497}
 498
 499/* The cycles histogram is lazily allocated. */
 500static int symbol__alloc_hist_cycles(struct symbol *sym)
 501{
 502	struct annotation *notes = symbol__annotation(sym);
 503	const size_t size = symbol__size(sym);
 504
 505	notes->src->cycles_hist = calloc(size, sizeof(struct cyc_hist));
 506	if (notes->src->cycles_hist == NULL)
 507		return -1;
 508	return 0;
 509}
 510
 511void symbol__annotate_zero_histograms(struct symbol *sym)
 512{
 513	struct annotation *notes = symbol__annotation(sym);
 514
 515	pthread_mutex_lock(&notes->lock);
 516	if (notes->src != NULL) {
 517		memset(notes->src->histograms, 0,
 518		       notes->src->nr_histograms * notes->src->sizeof_sym_hist);
 519		if (notes->src->cycles_hist)
 520			memset(notes->src->cycles_hist, 0,
 521				symbol__size(sym) * sizeof(struct cyc_hist));
 522	}
 523	pthread_mutex_unlock(&notes->lock);
 524}
 525
 526static int __symbol__account_cycles(struct annotation *notes,
 527				    u64 start,
 528				    unsigned offset, unsigned cycles,
 529				    unsigned have_start)
 530{
 531	struct cyc_hist *ch;
 532
 533	ch = notes->src->cycles_hist;
 534	/*
 535	 * For now we can only account one basic block per
 536	 * final jump. But multiple could be overlapping.
 537	 * Always account the longest one. So when
 538	 * a shorter one has been already seen throw it away.
 539	 *
 540	 * We separately always account the full cycles.
 541	 */
 542	ch[offset].num_aggr++;
 543	ch[offset].cycles_aggr += cycles;
 544
 545	if (!have_start && ch[offset].have_start)
 546		return 0;
 547	if (ch[offset].num) {
 548		if (have_start && (!ch[offset].have_start ||
 549				   ch[offset].start > start)) {
 550			ch[offset].have_start = 0;
 551			ch[offset].cycles = 0;
 552			ch[offset].num = 0;
 553			if (ch[offset].reset < 0xffff)
 554				ch[offset].reset++;
 555		} else if (have_start &&
 556			   ch[offset].start < start)
 557			return 0;
 558	}
 559	ch[offset].have_start = have_start;
 560	ch[offset].start = start;
 561	ch[offset].cycles += cycles;
 562	ch[offset].num++;
 563	return 0;
 564}
 565
 566static int __symbol__inc_addr_samples(struct symbol *sym, struct map *map,
 567				      struct annotation *notes, int evidx, u64 addr)
 568{
 569	unsigned offset;
 
 570	struct sym_hist *h;
 571
 
 
 
 
 572	pr_debug3("%s: addr=%#" PRIx64 "\n", __func__, map->unmap_ip(map, addr));
 573
 574	if (addr < sym->start || addr >= sym->end) {
 575		pr_debug("%s(%d): ERANGE! sym->name=%s, start=%#" PRIx64 ", addr=%#" PRIx64 ", end=%#" PRIx64 "\n",
 576		       __func__, __LINE__, sym->name, sym->start, addr, sym->end);
 577		return -ERANGE;
 578	}
 579
 580	offset = addr - sym->start;
 581	h = annotation__histogram(notes, evidx);
 582	h->sum++;
 583	h->addr[offset]++;
 584
 585	pr_debug3("%#" PRIx64 " %s: period++ [addr: %#" PRIx64 ", %#" PRIx64
 586		  ", evidx=%d] => %" PRIu64 "\n", sym->start, sym->name,
 587		  addr, addr - sym->start, evidx, h->addr[offset]);
 588	return 0;
 589}
 590
 591static struct annotation *symbol__get_annotation(struct symbol *sym, bool cycles)
 592{
 593	struct annotation *notes = symbol__annotation(sym);
 594
 595	if (notes->src == NULL) {
 596		if (symbol__alloc_hist(sym) < 0)
 597			return NULL;
 598	}
 599	if (!notes->src->cycles_hist && cycles) {
 600		if (symbol__alloc_hist_cycles(sym) < 0)
 601			return NULL;
 602	}
 603	return notes;
 604}
 605
 606static int symbol__inc_addr_samples(struct symbol *sym, struct map *map,
 607				    int evidx, u64 addr)
 608{
 609	struct annotation *notes;
 610
 611	if (sym == NULL)
 612		return 0;
 613	notes = symbol__get_annotation(sym, false);
 614	if (notes == NULL)
 615		return -ENOMEM;
 616	return __symbol__inc_addr_samples(sym, map, notes, evidx, addr);
 617}
 618
 619static int symbol__account_cycles(u64 addr, u64 start,
 620				  struct symbol *sym, unsigned cycles)
 621{
 622	struct annotation *notes;
 623	unsigned offset;
 624
 625	if (sym == NULL)
 626		return 0;
 627	notes = symbol__get_annotation(sym, true);
 628	if (notes == NULL)
 629		return -ENOMEM;
 630	if (addr < sym->start || addr >= sym->end)
 631		return -ERANGE;
 632
 633	if (start) {
 634		if (start < sym->start || start >= sym->end)
 635			return -ERANGE;
 636		if (start >= addr)
 637			start = 0;
 638	}
 639	offset = addr - sym->start;
 640	return __symbol__account_cycles(notes,
 641					start ? start - sym->start : 0,
 642					offset, cycles,
 643					!!start);
 644}
 645
 646int addr_map_symbol__account_cycles(struct addr_map_symbol *ams,
 647				    struct addr_map_symbol *start,
 648				    unsigned cycles)
 649{
 650	u64 saddr = 0;
 651	int err;
 652
 653	if (!cycles)
 654		return 0;
 655
 656	/*
 657	 * Only set start when IPC can be computed. We can only
 658	 * compute it when the basic block is completely in a single
 659	 * function.
 660	 * Special case the case when the jump is elsewhere, but
 661	 * it starts on the function start.
 662	 */
 663	if (start &&
 664		(start->sym == ams->sym ||
 665		 (ams->sym &&
 666		   start->addr == ams->sym->start + ams->map->start)))
 667		saddr = start->al_addr;
 668	if (saddr == 0)
 669		pr_debug2("BB with bad start: addr %"PRIx64" start %"PRIx64" sym %"PRIx64" saddr %"PRIx64"\n",
 670			ams->addr,
 671			start ? start->addr : 0,
 672			ams->sym ? ams->sym->start + ams->map->start : 0,
 673			saddr);
 674	err = symbol__account_cycles(ams->al_addr, saddr, ams->sym, cycles);
 675	if (err)
 676		pr_debug2("account_cycles failed %d\n", err);
 677	return err;
 678}
 679
 680int addr_map_symbol__inc_samples(struct addr_map_symbol *ams, int evidx)
 681{
 682	return symbol__inc_addr_samples(ams->sym, ams->map, evidx, ams->al_addr);
 
 683}
 684
 685int hist_entry__inc_addr_samples(struct hist_entry *he, int evidx, u64 ip)
 686{
 687	return symbol__inc_addr_samples(he->ms.sym, he->ms.map, evidx, ip);
 688}
 689
 690static void disasm_line__init_ins(struct disasm_line *dl)
 691{
 692	dl->ins = ins__find(dl->name);
 693
 694	if (dl->ins == NULL)
 695		return;
 696
 697	if (!dl->ins->ops)
 698		return;
 699
 700	if (dl->ins->ops->parse && dl->ins->ops->parse(&dl->ops) < 0)
 701		dl->ins = NULL;
 702}
 703
 704static int disasm_line__parse(char *line, char **namep, char **rawp)
 705{
 706	char *name = line, tmp;
 707
 708	while (isspace(name[0]))
 709		++name;
 710
 711	if (name[0] == '\0')
 712		return -1;
 713
 714	*rawp = name + 1;
 715
 716	while ((*rawp)[0] != '\0' && !isspace((*rawp)[0]))
 717		++*rawp;
 718
 719	tmp = (*rawp)[0];
 720	(*rawp)[0] = '\0';
 721	*namep = strdup(name);
 722
 723	if (*namep == NULL)
 724		goto out_free_name;
 725
 726	(*rawp)[0] = tmp;
 727
 728	if ((*rawp)[0] != '\0') {
 729		(*rawp)++;
 730		while (isspace((*rawp)[0]))
 731			++(*rawp);
 732	}
 733
 734	return 0;
 735
 736out_free_name:
 737	zfree(namep);
 738	return -1;
 739}
 740
 741static struct disasm_line *disasm_line__new(s64 offset, char *line,
 742					size_t privsize, int line_nr)
 743{
 744	struct disasm_line *dl = zalloc(sizeof(*dl) + privsize);
 745
 746	if (dl != NULL) {
 747		dl->offset = offset;
 748		dl->line = strdup(line);
 749		dl->line_nr = line_nr;
 750		if (dl->line == NULL)
 751			goto out_delete;
 752
 753		if (offset != -1) {
 754			if (disasm_line__parse(dl->line, &dl->name, &dl->ops.raw) < 0)
 755				goto out_free_line;
 756
 757			disasm_line__init_ins(dl);
 758		}
 759	}
 760
 761	return dl;
 762
 763out_free_line:
 764	zfree(&dl->line);
 765out_delete:
 766	free(dl);
 767	return NULL;
 768}
 769
 770void disasm_line__free(struct disasm_line *dl)
 771{
 772	zfree(&dl->line);
 773	zfree(&dl->name);
 774	if (dl->ins && dl->ins->ops->free)
 775		dl->ins->ops->free(&dl->ops);
 776	else
 777		ins__delete(&dl->ops);
 778	free(dl);
 779}
 780
 781int disasm_line__scnprintf(struct disasm_line *dl, char *bf, size_t size, bool raw)
 782{
 783	if (raw || !dl->ins)
 784		return scnprintf(bf, size, "%-6.6s %s", dl->name, dl->ops.raw);
 785
 786	return ins__scnprintf(dl->ins, bf, size, &dl->ops);
 787}
 788
 789static void disasm__add(struct list_head *head, struct disasm_line *line)
 790{
 791	list_add_tail(&line->node, head);
 792}
 793
 794struct disasm_line *disasm__get_next_ip_line(struct list_head *head, struct disasm_line *pos)
 
 795{
 796	list_for_each_entry_continue(pos, head, node)
 797		if (pos->offset >= 0)
 798			return pos;
 799
 800	return NULL;
 801}
 802
 803double disasm__calc_percent(struct annotation *notes, int evidx, s64 offset,
 804			    s64 end, const char **path, u64 *nr_samples)
 805{
 806	struct source_line *src_line = notes->src->lines;
 807	double percent = 0.0;
 808	*nr_samples = 0;
 809
 810	if (src_line) {
 811		size_t sizeof_src_line = sizeof(*src_line) +
 812				sizeof(src_line->samples) * (src_line->nr_pcnt - 1);
 813
 814		while (offset < end) {
 815			src_line = (void *)notes->src->lines +
 816					(sizeof_src_line * offset);
 817
 818			if (*path == NULL)
 819				*path = src_line->path;
 820
 821			percent += src_line->samples[evidx].percent;
 822			*nr_samples += src_line->samples[evidx].nr;
 823			offset++;
 824		}
 825	} else {
 826		struct sym_hist *h = annotation__histogram(notes, evidx);
 827		unsigned int hits = 0;
 828
 829		while (offset < end)
 830			hits += h->addr[offset++];
 831
 832		if (h->sum) {
 833			*nr_samples = hits;
 834			percent = 100.0 * hits / h->sum;
 835		}
 836	}
 837
 838	return percent;
 839}
 840
 841static int disasm_line__print(struct disasm_line *dl, struct symbol *sym, u64 start,
 842		      struct perf_evsel *evsel, u64 len, int min_pcnt, int printed,
 843		      int max_lines, struct disasm_line *queue)
 844{
 845	static const char *prev_line;
 846	static const char *prev_color;
 847
 848	if (dl->offset != -1) {
 849		const char *path = NULL;
 850		u64 nr_samples;
 851		double percent, max_percent = 0.0;
 852		double *ppercents = &percent;
 853		u64 *psamples = &nr_samples;
 854		int i, nr_percent = 1;
 855		const char *color;
 856		struct annotation *notes = symbol__annotation(sym);
 857		s64 offset = dl->offset;
 858		const u64 addr = start + offset;
 859		struct disasm_line *next;
 860
 861		next = disasm__get_next_ip_line(&notes->src->source, dl);
 862
 863		if (perf_evsel__is_group_event(evsel)) {
 864			nr_percent = evsel->nr_members;
 865			ppercents = calloc(nr_percent, sizeof(double));
 866			psamples = calloc(nr_percent, sizeof(u64));
 867			if (ppercents == NULL || psamples == NULL) {
 868				return -1;
 869			}
 870		}
 
 871
 872		for (i = 0; i < nr_percent; i++) {
 873			percent = disasm__calc_percent(notes,
 874					notes->src->lines ? i : evsel->idx + i,
 875					offset,
 876					next ? next->offset : (s64) len,
 877					&path, &nr_samples);
 878
 879			ppercents[i] = percent;
 880			psamples[i] = nr_samples;
 881			if (percent > max_percent)
 882				max_percent = percent;
 883		}
 884
 885		if (max_percent < min_pcnt)
 
 
 
 886			return -1;
 887
 888		if (max_lines && printed >= max_lines)
 889			return 1;
 890
 891		if (queue != NULL) {
 892			list_for_each_entry_from(queue, &notes->src->source, node) {
 893				if (queue == dl)
 894					break;
 895				disasm_line__print(queue, sym, start, evsel, len,
 896						    0, 0, 1, NULL);
 897			}
 898		}
 899
 900		color = get_percent_color(max_percent);
 901
 902		/*
 903		 * Also color the filename and line if needed, with
 904		 * the same color than the percentage. Don't print it
 905		 * twice for close colored addr with the same filename:line
 906		 */
 907		if (path) {
 908			if (!prev_line || strcmp(prev_line, path)
 909				       || color != prev_color) {
 910				color_fprintf(stdout, color, " %s", path);
 911				prev_line = path;
 912				prev_color = color;
 913			}
 914		}
 915
 916		for (i = 0; i < nr_percent; i++) {
 917			percent = ppercents[i];
 918			nr_samples = psamples[i];
 919			color = get_percent_color(percent);
 920
 921			if (symbol_conf.show_total_period)
 922				color_fprintf(stdout, color, " %7" PRIu64,
 923					      nr_samples);
 924			else
 925				color_fprintf(stdout, color, " %7.2f", percent);
 926		}
 927
 928		printf(" :	");
 929		color_fprintf(stdout, PERF_COLOR_MAGENTA, "  %" PRIx64 ":", addr);
 930		color_fprintf(stdout, PERF_COLOR_BLUE, "%s\n", dl->line);
 931
 932		if (ppercents != &percent)
 933			free(ppercents);
 934
 935		if (psamples != &nr_samples)
 936			free(psamples);
 937
 938	} else if (max_lines && printed >= max_lines)
 939		return 1;
 940	else {
 941		int width = 8;
 942
 943		if (queue)
 944			return -1;
 945
 946		if (perf_evsel__is_group_event(evsel))
 947			width *= evsel->nr_members;
 948
 949		if (!*dl->line)
 950			printf(" %*s:\n", width, " ");
 951		else
 952			printf(" %*s:	%s\n", width, " ", dl->line);
 953	}
 954
 955	return 0;
 956}
 957
 958/*
 959 * symbol__parse_objdump_line() parses objdump output (with -d --no-show-raw)
 960 * which looks like following
 961 *
 962 *  0000000000415500 <_init>:
 963 *    415500:       sub    $0x8,%rsp
 964 *    415504:       mov    0x2f5ad5(%rip),%rax        # 70afe0 <_DYNAMIC+0x2f8>
 965 *    41550b:       test   %rax,%rax
 966 *    41550e:       je     415515 <_init+0x15>
 967 *    415510:       callq  416e70 <__gmon_start__@plt>
 968 *    415515:       add    $0x8,%rsp
 969 *    415519:       retq
 970 *
 971 * it will be parsed and saved into struct disasm_line as
 972 *  <offset>       <name>  <ops.raw>
 973 *
 974 * The offset will be a relative offset from the start of the symbol and -1
 975 * means that it's not a disassembly line so should be treated differently.
 976 * The ops.raw part will be parsed further according to type of the instruction.
 977 */
 978static int symbol__parse_objdump_line(struct symbol *sym, struct map *map,
 979				      FILE *file, size_t privsize,
 980				      int *line_nr)
 981{
 982	struct annotation *notes = symbol__annotation(sym);
 983	struct disasm_line *dl;
 984	char *line = NULL, *parsed_line, *tmp, *tmp2, *c;
 985	size_t line_len;
 986	s64 line_ip, offset = -1;
 987	regmatch_t match[2];
 988
 989	if (getline(&line, &line_len, file) < 0)
 990		return -1;
 991
 992	if (!line)
 993		return -1;
 994
 995	while (line_len != 0 && isspace(line[line_len - 1]))
 996		line[--line_len] = '\0';
 997
 998	c = strchr(line, '\n');
 999	if (c)
1000		*c = 0;
1001
1002	line_ip = -1;
1003	parsed_line = line;
1004
1005	/* /filename:linenr ? Save line number and ignore. */
1006	if (regexec(&file_lineno, line, 2, match, 0) == 0) {
1007		*line_nr = atoi(line + match[1].rm_so);
1008		return 0;
1009	}
1010
1011	/*
1012	 * Strip leading spaces:
1013	 */
1014	tmp = line;
1015	while (*tmp) {
1016		if (*tmp != ' ')
1017			break;
1018		tmp++;
1019	}
1020
1021	if (*tmp) {
1022		/*
1023		 * Parse hexa addresses followed by ':'
1024		 */
1025		line_ip = strtoull(tmp, &tmp2, 16);
1026		if (*tmp2 != ':' || tmp == tmp2 || tmp2[1] == '\0')
1027			line_ip = -1;
1028	}
1029
1030	if (line_ip != -1) {
1031		u64 start = map__rip_2objdump(map, sym->start),
1032		    end = map__rip_2objdump(map, sym->end);
1033
1034		offset = line_ip - start;
1035		if ((u64)line_ip < start || (u64)line_ip >= end)
1036			offset = -1;
1037		else
1038			parsed_line = tmp2 + 1;
1039	}
1040
1041	dl = disasm_line__new(offset, parsed_line, privsize, *line_nr);
1042	free(line);
1043	(*line_nr)++;
1044
1045	if (dl == NULL)
1046		return -1;
1047
1048	if (dl->ops.target.offset == UINT64_MAX)
1049		dl->ops.target.offset = dl->ops.target.addr -
1050					map__rip_2objdump(map, sym->start);
1051
1052	/* kcore has no symbols, so add the call target name */
1053	if (dl->ins && ins__is_call(dl->ins) && !dl->ops.target.name) {
1054		struct addr_map_symbol target = {
1055			.map = map,
1056			.addr = dl->ops.target.addr,
1057		};
1058
1059		if (!map_groups__find_ams(&target, NULL) &&
1060		    target.sym->start == target.al_addr)
1061			dl->ops.target.name = strdup(target.sym->name);
1062	}
1063
1064	disasm__add(&notes->src->source, dl);
1065
1066	return 0;
1067}
1068
1069static __attribute__((constructor)) void symbol__init_regexpr(void)
1070{
1071	regcomp(&file_lineno, "^/[^:]+:([0-9]+)", REG_EXTENDED);
1072}
1073
1074static void delete_last_nop(struct symbol *sym)
1075{
1076	struct annotation *notes = symbol__annotation(sym);
1077	struct list_head *list = &notes->src->source;
1078	struct disasm_line *dl;
1079
1080	while (!list_empty(list)) {
1081		dl = list_entry(list->prev, struct disasm_line, node);
1082
1083		if (dl->ins && dl->ins->ops) {
1084			if (dl->ins->ops != &nop_ops)
1085				return;
1086		} else {
1087			if (!strstr(dl->line, " nop ") &&
1088			    !strstr(dl->line, " nopl ") &&
1089			    !strstr(dl->line, " nopw "))
1090				return;
1091		}
1092
1093		list_del(&dl->node);
1094		disasm_line__free(dl);
1095	}
1096}
1097
1098int symbol__annotate(struct symbol *sym, struct map *map, size_t privsize)
1099{
1100	struct dso *dso = map->dso;
1101	char *filename = dso__build_id_filename(dso, NULL, 0);
1102	bool free_filename = true;
1103	char command[PATH_MAX * 2];
1104	FILE *file;
1105	int err = 0;
1106	char symfs_filename[PATH_MAX];
1107	struct kcore_extract kce;
1108	bool delete_extract = false;
1109	int lineno = 0;
1110	int nline;
1111
1112	if (filename)
1113		symbol__join_symfs(symfs_filename, filename);
 
 
1114
1115	if (filename == NULL) {
1116		if (dso->has_build_id) {
1117			pr_err("Can't annotate %s: not enough memory\n",
1118			       sym->name);
1119			return -ENOMEM;
1120		}
1121		goto fallback;
1122	} else if (dso__is_kcore(dso)) {
1123		goto fallback;
1124	} else if (readlink(symfs_filename, command, sizeof(command)) < 0 ||
1125		   strstr(command, "[kernel.kallsyms]") ||
1126		   access(symfs_filename, R_OK)) {
1127		free(filename);
1128fallback:
1129		/*
1130		 * If we don't have build-ids or the build-id file isn't in the
1131		 * cache, or is just a kallsyms file, well, lets hope that this
1132		 * DSO is the same as when 'perf record' ran.
1133		 */
1134		filename = (char *)dso->long_name;
1135		symbol__join_symfs(symfs_filename, filename);
 
1136		free_filename = false;
1137	}
1138
1139	if (dso->symtab_type == DSO_BINARY_TYPE__KALLSYMS &&
1140	    !dso__is_kcore(dso)) {
1141		char bf[BUILD_ID_SIZE * 2 + 16] = " with build id ";
1142		char *build_id_msg = NULL;
1143
1144		if (dso->annotate_warned)
1145			goto out_free_filename;
1146
1147		if (dso->has_build_id) {
1148			build_id__sprintf(dso->build_id,
1149					  sizeof(dso->build_id), bf + 15);
1150			build_id_msg = bf;
1151		}
1152		err = -ENOENT;
1153		dso->annotate_warned = 1;
1154		pr_err("Can't annotate %s:\n\n"
1155		       "No vmlinux file%s\nwas found in the path.\n\n"
1156		       "Note that annotation using /proc/kcore requires CAP_SYS_RAWIO capability.\n\n"
1157		       "Please use:\n\n"
1158		       "  perf buildid-cache -vu vmlinux\n\n"
1159		       "or:\n\n"
1160		       "  --vmlinux vmlinux\n",
1161		       sym->name, build_id_msg ?: "");
1162		goto out_free_filename;
1163	}
1164
1165	pr_debug("%s: filename=%s, sym=%s, start=%#" PRIx64 ", end=%#" PRIx64 "\n", __func__,
1166		 filename, sym->name, map->unmap_ip(map, sym->start),
1167		 map->unmap_ip(map, sym->end));
1168
1169	pr_debug("annotating [%p] %30s : [%p] %30s\n",
1170		 dso, dso->long_name, sym, sym->name);
1171
1172	if (dso__is_kcore(dso)) {
1173		kce.kcore_filename = symfs_filename;
1174		kce.addr = map__rip_2objdump(map, sym->start);
1175		kce.offs = sym->start;
1176		kce.len = sym->end - sym->start;
1177		if (!kcore_extract__create(&kce)) {
1178			delete_extract = true;
1179			strlcpy(symfs_filename, kce.extract_filename,
1180				sizeof(symfs_filename));
1181			if (free_filename) {
1182				free(filename);
1183				free_filename = false;
1184			}
1185			filename = symfs_filename;
1186		}
1187	} else if (dso__needs_decompress(dso)) {
1188		char tmp[PATH_MAX];
1189		struct kmod_path m;
1190		int fd;
1191		bool ret;
1192
1193		if (kmod_path__parse_ext(&m, symfs_filename))
1194			goto out_free_filename;
1195
1196		snprintf(tmp, PATH_MAX, "/tmp/perf-kmod-XXXXXX");
1197
1198		fd = mkstemp(tmp);
1199		if (fd < 0) {
1200			free(m.ext);
1201			goto out_free_filename;
1202		}
1203
1204		ret = decompress_to_file(m.ext, symfs_filename, fd);
1205
1206		if (ret)
1207			pr_err("Cannot decompress %s %s\n", m.ext, symfs_filename);
1208
1209		free(m.ext);
1210		close(fd);
1211
1212		if (!ret)
1213			goto out_free_filename;
1214
1215		strcpy(symfs_filename, tmp);
1216	}
1217
1218	snprintf(command, sizeof(command),
1219		 "%s %s%s --start-address=0x%016" PRIx64
1220		 " --stop-address=0x%016" PRIx64
1221		 " -l -d %s %s -C %s 2>/dev/null|grep -v %s|expand",
1222		 objdump_path ? objdump_path : "objdump",
1223		 disassembler_style ? "-M " : "",
1224		 disassembler_style ? disassembler_style : "",
1225		 map__rip_2objdump(map, sym->start),
1226		 map__rip_2objdump(map, sym->end),
1227		 symbol_conf.annotate_asm_raw ? "" : "--no-show-raw",
1228		 symbol_conf.annotate_src ? "-S" : "",
1229		 symfs_filename, filename);
1230
1231	pr_debug("Executing: %s\n", command);
1232
1233	file = popen(command, "r");
1234	if (!file) {
1235		pr_err("Failure running %s\n", command);
1236		/*
1237		 * If we were using debug info should retry with
1238		 * original binary.
1239		 */
1240		goto out_remove_tmp;
1241	}
1242
1243	nline = 0;
1244	while (!feof(file)) {
1245		if (symbol__parse_objdump_line(sym, map, file, privsize,
1246			    &lineno) < 0)
1247			break;
1248		nline++;
1249	}
1250
1251	if (nline == 0)
1252		pr_err("No output from %s\n", command);
1253
1254	/*
1255	 * kallsyms does not have symbol sizes so there may a nop at the end.
1256	 * Remove it.
1257	 */
1258	if (dso__is_kcore(dso))
1259		delete_last_nop(sym);
1260
1261	pclose(file);
1262
1263out_remove_tmp:
1264	if (dso__needs_decompress(dso))
1265		unlink(symfs_filename);
1266out_free_filename:
1267	if (delete_extract)
1268		kcore_extract__delete(&kce);
1269	if (free_filename)
1270		free(filename);
1271	return err;
1272}
1273
1274static void insert_source_line(struct rb_root *root, struct source_line *src_line)
1275{
1276	struct source_line *iter;
1277	struct rb_node **p = &root->rb_node;
1278	struct rb_node *parent = NULL;
1279	int i, ret;
1280
1281	while (*p != NULL) {
1282		parent = *p;
1283		iter = rb_entry(parent, struct source_line, node);
1284
1285		ret = strcmp(iter->path, src_line->path);
1286		if (ret == 0) {
1287			for (i = 0; i < src_line->nr_pcnt; i++)
1288				iter->samples[i].percent_sum += src_line->samples[i].percent;
1289			return;
1290		}
1291
1292		if (ret < 0)
1293			p = &(*p)->rb_left;
1294		else
1295			p = &(*p)->rb_right;
1296	}
1297
1298	for (i = 0; i < src_line->nr_pcnt; i++)
1299		src_line->samples[i].percent_sum = src_line->samples[i].percent;
1300
1301	rb_link_node(&src_line->node, parent, p);
1302	rb_insert_color(&src_line->node, root);
1303}
1304
1305static int cmp_source_line(struct source_line *a, struct source_line *b)
1306{
1307	int i;
1308
1309	for (i = 0; i < a->nr_pcnt; i++) {
1310		if (a->samples[i].percent_sum == b->samples[i].percent_sum)
1311			continue;
1312		return a->samples[i].percent_sum > b->samples[i].percent_sum;
1313	}
1314
1315	return 0;
1316}
1317
1318static void __resort_source_line(struct rb_root *root, struct source_line *src_line)
1319{
1320	struct source_line *iter;
1321	struct rb_node **p = &root->rb_node;
1322	struct rb_node *parent = NULL;
1323
1324	while (*p != NULL) {
1325		parent = *p;
1326		iter = rb_entry(parent, struct source_line, node);
1327
1328		if (cmp_source_line(src_line, iter))
1329			p = &(*p)->rb_left;
1330		else
1331			p = &(*p)->rb_right;
1332	}
1333
1334	rb_link_node(&src_line->node, parent, p);
1335	rb_insert_color(&src_line->node, root);
1336}
1337
1338static void resort_source_line(struct rb_root *dest_root, struct rb_root *src_root)
1339{
1340	struct source_line *src_line;
1341	struct rb_node *node;
1342
1343	node = rb_first(src_root);
1344	while (node) {
1345		struct rb_node *next;
1346
1347		src_line = rb_entry(node, struct source_line, node);
1348		next = rb_next(node);
1349		rb_erase(node, src_root);
1350
1351		__resort_source_line(dest_root, src_line);
1352		node = next;
1353	}
1354}
1355
1356static void symbol__free_source_line(struct symbol *sym, int len)
1357{
1358	struct annotation *notes = symbol__annotation(sym);
1359	struct source_line *src_line = notes->src->lines;
1360	size_t sizeof_src_line;
1361	int i;
1362
1363	sizeof_src_line = sizeof(*src_line) +
1364			  (sizeof(src_line->samples) * (src_line->nr_pcnt - 1));
1365
1366	for (i = 0; i < len; i++) {
1367		free_srcline(src_line->path);
1368		src_line = (void *)src_line + sizeof_src_line;
1369	}
1370
1371	zfree(&notes->src->lines);
 
1372}
1373
1374/* Get the filename:line for the colored entries */
1375static int symbol__get_source_line(struct symbol *sym, struct map *map,
1376				   struct perf_evsel *evsel,
1377				   struct rb_root *root, int len)
1378{
1379	u64 start;
1380	int i, k;
1381	int evidx = evsel->idx;
1382	struct source_line *src_line;
1383	struct annotation *notes = symbol__annotation(sym);
1384	struct sym_hist *h = annotation__histogram(notes, evidx);
1385	struct rb_root tmp_root = RB_ROOT;
1386	int nr_pcnt = 1;
1387	u64 h_sum = h->sum;
1388	size_t sizeof_src_line = sizeof(struct source_line);
1389
1390	if (perf_evsel__is_group_event(evsel)) {
1391		for (i = 1; i < evsel->nr_members; i++) {
1392			h = annotation__histogram(notes, evidx + i);
1393			h_sum += h->sum;
1394		}
1395		nr_pcnt = evsel->nr_members;
1396		sizeof_src_line += (nr_pcnt - 1) * sizeof(src_line->samples);
1397	}
1398
1399	if (!h_sum)
1400		return 0;
1401
1402	src_line = notes->src->lines = calloc(len, sizeof_src_line);
1403	if (!notes->src->lines)
1404		return -1;
1405
1406	start = map__rip_2objdump(map, sym->start);
1407
1408	for (i = 0; i < len; i++) {
 
 
1409		u64 offset;
1410		double percent_max = 0.0;
1411
1412		src_line->nr_pcnt = nr_pcnt;
 
 
1413
1414		for (k = 0; k < nr_pcnt; k++) {
1415			h = annotation__histogram(notes, evidx + k);
1416			src_line->samples[k].percent = 100.0 * h->addr[i] / h->sum;
 
 
1417
1418			if (src_line->samples[k].percent > percent_max)
1419				percent_max = src_line->samples[k].percent;
1420		}
1421
1422		if (percent_max <= 0.5)
 
1423			goto next;
1424
1425		offset = start + i;
1426		src_line->path = get_srcline(map->dso, offset, NULL, false);
1427		insert_source_line(&tmp_root, src_line);
1428
1429	next:
1430		src_line = (void *)src_line + sizeof_src_line;
1431	}
1432
1433	resort_source_line(root, &tmp_root);
1434	return 0;
1435}
1436
1437static void print_summary(struct rb_root *root, const char *filename)
1438{
1439	struct source_line *src_line;
1440	struct rb_node *node;
1441
1442	printf("\nSorted summary for file %s\n", filename);
1443	printf("----------------------------------------------\n\n");
1444
1445	if (RB_EMPTY_ROOT(root)) {
1446		printf(" Nothing higher than %1.1f%%\n", MIN_GREEN);
1447		return;
1448	}
1449
1450	node = rb_first(root);
1451	while (node) {
1452		double percent, percent_max = 0.0;
1453		const char *color;
1454		char *path;
1455		int i;
1456
1457		src_line = rb_entry(node, struct source_line, node);
1458		for (i = 0; i < src_line->nr_pcnt; i++) {
1459			percent = src_line->samples[i].percent_sum;
1460			color = get_percent_color(percent);
1461			color_fprintf(stdout, color, " %7.2f", percent);
1462
1463			if (percent > percent_max)
1464				percent_max = percent;
1465		}
1466
1467		path = src_line->path;
1468		color = get_percent_color(percent_max);
1469		color_fprintf(stdout, color, " %s\n", path);
1470
 
1471		node = rb_next(node);
1472	}
1473}
1474
1475static void symbol__annotate_hits(struct symbol *sym, struct perf_evsel *evsel)
1476{
1477	struct annotation *notes = symbol__annotation(sym);
1478	struct sym_hist *h = annotation__histogram(notes, evsel->idx);
1479	u64 len = symbol__size(sym), offset;
1480
1481	for (offset = 0; offset < len; ++offset)
1482		if (h->addr[offset] != 0)
1483			printf("%*" PRIx64 ": %" PRIu64 "\n", BITS_PER_LONG / 2,
1484			       sym->start + offset, h->addr[offset]);
1485	printf("%*s: %" PRIu64 "\n", BITS_PER_LONG / 2, "h->sum", h->sum);
1486}
1487
1488int symbol__annotate_printf(struct symbol *sym, struct map *map,
1489			    struct perf_evsel *evsel, bool full_paths,
1490			    int min_pcnt, int max_lines, int context)
1491{
1492	struct dso *dso = map->dso;
1493	char *filename;
1494	const char *d_filename;
1495	const char *evsel_name = perf_evsel__name(evsel);
1496	struct annotation *notes = symbol__annotation(sym);
1497	struct disasm_line *pos, *queue = NULL;
1498	u64 start = map__rip_2objdump(map, sym->start);
1499	int printed = 2, queue_len = 0;
1500	int more = 0;
1501	u64 len;
1502	int width = 8;
1503	int namelen, evsel_name_len, graph_dotted_len;
1504
1505	filename = strdup(dso->long_name);
1506	if (!filename)
1507		return -ENOMEM;
1508
1509	if (full_paths)
1510		d_filename = filename;
1511	else
1512		d_filename = basename(filename);
1513
1514	len = symbol__size(sym);
1515	namelen = strlen(d_filename);
1516	evsel_name_len = strlen(evsel_name);
1517
1518	if (perf_evsel__is_group_event(evsel))
1519		width *= evsel->nr_members;
1520
1521	printf(" %-*.*s|	Source code & Disassembly of %s for %s\n",
1522	       width, width, "Percent", d_filename, evsel_name);
1523
1524	graph_dotted_len = width + namelen + evsel_name_len;
1525	printf("-%-*.*s-----------------------------------------\n",
1526	       graph_dotted_len, graph_dotted_len, graph_dotted_line);
1527
1528	if (verbose)
1529		symbol__annotate_hits(sym, evsel);
1530
1531	list_for_each_entry(pos, &notes->src->source, node) {
1532		if (context && queue == NULL) {
1533			queue = pos;
1534			queue_len = 0;
1535		}
1536
1537		switch (disasm_line__print(pos, sym, start, evsel, len,
1538					    min_pcnt, printed, max_lines,
1539					    queue)) {
1540		case 0:
1541			++printed;
1542			if (context) {
1543				printed += queue_len;
1544				queue = NULL;
1545				queue_len = 0;
1546			}
1547			break;
1548		case 1:
1549			/* filtered by max_lines */
1550			++more;
1551			break;
1552		case -1:
1553		default:
1554			/*
1555			 * Filtered by min_pcnt or non IP lines when
1556			 * context != 0
1557			 */
1558			if (!context)
1559				break;
1560			if (queue_len == context)
1561				queue = list_entry(queue->node.next, typeof(*queue), node);
1562			else
1563				++queue_len;
1564			break;
1565		}
1566	}
1567
1568	free(filename);
1569
1570	return more;
1571}
1572
1573void symbol__annotate_zero_histogram(struct symbol *sym, int evidx)
1574{
1575	struct annotation *notes = symbol__annotation(sym);
1576	struct sym_hist *h = annotation__histogram(notes, evidx);
1577
1578	memset(h, 0, notes->src->sizeof_sym_hist);
1579}
1580
1581void symbol__annotate_decay_histogram(struct symbol *sym, int evidx)
1582{
1583	struct annotation *notes = symbol__annotation(sym);
1584	struct sym_hist *h = annotation__histogram(notes, evidx);
1585	int len = symbol__size(sym), offset;
 
1586
1587	h->sum = 0;
1588	for (offset = 0; offset < len; ++offset) {
1589		h->addr[offset] = h->addr[offset] * 7 / 8;
1590		h->sum += h->addr[offset];
 
 
 
1591	}
1592}
1593
1594void disasm__purge(struct list_head *head)
1595{
1596	struct disasm_line *pos, *n;
1597
1598	list_for_each_entry_safe(pos, n, head, node) {
1599		list_del(&pos->node);
1600		disasm_line__free(pos);
1601	}
1602}
1603
1604static size_t disasm_line__fprintf(struct disasm_line *dl, FILE *fp)
1605{
1606	size_t printed;
1607
1608	if (dl->offset == -1)
1609		return fprintf(fp, "%s\n", dl->line);
1610
1611	printed = fprintf(fp, "%#" PRIx64 " %s", dl->offset, dl->name);
1612
1613	if (dl->ops.raw[0] != '\0') {
1614		printed += fprintf(fp, "%.*s %s\n", 6 - (int)printed, " ",
1615				   dl->ops.raw);
1616	}
1617
1618	return printed + fprintf(fp, "\n");
1619}
1620
1621size_t disasm__fprintf(struct list_head *head, FILE *fp)
1622{
1623	struct disasm_line *pos;
1624	size_t printed = 0;
1625
1626	list_for_each_entry(pos, head, node)
1627		printed += disasm_line__fprintf(pos, fp);
1628
1629	return printed;
1630}
1631
1632int symbol__tty_annotate(struct symbol *sym, struct map *map,
1633			 struct perf_evsel *evsel, bool print_lines,
1634			 bool full_paths, int min_pcnt, int max_lines)
1635{
1636	struct dso *dso = map->dso;
 
1637	struct rb_root source_line = RB_ROOT;
1638	u64 len;
1639
1640	if (symbol__annotate(sym, map, 0) < 0)
1641		return -1;
1642
1643	len = symbol__size(sym);
1644
1645	if (print_lines) {
1646		srcline_full_filename = full_paths;
1647		symbol__get_source_line(sym, map, evsel, &source_line, len);
1648		print_summary(&source_line, dso->long_name);
1649	}
1650
1651	symbol__annotate_printf(sym, map, evsel, full_paths,
1652				min_pcnt, max_lines, 0);
1653	if (print_lines)
1654		symbol__free_source_line(sym, len);
1655
1656	disasm__purge(&symbol__annotation(sym)->src->source);
1657
1658	return 0;
1659}
1660
1661int hist_entry__annotate(struct hist_entry *he, size_t privsize)
1662{
1663	return symbol__annotate(he->ms.sym, he->ms.map, privsize);
1664}
1665
1666bool ui__has_annotation(void)
1667{
1668	return use_browser == 1 && sort__has_sym;
1669}