?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'block-5.11-2021-01-10' of git://git.kernel.dk/linux-block
[linux/fpc-iii.git] / tools / perf / util / annotate.c
blobce8c07bc8c5626cae48a60fdc76e06fc56f99b1e
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Copyright (C) 2011, Red Hat Inc, Arnaldo Carvalho de Melo <acme@redhat.com>
4 *
5 * Parts came from builtin-annotate.c, see those files for further
6 * copyright notes.
7 */
8
9 #include <errno.h>
10 #include <inttypes.h>
11 #include <libgen.h>
12 #include <stdlib.h>
13 #include "util.h" // hex_width()
14 #include "ui/ui.h"
15 #include "sort.h"
16 #include "build-id.h"
17 #include "color.h"
18 #include "config.h"
19 #include "dso.h"
20 #include "env.h"
21 #include "map.h"
22 #include "maps.h"
23 #include "symbol.h"
24 #include "srcline.h"
25 #include "units.h"
26 #include "debug.h"
27 #include "annotate.h"
28 #include "evsel.h"
29 #include "evlist.h"
30 #include "bpf-event.h"
31 #include "block-range.h"
32 #include "string2.h"
33 #include "util/event.h"
34 #include "arch/common.h"
35 #include <regex.h>
36 #include <pthread.h>
37 #include <linux/bitops.h>
38 #include <linux/kernel.h>
39 #include <linux/string.h>
40 #include <subcmd/parse-options.h>
41 #include <subcmd/run-command.h>
42
43 /* FIXME: For the HE_COLORSET */
44 #include "ui/browser.h"
45
46 /*
47 * FIXME: Using the same values as slang.h,
48 * but that header may not be available everywhere
49 */
50 #define LARROW_CHAR ((unsigned char)',')
51 #define RARROW_CHAR ((unsigned char)'+')
52 #define DARROW_CHAR ((unsigned char)'.')
53 #define UARROW_CHAR ((unsigned char)'-')
54
55 #include <linux/ctype.h>
56
57 struct annotation_options annotation__default_options = {
58 .use_offset = true,
59 .jump_arrows = true,
60 .annotate_src = true,
61 .offset_level = ANNOTATION__OFFSET_JUMP_TARGETS,
62 .percent_type = PERCENT_PERIOD_LOCAL,
63 };
64
65 static regex_t file_lineno;
66
67 static struct ins_ops *ins__find(struct arch *arch, const char *name);
68 static void ins__sort(struct arch *arch);
69 static int disasm_line__parse(char *line, const char **namep, char **rawp);
70
71 struct arch {
72 const char *name;
73 struct ins *instructions;
74 size_t nr_instructions;
75 size_t nr_instructions_allocated;
76 struct ins_ops *(*associate_instruction_ops)(struct arch *arch, const char *name);
77 bool sorted_instructions;
78 bool initialized;
79 void *priv;
80 unsigned int model;
81 unsigned int family;
82 int (*init)(struct arch *arch, char *cpuid);
83 bool (*ins_is_fused)(struct arch *arch, const char *ins1,
84 const char *ins2);
85 struct {
86 char comment_char;
87 char skip_functions_char;
88 } objdump;
89 };
90
91 static struct ins_ops call_ops;
92 static struct ins_ops dec_ops;
93 static struct ins_ops jump_ops;
94 static struct ins_ops mov_ops;
95 static struct ins_ops nop_ops;
96 static struct ins_ops lock_ops;
97 static struct ins_ops ret_ops;
98
99 static int arch__grow_instructions(struct arch *arch)
100 {
101 struct ins *new_instructions;
102 size_t new_nr_allocated;
103
104 if (arch->nr_instructions_allocated == 0 && arch->instructions)
105 goto grow_from_non_allocated_table;
106
107 new_nr_allocated = arch->nr_instructions_allocated + 128;
108 new_instructions = realloc(arch->instructions, new_nr_allocated * sizeof(struct ins));
109 if (new_instructions == NULL)
110 return -1;
111
112 out_update_instructions:
113 arch->instructions = new_instructions;
114 arch->nr_instructions_allocated = new_nr_allocated;
115 return 0;
116
117 grow_from_non_allocated_table:
118 new_nr_allocated = arch->nr_instructions + 128;
119 new_instructions = calloc(new_nr_allocated, sizeof(struct ins));
120 if (new_instructions == NULL)
121 return -1;
122
123 memcpy(new_instructions, arch->instructions, arch->nr_instructions);
124 goto out_update_instructions;
125 }
126
127 static int arch__associate_ins_ops(struct arch* arch, const char *name, struct ins_ops *ops)
128 {
129 struct ins *ins;
130
131 if (arch->nr_instructions == arch->nr_instructions_allocated &&
132 arch__grow_instructions(arch))
133 return -1;
134
135 ins = &arch->instructions[arch->nr_instructions];
136 ins->name = strdup(name);
137 if (!ins->name)
138 return -1;
139
140 ins->ops = ops;
141 arch->nr_instructions++;
142
143 ins__sort(arch);
144 return 0;
145 }
146
147 #include "arch/arc/annotate/instructions.c"
148 #include "arch/arm/annotate/instructions.c"
149 #include "arch/arm64/annotate/instructions.c"
150 #include "arch/csky/annotate/instructions.c"
151 #include "arch/mips/annotate/instructions.c"
152 #include "arch/x86/annotate/instructions.c"
153 #include "arch/powerpc/annotate/instructions.c"
154 #include "arch/s390/annotate/instructions.c"
155 #include "arch/sparc/annotate/instructions.c"
156
157 static struct arch architectures[] = {
158 {
159 .name = "arc",
160 .init = arc__annotate_init,
161 },
162 {
163 .name = "arm",
164 .init = arm__annotate_init,
165 },
166 {
167 .name = "arm64",
168 .init = arm64__annotate_init,
169 },
170 {
171 .name = "csky",
172 .init = csky__annotate_init,
173 },
174 {
175 .name = "mips",
176 .init = mips__annotate_init,
177 .objdump = {
178 .comment_char = '#',
179 },
180 },
181 {
182 .name = "x86",
183 .init = x86__annotate_init,
184 .instructions = x86__instructions,
185 .nr_instructions = ARRAY_SIZE(x86__instructions),
186 .ins_is_fused = x86__ins_is_fused,
187 .objdump = {
188 .comment_char = '#',
189 },
190 },
191 {
192 .name = "powerpc",
193 .init = powerpc__annotate_init,
194 },
195 {
196 .name = "s390",
197 .init = s390__annotate_init,
198 .objdump = {
199 .comment_char = '#',
200 },
201 },
202 {
203 .name = "sparc",
204 .init = sparc__annotate_init,
205 .objdump = {
206 .comment_char = '#',
207 },
208 },
209 };
210
211 static void ins__delete(struct ins_operands *ops)
212 {
213 if (ops == NULL)
214 return;
215 zfree(&ops->source.raw);
216 zfree(&ops->source.name);
217 zfree(&ops->target.raw);
218 zfree(&ops->target.name);
219 }
220
221 static int ins__raw_scnprintf(struct ins *ins, char *bf, size_t size,
222 struct ins_operands *ops, int max_ins_name)
223 {
224 return scnprintf(bf, size, "%-*s %s", max_ins_name, ins->name, ops->raw);
225 }
226
227 int ins__scnprintf(struct ins *ins, char *bf, size_t size,
228 struct ins_operands *ops, int max_ins_name)
229 {
230 if (ins->ops->scnprintf)
231 return ins->ops->scnprintf(ins, bf, size, ops, max_ins_name);
232
233 return ins__raw_scnprintf(ins, bf, size, ops, max_ins_name);
234 }
235
236 bool ins__is_fused(struct arch *arch, const char *ins1, const char *ins2)
237 {
238 if (!arch || !arch->ins_is_fused)
239 return false;
240
241 return arch->ins_is_fused(arch, ins1, ins2);
242 }
243
244 static int call__parse(struct arch *arch, struct ins_operands *ops, struct map_symbol *ms)
245 {
246 char *endptr, *tok, *name;
247 struct map *map = ms->map;
248 struct addr_map_symbol target = {
249 .ms = { .map = map, },
250 };
251
252 ops->target.addr = strtoull(ops->raw, &endptr, 16);
253
254 name = strchr(endptr, '<');
255 if (name == NULL)
256 goto indirect_call;
257
258 name++;
259
260 if (arch->objdump.skip_functions_char &&
261 strchr(name, arch->objdump.skip_functions_char))
262 return -1;
263
264 tok = strchr(name, '>');
265 if (tok == NULL)
266 return -1;
267
268 *tok = '\0';
269 ops->target.name = strdup(name);
270 *tok = '>';
271
272 if (ops->target.name == NULL)
273 return -1;
274 find_target:
275 target.addr = map__objdump_2mem(map, ops->target.addr);
276
277 if (maps__find_ams(ms->maps, &target) == 0 &&
278 map__rip_2objdump(target.ms.map, map->map_ip(target.ms.map, target.addr)) == ops->target.addr)
279 ops->target.sym = target.ms.sym;
280
281 return 0;
282
283 indirect_call:
284 tok = strchr(endptr, '*');
285 if (tok != NULL) {
286 endptr++;
287
288 /* Indirect call can use a non-rip register and offset: callq *0x8(%rbx).
289 * Do not parse such instruction. */
290 if (strstr(endptr, "(%r") == NULL)
291 ops->target.addr = strtoull(endptr, NULL, 16);
292 }
293 goto find_target;
294 }
295
296 static int call__scnprintf(struct ins *ins, char *bf, size_t size,
297 struct ins_operands *ops, int max_ins_name)
298 {
299 if (ops->target.sym)
300 return scnprintf(bf, size, "%-*s %s", max_ins_name, ins->name, ops->target.sym->name);
301
302 if (ops->target.addr == 0)
303 return ins__raw_scnprintf(ins, bf, size, ops, max_ins_name);
304
305 if (ops->target.name)
306 return scnprintf(bf, size, "%-*s %s", max_ins_name, ins->name, ops->target.name);
307
308 return scnprintf(bf, size, "%-*s *%" PRIx64, max_ins_name, ins->name, ops->target.addr);
309 }
310
311 static struct ins_ops call_ops = {
312 .parse = call__parse,
313 .scnprintf = call__scnprintf,
314 };
315
316 bool ins__is_call(const struct ins *ins)
317 {
318 return ins->ops == &call_ops || ins->ops == &s390_call_ops;
319 }
320
321 /*
322 * Prevents from matching commas in the comment section, e.g.:
323 * ffff200008446e70: b.cs ffff2000084470f4 <generic_exec_single+0x314> // b.hs, b.nlast
324 */
325 static inline const char *validate_comma(const char *c, struct ins_operands *ops)
326 {
327 if (ops->raw_comment && c > ops->raw_comment)
328 return NULL;
329
330 return c;
331 }
332
333 static int jump__parse(struct arch *arch, struct ins_operands *ops, struct map_symbol *ms)
334 {
335 struct map *map = ms->map;
336 struct symbol *sym = ms->sym;
337 struct addr_map_symbol target = {
338 .ms = { .map = map, },
339 };
340 const char *c = strchr(ops->raw, ',');
341 u64 start, end;
342
343 ops->raw_comment = strchr(ops->raw, arch->objdump.comment_char);
344 c = validate_comma(c, ops);
345
346 /*
347 * Examples of lines to parse for the _cpp_lex_token@@Base
348 * function:
349 *
350 * 1159e6c: jne 115aa32 <_cpp_lex_token@@Base+0xf92>
351 * 1159e8b: jne c469be <cpp_named_operator2name@@Base+0xa72>
352 *
353 * The first is a jump to an offset inside the same function,
354 * the second is to another function, i.e. that 0xa72 is an
355 * offset in the cpp_named_operator2name@@base function.
356 */
357 /*
358 * skip over possible up to 2 operands to get to address, e.g.:
359 * tbnz w0, #26, ffff0000083cd190 <security_file_permission+0xd0>
360 */
361 if (c++ != NULL) {
362 ops->target.addr = strtoull(c, NULL, 16);
363 if (!ops->target.addr) {
364 c = strchr(c, ',');
365 c = validate_comma(c, ops);
366 if (c++ != NULL)
367 ops->target.addr = strtoull(c, NULL, 16);
368 }
369 } else {
370 ops->target.addr = strtoull(ops->raw, NULL, 16);
371 }
372
373 target.addr = map__objdump_2mem(map, ops->target.addr);
374 start = map->unmap_ip(map, sym->start),
375 end = map->unmap_ip(map, sym->end);
376
377 ops->target.outside = target.addr < start || target.addr > end;
378
379 /*
380 * FIXME: things like this in _cpp_lex_token (gcc's cc1 program):
381
382 cpp_named_operator2name@@Base+0xa72
383
384 * Point to a place that is after the cpp_named_operator2name
385 * boundaries, i.e. in the ELF symbol table for cc1
386 * cpp_named_operator2name is marked as being 32-bytes long, but it in
387 * fact is much larger than that, so we seem to need a symbols__find()
388 * routine that looks for >= current->start and < next_symbol->start,
389 * possibly just for C++ objects?
390 *
391 * For now lets just make some progress by marking jumps to outside the
392 * current function as call like.
393 *
394 * Actual navigation will come next, with further understanding of how
395 * the symbol searching and disassembly should be done.
396 */
397 if (maps__find_ams(ms->maps, &target) == 0 &&
398 map__rip_2objdump(target.ms.map, map->map_ip(target.ms.map, target.addr)) == ops->target.addr)
399 ops->target.sym = target.ms.sym;
400
401 if (!ops->target.outside) {
402 ops->target.offset = target.addr - start;
403 ops->target.offset_avail = true;
404 } else {
405 ops->target.offset_avail = false;
406 }
407
408 return 0;
409 }
410
411 static int jump__scnprintf(struct ins *ins, char *bf, size_t size,
412 struct ins_operands *ops, int max_ins_name)
413 {
414 const char *c;
415
416 if (!ops->target.addr || ops->target.offset < 0)
417 return ins__raw_scnprintf(ins, bf, size, ops, max_ins_name);
418
419 if (ops->target.outside && ops->target.sym != NULL)
420 return scnprintf(bf, size, "%-*s %s", max_ins_name, ins->name, ops->target.sym->name);
421
422 c = strchr(ops->raw, ',');
423 c = validate_comma(c, ops);
424
425 if (c != NULL) {
426 const char *c2 = strchr(c + 1, ',');
427
428 c2 = validate_comma(c2, ops);
429 /* check for 3-op insn */
430 if (c2 != NULL)
431 c = c2;
432 c++;
433
434 /* mirror arch objdump's space-after-comma style */
435 if (*c == ' ')
436 c++;
437 }
438
439 return scnprintf(bf, size, "%-*s %.*s%" PRIx64, max_ins_name,
440 ins->name, c ? c - ops->raw : 0, ops->raw,
441 ops->target.offset);
442 }
443
444 static struct ins_ops jump_ops = {
445 .parse = jump__parse,
446 .scnprintf = jump__scnprintf,
447 };
448
449 bool ins__is_jump(const struct ins *ins)
450 {
451 return ins->ops == &jump_ops;
452 }
453
454 static int comment__symbol(char *raw, char *comment, u64 *addrp, char **namep)
455 {
456 char *endptr, *name, *t;
457
458 if (strstr(raw, "(%rip)") == NULL)
459 return 0;
460
461 *addrp = strtoull(comment, &endptr, 16);
462 if (endptr == comment)
463 return 0;
464 name = strchr(endptr, '<');
465 if (name == NULL)
466 return -1;
467
468 name++;
469
470 t = strchr(name, '>');
471 if (t == NULL)
472 return 0;
473
474 *t = '\0';
475 *namep = strdup(name);
476 *t = '>';
477
478 return 0;
479 }
480
481 static int lock__parse(struct arch *arch, struct ins_operands *ops, struct map_symbol *ms)
482 {
483 ops->locked.ops = zalloc(sizeof(*ops->locked.ops));
484 if (ops->locked.ops == NULL)
485 return 0;
486
487 if (disasm_line__parse(ops->raw, &ops->locked.ins.name, &ops->locked.ops->raw) < 0)
488 goto out_free_ops;
489
490 ops->locked.ins.ops = ins__find(arch, ops->locked.ins.name);
491
492 if (ops->locked.ins.ops == NULL)
493 goto out_free_ops;
494
495 if (ops->locked.ins.ops->parse &&
496 ops->locked.ins.ops->parse(arch, ops->locked.ops, ms) < 0)
497 goto out_free_ops;
498
499 return 0;
500
501 out_free_ops:
502 zfree(&ops->locked.ops);
503 return 0;
504 }
505
506 static int lock__scnprintf(struct ins *ins, char *bf, size_t size,
507 struct ins_operands *ops, int max_ins_name)
508 {
509 int printed;
510
511 if (ops->locked.ins.ops == NULL)
512 return ins__raw_scnprintf(ins, bf, size, ops, max_ins_name);
513
514 printed = scnprintf(bf, size, "%-*s ", max_ins_name, ins->name);
515 return printed + ins__scnprintf(&ops->locked.ins, bf + printed,
516 size - printed, ops->locked.ops, max_ins_name);
517 }
518
519 static void lock__delete(struct ins_operands *ops)
520 {
521 struct ins *ins = &ops->locked.ins;
522
523 if (ins->ops && ins->ops->free)
524 ins->ops->free(ops->locked.ops);
525 else
526 ins__delete(ops->locked.ops);
527
528 zfree(&ops->locked.ops);
529 zfree(&ops->target.raw);
530 zfree(&ops->target.name);
531 }
532
533 static struct ins_ops lock_ops = {
534 .free = lock__delete,
535 .parse = lock__parse,
536 .scnprintf = lock__scnprintf,
537 };
538
539 static int mov__parse(struct arch *arch, struct ins_operands *ops, struct map_symbol *ms __maybe_unused)
540 {
541 char *s = strchr(ops->raw, ','), *target, *comment, prev;
542
543 if (s == NULL)
544 return -1;
545
546 *s = '\0';
547 ops->source.raw = strdup(ops->raw);
548 *s = ',';
549
550 if (ops->source.raw == NULL)
551 return -1;
552
553 target = ++s;
554 comment = strchr(s, arch->objdump.comment_char);
555
556 if (comment != NULL)
557 s = comment - 1;
558 else
559 s = strchr(s, '\0') - 1;
560
561 while (s > target && isspace(s[0]))
562 --s;
563 s++;
564 prev = *s;
565 *s = '\0';
566
567 ops->target.raw = strdup(target);
568 *s = prev;
569
570 if (ops->target.raw == NULL)
571 goto out_free_source;
572
573 if (comment == NULL)
574 return 0;
575
576 comment = skip_spaces(comment);
577 comment__symbol(ops->source.raw, comment + 1, &ops->source.addr, &ops->source.name);
578 comment__symbol(ops->target.raw, comment + 1, &ops->target.addr, &ops->target.name);
579
580 return 0;
581
582 out_free_source:
583 zfree(&ops->source.raw);
584 return -1;
585 }
586
587 static int mov__scnprintf(struct ins *ins, char *bf, size_t size,
588 struct ins_operands *ops, int max_ins_name)
589 {
590 return scnprintf(bf, size, "%-*s %s,%s", max_ins_name, ins->name,
591 ops->source.name ?: ops->source.raw,
592 ops->target.name ?: ops->target.raw);
593 }
594
595 static struct ins_ops mov_ops = {
596 .parse = mov__parse,
597 .scnprintf = mov__scnprintf,
598 };
599
600 static int dec__parse(struct arch *arch __maybe_unused, struct ins_operands *ops, struct map_symbol *ms __maybe_unused)
601 {
602 char *target, *comment, *s, prev;
603
604 target = s = ops->raw;
605
606 while (s[0] != '\0' && !isspace(s[0]))
607 ++s;
608 prev = *s;
609 *s = '\0';
610
611 ops->target.raw = strdup(target);
612 *s = prev;
613
614 if (ops->target.raw == NULL)
615 return -1;
616
617 comment = strchr(s, arch->objdump.comment_char);
618 if (comment == NULL)
619 return 0;
620
621 comment = skip_spaces(comment);
622 comment__symbol(ops->target.raw, comment + 1, &ops->target.addr, &ops->target.name);
623
624 return 0;
625 }
626
627 static int dec__scnprintf(struct ins *ins, char *bf, size_t size,
628 struct ins_operands *ops, int max_ins_name)
629 {
630 return scnprintf(bf, size, "%-*s %s", max_ins_name, ins->name,
631 ops->target.name ?: ops->target.raw);
632 }
633
634 static struct ins_ops dec_ops = {
635 .parse = dec__parse,
636 .scnprintf = dec__scnprintf,
637 };
638
639 static int nop__scnprintf(struct ins *ins __maybe_unused, char *bf, size_t size,
640 struct ins_operands *ops __maybe_unused, int max_ins_name)
641 {
642 return scnprintf(bf, size, "%-*s", max_ins_name, "nop");
643 }
644
645 static struct ins_ops nop_ops = {
646 .scnprintf = nop__scnprintf,
647 };
648
649 static struct ins_ops ret_ops = {
650 .scnprintf = ins__raw_scnprintf,
651 };
652
653 bool ins__is_ret(const struct ins *ins)
654 {
655 return ins->ops == &ret_ops;
656 }
657
658 bool ins__is_lock(const struct ins *ins)
659 {
660 return ins->ops == &lock_ops;
661 }
662
663 static int ins__key_cmp(const void *name, const void *insp)
664 {
665 const struct ins *ins = insp;
666
667 return strcmp(name, ins->name);
668 }
669
670 static int ins__cmp(const void *a, const void *b)
671 {
672 const struct ins *ia = a;
673 const struct ins *ib = b;
674
675 return strcmp(ia->name, ib->name);
676 }
677
678 static void ins__sort(struct arch *arch)
679 {
680 const int nmemb = arch->nr_instructions;
681
682 qsort(arch->instructions, nmemb, sizeof(struct ins), ins__cmp);
683 }
684
685 static struct ins_ops *__ins__find(struct arch *arch, const char *name)
686 {
687 struct ins *ins;
688 const int nmemb = arch->nr_instructions;
689
690 if (!arch->sorted_instructions) {
691 ins__sort(arch);
692 arch->sorted_instructions = true;
693 }
694
695 ins = bsearch(name, arch->instructions, nmemb, sizeof(struct ins), ins__key_cmp);
696 return ins ? ins->ops : NULL;
697 }
698
699 static struct ins_ops *ins__find(struct arch *arch, const char *name)
700 {
701 struct ins_ops *ops = __ins__find(arch, name);
702
703 if (!ops && arch->associate_instruction_ops)
704 ops = arch->associate_instruction_ops(arch, name);
705
706 return ops;
707 }
708
709 static int arch__key_cmp(const void *name, const void *archp)
710 {
711 const struct arch *arch = archp;
712
713 return strcmp(name, arch->name);
714 }
715
716 static int arch__cmp(const void *a, const void *b)
717 {
718 const struct arch *aa = a;
719 const struct arch *ab = b;
720
721 return strcmp(aa->name, ab->name);
722 }
723
724 static void arch__sort(void)
725 {
726 const int nmemb = ARRAY_SIZE(architectures);
727
728 qsort(architectures, nmemb, sizeof(struct arch), arch__cmp);
729 }
730
731 static struct arch *arch__find(const char *name)
732 {
733 const int nmemb = ARRAY_SIZE(architectures);
734 static bool sorted;
735
736 if (!sorted) {
737 arch__sort();
738 sorted = true;
739 }
740
741 return bsearch(name, architectures, nmemb, sizeof(struct arch), arch__key_cmp);
742 }
743
744 static struct annotated_source *annotated_source__new(void)
745 {
746 struct annotated_source *src = zalloc(sizeof(*src));
747
748 if (src != NULL)
749 INIT_LIST_HEAD(&src->source);
750
751 return src;
752 }
753
754 static __maybe_unused void annotated_source__delete(struct annotated_source *src)
755 {
756 if (src == NULL)
757 return;
758 zfree(&src->histograms);
759 zfree(&src->cycles_hist);
760 free(src);
761 }
762
763 static int annotated_source__alloc_histograms(struct annotated_source *src,
764 size_t size, int nr_hists)
765 {
766 size_t sizeof_sym_hist;
767
768 /*
769 * Add buffer of one element for zero length symbol.
770 * When sample is taken from first instruction of
771 * zero length symbol, perf still resolves it and
772 * shows symbol name in perf report and allows to
773 * annotate it.
774 */
775 if (size == 0)
776 size = 1;
777
778 /* Check for overflow when calculating sizeof_sym_hist */
779 if (size > (SIZE_MAX - sizeof(struct sym_hist)) / sizeof(struct sym_hist_entry))
780 return -1;
781
782 sizeof_sym_hist = (sizeof(struct sym_hist) + size * sizeof(struct sym_hist_entry));
783
784 /* Check for overflow in zalloc argument */
785 if (sizeof_sym_hist > SIZE_MAX / nr_hists)
786 return -1;
787
788 src->sizeof_sym_hist = sizeof_sym_hist;
789 src->nr_histograms = nr_hists;
790 src->histograms = calloc(nr_hists, sizeof_sym_hist) ;
791 return src->histograms ? 0 : -1;
792 }
793
794 /* The cycles histogram is lazily allocated. */
795 static int symbol__alloc_hist_cycles(struct symbol *sym)
796 {
797 struct annotation *notes = symbol__annotation(sym);
798 const size_t size = symbol__size(sym);
799
800 notes->src->cycles_hist = calloc(size, sizeof(struct cyc_hist));
801 if (notes->src->cycles_hist == NULL)
802 return -1;
803 return 0;
804 }
805
806 void symbol__annotate_zero_histograms(struct symbol *sym)
807 {
808 struct annotation *notes = symbol__annotation(sym);
809
810 pthread_mutex_lock(&notes->lock);
811 if (notes->src != NULL) {
812 memset(notes->src->histograms, 0,
813 notes->src->nr_histograms * notes->src->sizeof_sym_hist);
814 if (notes->src->cycles_hist)
815 memset(notes->src->cycles_hist, 0,
816 symbol__size(sym) * sizeof(struct cyc_hist));
817 }
818 pthread_mutex_unlock(&notes->lock);
819 }
820
821 static int __symbol__account_cycles(struct cyc_hist *ch,
822 u64 start,
823 unsigned offset, unsigned cycles,
824 unsigned have_start)
825 {
826 /*
827 * For now we can only account one basic block per
828 * final jump. But multiple could be overlapping.
829 * Always account the longest one. So when
830 * a shorter one has been already seen throw it away.
831 *
832 * We separately always account the full cycles.
833 */
834 ch[offset].num_aggr++;
835 ch[offset].cycles_aggr += cycles;
836
837 if (cycles > ch[offset].cycles_max)
838 ch[offset].cycles_max = cycles;
839
840 if (ch[offset].cycles_min) {
841 if (cycles && cycles < ch[offset].cycles_min)
842 ch[offset].cycles_min = cycles;
843 } else
844 ch[offset].cycles_min = cycles;
845
846 if (!have_start && ch[offset].have_start)
847 return 0;
848 if (ch[offset].num) {
849 if (have_start && (!ch[offset].have_start ||
850 ch[offset].start > start)) {
851 ch[offset].have_start = 0;
852 ch[offset].cycles = 0;
853 ch[offset].num = 0;
854 if (ch[offset].reset < 0xffff)
855 ch[offset].reset++;
856 } else if (have_start &&
857 ch[offset].start < start)
858 return 0;
859 }
860
861 if (ch[offset].num < NUM_SPARKS)
862 ch[offset].cycles_spark[ch[offset].num] = cycles;
863
864 ch[offset].have_start = have_start;
865 ch[offset].start = start;
866 ch[offset].cycles += cycles;
867 ch[offset].num++;
868 return 0;
869 }
870
871 static int __symbol__inc_addr_samples(struct map_symbol *ms,
872 struct annotated_source *src, int evidx, u64 addr,
873 struct perf_sample *sample)
874 {
875 struct symbol *sym = ms->sym;
876 unsigned offset;
877 struct sym_hist *h;
878
879 pr_debug3("%s: addr=%#" PRIx64 "\n", __func__, ms->map->unmap_ip(ms->map, addr));
880
881 if ((addr < sym->start || addr >= sym->end) &&
882 (addr != sym->end || sym->start != sym->end)) {
883 pr_debug("%s(%d): ERANGE! sym->name=%s, start=%#" PRIx64 ", addr=%#" PRIx64 ", end=%#" PRIx64 "\n",
884 __func__, __LINE__, sym->name, sym->start, addr, sym->end);
885 return -ERANGE;
886 }
887
888 offset = addr - sym->start;
889 h = annotated_source__histogram(src, evidx);
890 if (h == NULL) {
891 pr_debug("%s(%d): ENOMEM! sym->name=%s, start=%#" PRIx64 ", addr=%#" PRIx64 ", end=%#" PRIx64 ", func: %d\n",
892 __func__, __LINE__, sym->name, sym->start, addr, sym->end, sym->type == STT_FUNC);
893 return -ENOMEM;
894 }
895 h->nr_samples++;
896 h->addr[offset].nr_samples++;
897 h->period += sample->period;
898 h->addr[offset].period += sample->period;
899
900 pr_debug3("%#" PRIx64 " %s: period++ [addr: %#" PRIx64 ", %#" PRIx64
901 ", evidx=%d] => nr_samples: %" PRIu64 ", period: %" PRIu64 "\n",
902 sym->start, sym->name, addr, addr - sym->start, evidx,
903 h->addr[offset].nr_samples, h->addr[offset].period);
904 return 0;
905 }
906
907 static struct cyc_hist *symbol__cycles_hist(struct symbol *sym)
908 {
909 struct annotation *notes = symbol__annotation(sym);
910
911 if (notes->src == NULL) {
912 notes->src = annotated_source__new();
913 if (notes->src == NULL)
914 return NULL;
915 goto alloc_cycles_hist;
916 }
917
918 if (!notes->src->cycles_hist) {
919 alloc_cycles_hist:
920 symbol__alloc_hist_cycles(sym);
921 }
922
923 return notes->src->cycles_hist;
924 }
925
926 struct annotated_source *symbol__hists(struct symbol *sym, int nr_hists)
927 {
928 struct annotation *notes = symbol__annotation(sym);
929
930 if (notes->src == NULL) {
931 notes->src = annotated_source__new();
932 if (notes->src == NULL)
933 return NULL;
934 goto alloc_histograms;
935 }
936
937 if (notes->src->histograms == NULL) {
938 alloc_histograms:
939 annotated_source__alloc_histograms(notes->src, symbol__size(sym),
940 nr_hists);
941 }
942
943 return notes->src;
944 }
945
946 static int symbol__inc_addr_samples(struct map_symbol *ms,
947 struct evsel *evsel, u64 addr,
948 struct perf_sample *sample)
949 {
950 struct symbol *sym = ms->sym;
951 struct annotated_source *src;
952
953 if (sym == NULL)
954 return 0;
955 src = symbol__hists(sym, evsel->evlist->core.nr_entries);
956 return src ? __symbol__inc_addr_samples(ms, src, evsel->idx, addr, sample) : 0;
957 }
958
959 static int symbol__account_cycles(u64 addr, u64 start,
960 struct symbol *sym, unsigned cycles)
961 {
962 struct cyc_hist *cycles_hist;
963 unsigned offset;
964
965 if (sym == NULL)
966 return 0;
967 cycles_hist = symbol__cycles_hist(sym);
968 if (cycles_hist == NULL)
969 return -ENOMEM;
970 if (addr < sym->start || addr >= sym->end)
971 return -ERANGE;
972
973 if (start) {
974 if (start < sym->start || start >= sym->end)
975 return -ERANGE;
976 if (start >= addr)
977 start = 0;
978 }
979 offset = addr - sym->start;
980 return __symbol__account_cycles(cycles_hist,
981 start ? start - sym->start : 0,
982 offset, cycles,
983 !!start);
984 }
985
986 int addr_map_symbol__account_cycles(struct addr_map_symbol *ams,
987 struct addr_map_symbol *start,
988 unsigned cycles)
989 {
990 u64 saddr = 0;
991 int err;
992
993 if (!cycles)
994 return 0;
995
996 /*
997 * Only set start when IPC can be computed. We can only
998 * compute it when the basic block is completely in a single
999 * function.
1000 * Special case the case when the jump is elsewhere, but
1001 * it starts on the function start.
1002 */
1003 if (start &&
1004 (start->ms.sym == ams->ms.sym ||
1005 (ams->ms.sym &&
1006 start->addr == ams->ms.sym->start + ams->ms.map->start)))
1007 saddr = start->al_addr;
1008 if (saddr == 0)
1009 pr_debug2("BB with bad start: addr %"PRIx64" start %"PRIx64" sym %"PRIx64" saddr %"PRIx64"\n",
1010 ams->addr,
1011 start ? start->addr : 0,
1012 ams->ms.sym ? ams->ms.sym->start + ams->ms.map->start : 0,
1013 saddr);
1014 err = symbol__account_cycles(ams->al_addr, saddr, ams->ms.sym, cycles);
1015 if (err)
1016 pr_debug2("account_cycles failed %d\n", err);
1017 return err;
1018 }
1019
1020 static unsigned annotation__count_insn(struct annotation *notes, u64 start, u64 end)
1021 {
1022 unsigned n_insn = 0;
1023 u64 offset;
1024
1025 for (offset = start; offset <= end; offset++) {
1026 if (notes->offsets[offset])
1027 n_insn++;
1028 }
1029 return n_insn;
1030 }
1031
1032 static void annotation__count_and_fill(struct annotation *notes, u64 start, u64 end, struct cyc_hist *ch)
1033 {
1034 unsigned n_insn;
1035 unsigned int cover_insn = 0;
1036 u64 offset;
1037
1038 n_insn = annotation__count_insn(notes, start, end);
1039 if (n_insn && ch->num && ch->cycles) {
1040 float ipc = n_insn / ((double)ch->cycles / (double)ch->num);
1041
1042 /* Hide data when there are too many overlaps. */
1043 if (ch->reset >= 0x7fff)
1044 return;
1045
1046 for (offset = start; offset <= end; offset++) {
1047 struct annotation_line *al = notes->offsets[offset];
1048
1049 if (al && al->ipc == 0.0) {
1050 al->ipc = ipc;
1051 cover_insn++;
1052 }
1053 }
1054
1055 if (cover_insn) {
1056 notes->hit_cycles += ch->cycles;
1057 notes->hit_insn += n_insn * ch->num;
1058 notes->cover_insn += cover_insn;
1059 }
1060 }
1061 }
1062
1063 void annotation__compute_ipc(struct annotation *notes, size_t size)
1064 {
1065 s64 offset;
1066
1067 if (!notes->src || !notes->src->cycles_hist)
1068 return;
1069
1070 notes->total_insn = annotation__count_insn(notes, 0, size - 1);
1071 notes->hit_cycles = 0;
1072 notes->hit_insn = 0;
1073 notes->cover_insn = 0;
1074
1075 pthread_mutex_lock(&notes->lock);
1076 for (offset = size - 1; offset >= 0; --offset) {
1077 struct cyc_hist *ch;
1078
1079 ch = &notes->src->cycles_hist[offset];
1080 if (ch && ch->cycles) {
1081 struct annotation_line *al;
1082
1083 if (ch->have_start)
1084 annotation__count_and_fill(notes, ch->start, offset, ch);
1085 al = notes->offsets[offset];
1086 if (al && ch->num_aggr) {
1087 al->cycles = ch->cycles_aggr / ch->num_aggr;
1088 al->cycles_max = ch->cycles_max;
1089 al->cycles_min = ch->cycles_min;
1090 }
1091 notes->have_cycles = true;
1092 }
1093 }
1094 pthread_mutex_unlock(&notes->lock);
1095 }
1096
1097 int addr_map_symbol__inc_samples(struct addr_map_symbol *ams, struct perf_sample *sample,
1098 struct evsel *evsel)
1099 {
1100 return symbol__inc_addr_samples(&ams->ms, evsel, ams->al_addr, sample);
1101 }
1102
1103 int hist_entry__inc_addr_samples(struct hist_entry *he, struct perf_sample *sample,
1104 struct evsel *evsel, u64 ip)
1105 {
1106 return symbol__inc_addr_samples(&he->ms, evsel, ip, sample);
1107 }
1108
1109 static void disasm_line__init_ins(struct disasm_line *dl, struct arch *arch, struct map_symbol *ms)
1110 {
1111 dl->ins.ops = ins__find(arch, dl->ins.name);
1112
1113 if (!dl->ins.ops)
1114 return;
1115
1116 if (dl->ins.ops->parse && dl->ins.ops->parse(arch, &dl->ops, ms) < 0)
1117 dl->ins.ops = NULL;
1118 }
1119
1120 static int disasm_line__parse(char *line, const char **namep, char **rawp)
1121 {
1122 char tmp, *name = skip_spaces(line);
1123
1124 if (name[0] == '\0')
1125 return -1;
1126
1127 *rawp = name + 1;
1128
1129 while ((*rawp)[0] != '\0' && !isspace((*rawp)[0]))
1130 ++*rawp;
1131
1132 tmp = (*rawp)[0];
1133 (*rawp)[0] = '\0';
1134 *namep = strdup(name);
1135
1136 if (*namep == NULL)
1137 goto out;
1138
1139 (*rawp)[0] = tmp;
1140 *rawp = strim(*rawp);
1141
1142 return 0;
1143
1144 out:
1145 return -1;
1146 }
1147
1148 struct annotate_args {
1149 struct arch *arch;
1150 struct map_symbol ms;
1151 struct evsel *evsel;
1152 struct annotation_options *options;
1153 s64 offset;
1154 char *line;
1155 int line_nr;
1156 };
1157
1158 static void annotation_line__init(struct annotation_line *al,
1159 struct annotate_args *args,
1160 int nr)
1161 {
1162 al->offset = args->offset;
1163 al->line = strdup(args->line);
1164 al->line_nr = args->line_nr;
1165 al->data_nr = nr;
1166 }
1167
1168 static void annotation_line__exit(struct annotation_line *al)
1169 {
1170 free_srcline(al->path);
1171 zfree(&al->line);
1172 }
1173
1174 static size_t disasm_line_size(int nr)
1175 {
1176 struct annotation_line *al;
1177
1178 return (sizeof(struct disasm_line) + (sizeof(al->data[0]) * nr));
1179 }
1180
1181 /*
1182 * Allocating the disasm annotation line data with
1183 * following structure:
1184 *
1185 * -------------------------------------------
1186 * struct disasm_line | struct annotation_line
1187 * -------------------------------------------
1188 *
1189 * We have 'struct annotation_line' member as last member
1190 * of 'struct disasm_line' to have an easy access.
1191 */
1192 static struct disasm_line *disasm_line__new(struct annotate_args *args)
1193 {
1194 struct disasm_line *dl = NULL;
1195 int nr = 1;
1196
1197 if (evsel__is_group_event(args->evsel))
1198 nr = args->evsel->core.nr_members;
1199
1200 dl = zalloc(disasm_line_size(nr));
1201 if (!dl)
1202 return NULL;
1203
1204 annotation_line__init(&dl->al, args, nr);
1205 if (dl->al.line == NULL)
1206 goto out_delete;
1207
1208 if (args->offset != -1) {
1209 if (disasm_line__parse(dl->al.line, &dl->ins.name, &dl->ops.raw) < 0)
1210 goto out_free_line;
1211
1212 disasm_line__init_ins(dl, args->arch, &args->ms);
1213 }
1214
1215 return dl;
1216
1217 out_free_line:
1218 zfree(&dl->al.line);
1219 out_delete:
1220 free(dl);
1221 return NULL;
1222 }
1223
1224 void disasm_line__free(struct disasm_line *dl)
1225 {
1226 if (dl->ins.ops && dl->ins.ops->free)
1227 dl->ins.ops->free(&dl->ops);
1228 else
1229 ins__delete(&dl->ops);
1230 zfree(&dl->ins.name);
1231 annotation_line__exit(&dl->al);
1232 free(dl);
1233 }
1234
1235 int disasm_line__scnprintf(struct disasm_line *dl, char *bf, size_t size, bool raw, int max_ins_name)
1236 {
1237 if (raw || !dl->ins.ops)
1238 return scnprintf(bf, size, "%-*s %s", max_ins_name, dl->ins.name, dl->ops.raw);
1239
1240 return ins__scnprintf(&dl->ins, bf, size, &dl->ops, max_ins_name);
1241 }
1242
1243 static void annotation_line__add(struct annotation_line *al, struct list_head *head)
1244 {
1245 list_add_tail(&al->node, head);
1246 }
1247
1248 struct annotation_line *
1249 annotation_line__next(struct annotation_line *pos, struct list_head *head)
1250 {
1251 list_for_each_entry_continue(pos, head, node)
1252 if (pos->offset >= 0)
1253 return pos;
1254
1255 return NULL;
1256 }
1257
1258 static const char *annotate__address_color(struct block_range *br)
1259 {
1260 double cov = block_range__coverage(br);
1261
1262 if (cov >= 0) {
1263 /* mark red for >75% coverage */
1264 if (cov > 0.75)
1265 return PERF_COLOR_RED;
1266
1267 /* mark dull for <1% coverage */
1268 if (cov < 0.01)
1269 return PERF_COLOR_NORMAL;
1270 }
1271
1272 return PERF_COLOR_MAGENTA;
1273 }
1274
1275 static const char *annotate__asm_color(struct block_range *br)
1276 {
1277 double cov = block_range__coverage(br);
1278
1279 if (cov >= 0) {
1280 /* mark dull for <1% coverage */
1281 if (cov < 0.01)
1282 return PERF_COLOR_NORMAL;
1283 }
1284
1285 return PERF_COLOR_BLUE;
1286 }
1287
1288 static void annotate__branch_printf(struct block_range *br, u64 addr)
1289 {
1290 bool emit_comment = true;
1291
1292 if (!br)
1293 return;
1294
1295 #if 1
1296 if (br->is_target && br->start == addr) {
1297 struct block_range *branch = br;
1298 double p;
1299
1300 /*
1301 * Find matching branch to our target.
1302 */
1303 while (!branch->is_branch)
1304 branch = block_range__next(branch);
1305
1306 p = 100 *(double)br->entry / branch->coverage;
1307
1308 if (p > 0.1) {
1309 if (emit_comment) {
1310 emit_comment = false;
1311 printf("\t#");
1312 }
1313
1314 /*
1315 * The percentage of coverage joined at this target in relation
1316 * to the next branch.
1317 */
1318 printf(" +%.2f%%", p);
1319 }
1320 }
1321 #endif
1322 if (br->is_branch && br->end == addr) {
1323 double p = 100*(double)br->taken / br->coverage;
1324
1325 if (p > 0.1) {
1326 if (emit_comment) {
1327 emit_comment = false;
1328 printf("\t#");
1329 }
1330
1331 /*
1332 * The percentage of coverage leaving at this branch, and
1333 * its prediction ratio.
1334 */
1335 printf(" -%.2f%% (p:%.2f%%)", p, 100*(double)br->pred / br->taken);
1336 }
1337 }
1338 }
1339
1340 static int disasm_line__print(struct disasm_line *dl, u64 start, int addr_fmt_width)
1341 {
1342 s64 offset = dl->al.offset;
1343 const u64 addr = start + offset;
1344 struct block_range *br;
1345
1346 br = block_range__find(addr);
1347 color_fprintf(stdout, annotate__address_color(br), " %*" PRIx64 ":", addr_fmt_width, addr);
1348 color_fprintf(stdout, annotate__asm_color(br), "%s", dl->al.line);
1349 annotate__branch_printf(br, addr);
1350 return 0;
1351 }
1352
1353 static int
1354 annotation_line__print(struct annotation_line *al, struct symbol *sym, u64 start,
1355 struct evsel *evsel, u64 len, int min_pcnt, int printed,
1356 int max_lines, struct annotation_line *queue, int addr_fmt_width,
1357 int percent_type)
1358 {
1359 struct disasm_line *dl = container_of(al, struct disasm_line, al);
1360 static const char *prev_line;
1361 static const char *prev_color;
1362
1363 if (al->offset != -1) {
1364 double max_percent = 0.0;
1365 int i, nr_percent = 1;
1366 const char *color;
1367 struct annotation *notes = symbol__annotation(sym);
1368
1369 for (i = 0; i < al->data_nr; i++) {
1370 double percent;
1371
1372 percent = annotation_data__percent(&al->data[i],
1373 percent_type);
1374
1375 if (percent > max_percent)
1376 max_percent = percent;
1377 }
1378
1379 if (al->data_nr > nr_percent)
1380 nr_percent = al->data_nr;
1381
1382 if (max_percent < min_pcnt)
1383 return -1;
1384
1385 if (max_lines && printed >= max_lines)
1386 return 1;
1387
1388 if (queue != NULL) {
1389 list_for_each_entry_from(queue, &notes->src->source, node) {
1390 if (queue == al)
1391 break;
1392 annotation_line__print(queue, sym, start, evsel, len,
1393 0, 0, 1, NULL, addr_fmt_width,
1394 percent_type);
1395 }
1396 }
1397
1398 color = get_percent_color(max_percent);
1399
1400 /*
1401 * Also color the filename and line if needed, with
1402 * the same color than the percentage. Don't print it
1403 * twice for close colored addr with the same filename:line
1404 */
1405 if (al->path) {
1406 if (!prev_line || strcmp(prev_line, al->path)
1407 || color != prev_color) {
1408 color_fprintf(stdout, color, " %s", al->path);
1409 prev_line = al->path;
1410 prev_color = color;
1411 }
1412 }
1413
1414 for (i = 0; i < nr_percent; i++) {
1415 struct annotation_data *data = &al->data[i];
1416 double percent;
1417
1418 percent = annotation_data__percent(data, percent_type);
1419 color = get_percent_color(percent);
1420
1421 if (symbol_conf.show_total_period)
1422 color_fprintf(stdout, color, " %11" PRIu64,
1423 data->he.period);
1424 else if (symbol_conf.show_nr_samples)
1425 color_fprintf(stdout, color, " %7" PRIu64,
1426 data->he.nr_samples);
1427 else
1428 color_fprintf(stdout, color, " %7.2f", percent);
1429 }
1430
1431 printf(" : ");
1432
1433 disasm_line__print(dl, start, addr_fmt_width);
1434 printf("\n");
1435 } else if (max_lines && printed >= max_lines)
1436 return 1;
1437 else {
1438 int width = symbol_conf.show_total_period ? 12 : 8;
1439
1440 if (queue)
1441 return -1;
1442
1443 if (evsel__is_group_event(evsel))
1444 width *= evsel->core.nr_members;
1445
1446 if (!*al->line)
1447 printf(" %*s:\n", width, " ");
1448 else
1449 printf(" %*s: %*s %s\n", width, " ", addr_fmt_width, " ", al->line);
1450 }
1451
1452 return 0;
1453 }
1454
1455 /*
1456 * symbol__parse_objdump_line() parses objdump output (with -d --no-show-raw)
1457 * which looks like following
1458 *
1459 * 0000000000415500 <_init>:
1460 * 415500: sub $0x8,%rsp
1461 * 415504: mov 0x2f5ad5(%rip),%rax # 70afe0 <_DYNAMIC+0x2f8>
1462 * 41550b: test %rax,%rax
1463 * 41550e: je 415515 <_init+0x15>
1464 * 415510: callq 416e70 <__gmon_start__@plt>
1465 * 415515: add $0x8,%rsp
1466 * 415519: retq
1467 *
1468 * it will be parsed and saved into struct disasm_line as
1469 * <offset> <name> <ops.raw>
1470 *
1471 * The offset will be a relative offset from the start of the symbol and -1
1472 * means that it's not a disassembly line so should be treated differently.
1473 * The ops.raw part will be parsed further according to type of the instruction.
1474 */
1475 static int symbol__parse_objdump_line(struct symbol *sym,
1476 struct annotate_args *args,
1477 char *parsed_line, int *line_nr)
1478 {
1479 struct map *map = args->ms.map;
1480 struct annotation *notes = symbol__annotation(sym);
1481 struct disasm_line *dl;
1482 char *tmp;
1483 s64 line_ip, offset = -1;
1484 regmatch_t match[2];
1485
1486 /* /filename:linenr ? Save line number and ignore. */
1487 if (regexec(&file_lineno, parsed_line, 2, match, 0) == 0) {
1488 *line_nr = atoi(parsed_line + match[1].rm_so);
1489 return 0;
1490 }
1491
1492 /* Process hex address followed by ':'. */
1493 line_ip = strtoull(parsed_line, &tmp, 16);
1494 if (parsed_line != tmp && tmp[0] == ':' && tmp[1] != '\0') {
1495 u64 start = map__rip_2objdump(map, sym->start),
1496 end = map__rip_2objdump(map, sym->end);
1497
1498 offset = line_ip - start;
1499 if ((u64)line_ip < start || (u64)line_ip >= end)
1500 offset = -1;
1501 else
1502 parsed_line = tmp + 1;
1503 }
1504
1505 args->offset = offset;
1506 args->line = parsed_line;
1507 args->line_nr = *line_nr;
1508 args->ms.sym = sym;
1509
1510 dl = disasm_line__new(args);
1511 (*line_nr)++;
1512
1513 if (dl == NULL)
1514 return -1;
1515
1516 if (!disasm_line__has_local_offset(dl)) {
1517 dl->ops.target.offset = dl->ops.target.addr -
1518 map__rip_2objdump(map, sym->start);
1519 dl->ops.target.offset_avail = true;
1520 }
1521
1522 /* kcore has no symbols, so add the call target symbol */
1523 if (dl->ins.ops && ins__is_call(&dl->ins) && !dl->ops.target.sym) {
1524 struct addr_map_symbol target = {
1525 .addr = dl->ops.target.addr,
1526 .ms = { .map = map, },
1527 };
1528
1529 if (!maps__find_ams(args->ms.maps, &target) &&
1530 target.ms.sym->start == target.al_addr)
1531 dl->ops.target.sym = target.ms.sym;
1532 }
1533
1534 annotation_line__add(&dl->al, &notes->src->source);
1535
1536 return 0;
1537 }
1538
1539 static __attribute__((constructor)) void symbol__init_regexpr(void)
1540 {
1541 regcomp(&file_lineno, "^/[^:]+:([0-9]+)", REG_EXTENDED);
1542 }
1543
1544 static void delete_last_nop(struct symbol *sym)
1545 {
1546 struct annotation *notes = symbol__annotation(sym);
1547 struct list_head *list = &notes->src->source;
1548 struct disasm_line *dl;
1549
1550 while (!list_empty(list)) {
1551 dl = list_entry(list->prev, struct disasm_line, al.node);
1552
1553 if (dl->ins.ops) {
1554 if (dl->ins.ops != &nop_ops)
1555 return;
1556 } else {
1557 if (!strstr(dl->al.line, " nop ") &&
1558 !strstr(dl->al.line, " nopl ") &&
1559 !strstr(dl->al.line, " nopw "))
1560 return;
1561 }
1562
1563 list_del_init(&dl->al.node);
1564 disasm_line__free(dl);
1565 }
1566 }
1567
1568 int symbol__strerror_disassemble(struct map_symbol *ms, int errnum, char *buf, size_t buflen)
1569 {
1570 struct dso *dso = ms->map->dso;
1571
1572 BUG_ON(buflen == 0);
1573
1574 if (errnum >= 0) {
1575 str_error_r(errnum, buf, buflen);
1576 return 0;
1577 }
1578
1579 switch (errnum) {
1580 case SYMBOL_ANNOTATE_ERRNO__NO_VMLINUX: {
1581 char bf[SBUILD_ID_SIZE + 15] = " with build id ";
1582 char *build_id_msg = NULL;
1583
1584 if (dso->has_build_id) {
1585 build_id__sprintf(&dso->bid, bf + 15);
1586 build_id_msg = bf;
1587 }
1588 scnprintf(buf, buflen,
1589 "No vmlinux file%s\nwas found in the path.\n\n"
1590 "Note that annotation using /proc/kcore requires CAP_SYS_RAWIO capability.\n\n"
1591 "Please use:\n\n"
1592 " perf buildid-cache -vu vmlinux\n\n"
1593 "or:\n\n"
1594 " --vmlinux vmlinux\n", build_id_msg ?: "");
1595 }
1596 break;
1597 case SYMBOL_ANNOTATE_ERRNO__NO_LIBOPCODES_FOR_BPF:
1598 scnprintf(buf, buflen, "Please link with binutils's libopcode to enable BPF annotation");
1599 break;
1600 case SYMBOL_ANNOTATE_ERRNO__ARCH_INIT_REGEXP:
1601 scnprintf(buf, buflen, "Problems with arch specific instruction name regular expressions.");
1602 break;
1603 case SYMBOL_ANNOTATE_ERRNO__ARCH_INIT_CPUID_PARSING:
1604 scnprintf(buf, buflen, "Problems while parsing the CPUID in the arch specific initialization.");
1605 break;
1606 case SYMBOL_ANNOTATE_ERRNO__BPF_INVALID_FILE:
1607 scnprintf(buf, buflen, "Invalid BPF file: %s.", dso->long_name);
1608 break;
1609 case SYMBOL_ANNOTATE_ERRNO__BPF_MISSING_BTF:
1610 scnprintf(buf, buflen, "The %s BPF file has no BTF section, compile with -g or use pahole -J.",
1611 dso->long_name);
1612 break;
1613 default:
1614 scnprintf(buf, buflen, "Internal error: Invalid %d error code\n", errnum);
1615 break;
1616 }
1617
1618 return 0;
1619 }
1620
1621 static int dso__disassemble_filename(struct dso *dso, char *filename, size_t filename_size)
1622 {
1623 char linkname[PATH_MAX];
1624 char *build_id_filename;
1625 char *build_id_path = NULL;
1626 char *pos;
1627 int len;
1628
1629 if (dso->symtab_type == DSO_BINARY_TYPE__KALLSYMS &&
1630 !dso__is_kcore(dso))
1631 return SYMBOL_ANNOTATE_ERRNO__NO_VMLINUX;
1632
1633 build_id_filename = dso__build_id_filename(dso, NULL, 0, false);
1634 if (build_id_filename) {
1635 __symbol__join_symfs(filename, filename_size, build_id_filename);
1636 free(build_id_filename);
1637 } else {
1638 if (dso->has_build_id)
1639 return ENOMEM;
1640 goto fallback;
1641 }
1642
1643 build_id_path = strdup(filename);
1644 if (!build_id_path)
1645 return ENOMEM;
1646
1647 /*
1648 * old style build-id cache has name of XX/XXXXXXX.. while
1649 * new style has XX/XXXXXXX../{elf,kallsyms,vdso}.
1650 * extract the build-id part of dirname in the new style only.
1651 */
1652 pos = strrchr(build_id_path, '/');
1653 if (pos && strlen(pos) < SBUILD_ID_SIZE - 2)
1654 dirname(build_id_path);
1655
1656 if (dso__is_kcore(dso))
1657 goto fallback;
1658
1659 len = readlink(build_id_path, linkname, sizeof(linkname) - 1);
1660 if (len < 0)
1661 goto fallback;
1662
1663 linkname[len] = '\0';
1664 if (strstr(linkname, DSO__NAME_KALLSYMS) ||
1665 access(filename, R_OK)) {
1666 fallback:
1667 /*
1668 * If we don't have build-ids or the build-id file isn't in the
1669 * cache, or is just a kallsyms file, well, lets hope that this
1670 * DSO is the same as when 'perf record' ran.
1671 */
1672 __symbol__join_symfs(filename, filename_size, dso->long_name);
1673 }
1674
1675 free(build_id_path);
1676 return 0;
1677 }
1678
1679 #if defined(HAVE_LIBBFD_SUPPORT) && defined(HAVE_LIBBPF_SUPPORT)
1680 #define PACKAGE "perf"
1681 #include <bfd.h>
1682 #include <dis-asm.h>
1683 #include <bpf/bpf.h>
1684 #include <bpf/btf.h>
1685 #include <bpf/libbpf.h>
1686 #include <linux/btf.h>
1687
1688 static int symbol__disassemble_bpf(struct symbol *sym,
1689 struct annotate_args *args)
1690 {
1691 struct annotation *notes = symbol__annotation(sym);
1692 struct annotation_options *opts = args->options;
1693 struct bpf_prog_info_linear *info_linear;
1694 struct bpf_prog_linfo *prog_linfo = NULL;
1695 struct bpf_prog_info_node *info_node;
1696 int len = sym->end - sym->start;
1697 disassembler_ftype disassemble;
1698 struct map *map = args->ms.map;
1699 struct disassemble_info info;
1700 struct dso *dso = map->dso;
1701 int pc = 0, count, sub_id;
1702 struct btf *btf = NULL;
1703 char tpath[PATH_MAX];
1704 size_t buf_size;
1705 int nr_skip = 0;
1706 char *buf;
1707 bfd *bfdf;
1708 int ret;
1709 FILE *s;
1710
1711 if (dso->binary_type != DSO_BINARY_TYPE__BPF_PROG_INFO)
1712 return SYMBOL_ANNOTATE_ERRNO__BPF_INVALID_FILE;
1713
1714 pr_debug("%s: handling sym %s addr %" PRIx64 " len %" PRIx64 "\n", __func__,
1715 sym->name, sym->start, sym->end - sym->start);
1716
1717 memset(tpath, 0, sizeof(tpath));
1718 perf_exe(tpath, sizeof(tpath));
1719
1720 bfdf = bfd_openr(tpath, NULL);
1721 assert(bfdf);
1722 assert(bfd_check_format(bfdf, bfd_object));
1723
1724 s = open_memstream(&buf, &buf_size);
1725 if (!s) {
1726 ret = errno;
1727 goto out;
1728 }
1729 init_disassemble_info(&info, s,
1730 (fprintf_ftype) fprintf);
1731
1732 info.arch = bfd_get_arch(bfdf);
1733 info.mach = bfd_get_mach(bfdf);
1734
1735 info_node = perf_env__find_bpf_prog_info(dso->bpf_prog.env,
1736 dso->bpf_prog.id);
1737 if (!info_node) {
1738 ret = SYMBOL_ANNOTATE_ERRNO__BPF_MISSING_BTF;
1739 goto out;
1740 }
1741 info_linear = info_node->info_linear;
1742 sub_id = dso->bpf_prog.sub_id;
1743
1744 info.buffer = (void *)(uintptr_t)(info_linear->info.jited_prog_insns);
1745 info.buffer_length = info_linear->info.jited_prog_len;
1746
1747 if (info_linear->info.nr_line_info)
1748 prog_linfo = bpf_prog_linfo__new(&info_linear->info);
1749
1750 if (info_linear->info.btf_id) {
1751 struct btf_node *node;
1752
1753 node = perf_env__find_btf(dso->bpf_prog.env,
1754 info_linear->info.btf_id);
1755 if (node)
1756 btf = btf__new((__u8 *)(node->data),
1757 node->data_size);
1758 }
1759
1760 disassemble_init_for_target(&info);
1761
1762 #ifdef DISASM_FOUR_ARGS_SIGNATURE
1763 disassemble = disassembler(info.arch,
1764 bfd_big_endian(bfdf),
1765 info.mach,
1766 bfdf);
1767 #else
1768 disassemble = disassembler(bfdf);
1769 #endif
1770 assert(disassemble);
1771
1772 fflush(s);
1773 do {
1774 const struct bpf_line_info *linfo = NULL;
1775 struct disasm_line *dl;
1776 size_t prev_buf_size;
1777 const char *srcline;
1778 u64 addr;
1779
1780 addr = pc + ((u64 *)(uintptr_t)(info_linear->info.jited_ksyms))[sub_id];
1781 count = disassemble(pc, &info);
1782
1783 if (prog_linfo)
1784 linfo = bpf_prog_linfo__lfind_addr_func(prog_linfo,
1785 addr, sub_id,
1786 nr_skip);
1787
1788 if (linfo && btf) {
1789 srcline = btf__name_by_offset(btf, linfo->line_off);
1790 nr_skip++;
1791 } else
1792 srcline = NULL;
1793
1794 fprintf(s, "\n");
1795 prev_buf_size = buf_size;
1796 fflush(s);
1797
1798 if (!opts->hide_src_code && srcline) {
1799 args->offset = -1;
1800 args->line = strdup(srcline);
1801 args->line_nr = 0;
1802 args->ms.sym = sym;
1803 dl = disasm_line__new(args);
1804 if (dl) {
1805 annotation_line__add(&dl->al,
1806 &notes->src->source);
1807 }
1808 }
1809
1810 args->offset = pc;
1811 args->line = buf + prev_buf_size;
1812 args->line_nr = 0;
1813 args->ms.sym = sym;
1814 dl = disasm_line__new(args);
1815 if (dl)
1816 annotation_line__add(&dl->al, &notes->src->source);
1817
1818 pc += count;
1819 } while (count > 0 && pc < len);
1820
1821 ret = 0;
1822 out:
1823 free(prog_linfo);
1824 free(btf);
1825 fclose(s);
1826 bfd_close(bfdf);
1827 return ret;
1828 }
1829 #else // defined(HAVE_LIBBFD_SUPPORT) && defined(HAVE_LIBBPF_SUPPORT)
1830 static int symbol__disassemble_bpf(struct symbol *sym __maybe_unused,
1831 struct annotate_args *args __maybe_unused)
1832 {
1833 return SYMBOL_ANNOTATE_ERRNO__NO_LIBOPCODES_FOR_BPF;
1834 }
1835 #endif // defined(HAVE_LIBBFD_SUPPORT) && defined(HAVE_LIBBPF_SUPPORT)
1836
1837 static int
1838 symbol__disassemble_bpf_image(struct symbol *sym,
1839 struct annotate_args *args)
1840 {
1841 struct annotation *notes = symbol__annotation(sym);
1842 struct disasm_line *dl;
1843
1844 args->offset = -1;
1845 args->line = strdup("to be implemented");
1846 args->line_nr = 0;
1847 dl = disasm_line__new(args);
1848 if (dl)
1849 annotation_line__add(&dl->al, &notes->src->source);
1850
1851 free(args->line);
1852 return 0;
1853 }
1854
1855 /*
1856 * Possibly create a new version of line with tabs expanded. Returns the
1857 * existing or new line, storage is updated if a new line is allocated. If
1858 * allocation fails then NULL is returned.
1859 */
1860 static char *expand_tabs(char *line, char **storage, size_t *storage_len)
1861 {
1862 size_t i, src, dst, len, new_storage_len, num_tabs;
1863 char *new_line;
1864 size_t line_len = strlen(line);
1865
1866 for (num_tabs = 0, i = 0; i < line_len; i++)
1867 if (line[i] == '\t')
1868 num_tabs++;
1869
1870 if (num_tabs == 0)
1871 return line;
1872
1873 /*
1874 * Space for the line and '\0', less the leading and trailing
1875 * spaces. Each tab may introduce 7 additional spaces.
1876 */
1877 new_storage_len = line_len + 1 + (num_tabs * 7);
1878
1879 new_line = malloc(new_storage_len);
1880 if (new_line == NULL) {
1881 pr_err("Failure allocating memory for tab expansion\n");
1882 return NULL;
1883 }
1884
1885 /*
1886 * Copy regions starting at src and expand tabs. If there are two
1887 * adjacent tabs then 'src == i', the memcpy is of size 0 and the spaces
1888 * are inserted.
1889 */
1890 for (i = 0, src = 0, dst = 0; i < line_len && num_tabs; i++) {
1891 if (line[i] == '\t') {
1892 len = i - src;
1893 memcpy(&new_line[dst], &line[src], len);
1894 dst += len;
1895 new_line[dst++] = ' ';
1896 while (dst % 8 != 0)
1897 new_line[dst++] = ' ';
1898 src = i + 1;
1899 num_tabs--;
1900 }
1901 }
1902
1903 /* Expand the last region. */
1904 len = line_len - src;
1905 memcpy(&new_line[dst], &line[src], len);
1906 dst += len;
1907 new_line[dst] = '\0';
1908
1909 free(*storage);
1910 *storage = new_line;
1911 *storage_len = new_storage_len;
1912 return new_line;
1913
1914 }
1915
1916 static int symbol__disassemble(struct symbol *sym, struct annotate_args *args)
1917 {
1918 struct annotation_options *opts = args->options;
1919 struct map *map = args->ms.map;
1920 struct dso *dso = map->dso;
1921 char *command;
1922 FILE *file;
1923 char symfs_filename[PATH_MAX];
1924 struct kcore_extract kce;
1925 bool delete_extract = false;
1926 bool decomp = false;
1927 int lineno = 0;
1928 int nline;
1929 char *line;
1930 size_t line_len;
1931 const char *objdump_argv[] = {
1932 "/bin/sh",
1933 "-c",
1934 NULL, /* Will be the objdump command to run. */
1935 "--",
1936 NULL, /* Will be the symfs path. */
1937 NULL,
1938 };
1939 struct child_process objdump_process;
1940 int err = dso__disassemble_filename(dso, symfs_filename, sizeof(symfs_filename));
1941
1942 if (err)
1943 return err;
1944
1945 pr_debug("%s: filename=%s, sym=%s, start=%#" PRIx64 ", end=%#" PRIx64 "\n", __func__,
1946 symfs_filename, sym->name, map->unmap_ip(map, sym->start),
1947 map->unmap_ip(map, sym->end));
1948
1949 pr_debug("annotating [%p] %30s : [%p] %30s\n",
1950 dso, dso->long_name, sym, sym->name);
1951
1952 if (dso->binary_type == DSO_BINARY_TYPE__BPF_PROG_INFO) {
1953 return symbol__disassemble_bpf(sym, args);
1954 } else if (dso->binary_type == DSO_BINARY_TYPE__BPF_IMAGE) {
1955 return symbol__disassemble_bpf_image(sym, args);
1956 } else if (dso__is_kcore(dso)) {
1957 kce.kcore_filename = symfs_filename;
1958 kce.addr = map__rip_2objdump(map, sym->start);
1959 kce.offs = sym->start;
1960 kce.len = sym->end - sym->start;
1961 if (!kcore_extract__create(&kce)) {
1962 delete_extract = true;
1963 strlcpy(symfs_filename, kce.extract_filename,
1964 sizeof(symfs_filename));
1965 }
1966 } else if (dso__needs_decompress(dso)) {
1967 char tmp[KMOD_DECOMP_LEN];
1968
1969 if (dso__decompress_kmodule_path(dso, symfs_filename,
1970 tmp, sizeof(tmp)) < 0)
1971 return -1;
1972
1973 decomp = true;
1974 strcpy(symfs_filename, tmp);
1975 }
1976
1977 err = asprintf(&command,
1978 "%s %s%s --start-address=0x%016" PRIx64
1979 " --stop-address=0x%016" PRIx64
1980 " -l -d %s %s %s %c%s%c %s%s -C \"$1\"",
1981 opts->objdump_path ?: "objdump",
1982 opts->disassembler_style ? "-M " : "",
1983 opts->disassembler_style ?: "",
1984 map__rip_2objdump(map, sym->start),
1985 map__rip_2objdump(map, sym->end),
1986 opts->show_asm_raw ? "" : "--no-show-raw-insn",
1987 opts->annotate_src ? "-S" : "",
1988 opts->prefix ? "--prefix " : "",
1989 opts->prefix ? '"' : ' ',
1990 opts->prefix ?: "",
1991 opts->prefix ? '"' : ' ',
1992 opts->prefix_strip ? "--prefix-strip=" : "",
1993 opts->prefix_strip ?: "");
1994
1995 if (err < 0) {
1996 pr_err("Failure allocating memory for the command to run\n");
1997 goto out_remove_tmp;
1998 }
1999
2000 pr_debug("Executing: %s\n", command);
2001
2002 objdump_argv[2] = command;
2003 objdump_argv[4] = symfs_filename;
2004
2005 /* Create a pipe to read from for stdout */
2006 memset(&objdump_process, 0, sizeof(objdump_process));
2007 objdump_process.argv = objdump_argv;
2008 objdump_process.out = -1;
2009 if (start_command(&objdump_process)) {
2010 pr_err("Failure starting to run %s\n", command);
2011 err = -1;
2012 goto out_free_command;
2013 }
2014
2015 file = fdopen(objdump_process.out, "r");
2016 if (!file) {
2017 pr_err("Failure creating FILE stream for %s\n", command);
2018 /*
2019 * If we were using debug info should retry with
2020 * original binary.
2021 */
2022 err = -1;
2023 goto out_close_stdout;
2024 }
2025
2026 /* Storage for getline. */
2027 line = NULL;
2028 line_len = 0;
2029
2030 nline = 0;
2031 while (!feof(file)) {
2032 const char *match;
2033 char *expanded_line;
2034
2035 if (getline(&line, &line_len, file) < 0 || !line)
2036 break;
2037
2038 /* Skip lines containing "filename:" */
2039 match = strstr(line, symfs_filename);
2040 if (match && match[strlen(symfs_filename)] == ':')
2041 continue;
2042
2043 expanded_line = strim(line);
2044 expanded_line = expand_tabs(expanded_line, &line, &line_len);
2045 if (!expanded_line)
2046 break;
2047
2048 /*
2049 * The source code line number (lineno) needs to be kept in
2050 * across calls to symbol__parse_objdump_line(), so that it
2051 * can associate it with the instructions till the next one.
2052 * See disasm_line__new() and struct disasm_line::line_nr.
2053 */
2054 if (symbol__parse_objdump_line(sym, args, expanded_line,
2055 &lineno) < 0)
2056 break;
2057 nline++;
2058 }
2059 free(line);
2060
2061 err = finish_command(&objdump_process);
2062 if (err)
2063 pr_err("Error running %s\n", command);
2064
2065 if (nline == 0) {
2066 err = -1;
2067 pr_err("No output from %s\n", command);
2068 }
2069
2070 /*
2071 * kallsyms does not have symbol sizes so there may a nop at the end.
2072 * Remove it.
2073 */
2074 if (dso__is_kcore(dso))
2075 delete_last_nop(sym);
2076
2077 fclose(file);
2078
2079 out_close_stdout:
2080 close(objdump_process.out);
2081
2082 out_free_command:
2083 free(command);
2084
2085 out_remove_tmp:
2086 if (decomp)
2087 unlink(symfs_filename);
2088
2089 if (delete_extract)
2090 kcore_extract__delete(&kce);
2091
2092 return err;
2093 }
2094
2095 static void calc_percent(struct sym_hist *sym_hist,
2096 struct hists *hists,
2097 struct annotation_data *data,
2098 s64 offset, s64 end)
2099 {
2100 unsigned int hits = 0;
2101 u64 period = 0;
2102
2103 while (offset < end) {
2104 hits += sym_hist->addr[offset].nr_samples;
2105 period += sym_hist->addr[offset].period;
2106 ++offset;
2107 }
2108
2109 if (sym_hist->nr_samples) {
2110 data->he.period = period;
2111 data->he.nr_samples = hits;
2112 data->percent[PERCENT_HITS_LOCAL] = 100.0 * hits / sym_hist->nr_samples;
2113 }
2114
2115 if (hists->stats.nr_non_filtered_samples)
2116 data->percent[PERCENT_HITS_GLOBAL] = 100.0 * hits / hists->stats.nr_non_filtered_samples;
2117
2118 if (sym_hist->period)
2119 data->percent[PERCENT_PERIOD_LOCAL] = 100.0 * period / sym_hist->period;
2120
2121 if (hists->stats.total_period)
2122 data->percent[PERCENT_PERIOD_GLOBAL] = 100.0 * period / hists->stats.total_period;
2123 }
2124
2125 static void annotation__calc_percent(struct annotation *notes,
2126 struct evsel *leader, s64 len)
2127 {
2128 struct annotation_line *al, *next;
2129 struct evsel *evsel;
2130
2131 list_for_each_entry(al, &notes->src->source, node) {
2132 s64 end;
2133 int i = 0;
2134
2135 if (al->offset == -1)
2136 continue;
2137
2138 next = annotation_line__next(al, &notes->src->source);
2139 end = next ? next->offset : len;
2140
2141 for_each_group_evsel(evsel, leader) {
2142 struct hists *hists = evsel__hists(evsel);
2143 struct annotation_data *data;
2144 struct sym_hist *sym_hist;
2145
2146 BUG_ON(i >= al->data_nr);
2147
2148 sym_hist = annotation__histogram(notes, evsel->idx);
2149 data = &al->data[i++];
2150
2151 calc_percent(sym_hist, hists, data, al->offset, end);
2152 }
2153 }
2154 }
2155
2156 void symbol__calc_percent(struct symbol *sym, struct evsel *evsel)
2157 {
2158 struct annotation *notes = symbol__annotation(sym);
2159
2160 annotation__calc_percent(notes, evsel, symbol__size(sym));
2161 }
2162
2163 int symbol__annotate(struct map_symbol *ms, struct evsel *evsel,
2164 struct annotation_options *options, struct arch **parch)
2165 {
2166 struct symbol *sym = ms->sym;
2167 struct annotation *notes = symbol__annotation(sym);
2168 struct annotate_args args = {
2169 .evsel = evsel,
2170 .options = options,
2171 };
2172 struct perf_env *env = evsel__env(evsel);
2173 const char *arch_name = perf_env__arch(env);
2174 struct arch *arch;
2175 int err;
2176
2177 if (!arch_name)
2178 return errno;
2179
2180 args.arch = arch = arch__find(arch_name);
2181 if (arch == NULL)
2182 return ENOTSUP;
2183
2184 if (parch)
2185 *parch = arch;
2186
2187 if (arch->init) {
2188 err = arch->init(arch, env ? env->cpuid : NULL);
2189 if (err) {
2190 pr_err("%s: failed to initialize %s arch priv area\n", __func__, arch->name);
2191 return err;
2192 }
2193 }
2194
2195 args.ms = *ms;
2196 notes->start = map__rip_2objdump(ms->map, sym->start);
2197
2198 return symbol__disassemble(sym, &args);
2199 }
2200
2201 static void insert_source_line(struct rb_root *root, struct annotation_line *al,
2202 struct annotation_options *opts)
2203 {
2204 struct annotation_line *iter;
2205 struct rb_node **p = &root->rb_node;
2206 struct rb_node *parent = NULL;
2207 int i, ret;
2208
2209 while (*p != NULL) {
2210 parent = *p;
2211 iter = rb_entry(parent, struct annotation_line, rb_node);
2212
2213 ret = strcmp(iter->path, al->path);
2214 if (ret == 0) {
2215 for (i = 0; i < al->data_nr; i++) {
2216 iter->data[i].percent_sum += annotation_data__percent(&al->data[i],
2217 opts->percent_type);
2218 }
2219 return;
2220 }
2221
2222 if (ret < 0)
2223 p = &(*p)->rb_left;
2224 else
2225 p = &(*p)->rb_right;
2226 }
2227
2228 for (i = 0; i < al->data_nr; i++) {
2229 al->data[i].percent_sum = annotation_data__percent(&al->data[i],
2230 opts->percent_type);
2231 }
2232
2233 rb_link_node(&al->rb_node, parent, p);
2234 rb_insert_color(&al->rb_node, root);
2235 }
2236
2237 static int cmp_source_line(struct annotation_line *a, struct annotation_line *b)
2238 {
2239 int i;
2240
2241 for (i = 0; i < a->data_nr; i++) {
2242 if (a->data[i].percent_sum == b->data[i].percent_sum)
2243 continue;
2244 return a->data[i].percent_sum > b->data[i].percent_sum;
2245 }
2246
2247 return 0;
2248 }
2249
2250 static void __resort_source_line(struct rb_root *root, struct annotation_line *al)
2251 {
2252 struct annotation_line *iter;
2253 struct rb_node **p = &root->rb_node;
2254 struct rb_node *parent = NULL;
2255
2256 while (*p != NULL) {
2257 parent = *p;
2258 iter = rb_entry(parent, struct annotation_line, rb_node);
2259
2260 if (cmp_source_line(al, iter))
2261 p = &(*p)->rb_left;
2262 else
2263 p = &(*p)->rb_right;
2264 }
2265
2266 rb_link_node(&al->rb_node, parent, p);
2267 rb_insert_color(&al->rb_node, root);
2268 }
2269
2270 static void resort_source_line(struct rb_root *dest_root, struct rb_root *src_root)
2271 {
2272 struct annotation_line *al;
2273 struct rb_node *node;
2274
2275 node = rb_first(src_root);
2276 while (node) {
2277 struct rb_node *next;
2278
2279 al = rb_entry(node, struct annotation_line, rb_node);
2280 next = rb_next(node);
2281 rb_erase(node, src_root);
2282
2283 __resort_source_line(dest_root, al);
2284 node = next;
2285 }
2286 }
2287
2288 static void print_summary(struct rb_root *root, const char *filename)
2289 {
2290 struct annotation_line *al;
2291 struct rb_node *node;
2292
2293 printf("\nSorted summary for file %s\n", filename);
2294 printf("----------------------------------------------\n\n");
2295
2296 if (RB_EMPTY_ROOT(root)) {
2297 printf(" Nothing higher than %1.1f%%\n", MIN_GREEN);
2298 return;
2299 }
2300
2301 node = rb_first(root);
2302 while (node) {
2303 double percent, percent_max = 0.0;
2304 const char *color;
2305 char *path;
2306 int i;
2307
2308 al = rb_entry(node, struct annotation_line, rb_node);
2309 for (i = 0; i < al->data_nr; i++) {
2310 percent = al->data[i].percent_sum;
2311 color = get_percent_color(percent);
2312 color_fprintf(stdout, color, " %7.2f", percent);
2313
2314 if (percent > percent_max)
2315 percent_max = percent;
2316 }
2317
2318 path = al->path;
2319 color = get_percent_color(percent_max);
2320 color_fprintf(stdout, color, " %s\n", path);
2321
2322 node = rb_next(node);
2323 }
2324 }
2325
2326 static void symbol__annotate_hits(struct symbol *sym, struct evsel *evsel)
2327 {
2328 struct annotation *notes = symbol__annotation(sym);
2329 struct sym_hist *h = annotation__histogram(notes, evsel->idx);
2330 u64 len = symbol__size(sym), offset;
2331
2332 for (offset = 0; offset < len; ++offset)
2333 if (h->addr[offset].nr_samples != 0)
2334 printf("%*" PRIx64 ": %" PRIu64 "\n", BITS_PER_LONG / 2,
2335 sym->start + offset, h->addr[offset].nr_samples);
2336 printf("%*s: %" PRIu64 "\n", BITS_PER_LONG / 2, "h->nr_samples", h->nr_samples);
2337 }
2338
2339 static int annotated_source__addr_fmt_width(struct list_head *lines, u64 start)
2340 {
2341 char bf[32];
2342 struct annotation_line *line;
2343
2344 list_for_each_entry_reverse(line, lines, node) {
2345 if (line->offset != -1)
2346 return scnprintf(bf, sizeof(bf), "%" PRIx64, start + line->offset);
2347 }
2348
2349 return 0;
2350 }
2351
2352 int symbol__annotate_printf(struct map_symbol *ms, struct evsel *evsel,
2353 struct annotation_options *opts)
2354 {
2355 struct map *map = ms->map;
2356 struct symbol *sym = ms->sym;
2357 struct dso *dso = map->dso;
2358 char *filename;
2359 const char *d_filename;
2360 const char *evsel_name = evsel__name(evsel);
2361 struct annotation *notes = symbol__annotation(sym);
2362 struct sym_hist *h = annotation__histogram(notes, evsel->idx);
2363 struct annotation_line *pos, *queue = NULL;
2364 u64 start = map__rip_2objdump(map, sym->start);
2365 int printed = 2, queue_len = 0, addr_fmt_width;
2366 int more = 0;
2367 bool context = opts->context;
2368 u64 len;
2369 int width = symbol_conf.show_total_period ? 12 : 8;
2370 int graph_dotted_len;
2371 char buf[512];
2372
2373 filename = strdup(dso->long_name);
2374 if (!filename)
2375 return -ENOMEM;
2376
2377 if (opts->full_path)
2378 d_filename = filename;
2379 else
2380 d_filename = basename(filename);
2381
2382 len = symbol__size(sym);
2383
2384 if (evsel__is_group_event(evsel)) {
2385 width *= evsel->core.nr_members;
2386 evsel__group_desc(evsel, buf, sizeof(buf));
2387 evsel_name = buf;
2388 }
2389
2390 graph_dotted_len = printf(" %-*.*s| Source code & Disassembly of %s for %s (%" PRIu64 " samples, "
2391 "percent: %s)\n",
2392 width, width, symbol_conf.show_total_period ? "Period" :
2393 symbol_conf.show_nr_samples ? "Samples" : "Percent",
2394 d_filename, evsel_name, h->nr_samples,
2395 percent_type_str(opts->percent_type));
2396
2397 printf("%-*.*s----\n",
2398 graph_dotted_len, graph_dotted_len, graph_dotted_line);
2399
2400 if (verbose > 0)
2401 symbol__annotate_hits(sym, evsel);
2402
2403 addr_fmt_width = annotated_source__addr_fmt_width(&notes->src->source, start);
2404
2405 list_for_each_entry(pos, &notes->src->source, node) {
2406 int err;
2407
2408 if (context && queue == NULL) {
2409 queue = pos;
2410 queue_len = 0;
2411 }
2412
2413 err = annotation_line__print(pos, sym, start, evsel, len,
2414 opts->min_pcnt, printed, opts->max_lines,
2415 queue, addr_fmt_width, opts->percent_type);
2416
2417 switch (err) {
2418 case 0:
2419 ++printed;
2420 if (context) {
2421 printed += queue_len;
2422 queue = NULL;
2423 queue_len = 0;
2424 }
2425 break;
2426 case 1:
2427 /* filtered by max_lines */
2428 ++more;
2429 break;
2430 case -1:
2431 default:
2432 /*
2433 * Filtered by min_pcnt or non IP lines when
2434 * context != 0
2435 */
2436 if (!context)
2437 break;
2438 if (queue_len == context)
2439 queue = list_entry(queue->node.next, typeof(*queue), node);
2440 else
2441 ++queue_len;
2442 break;
2443 }
2444 }
2445
2446 free(filename);
2447
2448 return more;
2449 }
2450
2451 static void FILE__set_percent_color(void *fp __maybe_unused,
2452 double percent __maybe_unused,
2453 bool current __maybe_unused)
2454 {
2455 }
2456
2457 static int FILE__set_jumps_percent_color(void *fp __maybe_unused,
2458 int nr __maybe_unused, bool current __maybe_unused)
2459 {
2460 return 0;
2461 }
2462
2463 static int FILE__set_color(void *fp __maybe_unused, int color __maybe_unused)
2464 {
2465 return 0;
2466 }
2467
2468 static void FILE__printf(void *fp, const char *fmt, ...)
2469 {
2470 va_list args;
2471
2472 va_start(args, fmt);
2473 vfprintf(fp, fmt, args);
2474 va_end(args);
2475 }
2476
2477 static void FILE__write_graph(void *fp, int graph)
2478 {
2479 const char *s;
2480 switch (graph) {
2481
2482 case DARROW_CHAR: s = "↓"; break;
2483 case UARROW_CHAR: s = "↑"; break;
2484 case LARROW_CHAR: s = "←"; break;
2485 case RARROW_CHAR: s = "→"; break;
2486 default: s = "?"; break;
2487 }
2488
2489 fputs(s, fp);
2490 }
2491
2492 static int symbol__annotate_fprintf2(struct symbol *sym, FILE *fp,
2493 struct annotation_options *opts)
2494 {
2495 struct annotation *notes = symbol__annotation(sym);
2496 struct annotation_write_ops wops = {
2497 .first_line = true,
2498 .obj = fp,
2499 .set_color = FILE__set_color,
2500 .set_percent_color = FILE__set_percent_color,
2501 .set_jumps_percent_color = FILE__set_jumps_percent_color,
2502 .printf = FILE__printf,
2503 .write_graph = FILE__write_graph,
2504 };
2505 struct annotation_line *al;
2506
2507 list_for_each_entry(al, &notes->src->source, node) {
2508 if (annotation_line__filter(al, notes))
2509 continue;
2510 annotation_line__write(al, notes, &wops, opts);
2511 fputc('\n', fp);
2512 wops.first_line = false;
2513 }
2514
2515 return 0;
2516 }
2517
2518 int map_symbol__annotation_dump(struct map_symbol *ms, struct evsel *evsel,
2519 struct annotation_options *opts)
2520 {
2521 const char *ev_name = evsel__name(evsel);
2522 char buf[1024];
2523 char *filename;
2524 int err = -1;
2525 FILE *fp;
2526
2527 if (asprintf(&filename, "%s.annotation", ms->sym->name) < 0)
2528 return -1;
2529
2530 fp = fopen(filename, "w");
2531 if (fp == NULL)
2532 goto out_free_filename;
2533
2534 if (evsel__is_group_event(evsel)) {
2535 evsel__group_desc(evsel, buf, sizeof(buf));
2536 ev_name = buf;
2537 }
2538
2539 fprintf(fp, "%s() %s\nEvent: %s\n\n",
2540 ms->sym->name, ms->map->dso->long_name, ev_name);
2541 symbol__annotate_fprintf2(ms->sym, fp, opts);
2542
2543 fclose(fp);
2544 err = 0;
2545 out_free_filename:
2546 free(filename);
2547 return err;
2548 }
2549
2550 void symbol__annotate_zero_histogram(struct symbol *sym, int evidx)
2551 {
2552 struct annotation *notes = symbol__annotation(sym);
2553 struct sym_hist *h = annotation__histogram(notes, evidx);
2554
2555 memset(h, 0, notes->src->sizeof_sym_hist);
2556 }
2557
2558 void symbol__annotate_decay_histogram(struct symbol *sym, int evidx)
2559 {
2560 struct annotation *notes = symbol__annotation(sym);
2561 struct sym_hist *h = annotation__histogram(notes, evidx);
2562 int len = symbol__size(sym), offset;
2563
2564 h->nr_samples = 0;
2565 for (offset = 0; offset < len; ++offset) {
2566 h->addr[offset].nr_samples = h->addr[offset].nr_samples * 7 / 8;
2567 h->nr_samples += h->addr[offset].nr_samples;
2568 }
2569 }
2570
2571 void annotated_source__purge(struct annotated_source *as)
2572 {
2573 struct annotation_line *al, *n;
2574
2575 list_for_each_entry_safe(al, n, &as->source, node) {
2576 list_del_init(&al->node);
2577 disasm_line__free(disasm_line(al));
2578 }
2579 }
2580
2581 static size_t disasm_line__fprintf(struct disasm_line *dl, FILE *fp)
2582 {
2583 size_t printed;
2584
2585 if (dl->al.offset == -1)
2586 return fprintf(fp, "%s\n", dl->al.line);
2587
2588 printed = fprintf(fp, "%#" PRIx64 " %s", dl->al.offset, dl->ins.name);
2589
2590 if (dl->ops.raw[0] != '\0') {
2591 printed += fprintf(fp, "%.*s %s\n", 6 - (int)printed, " ",
2592 dl->ops.raw);
2593 }
2594
2595 return printed + fprintf(fp, "\n");
2596 }
2597
2598 size_t disasm__fprintf(struct list_head *head, FILE *fp)
2599 {
2600 struct disasm_line *pos;
2601 size_t printed = 0;
2602
2603 list_for_each_entry(pos, head, al.node)
2604 printed += disasm_line__fprintf(pos, fp);
2605
2606 return printed;
2607 }
2608
2609 bool disasm_line__is_valid_local_jump(struct disasm_line *dl, struct symbol *sym)
2610 {
2611 if (!dl || !dl->ins.ops || !ins__is_jump(&dl->ins) ||
2612 !disasm_line__has_local_offset(dl) || dl->ops.target.offset < 0 ||
2613 dl->ops.target.offset >= (s64)symbol__size(sym))
2614 return false;
2615
2616 return true;
2617 }
2618
2619 void annotation__mark_jump_targets(struct annotation *notes, struct symbol *sym)
2620 {
2621 u64 offset, size = symbol__size(sym);
2622
2623 /* PLT symbols contain external offsets */
2624 if (strstr(sym->name, "@plt"))
2625 return;
2626
2627 for (offset = 0; offset < size; ++offset) {
2628 struct annotation_line *al = notes->offsets[offset];
2629 struct disasm_line *dl;
2630
2631 dl = disasm_line(al);
2632
2633 if (!disasm_line__is_valid_local_jump(dl, sym))
2634 continue;
2635
2636 al = notes->offsets[dl->ops.target.offset];
2637
2638 /*
2639 * FIXME: Oops, no jump target? Buggy disassembler? Or do we
2640 * have to adjust to the previous offset?
2641 */
2642 if (al == NULL)
2643 continue;
2644
2645 if (++al->jump_sources > notes->max_jump_sources)
2646 notes->max_jump_sources = al->jump_sources;
2647 }
2648 }
2649
2650 void annotation__set_offsets(struct annotation *notes, s64 size)
2651 {
2652 struct annotation_line *al;
2653
2654 notes->max_line_len = 0;
2655 notes->nr_entries = 0;
2656 notes->nr_asm_entries = 0;
2657
2658 list_for_each_entry(al, &notes->src->source, node) {
2659 size_t line_len = strlen(al->line);
2660
2661 if (notes->max_line_len < line_len)
2662 notes->max_line_len = line_len;
2663 al->idx = notes->nr_entries++;
2664 if (al->offset != -1) {
2665 al->idx_asm = notes->nr_asm_entries++;
2666 /*
2667 * FIXME: short term bandaid to cope with assembly
2668 * routines that comes with labels in the same column
2669 * as the address in objdump, sigh.
2670 *
2671 * E.g. copy_user_generic_unrolled
2672 */
2673 if (al->offset < size)
2674 notes->offsets[al->offset] = al;
2675 } else
2676 al->idx_asm = -1;
2677 }
2678 }
2679
2680 static inline int width_jumps(int n)
2681 {
2682 if (n >= 100)
2683 return 5;
2684 if (n / 10)
2685 return 2;
2686 return 1;
2687 }
2688
2689 static int annotation__max_ins_name(struct annotation *notes)
2690 {
2691 int max_name = 0, len;
2692 struct annotation_line *al;
2693
2694 list_for_each_entry(al, &notes->src->source, node) {
2695 if (al->offset == -1)
2696 continue;
2697
2698 len = strlen(disasm_line(al)->ins.name);
2699 if (max_name < len)
2700 max_name = len;
2701 }
2702
2703 return max_name;
2704 }
2705
2706 void annotation__init_column_widths(struct annotation *notes, struct symbol *sym)
2707 {
2708 notes->widths.addr = notes->widths.target =
2709 notes->widths.min_addr = hex_width(symbol__size(sym));
2710 notes->widths.max_addr = hex_width(sym->end);
2711 notes->widths.jumps = width_jumps(notes->max_jump_sources);
2712 notes->widths.max_ins_name = annotation__max_ins_name(notes);
2713 }
2714
2715 void annotation__update_column_widths(struct annotation *notes)
2716 {
2717 if (notes->options->use_offset)
2718 notes->widths.target = notes->widths.min_addr;
2719 else
2720 notes->widths.target = notes->widths.max_addr;
2721
2722 notes->widths.addr = notes->widths.target;
2723
2724 if (notes->options->show_nr_jumps)
2725 notes->widths.addr += notes->widths.jumps + 1;
2726 }
2727
2728 static void annotation__calc_lines(struct annotation *notes, struct map *map,
2729 struct rb_root *root,
2730 struct annotation_options *opts)
2731 {
2732 struct annotation_line *al;
2733 struct rb_root tmp_root = RB_ROOT;
2734
2735 list_for_each_entry(al, &notes->src->source, node) {
2736 double percent_max = 0.0;
2737 int i;
2738
2739 for (i = 0; i < al->data_nr; i++) {
2740 double percent;
2741
2742 percent = annotation_data__percent(&al->data[i],
2743 opts->percent_type);
2744
2745 if (percent > percent_max)
2746 percent_max = percent;
2747 }
2748
2749 if (percent_max <= 0.5)
2750 continue;
2751
2752 al->path = get_srcline(map->dso, notes->start + al->offset, NULL,
2753 false, true, notes->start + al->offset);
2754 insert_source_line(&tmp_root, al, opts);
2755 }
2756
2757 resort_source_line(root, &tmp_root);
2758 }
2759
2760 static void symbol__calc_lines(struct map_symbol *ms, struct rb_root *root,
2761 struct annotation_options *opts)
2762 {
2763 struct annotation *notes = symbol__annotation(ms->sym);
2764
2765 annotation__calc_lines(notes, ms->map, root, opts);
2766 }
2767
2768 int symbol__tty_annotate2(struct map_symbol *ms, struct evsel *evsel,
2769 struct annotation_options *opts)
2770 {
2771 struct dso *dso = ms->map->dso;
2772 struct symbol *sym = ms->sym;
2773 struct rb_root source_line = RB_ROOT;
2774 struct hists *hists = evsel__hists(evsel);
2775 char buf[1024];
2776
2777 if (symbol__annotate2(ms, evsel, opts, NULL) < 0)
2778 return -1;
2779
2780 if (opts->print_lines) {
2781 srcline_full_filename = opts->full_path;
2782 symbol__calc_lines(ms, &source_line, opts);
2783 print_summary(&source_line, dso->long_name);
2784 }
2785
2786 hists__scnprintf_title(hists, buf, sizeof(buf));
2787 fprintf(stdout, "%s, [percent: %s]\n%s() %s\n",
2788 buf, percent_type_str(opts->percent_type), sym->name, dso->long_name);
2789 symbol__annotate_fprintf2(sym, stdout, opts);
2790
2791 annotated_source__purge(symbol__annotation(sym)->src);
2792
2793 return 0;
2794 }
2795
2796 int symbol__tty_annotate(struct map_symbol *ms, struct evsel *evsel,
2797 struct annotation_options *opts)
2798 {
2799 struct dso *dso = ms->map->dso;
2800 struct symbol *sym = ms->sym;
2801 struct rb_root source_line = RB_ROOT;
2802
2803 if (symbol__annotate(ms, evsel, opts, NULL) < 0)
2804 return -1;
2805
2806 symbol__calc_percent(sym, evsel);
2807
2808 if (opts->print_lines) {
2809 srcline_full_filename = opts->full_path;
2810 symbol__calc_lines(ms, &source_line, opts);
2811 print_summary(&source_line, dso->long_name);
2812 }
2813
2814 symbol__annotate_printf(ms, evsel, opts);
2815
2816 annotated_source__purge(symbol__annotation(sym)->src);
2817
2818 return 0;
2819 }
2820
2821 bool ui__has_annotation(void)
2822 {
2823 return use_browser == 1 && perf_hpp_list.sym;
2824 }
2825
2826
2827 static double annotation_line__max_percent(struct annotation_line *al,
2828 struct annotation *notes,
2829 unsigned int percent_type)
2830 {
2831 double percent_max = 0.0;
2832 int i;
2833
2834 for (i = 0; i < notes->nr_events; i++) {
2835 double percent;
2836
2837 percent = annotation_data__percent(&al->data[i],
2838 percent_type);
2839
2840 if (percent > percent_max)
2841 percent_max = percent;
2842 }
2843
2844 return percent_max;
2845 }
2846
2847 static void disasm_line__write(struct disasm_line *dl, struct annotation *notes,
2848 void *obj, char *bf, size_t size,
2849 void (*obj__printf)(void *obj, const char *fmt, ...),
2850 void (*obj__write_graph)(void *obj, int graph))
2851 {
2852 if (dl->ins.ops && dl->ins.ops->scnprintf) {
2853 if (ins__is_jump(&dl->ins)) {
2854 bool fwd;
2855
2856 if (dl->ops.target.outside)
2857 goto call_like;
2858 fwd = dl->ops.target.offset > dl->al.offset;
2859 obj__write_graph(obj, fwd ? DARROW_CHAR : UARROW_CHAR);
2860 obj__printf(obj, " ");
2861 } else if (ins__is_call(&dl->ins)) {
2862 call_like:
2863 obj__write_graph(obj, RARROW_CHAR);
2864 obj__printf(obj, " ");
2865 } else if (ins__is_ret(&dl->ins)) {
2866 obj__write_graph(obj, LARROW_CHAR);
2867 obj__printf(obj, " ");
2868 } else {
2869 obj__printf(obj, " ");
2870 }
2871 } else {
2872 obj__printf(obj, " ");
2873 }
2874
2875 disasm_line__scnprintf(dl, bf, size, !notes->options->use_offset, notes->widths.max_ins_name);
2876 }
2877
2878 static void ipc_coverage_string(char *bf, int size, struct annotation *notes)
2879 {
2880 double ipc = 0.0, coverage = 0.0;
2881
2882 if (notes->hit_cycles)
2883 ipc = notes->hit_insn / ((double)notes->hit_cycles);
2884
2885 if (notes->total_insn) {
2886 coverage = notes->cover_insn * 100.0 /
2887 ((double)notes->total_insn);
2888 }
2889
2890 scnprintf(bf, size, "(Average IPC: %.2f, IPC Coverage: %.1f%%)",
2891 ipc, coverage);
2892 }
2893
2894 static void __annotation_line__write(struct annotation_line *al, struct annotation *notes,
2895 bool first_line, bool current_entry, bool change_color, int width,
2896 void *obj, unsigned int percent_type,
2897 int (*obj__set_color)(void *obj, int color),
2898 void (*obj__set_percent_color)(void *obj, double percent, bool current),
2899 int (*obj__set_jumps_percent_color)(void *obj, int nr, bool current),
2900 void (*obj__printf)(void *obj, const char *fmt, ...),
2901 void (*obj__write_graph)(void *obj, int graph))
2902
2903 {
2904 double percent_max = annotation_line__max_percent(al, notes, percent_type);
2905 int pcnt_width = annotation__pcnt_width(notes),
2906 cycles_width = annotation__cycles_width(notes);
2907 bool show_title = false;
2908 char bf[256];
2909 int printed;
2910
2911 if (first_line && (al->offset == -1 || percent_max == 0.0)) {
2912 if (notes->have_cycles) {
2913 if (al->ipc == 0.0 && al->cycles == 0)
2914 show_title = true;
2915 } else
2916 show_title = true;
2917 }
2918
2919 if (al->offset != -1 && percent_max != 0.0) {
2920 int i;
2921
2922 for (i = 0; i < notes->nr_events; i++) {
2923 double percent;
2924
2925 percent = annotation_data__percent(&al->data[i], percent_type);
2926
2927 obj__set_percent_color(obj, percent, current_entry);
2928 if (symbol_conf.show_total_period) {
2929 obj__printf(obj, "%11" PRIu64 " ", al->data[i].he.period);
2930 } else if (symbol_conf.show_nr_samples) {
2931 obj__printf(obj, "%6" PRIu64 " ",
2932 al->data[i].he.nr_samples);
2933 } else {
2934 obj__printf(obj, "%6.2f ", percent);
2935 }
2936 }
2937 } else {
2938 obj__set_percent_color(obj, 0, current_entry);
2939
2940 if (!show_title)
2941 obj__printf(obj, "%-*s", pcnt_width, " ");
2942 else {
2943 obj__printf(obj, "%-*s", pcnt_width,
2944 symbol_conf.show_total_period ? "Period" :
2945 symbol_conf.show_nr_samples ? "Samples" : "Percent");
2946 }
2947 }
2948
2949 if (notes->have_cycles) {
2950 if (al->ipc)
2951 obj__printf(obj, "%*.2f ", ANNOTATION__IPC_WIDTH - 1, al->ipc);
2952 else if (!show_title)
2953 obj__printf(obj, "%*s", ANNOTATION__IPC_WIDTH, " ");
2954 else
2955 obj__printf(obj, "%*s ", ANNOTATION__IPC_WIDTH - 1, "IPC");
2956
2957 if (!notes->options->show_minmax_cycle) {
2958 if (al->cycles)
2959 obj__printf(obj, "%*" PRIu64 " ",
2960 ANNOTATION__CYCLES_WIDTH - 1, al->cycles);
2961 else if (!show_title)
2962 obj__printf(obj, "%*s",
2963 ANNOTATION__CYCLES_WIDTH, " ");
2964 else
2965 obj__printf(obj, "%*s ",
2966 ANNOTATION__CYCLES_WIDTH - 1,
2967 "Cycle");
2968 } else {
2969 if (al->cycles) {
2970 char str[32];
2971
2972 scnprintf(str, sizeof(str),
2973 "%" PRIu64 "(%" PRIu64 "/%" PRIu64 ")",
2974 al->cycles, al->cycles_min,
2975 al->cycles_max);
2976
2977 obj__printf(obj, "%*s ",
2978 ANNOTATION__MINMAX_CYCLES_WIDTH - 1,
2979 str);
2980 } else if (!show_title)
2981 obj__printf(obj, "%*s",
2982 ANNOTATION__MINMAX_CYCLES_WIDTH,
2983 " ");
2984 else
2985 obj__printf(obj, "%*s ",
2986 ANNOTATION__MINMAX_CYCLES_WIDTH - 1,
2987 "Cycle(min/max)");
2988 }
2989
2990 if (show_title && !*al->line) {
2991 ipc_coverage_string(bf, sizeof(bf), notes);
2992 obj__printf(obj, "%*s", ANNOTATION__AVG_IPC_WIDTH, bf);
2993 }
2994 }
2995
2996 obj__printf(obj, " ");
2997
2998 if (!*al->line)
2999 obj__printf(obj, "%-*s", width - pcnt_width - cycles_width, " ");
3000 else if (al->offset == -1) {
3001 if (al->line_nr && notes->options->show_linenr)
3002 printed = scnprintf(bf, sizeof(bf), "%-*d ", notes->widths.addr + 1, al->line_nr);
3003 else
3004 printed = scnprintf(bf, sizeof(bf), "%-*s ", notes->widths.addr, " ");
3005 obj__printf(obj, bf);
3006 obj__printf(obj, "%-*s", width - printed - pcnt_width - cycles_width + 1, al->line);
3007 } else {
3008 u64 addr = al->offset;
3009 int color = -1;
3010
3011 if (!notes->options->use_offset)
3012 addr += notes->start;
3013
3014 if (!notes->options->use_offset) {
3015 printed = scnprintf(bf, sizeof(bf), "%" PRIx64 ": ", addr);
3016 } else {
3017 if (al->jump_sources &&
3018 notes->options->offset_level >= ANNOTATION__OFFSET_JUMP_TARGETS) {
3019 if (notes->options->show_nr_jumps) {
3020 int prev;
3021 printed = scnprintf(bf, sizeof(bf), "%*d ",
3022 notes->widths.jumps,
3023 al->jump_sources);
3024 prev = obj__set_jumps_percent_color(obj, al->jump_sources,
3025 current_entry);
3026 obj__printf(obj, bf);
3027 obj__set_color(obj, prev);
3028 }
3029 print_addr:
3030 printed = scnprintf(bf, sizeof(bf), "%*" PRIx64 ": ",
3031 notes->widths.target, addr);
3032 } else if (ins__is_call(&disasm_line(al)->ins) &&
3033 notes->options->offset_level >= ANNOTATION__OFFSET_CALL) {
3034 goto print_addr;
3035 } else if (notes->options->offset_level == ANNOTATION__MAX_OFFSET_LEVEL) {
3036 goto print_addr;
3037 } else {
3038 printed = scnprintf(bf, sizeof(bf), "%-*s ",
3039 notes->widths.addr, " ");
3040 }
3041 }
3042
3043 if (change_color)
3044 color = obj__set_color(obj, HE_COLORSET_ADDR);
3045 obj__printf(obj, bf);
3046 if (change_color)
3047 obj__set_color(obj, color);
3048
3049 disasm_line__write(disasm_line(al), notes, obj, bf, sizeof(bf), obj__printf, obj__write_graph);
3050
3051 obj__printf(obj, "%-*s", width - pcnt_width - cycles_width - 3 - printed, bf);
3052 }
3053
3054 }
3055
3056 void annotation_line__write(struct annotation_line *al, struct annotation *notes,
3057 struct annotation_write_ops *wops,
3058 struct annotation_options *opts)
3059 {
3060 __annotation_line__write(al, notes, wops->first_line, wops->current_entry,
3061 wops->change_color, wops->width, wops->obj,
3062 opts->percent_type,
3063 wops->set_color, wops->set_percent_color,
3064 wops->set_jumps_percent_color, wops->printf,
3065 wops->write_graph);
3066 }
3067
3068 int symbol__annotate2(struct map_symbol *ms, struct evsel *evsel,
3069 struct annotation_options *options, struct arch **parch)
3070 {
3071 struct symbol *sym = ms->sym;
3072 struct annotation *notes = symbol__annotation(sym);
3073 size_t size = symbol__size(sym);
3074 int nr_pcnt = 1, err;
3075
3076 notes->offsets = zalloc(size * sizeof(struct annotation_line *));
3077 if (notes->offsets == NULL)
3078 return ENOMEM;
3079
3080 if (evsel__is_group_event(evsel))
3081 nr_pcnt = evsel->core.nr_members;
3082
3083 err = symbol__annotate(ms, evsel, options, parch);
3084 if (err)
3085 goto out_free_offsets;
3086
3087 notes->options = options;
3088
3089 symbol__calc_percent(sym, evsel);
3090
3091 annotation__set_offsets(notes, size);
3092 annotation__mark_jump_targets(notes, sym);
3093 annotation__compute_ipc(notes, size);
3094 annotation__init_column_widths(notes, sym);
3095 notes->nr_events = nr_pcnt;
3096
3097 annotation__update_column_widths(notes);
3098 sym->annotate2 = true;
3099
3100 return 0;
3101
3102 out_free_offsets:
3103 zfree(&notes->offsets);
3104 return err;
3105 }
3106
3107 static int annotation__config(const char *var, const char *value, void *data)
3108 {
3109 struct annotation_options *opt = data;
3110
3111 if (!strstarts(var, "annotate."))
3112 return 0;
3113
3114 if (!strcmp(var, "annotate.offset_level")) {
3115 perf_config_u8(&opt->offset_level, "offset_level", value);
3116
3117 if (opt->offset_level > ANNOTATION__MAX_OFFSET_LEVEL)
3118 opt->offset_level = ANNOTATION__MAX_OFFSET_LEVEL;
3119 else if (opt->offset_level < ANNOTATION__MIN_OFFSET_LEVEL)
3120 opt->offset_level = ANNOTATION__MIN_OFFSET_LEVEL;
3121 } else if (!strcmp(var, "annotate.hide_src_code")) {
3122 opt->hide_src_code = perf_config_bool("hide_src_code", value);
3123 } else if (!strcmp(var, "annotate.jump_arrows")) {
3124 opt->jump_arrows = perf_config_bool("jump_arrows", value);
3125 } else if (!strcmp(var, "annotate.show_linenr")) {
3126 opt->show_linenr = perf_config_bool("show_linenr", value);
3127 } else if (!strcmp(var, "annotate.show_nr_jumps")) {
3128 opt->show_nr_jumps = perf_config_bool("show_nr_jumps", value);
3129 } else if (!strcmp(var, "annotate.show_nr_samples")) {
3130 symbol_conf.show_nr_samples = perf_config_bool("show_nr_samples",
3131 value);
3132 } else if (!strcmp(var, "annotate.show_total_period")) {
3133 symbol_conf.show_total_period = perf_config_bool("show_total_period",
3134 value);
3135 } else if (!strcmp(var, "annotate.use_offset")) {
3136 opt->use_offset = perf_config_bool("use_offset", value);
3137 } else if (!strcmp(var, "annotate.disassembler_style")) {
3138 opt->disassembler_style = value;
3139 } else {
3140 pr_debug("%s variable unknown, ignoring...", var);
3141 }
3142
3143 return 0;
3144 }
3145
3146 void annotation_config__init(struct annotation_options *opt)
3147 {
3148 perf_config(annotation__config, opt);
3149 }
3150
3151 static unsigned int parse_percent_type(char *str1, char *str2)
3152 {
3153 unsigned int type = (unsigned int) -1;
3154
3155 if (!strcmp("period", str1)) {
3156 if (!strcmp("local", str2))
3157 type = PERCENT_PERIOD_LOCAL;
3158 else if (!strcmp("global", str2))
3159 type = PERCENT_PERIOD_GLOBAL;
3160 }
3161
3162 if (!strcmp("hits", str1)) {
3163 if (!strcmp("local", str2))
3164 type = PERCENT_HITS_LOCAL;
3165 else if (!strcmp("global", str2))
3166 type = PERCENT_HITS_GLOBAL;
3167 }
3168
3169 return type;
3170 }
3171
3172 int annotate_parse_percent_type(const struct option *opt, const char *_str,
3173 int unset __maybe_unused)
3174 {
3175 struct annotation_options *opts = opt->value;
3176 unsigned int type;
3177 char *str1, *str2;
3178 int err = -1;
3179
3180 str1 = strdup(_str);
3181 if (!str1)
3182 return -ENOMEM;
3183
3184 str2 = strchr(str1, '-');
3185 if (!str2)
3186 goto out;
3187
3188 *str2++ = 0;
3189
3190 type = parse_percent_type(str1, str2);
3191 if (type == (unsigned int) -1)
3192 type = parse_percent_type(str2, str1);
3193 if (type != (unsigned int) -1) {
3194 opts->percent_type = type;
3195 err = 0;
3196 }
3197
3198 out:
3199 free(str1);
3200 return err;
3201 }
3202
3203 int annotate_check_args(struct annotation_options *args)
3204 {
3205 if (args->prefix_strip && !args->prefix) {
3206 pr_err("--prefix-strip requires --prefix\n");
3207 return -1;
3208 }
3209 return 0;
3210 }
Linux with added FPC-III support