?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'trace-printf-v6.13' of git://git.kernel.org/pub/scm/linux/kernel/git/trace...
[drm/drm-misc.git] / tools / perf / util / disasm.c
blob41a2b08670dc5b0e78c889f78baf13243de57440
1 // SPDX-License-Identifier: GPL-2.0-only
2 #include <ctype.h>
3 #include <errno.h>
4 #include <fcntl.h>
5 #include <inttypes.h>
6 #include <libgen.h>
7 #include <regex.h>
8 #include <stdlib.h>
9 #include <unistd.h>
10
11 #include <linux/string.h>
12 #include <subcmd/run-command.h>
13
14 #include "annotate.h"
15 #include "annotate-data.h"
16 #include "build-id.h"
17 #include "debug.h"
18 #include "disasm.h"
19 #include "disasm_bpf.h"
20 #include "dso.h"
21 #include "dwarf-regs.h"
22 #include "env.h"
23 #include "evsel.h"
24 #include "map.h"
25 #include "maps.h"
26 #include "namespaces.h"
27 #include "srcline.h"
28 #include "symbol.h"
29 #include "util.h"
30
31 static regex_t file_lineno;
32
33 /* These can be referred from the arch-dependent code */
34 static struct ins_ops call_ops;
35 static struct ins_ops dec_ops;
36 static struct ins_ops jump_ops;
37 static struct ins_ops mov_ops;
38 static struct ins_ops nop_ops;
39 static struct ins_ops lock_ops;
40 static struct ins_ops ret_ops;
41 static struct ins_ops load_store_ops;
42 static struct ins_ops arithmetic_ops;
43
44 static int jump__scnprintf(struct ins *ins, char *bf, size_t size,
45 struct ins_operands *ops, int max_ins_name);
46 static int call__scnprintf(struct ins *ins, char *bf, size_t size,
47 struct ins_operands *ops, int max_ins_name);
48
49 static void ins__sort(struct arch *arch);
50 static int disasm_line__parse(char *line, const char **namep, char **rawp);
51 static int disasm_line__parse_powerpc(struct disasm_line *dl);
52 static char *expand_tabs(char *line, char **storage, size_t *storage_len);
53
54 static __attribute__((constructor)) void symbol__init_regexpr(void)
55 {
56 regcomp(&file_lineno, "^/[^:]+:([0-9]+)", REG_EXTENDED);
57 }
58
59 static int arch__grow_instructions(struct arch *arch)
60 {
61 struct ins *new_instructions;
62 size_t new_nr_allocated;
63
64 if (arch->nr_instructions_allocated == 0 && arch->instructions)
65 goto grow_from_non_allocated_table;
66
67 new_nr_allocated = arch->nr_instructions_allocated + 128;
68 new_instructions = realloc(arch->instructions, new_nr_allocated * sizeof(struct ins));
69 if (new_instructions == NULL)
70 return -1;
71
72 out_update_instructions:
73 arch->instructions = new_instructions;
74 arch->nr_instructions_allocated = new_nr_allocated;
75 return 0;
76
77 grow_from_non_allocated_table:
78 new_nr_allocated = arch->nr_instructions + 128;
79 new_instructions = calloc(new_nr_allocated, sizeof(struct ins));
80 if (new_instructions == NULL)
81 return -1;
82
83 memcpy(new_instructions, arch->instructions, arch->nr_instructions);
84 goto out_update_instructions;
85 }
86
87 static int arch__associate_ins_ops(struct arch* arch, const char *name, struct ins_ops *ops)
88 {
89 struct ins *ins;
90
91 if (arch->nr_instructions == arch->nr_instructions_allocated &&
92 arch__grow_instructions(arch))
93 return -1;
94
95 ins = &arch->instructions[arch->nr_instructions];
96 ins->name = strdup(name);
97 if (!ins->name)
98 return -1;
99
100 ins->ops = ops;
101 arch->nr_instructions++;
102
103 ins__sort(arch);
104 return 0;
105 }
106
107 #include "arch/arc/annotate/instructions.c"
108 #include "arch/arm/annotate/instructions.c"
109 #include "arch/arm64/annotate/instructions.c"
110 #include "arch/csky/annotate/instructions.c"
111 #include "arch/loongarch/annotate/instructions.c"
112 #include "arch/mips/annotate/instructions.c"
113 #include "arch/x86/annotate/instructions.c"
114 #include "arch/powerpc/annotate/instructions.c"
115 #include "arch/riscv64/annotate/instructions.c"
116 #include "arch/s390/annotate/instructions.c"
117 #include "arch/sparc/annotate/instructions.c"
118
119 static struct arch architectures[] = {
120 {
121 .name = "arc",
122 .init = arc__annotate_init,
123 },
124 {
125 .name = "arm",
126 .init = arm__annotate_init,
127 },
128 {
129 .name = "arm64",
130 .init = arm64__annotate_init,
131 },
132 {
133 .name = "csky",
134 .init = csky__annotate_init,
135 },
136 {
137 .name = "mips",
138 .init = mips__annotate_init,
139 .objdump = {
140 .comment_char = '#',
141 },
142 },
143 {
144 .name = "x86",
145 .init = x86__annotate_init,
146 .instructions = x86__instructions,
147 .nr_instructions = ARRAY_SIZE(x86__instructions),
148 .insn_suffix = "bwlq",
149 .objdump = {
150 .comment_char = '#',
151 .register_char = '%',
152 .memory_ref_char = '(',
153 .imm_char = '$',
154 },
155 #ifdef HAVE_LIBDW_SUPPORT
156 .update_insn_state = update_insn_state_x86,
157 #endif
158 },
159 {
160 .name = "powerpc",
161 .init = powerpc__annotate_init,
162 #ifdef HAVE_LIBDW_SUPPORT
163 .update_insn_state = update_insn_state_powerpc,
164 #endif
165 },
166 {
167 .name = "riscv64",
168 .init = riscv64__annotate_init,
169 },
170 {
171 .name = "s390",
172 .init = s390__annotate_init,
173 .objdump = {
174 .comment_char = '#',
175 },
176 },
177 {
178 .name = "sparc",
179 .init = sparc__annotate_init,
180 .objdump = {
181 .comment_char = '#',
182 },
183 },
184 {
185 .name = "loongarch",
186 .init = loongarch__annotate_init,
187 .objdump = {
188 .comment_char = '#',
189 },
190 },
191 };
192
193 static int arch__key_cmp(const void *name, const void *archp)
194 {
195 const struct arch *arch = archp;
196
197 return strcmp(name, arch->name);
198 }
199
200 static int arch__cmp(const void *a, const void *b)
201 {
202 const struct arch *aa = a;
203 const struct arch *ab = b;
204
205 return strcmp(aa->name, ab->name);
206 }
207
208 static void arch__sort(void)
209 {
210 const int nmemb = ARRAY_SIZE(architectures);
211
212 qsort(architectures, nmemb, sizeof(struct arch), arch__cmp);
213 }
214
215 struct arch *arch__find(const char *name)
216 {
217 const int nmemb = ARRAY_SIZE(architectures);
218 static bool sorted;
219
220 if (!sorted) {
221 arch__sort();
222 sorted = true;
223 }
224
225 return bsearch(name, architectures, nmemb, sizeof(struct arch), arch__key_cmp);
226 }
227
228 bool arch__is(struct arch *arch, const char *name)
229 {
230 return !strcmp(arch->name, name);
231 }
232
233 static void ins_ops__delete(struct ins_operands *ops)
234 {
235 if (ops == NULL)
236 return;
237 zfree(&ops->source.raw);
238 zfree(&ops->source.name);
239 zfree(&ops->target.raw);
240 zfree(&ops->target.name);
241 }
242
243 static int ins__raw_scnprintf(struct ins *ins, char *bf, size_t size,
244 struct ins_operands *ops, int max_ins_name)
245 {
246 return scnprintf(bf, size, "%-*s %s", max_ins_name, ins->name, ops->raw);
247 }
248
249 int ins__scnprintf(struct ins *ins, char *bf, size_t size,
250 struct ins_operands *ops, int max_ins_name)
251 {
252 if (ins->ops->scnprintf)
253 return ins->ops->scnprintf(ins, bf, size, ops, max_ins_name);
254
255 return ins__raw_scnprintf(ins, bf, size, ops, max_ins_name);
256 }
257
258 bool ins__is_fused(struct arch *arch, const char *ins1, const char *ins2)
259 {
260 if (!arch || !arch->ins_is_fused)
261 return false;
262
263 return arch->ins_is_fused(arch, ins1, ins2);
264 }
265
266 static int call__parse(struct arch *arch, struct ins_operands *ops, struct map_symbol *ms,
267 struct disasm_line *dl __maybe_unused)
268 {
269 char *endptr, *tok, *name;
270 struct map *map = ms->map;
271 struct addr_map_symbol target = {
272 .ms = { .map = map, },
273 };
274
275 ops->target.addr = strtoull(ops->raw, &endptr, 16);
276
277 name = strchr(endptr, '<');
278 if (name == NULL)
279 goto indirect_call;
280
281 name++;
282
283 if (arch->objdump.skip_functions_char &&
284 strchr(name, arch->objdump.skip_functions_char))
285 return -1;
286
287 tok = strchr(name, '>');
288 if (tok == NULL)
289 return -1;
290
291 *tok = '\0';
292 ops->target.name = strdup(name);
293 *tok = '>';
294
295 if (ops->target.name == NULL)
296 return -1;
297 find_target:
298 target.addr = map__objdump_2mem(map, ops->target.addr);
299
300 if (maps__find_ams(ms->maps, &target) == 0 &&
301 map__rip_2objdump(target.ms.map, map__map_ip(target.ms.map, target.addr)) == ops->target.addr)
302 ops->target.sym = target.ms.sym;
303
304 return 0;
305
306 indirect_call:
307 tok = strchr(endptr, '*');
308 if (tok != NULL) {
309 endptr++;
310
311 /* Indirect call can use a non-rip register and offset: callq *0x8(%rbx).
312 * Do not parse such instruction. */
313 if (strstr(endptr, "(%r") == NULL)
314 ops->target.addr = strtoull(endptr, NULL, 16);
315 }
316 goto find_target;
317 }
318
319 static int call__scnprintf(struct ins *ins, char *bf, size_t size,
320 struct ins_operands *ops, int max_ins_name)
321 {
322 if (ops->target.sym)
323 return scnprintf(bf, size, "%-*s %s", max_ins_name, ins->name, ops->target.sym->name);
324
325 if (ops->target.addr == 0)
326 return ins__raw_scnprintf(ins, bf, size, ops, max_ins_name);
327
328 if (ops->target.name)
329 return scnprintf(bf, size, "%-*s %s", max_ins_name, ins->name, ops->target.name);
330
331 return scnprintf(bf, size, "%-*s *%" PRIx64, max_ins_name, ins->name, ops->target.addr);
332 }
333
334 static struct ins_ops call_ops = {
335 .parse = call__parse,
336 .scnprintf = call__scnprintf,
337 };
338
339 bool ins__is_call(const struct ins *ins)
340 {
341 return ins->ops == &call_ops || ins->ops == &s390_call_ops || ins->ops == &loongarch_call_ops;
342 }
343
344 /*
345 * Prevents from matching commas in the comment section, e.g.:
346 * ffff200008446e70: b.cs ffff2000084470f4 <generic_exec_single+0x314> // b.hs, b.nlast
347 *
348 * and skip comma as part of function arguments, e.g.:
349 * 1d8b4ac <linemap_lookup(line_maps const*, unsigned int)+0xcc>
350 */
351 static inline const char *validate_comma(const char *c, struct ins_operands *ops)
352 {
353 if (ops->jump.raw_comment && c > ops->jump.raw_comment)
354 return NULL;
355
356 if (ops->jump.raw_func_start && c > ops->jump.raw_func_start)
357 return NULL;
358
359 return c;
360 }
361
362 static int jump__parse(struct arch *arch, struct ins_operands *ops, struct map_symbol *ms,
363 struct disasm_line *dl __maybe_unused)
364 {
365 struct map *map = ms->map;
366 struct symbol *sym = ms->sym;
367 struct addr_map_symbol target = {
368 .ms = { .map = map, },
369 };
370 const char *c = strchr(ops->raw, ',');
371 u64 start, end;
372
373 ops->jump.raw_comment = strchr(ops->raw, arch->objdump.comment_char);
374 ops->jump.raw_func_start = strchr(ops->raw, '<');
375
376 c = validate_comma(c, ops);
377
378 /*
379 * Examples of lines to parse for the _cpp_lex_token@@Base
380 * function:
381 *
382 * 1159e6c: jne 115aa32 <_cpp_lex_token@@Base+0xf92>
383 * 1159e8b: jne c469be <cpp_named_operator2name@@Base+0xa72>
384 *
385 * The first is a jump to an offset inside the same function,
386 * the second is to another function, i.e. that 0xa72 is an
387 * offset in the cpp_named_operator2name@@base function.
388 */
389 /*
390 * skip over possible up to 2 operands to get to address, e.g.:
391 * tbnz w0, #26, ffff0000083cd190 <security_file_permission+0xd0>
392 */
393 if (c++ != NULL) {
394 ops->target.addr = strtoull(c, NULL, 16);
395 if (!ops->target.addr) {
396 c = strchr(c, ',');
397 c = validate_comma(c, ops);
398 if (c++ != NULL)
399 ops->target.addr = strtoull(c, NULL, 16);
400 }
401 } else {
402 ops->target.addr = strtoull(ops->raw, NULL, 16);
403 }
404
405 target.addr = map__objdump_2mem(map, ops->target.addr);
406 start = map__unmap_ip(map, sym->start);
407 end = map__unmap_ip(map, sym->end);
408
409 ops->target.outside = target.addr < start || target.addr > end;
410
411 /*
412 * FIXME: things like this in _cpp_lex_token (gcc's cc1 program):
413
414 cpp_named_operator2name@@Base+0xa72
415
416 * Point to a place that is after the cpp_named_operator2name
417 * boundaries, i.e. in the ELF symbol table for cc1
418 * cpp_named_operator2name is marked as being 32-bytes long, but it in
419 * fact is much larger than that, so we seem to need a symbols__find()
420 * routine that looks for >= current->start and < next_symbol->start,
421 * possibly just for C++ objects?
422 *
423 * For now lets just make some progress by marking jumps to outside the
424 * current function as call like.
425 *
426 * Actual navigation will come next, with further understanding of how
427 * the symbol searching and disassembly should be done.
428 */
429 if (maps__find_ams(ms->maps, &target) == 0 &&
430 map__rip_2objdump(target.ms.map, map__map_ip(target.ms.map, target.addr)) == ops->target.addr)
431 ops->target.sym = target.ms.sym;
432
433 if (!ops->target.outside) {
434 ops->target.offset = target.addr - start;
435 ops->target.offset_avail = true;
436 } else {
437 ops->target.offset_avail = false;
438 }
439
440 return 0;
441 }
442
443 static int jump__scnprintf(struct ins *ins, char *bf, size_t size,
444 struct ins_operands *ops, int max_ins_name)
445 {
446 const char *c;
447
448 if (!ops->target.addr || ops->target.offset < 0)
449 return ins__raw_scnprintf(ins, bf, size, ops, max_ins_name);
450
451 if (ops->target.outside && ops->target.sym != NULL)
452 return scnprintf(bf, size, "%-*s %s", max_ins_name, ins->name, ops->target.sym->name);
453
454 c = strchr(ops->raw, ',');
455 c = validate_comma(c, ops);
456
457 if (c != NULL) {
458 const char *c2 = strchr(c + 1, ',');
459
460 c2 = validate_comma(c2, ops);
461 /* check for 3-op insn */
462 if (c2 != NULL)
463 c = c2;
464 c++;
465
466 /* mirror arch objdump's space-after-comma style */
467 if (*c == ' ')
468 c++;
469 }
470
471 return scnprintf(bf, size, "%-*s %.*s%" PRIx64, max_ins_name,
472 ins->name, c ? c - ops->raw : 0, ops->raw,
473 ops->target.offset);
474 }
475
476 static void jump__delete(struct ins_operands *ops __maybe_unused)
477 {
478 /*
479 * The ops->jump.raw_comment and ops->jump.raw_func_start belong to the
480 * raw string, don't free them.
481 */
482 }
483
484 static struct ins_ops jump_ops = {
485 .free = jump__delete,
486 .parse = jump__parse,
487 .scnprintf = jump__scnprintf,
488 };
489
490 bool ins__is_jump(const struct ins *ins)
491 {
492 return ins->ops == &jump_ops || ins->ops == &loongarch_jump_ops;
493 }
494
495 static int comment__symbol(char *raw, char *comment, u64 *addrp, char **namep)
496 {
497 char *endptr, *name, *t;
498
499 if (strstr(raw, "(%rip)") == NULL)
500 return 0;
501
502 *addrp = strtoull(comment, &endptr, 16);
503 if (endptr == comment)
504 return 0;
505 name = strchr(endptr, '<');
506 if (name == NULL)
507 return -1;
508
509 name++;
510
511 t = strchr(name, '>');
512 if (t == NULL)
513 return 0;
514
515 *t = '\0';
516 *namep = strdup(name);
517 *t = '>';
518
519 return 0;
520 }
521
522 static int lock__parse(struct arch *arch, struct ins_operands *ops, struct map_symbol *ms,
523 struct disasm_line *dl __maybe_unused)
524 {
525 ops->locked.ops = zalloc(sizeof(*ops->locked.ops));
526 if (ops->locked.ops == NULL)
527 return 0;
528
529 if (disasm_line__parse(ops->raw, &ops->locked.ins.name, &ops->locked.ops->raw) < 0)
530 goto out_free_ops;
531
532 ops->locked.ins.ops = ins__find(arch, ops->locked.ins.name, 0);
533
534 if (ops->locked.ins.ops == NULL)
535 goto out_free_ops;
536
537 if (ops->locked.ins.ops->parse &&
538 ops->locked.ins.ops->parse(arch, ops->locked.ops, ms, NULL) < 0)
539 goto out_free_ops;
540
541 return 0;
542
543 out_free_ops:
544 zfree(&ops->locked.ops);
545 return 0;
546 }
547
548 static int lock__scnprintf(struct ins *ins, char *bf, size_t size,
549 struct ins_operands *ops, int max_ins_name)
550 {
551 int printed;
552
553 if (ops->locked.ins.ops == NULL)
554 return ins__raw_scnprintf(ins, bf, size, ops, max_ins_name);
555
556 printed = scnprintf(bf, size, "%-*s ", max_ins_name, ins->name);
557 return printed + ins__scnprintf(&ops->locked.ins, bf + printed,
558 size - printed, ops->locked.ops, max_ins_name);
559 }
560
561 static void lock__delete(struct ins_operands *ops)
562 {
563 struct ins *ins = &ops->locked.ins;
564
565 if (ins->ops && ins->ops->free)
566 ins->ops->free(ops->locked.ops);
567 else
568 ins_ops__delete(ops->locked.ops);
569
570 zfree(&ops->locked.ops);
571 zfree(&ops->locked.ins.name);
572 zfree(&ops->target.raw);
573 zfree(&ops->target.name);
574 }
575
576 static struct ins_ops lock_ops = {
577 .free = lock__delete,
578 .parse = lock__parse,
579 .scnprintf = lock__scnprintf,
580 };
581
582 /*
583 * Check if the operand has more than one registers like x86 SIB addressing:
584 * 0x1234(%rax, %rbx, 8)
585 *
586 * But it doesn't care segment selectors like %gs:0x5678(%rcx), so just check
587 * the input string after 'memory_ref_char' if exists.
588 */
589 static bool check_multi_regs(struct arch *arch, const char *op)
590 {
591 int count = 0;
592
593 if (arch->objdump.register_char == 0)
594 return false;
595
596 if (arch->objdump.memory_ref_char) {
597 op = strchr(op, arch->objdump.memory_ref_char);
598 if (op == NULL)
599 return false;
600 }
601
602 while ((op = strchr(op, arch->objdump.register_char)) != NULL) {
603 count++;
604 op++;
605 }
606
607 return count > 1;
608 }
609
610 static int mov__parse(struct arch *arch, struct ins_operands *ops, struct map_symbol *ms __maybe_unused,
611 struct disasm_line *dl __maybe_unused)
612 {
613 char *s = strchr(ops->raw, ','), *target, *comment, prev;
614
615 if (s == NULL)
616 return -1;
617
618 *s = '\0';
619
620 /*
621 * x86 SIB addressing has something like 0x8(%rax, %rcx, 1)
622 * then it needs to have the closing parenthesis.
623 */
624 if (strchr(ops->raw, '(')) {
625 *s = ',';
626 s = strchr(ops->raw, ')');
627 if (s == NULL || s[1] != ',')
628 return -1;
629 *++s = '\0';
630 }
631
632 ops->source.raw = strdup(ops->raw);
633 *s = ',';
634
635 if (ops->source.raw == NULL)
636 return -1;
637
638 ops->source.multi_regs = check_multi_regs(arch, ops->source.raw);
639
640 target = skip_spaces(++s);
641 comment = strchr(s, arch->objdump.comment_char);
642
643 if (comment != NULL)
644 s = comment - 1;
645 else
646 s = strchr(s, '\0') - 1;
647
648 while (s > target && isspace(s[0]))
649 --s;
650 s++;
651 prev = *s;
652 *s = '\0';
653
654 ops->target.raw = strdup(target);
655 *s = prev;
656
657 if (ops->target.raw == NULL)
658 goto out_free_source;
659
660 ops->target.multi_regs = check_multi_regs(arch, ops->target.raw);
661
662 if (comment == NULL)
663 return 0;
664
665 comment = skip_spaces(comment);
666 comment__symbol(ops->source.raw, comment + 1, &ops->source.addr, &ops->source.name);
667 comment__symbol(ops->target.raw, comment + 1, &ops->target.addr, &ops->target.name);
668
669 return 0;
670
671 out_free_source:
672 zfree(&ops->source.raw);
673 return -1;
674 }
675
676 static int mov__scnprintf(struct ins *ins, char *bf, size_t size,
677 struct ins_operands *ops, int max_ins_name)
678 {
679 return scnprintf(bf, size, "%-*s %s,%s", max_ins_name, ins->name,
680 ops->source.name ?: ops->source.raw,
681 ops->target.name ?: ops->target.raw);
682 }
683
684 static struct ins_ops mov_ops = {
685 .parse = mov__parse,
686 .scnprintf = mov__scnprintf,
687 };
688
689 #define PPC_22_30(R) (((R) >> 1) & 0x1ff)
690 #define MINUS_EXT_XO_FORM 234
691 #define SUB_EXT_XO_FORM 232
692 #define ADD_ZERO_EXT_XO_FORM 202
693 #define SUB_ZERO_EXT_XO_FORM 200
694
695 static int arithmetic__scnprintf(struct ins *ins, char *bf, size_t size,
696 struct ins_operands *ops, int max_ins_name)
697 {
698 return scnprintf(bf, size, "%-*s %s", max_ins_name, ins->name,
699 ops->raw);
700 }
701
702 /*
703 * Sets the fields: multi_regs and "mem_ref".
704 * "mem_ref" is set for ops->source which is later used to
705 * fill the objdump->memory_ref-char field. This ops is currently
706 * used by powerpc and since binary instruction code is used to
707 * extract opcode, regs and offset, no other parsing is needed here.
708 *
709 * Dont set multi regs for 4 cases since it has only one operand
710 * for source:
711 * - Add to Minus One Extended XO-form ( Ex: addme, addmeo )
712 * - Subtract From Minus One Extended XO-form ( Ex: subfme )
713 * - Add to Zero Extended XO-form ( Ex: addze, addzeo )
714 * - Subtract From Zero Extended XO-form ( Ex: subfze )
715 */
716 static int arithmetic__parse(struct arch *arch __maybe_unused, struct ins_operands *ops,
717 struct map_symbol *ms __maybe_unused, struct disasm_line *dl)
718 {
719 int opcode = PPC_OP(dl->raw.raw_insn);
720
721 ops->source.mem_ref = false;
722 if (opcode == 31) {
723 if ((opcode != MINUS_EXT_XO_FORM) && (opcode != SUB_EXT_XO_FORM) \
724 && (opcode != ADD_ZERO_EXT_XO_FORM) && (opcode != SUB_ZERO_EXT_XO_FORM))
725 ops->source.multi_regs = true;
726 }
727
728 ops->target.mem_ref = false;
729 ops->target.multi_regs = false;
730
731 return 0;
732 }
733
734 static struct ins_ops arithmetic_ops = {
735 .parse = arithmetic__parse,
736 .scnprintf = arithmetic__scnprintf,
737 };
738
739 static int load_store__scnprintf(struct ins *ins, char *bf, size_t size,
740 struct ins_operands *ops, int max_ins_name)
741 {
742 return scnprintf(bf, size, "%-*s %s", max_ins_name, ins->name,
743 ops->raw);
744 }
745
746 /*
747 * Sets the fields: multi_regs and "mem_ref".
748 * "mem_ref" is set for ops->source which is later used to
749 * fill the objdump->memory_ref-char field. This ops is currently
750 * used by powerpc and since binary instruction code is used to
751 * extract opcode, regs and offset, no other parsing is needed here
752 */
753 static int load_store__parse(struct arch *arch __maybe_unused, struct ins_operands *ops,
754 struct map_symbol *ms __maybe_unused, struct disasm_line *dl __maybe_unused)
755 {
756 ops->source.mem_ref = true;
757 ops->source.multi_regs = false;
758 /* opcode 31 is of X form */
759 if (PPC_OP(dl->raw.raw_insn) == 31)
760 ops->source.multi_regs = true;
761
762 ops->target.mem_ref = false;
763 ops->target.multi_regs = false;
764
765 return 0;
766 }
767
768 static struct ins_ops load_store_ops = {
769 .parse = load_store__parse,
770 .scnprintf = load_store__scnprintf,
771 };
772
773 static int dec__parse(struct arch *arch __maybe_unused, struct ins_operands *ops, struct map_symbol *ms __maybe_unused,
774 struct disasm_line *dl __maybe_unused)
775 {
776 char *target, *comment, *s, prev;
777
778 target = s = ops->raw;
779
780 while (s[0] != '\0' && !isspace(s[0]))
781 ++s;
782 prev = *s;
783 *s = '\0';
784
785 ops->target.raw = strdup(target);
786 *s = prev;
787
788 if (ops->target.raw == NULL)
789 return -1;
790
791 comment = strchr(s, arch->objdump.comment_char);
792 if (comment == NULL)
793 return 0;
794
795 comment = skip_spaces(comment);
796 comment__symbol(ops->target.raw, comment + 1, &ops->target.addr, &ops->target.name);
797
798 return 0;
799 }
800
801 static int dec__scnprintf(struct ins *ins, char *bf, size_t size,
802 struct ins_operands *ops, int max_ins_name)
803 {
804 return scnprintf(bf, size, "%-*s %s", max_ins_name, ins->name,
805 ops->target.name ?: ops->target.raw);
806 }
807
808 static struct ins_ops dec_ops = {
809 .parse = dec__parse,
810 .scnprintf = dec__scnprintf,
811 };
812
813 static int nop__scnprintf(struct ins *ins __maybe_unused, char *bf, size_t size,
814 struct ins_operands *ops __maybe_unused, int max_ins_name)
815 {
816 return scnprintf(bf, size, "%-*s", max_ins_name, "nop");
817 }
818
819 static struct ins_ops nop_ops = {
820 .scnprintf = nop__scnprintf,
821 };
822
823 static struct ins_ops ret_ops = {
824 .scnprintf = ins__raw_scnprintf,
825 };
826
827 bool ins__is_nop(const struct ins *ins)
828 {
829 return ins->ops == &nop_ops;
830 }
831
832 bool ins__is_ret(const struct ins *ins)
833 {
834 return ins->ops == &ret_ops;
835 }
836
837 bool ins__is_lock(const struct ins *ins)
838 {
839 return ins->ops == &lock_ops;
840 }
841
842 static int ins__key_cmp(const void *name, const void *insp)
843 {
844 const struct ins *ins = insp;
845
846 return strcmp(name, ins->name);
847 }
848
849 static int ins__cmp(const void *a, const void *b)
850 {
851 const struct ins *ia = a;
852 const struct ins *ib = b;
853
854 return strcmp(ia->name, ib->name);
855 }
856
857 static void ins__sort(struct arch *arch)
858 {
859 const int nmemb = arch->nr_instructions;
860
861 qsort(arch->instructions, nmemb, sizeof(struct ins), ins__cmp);
862 }
863
864 static struct ins_ops *__ins__find(struct arch *arch, const char *name, struct disasm_line *dl)
865 {
866 struct ins *ins;
867 const int nmemb = arch->nr_instructions;
868
869 if (arch__is(arch, "powerpc")) {
870 /*
871 * For powerpc, identify the instruction ops
872 * from the opcode using raw_insn.
873 */
874 struct ins_ops *ops;
875
876 ops = check_ppc_insn(dl);
877 if (ops)
878 return ops;
879 }
880
881 if (!arch->sorted_instructions) {
882 ins__sort(arch);
883 arch->sorted_instructions = true;
884 }
885
886 ins = bsearch(name, arch->instructions, nmemb, sizeof(struct ins), ins__key_cmp);
887 if (ins)
888 return ins->ops;
889
890 if (arch->insn_suffix) {
891 char tmp[32];
892 char suffix;
893 size_t len = strlen(name);
894
895 if (len == 0 || len >= sizeof(tmp))
896 return NULL;
897
898 suffix = name[len - 1];
899 if (strchr(arch->insn_suffix, suffix) == NULL)
900 return NULL;
901
902 strcpy(tmp, name);
903 tmp[len - 1] = '\0'; /* remove the suffix and check again */
904
905 ins = bsearch(tmp, arch->instructions, nmemb, sizeof(struct ins), ins__key_cmp);
906 }
907 return ins ? ins->ops : NULL;
908 }
909
910 struct ins_ops *ins__find(struct arch *arch, const char *name, struct disasm_line *dl)
911 {
912 struct ins_ops *ops = __ins__find(arch, name, dl);
913
914 if (!ops && arch->associate_instruction_ops)
915 ops = arch->associate_instruction_ops(arch, name);
916
917 return ops;
918 }
919
920 static void disasm_line__init_ins(struct disasm_line *dl, struct arch *arch, struct map_symbol *ms)
921 {
922 dl->ins.ops = ins__find(arch, dl->ins.name, dl);
923
924 if (!dl->ins.ops)
925 return;
926
927 if (dl->ins.ops->parse && dl->ins.ops->parse(arch, &dl->ops, ms, dl) < 0)
928 dl->ins.ops = NULL;
929 }
930
931 static int disasm_line__parse(char *line, const char **namep, char **rawp)
932 {
933 char tmp, *name = skip_spaces(line);
934
935 if (name[0] == '\0')
936 return -1;
937
938 *rawp = name + 1;
939
940 while ((*rawp)[0] != '\0' && !isspace((*rawp)[0]))
941 ++*rawp;
942
943 tmp = (*rawp)[0];
944 (*rawp)[0] = '\0';
945 *namep = strdup(name);
946
947 if (*namep == NULL)
948 goto out;
949
950 (*rawp)[0] = tmp;
951 *rawp = strim(*rawp);
952
953 return 0;
954
955 out:
956 return -1;
957 }
958
959 /*
960 * Parses the result captured from symbol__disassemble_*
961 * Example, line read from DSO file in powerpc:
962 * line: 38 01 81 e8
963 * opcode: fetched from arch specific get_opcode_insn
964 * rawp_insn: e8810138
965 *
966 * rawp_insn is used later to extract the reg/offset fields
967 */
968 #define PPC_OP(op) (((op) >> 26) & 0x3F)
969 #define RAW_BYTES 11
970
971 static int disasm_line__parse_powerpc(struct disasm_line *dl)
972 {
973 char *line = dl->al.line;
974 const char **namep = &dl->ins.name;
975 char **rawp = &dl->ops.raw;
976 char *tmp_raw_insn, *name_raw_insn = skip_spaces(line);
977 char *name = skip_spaces(name_raw_insn + RAW_BYTES);
978 int objdump = 0;
979
980 if (strlen(line) > RAW_BYTES)
981 objdump = 1;
982
983 if (name_raw_insn[0] == '\0')
984 return -1;
985
986 if (objdump) {
987 disasm_line__parse(name, namep, rawp);
988 } else
989 *namep = "";
990
991 tmp_raw_insn = strndup(name_raw_insn, 11);
992 if (tmp_raw_insn == NULL)
993 return -1;
994
995 remove_spaces(tmp_raw_insn);
996
997 sscanf(tmp_raw_insn, "%x", &dl->raw.raw_insn);
998 if (objdump)
999 dl->raw.raw_insn = be32_to_cpu(dl->raw.raw_insn);
1000
1001 return 0;
1002 }
1003
1004 static void annotation_line__init(struct annotation_line *al,
1005 struct annotate_args *args,
1006 int nr)
1007 {
1008 al->offset = args->offset;
1009 al->line = strdup(args->line);
1010 al->line_nr = args->line_nr;
1011 al->fileloc = args->fileloc;
1012 al->data_nr = nr;
1013 }
1014
1015 static void annotation_line__exit(struct annotation_line *al)
1016 {
1017 zfree_srcline(&al->path);
1018 zfree(&al->line);
1019 zfree(&al->cycles);
1020 zfree(&al->br_cntr);
1021 }
1022
1023 static size_t disasm_line_size(int nr)
1024 {
1025 struct annotation_line *al;
1026
1027 return (sizeof(struct disasm_line) + (sizeof(al->data[0]) * nr));
1028 }
1029
1030 /*
1031 * Allocating the disasm annotation line data with
1032 * following structure:
1033 *
1034 * -------------------------------------------
1035 * struct disasm_line | struct annotation_line
1036 * -------------------------------------------
1037 *
1038 * We have 'struct annotation_line' member as last member
1039 * of 'struct disasm_line' to have an easy access.
1040 */
1041 struct disasm_line *disasm_line__new(struct annotate_args *args)
1042 {
1043 struct disasm_line *dl = NULL;
1044 struct annotation *notes = symbol__annotation(args->ms.sym);
1045 int nr = notes->src->nr_events;
1046
1047 dl = zalloc(disasm_line_size(nr));
1048 if (!dl)
1049 return NULL;
1050
1051 annotation_line__init(&dl->al, args, nr);
1052 if (dl->al.line == NULL)
1053 goto out_delete;
1054
1055 if (args->offset != -1) {
1056 if (arch__is(args->arch, "powerpc")) {
1057 if (disasm_line__parse_powerpc(dl) < 0)
1058 goto out_free_line;
1059 } else if (disasm_line__parse(dl->al.line, &dl->ins.name, &dl->ops.raw) < 0)
1060 goto out_free_line;
1061
1062 disasm_line__init_ins(dl, args->arch, &args->ms);
1063 }
1064
1065 return dl;
1066
1067 out_free_line:
1068 zfree(&dl->al.line);
1069 out_delete:
1070 free(dl);
1071 return NULL;
1072 }
1073
1074 void disasm_line__free(struct disasm_line *dl)
1075 {
1076 if (dl->ins.ops && dl->ins.ops->free)
1077 dl->ins.ops->free(&dl->ops);
1078 else
1079 ins_ops__delete(&dl->ops);
1080 zfree(&dl->ins.name);
1081 annotation_line__exit(&dl->al);
1082 free(dl);
1083 }
1084
1085 int disasm_line__scnprintf(struct disasm_line *dl, char *bf, size_t size, bool raw, int max_ins_name)
1086 {
1087 if (raw || !dl->ins.ops)
1088 return scnprintf(bf, size, "%-*s %s", max_ins_name, dl->ins.name, dl->ops.raw);
1089
1090 return ins__scnprintf(&dl->ins, bf, size, &dl->ops, max_ins_name);
1091 }
1092
1093 /*
1094 * symbol__parse_objdump_line() parses objdump output (with -d --no-show-raw)
1095 * which looks like following
1096 *
1097 * 0000000000415500 <_init>:
1098 * 415500: sub $0x8,%rsp
1099 * 415504: mov 0x2f5ad5(%rip),%rax # 70afe0 <_DYNAMIC+0x2f8>
1100 * 41550b: test %rax,%rax
1101 * 41550e: je 415515 <_init+0x15>
1102 * 415510: callq 416e70 <__gmon_start__@plt>
1103 * 415515: add $0x8,%rsp
1104 * 415519: retq
1105 *
1106 * it will be parsed and saved into struct disasm_line as
1107 * <offset> <name> <ops.raw>
1108 *
1109 * The offset will be a relative offset from the start of the symbol and -1
1110 * means that it's not a disassembly line so should be treated differently.
1111 * The ops.raw part will be parsed further according to type of the instruction.
1112 */
1113 static int symbol__parse_objdump_line(struct symbol *sym,
1114 struct annotate_args *args,
1115 char *parsed_line, int *line_nr, char **fileloc)
1116 {
1117 struct map *map = args->ms.map;
1118 struct annotation *notes = symbol__annotation(sym);
1119 struct disasm_line *dl;
1120 char *tmp;
1121 s64 line_ip, offset = -1;
1122 regmatch_t match[2];
1123
1124 /* /filename:linenr ? Save line number and ignore. */
1125 if (regexec(&file_lineno, parsed_line, 2, match, 0) == 0) {
1126 *line_nr = atoi(parsed_line + match[1].rm_so);
1127 free(*fileloc);
1128 *fileloc = strdup(parsed_line);
1129 return 0;
1130 }
1131
1132 /* Process hex address followed by ':'. */
1133 line_ip = strtoull(parsed_line, &tmp, 16);
1134 if (parsed_line != tmp && tmp[0] == ':' && tmp[1] != '\0') {
1135 u64 start = map__rip_2objdump(map, sym->start),
1136 end = map__rip_2objdump(map, sym->end);
1137
1138 offset = line_ip - start;
1139 if ((u64)line_ip < start || (u64)line_ip >= end)
1140 offset = -1;
1141 else
1142 parsed_line = tmp + 1;
1143 }
1144
1145 args->offset = offset;
1146 args->line = parsed_line;
1147 args->line_nr = *line_nr;
1148 args->fileloc = *fileloc;
1149 args->ms.sym = sym;
1150
1151 dl = disasm_line__new(args);
1152 (*line_nr)++;
1153
1154 if (dl == NULL)
1155 return -1;
1156
1157 if (!disasm_line__has_local_offset(dl)) {
1158 dl->ops.target.offset = dl->ops.target.addr -
1159 map__rip_2objdump(map, sym->start);
1160 dl->ops.target.offset_avail = true;
1161 }
1162
1163 /* kcore has no symbols, so add the call target symbol */
1164 if (dl->ins.ops && ins__is_call(&dl->ins) && !dl->ops.target.sym) {
1165 struct addr_map_symbol target = {
1166 .addr = dl->ops.target.addr,
1167 .ms = { .map = map, },
1168 };
1169
1170 if (!maps__find_ams(args->ms.maps, &target) &&
1171 target.ms.sym->start == target.al_addr)
1172 dl->ops.target.sym = target.ms.sym;
1173 }
1174
1175 annotation_line__add(&dl->al, &notes->src->source);
1176 return 0;
1177 }
1178
1179 static void delete_last_nop(struct symbol *sym)
1180 {
1181 struct annotation *notes = symbol__annotation(sym);
1182 struct list_head *list = &notes->src->source;
1183 struct disasm_line *dl;
1184
1185 while (!list_empty(list)) {
1186 dl = list_entry(list->prev, struct disasm_line, al.node);
1187
1188 if (dl->ins.ops) {
1189 if (!ins__is_nop(&dl->ins))
1190 return;
1191 } else {
1192 if (!strstr(dl->al.line, " nop ") &&
1193 !strstr(dl->al.line, " nopl ") &&
1194 !strstr(dl->al.line, " nopw "))
1195 return;
1196 }
1197
1198 list_del_init(&dl->al.node);
1199 disasm_line__free(dl);
1200 }
1201 }
1202
1203 int symbol__strerror_disassemble(struct map_symbol *ms, int errnum, char *buf, size_t buflen)
1204 {
1205 struct dso *dso = map__dso(ms->map);
1206
1207 BUG_ON(buflen == 0);
1208
1209 if (errnum >= 0) {
1210 str_error_r(errnum, buf, buflen);
1211 return 0;
1212 }
1213
1214 switch (errnum) {
1215 case SYMBOL_ANNOTATE_ERRNO__NO_VMLINUX: {
1216 char bf[SBUILD_ID_SIZE + 15] = " with build id ";
1217 char *build_id_msg = NULL;
1218
1219 if (dso__has_build_id(dso)) {
1220 build_id__sprintf(dso__bid(dso), bf + 15);
1221 build_id_msg = bf;
1222 }
1223 scnprintf(buf, buflen,
1224 "No vmlinux file%s\nwas found in the path.\n\n"
1225 "Note that annotation using /proc/kcore requires CAP_SYS_RAWIO capability.\n\n"
1226 "Please use:\n\n"
1227 " perf buildid-cache -vu vmlinux\n\n"
1228 "or:\n\n"
1229 " --vmlinux vmlinux\n", build_id_msg ?: "");
1230 }
1231 break;
1232 case SYMBOL_ANNOTATE_ERRNO__NO_LIBOPCODES_FOR_BPF:
1233 scnprintf(buf, buflen, "Please link with binutils's libopcode to enable BPF annotation");
1234 break;
1235 case SYMBOL_ANNOTATE_ERRNO__ARCH_INIT_REGEXP:
1236 scnprintf(buf, buflen, "Problems with arch specific instruction name regular expressions.");
1237 break;
1238 case SYMBOL_ANNOTATE_ERRNO__ARCH_INIT_CPUID_PARSING:
1239 scnprintf(buf, buflen, "Problems while parsing the CPUID in the arch specific initialization.");
1240 break;
1241 case SYMBOL_ANNOTATE_ERRNO__BPF_INVALID_FILE:
1242 scnprintf(buf, buflen, "Invalid BPF file: %s.", dso__long_name(dso));
1243 break;
1244 case SYMBOL_ANNOTATE_ERRNO__BPF_MISSING_BTF:
1245 scnprintf(buf, buflen, "The %s BPF file has no BTF section, compile with -g or use pahole -J.",
1246 dso__long_name(dso));
1247 break;
1248 default:
1249 scnprintf(buf, buflen, "Internal error: Invalid %d error code\n", errnum);
1250 break;
1251 }
1252
1253 return 0;
1254 }
1255
1256 static int dso__disassemble_filename(struct dso *dso, char *filename, size_t filename_size)
1257 {
1258 char linkname[PATH_MAX];
1259 char *build_id_filename;
1260 char *build_id_path = NULL;
1261 char *pos;
1262 int len;
1263
1264 if (dso__symtab_type(dso) == DSO_BINARY_TYPE__KALLSYMS &&
1265 !dso__is_kcore(dso))
1266 return SYMBOL_ANNOTATE_ERRNO__NO_VMLINUX;
1267
1268 build_id_filename = dso__build_id_filename(dso, NULL, 0, false);
1269 if (build_id_filename) {
1270 __symbol__join_symfs(filename, filename_size, build_id_filename);
1271 free(build_id_filename);
1272 } else {
1273 if (dso__has_build_id(dso))
1274 return ENOMEM;
1275 goto fallback;
1276 }
1277
1278 build_id_path = strdup(filename);
1279 if (!build_id_path)
1280 return ENOMEM;
1281
1282 /*
1283 * old style build-id cache has name of XX/XXXXXXX.. while
1284 * new style has XX/XXXXXXX../{elf,kallsyms,vdso}.
1285 * extract the build-id part of dirname in the new style only.
1286 */
1287 pos = strrchr(build_id_path, '/');
1288 if (pos && strlen(pos) < SBUILD_ID_SIZE - 2)
1289 dirname(build_id_path);
1290
1291 if (dso__is_kcore(dso))
1292 goto fallback;
1293
1294 len = readlink(build_id_path, linkname, sizeof(linkname) - 1);
1295 if (len < 0)
1296 goto fallback;
1297
1298 linkname[len] = '\0';
1299 if (strstr(linkname, DSO__NAME_KALLSYMS) ||
1300 access(filename, R_OK)) {
1301 fallback:
1302 /*
1303 * If we don't have build-ids or the build-id file isn't in the
1304 * cache, or is just a kallsyms file, well, lets hope that this
1305 * DSO is the same as when 'perf record' ran.
1306 */
1307 if (dso__kernel(dso) && dso__long_name(dso)[0] == '/')
1308 snprintf(filename, filename_size, "%s", dso__long_name(dso));
1309 else
1310 __symbol__join_symfs(filename, filename_size, dso__long_name(dso));
1311
1312 mutex_lock(dso__lock(dso));
1313 if (access(filename, R_OK) && errno == ENOENT && dso__nsinfo(dso)) {
1314 char *new_name = dso__filename_with_chroot(dso, filename);
1315 if (new_name) {
1316 strlcpy(filename, new_name, filename_size);
1317 free(new_name);
1318 }
1319 }
1320 mutex_unlock(dso__lock(dso));
1321 } else if (dso__binary_type(dso) == DSO_BINARY_TYPE__NOT_FOUND) {
1322 dso__set_binary_type(dso, DSO_BINARY_TYPE__BUILD_ID_CACHE);
1323 }
1324
1325 free(build_id_path);
1326 return 0;
1327 }
1328
1329 #ifdef HAVE_LIBCAPSTONE_SUPPORT
1330 #include <capstone/capstone.h>
1331
1332 int capstone_init(struct machine *machine, csh *cs_handle, bool is64, bool disassembler_style);
1333
1334 static int open_capstone_handle(struct annotate_args *args, bool is_64bit,
1335 csh *handle)
1336 {
1337 struct annotation_options *opt = args->options;
1338 cs_mode mode = is_64bit ? CS_MODE_64 : CS_MODE_32;
1339
1340 /* TODO: support more architectures */
1341 if (!arch__is(args->arch, "x86"))
1342 return -1;
1343
1344 if (cs_open(CS_ARCH_X86, mode, handle) != CS_ERR_OK)
1345 return -1;
1346
1347 if (!opt->disassembler_style ||
1348 !strcmp(opt->disassembler_style, "att"))
1349 cs_option(*handle, CS_OPT_SYNTAX, CS_OPT_SYNTAX_ATT);
1350
1351 /*
1352 * Resolving address operands to symbols is implemented
1353 * on x86 by investigating instruction details.
1354 */
1355 cs_option(*handle, CS_OPT_DETAIL, CS_OPT_ON);
1356
1357 return 0;
1358 }
1359 #endif
1360
1361 #if defined(HAVE_LIBCAPSTONE_SUPPORT) || defined(HAVE_LIBLLVM_SUPPORT)
1362 struct find_file_offset_data {
1363 u64 ip;
1364 u64 offset;
1365 };
1366
1367 /* This will be called for each PHDR in an ELF binary */
1368 static int find_file_offset(u64 start, u64 len, u64 pgoff, void *arg)
1369 {
1370 struct find_file_offset_data *data = arg;
1371
1372 if (start <= data->ip && data->ip < start + len) {
1373 data->offset = pgoff + data->ip - start;
1374 return 1;
1375 }
1376 return 0;
1377 }
1378
1379 static u8 *
1380 read_symbol(const char *filename, struct map *map, struct symbol *sym,
1381 u64 *len, bool *is_64bit)
1382 {
1383 struct dso *dso = map__dso(map);
1384 struct nscookie nsc;
1385 u64 start = map__rip_2objdump(map, sym->start);
1386 u64 end = map__rip_2objdump(map, sym->end);
1387 int fd, count;
1388 u8 *buf = NULL;
1389 struct find_file_offset_data data = {
1390 .ip = start,
1391 };
1392
1393 *is_64bit = false;
1394
1395 nsinfo__mountns_enter(dso__nsinfo(dso), &nsc);
1396 fd = open(filename, O_RDONLY);
1397 nsinfo__mountns_exit(&nsc);
1398 if (fd < 0)
1399 return NULL;
1400
1401 if (file__read_maps(fd, /*exe=*/true, find_file_offset, &data,
1402 is_64bit) == 0)
1403 goto err;
1404
1405 *len = end - start;
1406 buf = malloc(*len);
1407 if (buf == NULL)
1408 goto err;
1409
1410 count = pread(fd, buf, *len, data.offset);
1411 close(fd);
1412 fd = -1;
1413
1414 if ((u64)count != *len)
1415 goto err;
1416
1417 return buf;
1418
1419 err:
1420 if (fd >= 0)
1421 close(fd);
1422 free(buf);
1423 return NULL;
1424 }
1425 #endif
1426
1427 #if !defined(HAVE_LIBCAPSTONE_SUPPORT) || !defined(HAVE_LIBLLVM_SUPPORT)
1428 static void symbol__disassembler_missing(const char *disassembler, const char *filename,
1429 struct symbol *sym)
1430 {
1431 pr_debug("The %s disassembler isn't linked in for %s in %s\n",
1432 disassembler, sym->name, filename);
1433 }
1434 #endif
1435
1436 #ifdef HAVE_LIBCAPSTONE_SUPPORT
1437 static void print_capstone_detail(cs_insn *insn, char *buf, size_t len,
1438 struct annotate_args *args, u64 addr)
1439 {
1440 int i;
1441 struct map *map = args->ms.map;
1442 struct symbol *sym;
1443
1444 /* TODO: support more architectures */
1445 if (!arch__is(args->arch, "x86"))
1446 return;
1447
1448 if (insn->detail == NULL)
1449 return;
1450
1451 for (i = 0; i < insn->detail->x86.op_count; i++) {
1452 cs_x86_op *op = &insn->detail->x86.operands[i];
1453 u64 orig_addr;
1454
1455 if (op->type != X86_OP_MEM)
1456 continue;
1457
1458 /* only print RIP-based global symbols for now */
1459 if (op->mem.base != X86_REG_RIP)
1460 continue;
1461
1462 /* get the target address */
1463 orig_addr = addr + insn->size + op->mem.disp;
1464 addr = map__objdump_2mem(map, orig_addr);
1465
1466 if (dso__kernel(map__dso(map))) {
1467 /*
1468 * The kernel maps can be splitted into sections,
1469 * let's find the map first and the search the symbol.
1470 */
1471 map = maps__find(map__kmaps(map), addr);
1472 if (map == NULL)
1473 continue;
1474 }
1475
1476 /* convert it to map-relative address for search */
1477 addr = map__map_ip(map, addr);
1478
1479 sym = map__find_symbol(map, addr);
1480 if (sym == NULL)
1481 continue;
1482
1483 if (addr == sym->start) {
1484 scnprintf(buf, len, "\t# %"PRIx64" <%s>",
1485 orig_addr, sym->name);
1486 } else {
1487 scnprintf(buf, len, "\t# %"PRIx64" <%s+%#"PRIx64">",
1488 orig_addr, sym->name, addr - sym->start);
1489 }
1490 break;
1491 }
1492 }
1493
1494 static int symbol__disassemble_capstone_powerpc(char *filename, struct symbol *sym,
1495 struct annotate_args *args)
1496 {
1497 struct annotation *notes = symbol__annotation(sym);
1498 struct map *map = args->ms.map;
1499 struct dso *dso = map__dso(map);
1500 struct nscookie nsc;
1501 u64 start = map__rip_2objdump(map, sym->start);
1502 u64 end = map__rip_2objdump(map, sym->end);
1503 u64 len = end - start;
1504 u64 offset;
1505 int i, fd, count;
1506 bool is_64bit = false;
1507 bool needs_cs_close = false;
1508 u8 *buf = NULL;
1509 struct find_file_offset_data data = {
1510 .ip = start,
1511 };
1512 csh handle;
1513 char disasm_buf[512];
1514 struct disasm_line *dl;
1515 u32 *line;
1516 bool disassembler_style = false;
1517
1518 if (args->options->objdump_path)
1519 return -1;
1520
1521 nsinfo__mountns_enter(dso__nsinfo(dso), &nsc);
1522 fd = open(filename, O_RDONLY);
1523 nsinfo__mountns_exit(&nsc);
1524 if (fd < 0)
1525 return -1;
1526
1527 if (file__read_maps(fd, /*exe=*/true, find_file_offset, &data,
1528 &is_64bit) == 0)
1529 goto err;
1530
1531 if (!args->options->disassembler_style ||
1532 !strcmp(args->options->disassembler_style, "att"))
1533 disassembler_style = true;
1534
1535 if (capstone_init(maps__machine(args->ms.maps), &handle, is_64bit, disassembler_style) < 0)
1536 goto err;
1537
1538 needs_cs_close = true;
1539
1540 buf = malloc(len);
1541 if (buf == NULL)
1542 goto err;
1543
1544 count = pread(fd, buf, len, data.offset);
1545 close(fd);
1546 fd = -1;
1547
1548 if ((u64)count != len)
1549 goto err;
1550
1551 line = (u32 *)buf;
1552
1553 /* add the function address and name */
1554 scnprintf(disasm_buf, sizeof(disasm_buf), "%#"PRIx64" <%s>:",
1555 start, sym->name);
1556
1557 args->offset = -1;
1558 args->line = disasm_buf;
1559 args->line_nr = 0;
1560 args->fileloc = NULL;
1561 args->ms.sym = sym;
1562
1563 dl = disasm_line__new(args);
1564 if (dl == NULL)
1565 goto err;
1566
1567 annotation_line__add(&dl->al, &notes->src->source);
1568
1569 /*
1570 * TODO: enable disassm for powerpc
1571 * count = cs_disasm(handle, buf, len, start, len, &insn);
1572 *
1573 * For now, only binary code is saved in disassembled line
1574 * to be used in "type" and "typeoff" sort keys. Each raw code
1575 * is 32 bit instruction. So use "len/4" to get the number of
1576 * entries.
1577 */
1578 count = len/4;
1579
1580 for (i = 0, offset = 0; i < count; i++) {
1581 args->offset = offset;
1582 sprintf(args->line, "%x", line[i]);
1583
1584 dl = disasm_line__new(args);
1585 if (dl == NULL)
1586 break;
1587
1588 annotation_line__add(&dl->al, &notes->src->source);
1589
1590 offset += 4;
1591 }
1592
1593 /* It failed in the middle */
1594 if (offset != len) {
1595 struct list_head *list = &notes->src->source;
1596
1597 /* Discard all lines and fallback to objdump */
1598 while (!list_empty(list)) {
1599 dl = list_first_entry(list, struct disasm_line, al.node);
1600
1601 list_del_init(&dl->al.node);
1602 disasm_line__free(dl);
1603 }
1604 count = -1;
1605 }
1606
1607 out:
1608 if (needs_cs_close)
1609 cs_close(&handle);
1610 free(buf);
1611 return count < 0 ? count : 0;
1612
1613 err:
1614 if (fd >= 0)
1615 close(fd);
1616 count = -1;
1617 goto out;
1618 }
1619
1620 static int symbol__disassemble_capstone(char *filename, struct symbol *sym,
1621 struct annotate_args *args)
1622 {
1623 struct annotation *notes = symbol__annotation(sym);
1624 struct map *map = args->ms.map;
1625 u64 start = map__rip_2objdump(map, sym->start);
1626 u64 len;
1627 u64 offset;
1628 int i, count, free_count;
1629 bool is_64bit = false;
1630 bool needs_cs_close = false;
1631 u8 *buf = NULL;
1632 csh handle;
1633 cs_insn *insn = NULL;
1634 char disasm_buf[512];
1635 struct disasm_line *dl;
1636
1637 if (args->options->objdump_path)
1638 return -1;
1639
1640 buf = read_symbol(filename, map, sym, &len, &is_64bit);
1641 if (buf == NULL)
1642 return -1;
1643
1644 /* add the function address and name */
1645 scnprintf(disasm_buf, sizeof(disasm_buf), "%#"PRIx64" <%s>:",
1646 start, sym->name);
1647
1648 args->offset = -1;
1649 args->line = disasm_buf;
1650 args->line_nr = 0;
1651 args->fileloc = NULL;
1652 args->ms.sym = sym;
1653
1654 dl = disasm_line__new(args);
1655 if (dl == NULL)
1656 goto err;
1657
1658 annotation_line__add(&dl->al, &notes->src->source);
1659
1660 if (open_capstone_handle(args, is_64bit, &handle) < 0)
1661 goto err;
1662
1663 needs_cs_close = true;
1664
1665 free_count = count = cs_disasm(handle, buf, len, start, len, &insn);
1666 for (i = 0, offset = 0; i < count; i++) {
1667 int printed;
1668
1669 printed = scnprintf(disasm_buf, sizeof(disasm_buf),
1670 " %-7s %s",
1671 insn[i].mnemonic, insn[i].op_str);
1672 print_capstone_detail(&insn[i], disasm_buf + printed,
1673 sizeof(disasm_buf) - printed, args,
1674 start + offset);
1675
1676 args->offset = offset;
1677 args->line = disasm_buf;
1678
1679 dl = disasm_line__new(args);
1680 if (dl == NULL)
1681 goto err;
1682
1683 annotation_line__add(&dl->al, &notes->src->source);
1684
1685 offset += insn[i].size;
1686 }
1687
1688 /* It failed in the middle: probably due to unknown instructions */
1689 if (offset != len) {
1690 struct list_head *list = &notes->src->source;
1691
1692 /* Discard all lines and fallback to objdump */
1693 while (!list_empty(list)) {
1694 dl = list_first_entry(list, struct disasm_line, al.node);
1695
1696 list_del_init(&dl->al.node);
1697 disasm_line__free(dl);
1698 }
1699 count = -1;
1700 }
1701
1702 out:
1703 if (needs_cs_close) {
1704 cs_close(&handle);
1705 if (free_count > 0)
1706 cs_free(insn, free_count);
1707 }
1708 free(buf);
1709 return count < 0 ? count : 0;
1710
1711 err:
1712 if (needs_cs_close) {
1713 struct disasm_line *tmp;
1714
1715 /*
1716 * It probably failed in the middle of the above loop.
1717 * Release any resources it might add.
1718 */
1719 list_for_each_entry_safe(dl, tmp, &notes->src->source, al.node) {
1720 list_del(&dl->al.node);
1721 disasm_line__free(dl);
1722 }
1723 }
1724 count = -1;
1725 goto out;
1726 }
1727 #else // HAVE_LIBCAPSTONE_SUPPORT
1728 static int symbol__disassemble_capstone(char *filename, struct symbol *sym,
1729 struct annotate_args *args __maybe_unused)
1730 {
1731 symbol__disassembler_missing("capstone", filename, sym);
1732 return -1;
1733 }
1734
1735 static int symbol__disassemble_capstone_powerpc(char *filename, struct symbol *sym,
1736 struct annotate_args *args __maybe_unused)
1737 {
1738 symbol__disassembler_missing("capstone powerpc", filename, sym);
1739 return -1;
1740 }
1741 #endif // HAVE_LIBCAPSTONE_SUPPORT
1742
1743 static int symbol__disassemble_raw(char *filename, struct symbol *sym,
1744 struct annotate_args *args)
1745 {
1746 struct annotation *notes = symbol__annotation(sym);
1747 struct map *map = args->ms.map;
1748 struct dso *dso = map__dso(map);
1749 u64 start = map__rip_2objdump(map, sym->start);
1750 u64 end = map__rip_2objdump(map, sym->end);
1751 u64 len = end - start;
1752 u64 offset;
1753 int i, count;
1754 u8 *buf = NULL;
1755 char disasm_buf[512];
1756 struct disasm_line *dl;
1757 u32 *line;
1758
1759 /* Return if objdump is specified explicitly */
1760 if (args->options->objdump_path)
1761 return -1;
1762
1763 pr_debug("Reading raw instruction from : %s using dso__data_read_offset\n", filename);
1764
1765 buf = malloc(len);
1766 if (buf == NULL)
1767 goto err;
1768
1769 count = dso__data_read_offset(dso, NULL, sym->start, buf, len);
1770
1771 line = (u32 *)buf;
1772
1773 if ((u64)count != len)
1774 goto err;
1775
1776 /* add the function address and name */
1777 scnprintf(disasm_buf, sizeof(disasm_buf), "%#"PRIx64" <%s>:",
1778 start, sym->name);
1779
1780 args->offset = -1;
1781 args->line = disasm_buf;
1782 args->line_nr = 0;
1783 args->fileloc = NULL;
1784 args->ms.sym = sym;
1785
1786 dl = disasm_line__new(args);
1787 if (dl == NULL)
1788 goto err;
1789
1790 annotation_line__add(&dl->al, &notes->src->source);
1791
1792 /* Each raw instruction is 4 byte */
1793 count = len/4;
1794
1795 for (i = 0, offset = 0; i < count; i++) {
1796 args->offset = offset;
1797 sprintf(args->line, "%x", line[i]);
1798 dl = disasm_line__new(args);
1799 if (dl == NULL)
1800 break;
1801
1802 annotation_line__add(&dl->al, &notes->src->source);
1803 offset += 4;
1804 }
1805
1806 /* It failed in the middle */
1807 if (offset != len) {
1808 struct list_head *list = &notes->src->source;
1809
1810 /* Discard all lines and fallback to objdump */
1811 while (!list_empty(list)) {
1812 dl = list_first_entry(list, struct disasm_line, al.node);
1813
1814 list_del_init(&dl->al.node);
1815 disasm_line__free(dl);
1816 }
1817 count = -1;
1818 }
1819
1820 out:
1821 free(buf);
1822 return count < 0 ? count : 0;
1823
1824 err:
1825 count = -1;
1826 goto out;
1827 }
1828
1829 #ifdef HAVE_LIBLLVM_SUPPORT
1830 #include <llvm-c/Disassembler.h>
1831 #include <llvm-c/Target.h>
1832 #include "util/llvm-c-helpers.h"
1833
1834 struct symbol_lookup_storage {
1835 u64 branch_addr;
1836 u64 pcrel_load_addr;
1837 };
1838
1839 /*
1840 * Whenever LLVM wants to resolve an address into a symbol, it calls this
1841 * callback. We don't ever actually _return_ anything (in particular, because
1842 * it puts quotation marks around what we return), but we use this as a hint
1843 * that there is a branch or PC-relative address in the expression that we
1844 * should add some textual annotation for after the instruction. The caller
1845 * will use this information to add the actual annotation.
1846 */
1847 static const char *
1848 symbol_lookup_callback(void *disinfo, uint64_t value,
1849 uint64_t *ref_type,
1850 uint64_t address __maybe_unused,
1851 const char **ref __maybe_unused)
1852 {
1853 struct symbol_lookup_storage *storage = disinfo;
1854
1855 if (*ref_type == LLVMDisassembler_ReferenceType_In_Branch)
1856 storage->branch_addr = value;
1857 else if (*ref_type == LLVMDisassembler_ReferenceType_In_PCrel_Load)
1858 storage->pcrel_load_addr = value;
1859 *ref_type = LLVMDisassembler_ReferenceType_InOut_None;
1860 return NULL;
1861 }
1862
1863 static int symbol__disassemble_llvm(char *filename, struct symbol *sym,
1864 struct annotate_args *args)
1865 {
1866 struct annotation *notes = symbol__annotation(sym);
1867 struct map *map = args->ms.map;
1868 struct dso *dso = map__dso(map);
1869 u64 start = map__rip_2objdump(map, sym->start);
1870 u8 *buf;
1871 u64 len;
1872 u64 pc;
1873 bool is_64bit;
1874 char triplet[64];
1875 char disasm_buf[2048];
1876 size_t disasm_len;
1877 struct disasm_line *dl;
1878 LLVMDisasmContextRef disasm = NULL;
1879 struct symbol_lookup_storage storage;
1880 char *line_storage = NULL;
1881 size_t line_storage_len = 0;
1882 int ret = -1;
1883
1884 if (args->options->objdump_path)
1885 return -1;
1886
1887 LLVMInitializeAllTargetInfos();
1888 LLVMInitializeAllTargetMCs();
1889 LLVMInitializeAllDisassemblers();
1890
1891 buf = read_symbol(filename, map, sym, &len, &is_64bit);
1892 if (buf == NULL)
1893 return -1;
1894
1895 if (arch__is(args->arch, "x86")) {
1896 if (is_64bit)
1897 scnprintf(triplet, sizeof(triplet), "x86_64-pc-linux");
1898 else
1899 scnprintf(triplet, sizeof(triplet), "i686-pc-linux");
1900 } else {
1901 scnprintf(triplet, sizeof(triplet), "%s-linux-gnu",
1902 args->arch->name);
1903 }
1904
1905 disasm = LLVMCreateDisasm(triplet, &storage, 0, NULL,
1906 symbol_lookup_callback);
1907 if (disasm == NULL)
1908 goto err;
1909
1910 if (args->options->disassembler_style &&
1911 !strcmp(args->options->disassembler_style, "intel"))
1912 LLVMSetDisasmOptions(disasm,
1913 LLVMDisassembler_Option_AsmPrinterVariant);
1914
1915 /*
1916 * This needs to be set after AsmPrinterVariant, due to a bug in LLVM;
1917 * setting AsmPrinterVariant makes a new instruction printer, making it
1918 * forget about the PrintImmHex flag (which is applied before if both
1919 * are given to the same call).
1920 */
1921 LLVMSetDisasmOptions(disasm, LLVMDisassembler_Option_PrintImmHex);
1922
1923 /* add the function address and name */
1924 scnprintf(disasm_buf, sizeof(disasm_buf), "%#"PRIx64" <%s>:",
1925 start, sym->name);
1926
1927 args->offset = -1;
1928 args->line = disasm_buf;
1929 args->line_nr = 0;
1930 args->fileloc = NULL;
1931 args->ms.sym = sym;
1932
1933 dl = disasm_line__new(args);
1934 if (dl == NULL)
1935 goto err;
1936
1937 annotation_line__add(&dl->al, &notes->src->source);
1938
1939 pc = start;
1940 for (u64 offset = 0; offset < len; ) {
1941 unsigned int ins_len;
1942
1943 storage.branch_addr = 0;
1944 storage.pcrel_load_addr = 0;
1945
1946 ins_len = LLVMDisasmInstruction(disasm, buf + offset,
1947 len - offset, pc,
1948 disasm_buf, sizeof(disasm_buf));
1949 if (ins_len == 0)
1950 goto err;
1951 disasm_len = strlen(disasm_buf);
1952
1953 if (storage.branch_addr != 0) {
1954 char *name = llvm_name_for_code(dso, filename,
1955 storage.branch_addr);
1956 if (name != NULL) {
1957 disasm_len += scnprintf(disasm_buf + disasm_len,
1958 sizeof(disasm_buf) -
1959 disasm_len,
1960 " <%s>", name);
1961 free(name);
1962 }
1963 }
1964 if (storage.pcrel_load_addr != 0) {
1965 char *name = llvm_name_for_data(dso, filename,
1966 storage.pcrel_load_addr);
1967 disasm_len += scnprintf(disasm_buf + disasm_len,
1968 sizeof(disasm_buf) - disasm_len,
1969 " # %#"PRIx64,
1970 storage.pcrel_load_addr);
1971 if (name) {
1972 disasm_len += scnprintf(disasm_buf + disasm_len,
1973 sizeof(disasm_buf) -
1974 disasm_len,
1975 " <%s>", name);
1976 free(name);
1977 }
1978 }
1979
1980 args->offset = offset;
1981 args->line = expand_tabs(disasm_buf, &line_storage,
1982 &line_storage_len);
1983 args->line_nr = 0;
1984 args->fileloc = NULL;
1985 args->ms.sym = sym;
1986
1987 llvm_addr2line(filename, pc, &args->fileloc,
1988 (unsigned int *)&args->line_nr, false, NULL);
1989
1990 dl = disasm_line__new(args);
1991 if (dl == NULL)
1992 goto err;
1993
1994 annotation_line__add(&dl->al, &notes->src->source);
1995
1996 free(args->fileloc);
1997 pc += ins_len;
1998 offset += ins_len;
1999 }
2000
2001 ret = 0;
2002
2003 err:
2004 LLVMDisasmDispose(disasm);
2005 free(buf);
2006 free(line_storage);
2007 return ret;
2008 }
2009 #else // HAVE_LIBLLVM_SUPPORT
2010 static int symbol__disassemble_llvm(char *filename, struct symbol *sym,
2011 struct annotate_args *args __maybe_unused)
2012 {
2013 symbol__disassembler_missing("LLVM", filename, sym);
2014 return -1;
2015 }
2016 #endif // HAVE_LIBLLVM_SUPPORT
2017
2018 /*
2019 * Possibly create a new version of line with tabs expanded. Returns the
2020 * existing or new line, storage is updated if a new line is allocated. If
2021 * allocation fails then NULL is returned.
2022 */
2023 static char *expand_tabs(char *line, char **storage, size_t *storage_len)
2024 {
2025 size_t i, src, dst, len, new_storage_len, num_tabs;
2026 char *new_line;
2027 size_t line_len = strlen(line);
2028
2029 for (num_tabs = 0, i = 0; i < line_len; i++)
2030 if (line[i] == '\t')
2031 num_tabs++;
2032
2033 if (num_tabs == 0)
2034 return line;
2035
2036 /*
2037 * Space for the line and '\0', less the leading and trailing
2038 * spaces. Each tab may introduce 7 additional spaces.
2039 */
2040 new_storage_len = line_len + 1 + (num_tabs * 7);
2041
2042 new_line = malloc(new_storage_len);
2043 if (new_line == NULL) {
2044 pr_err("Failure allocating memory for tab expansion\n");
2045 return NULL;
2046 }
2047
2048 /*
2049 * Copy regions starting at src and expand tabs. If there are two
2050 * adjacent tabs then 'src == i', the memcpy is of size 0 and the spaces
2051 * are inserted.
2052 */
2053 for (i = 0, src = 0, dst = 0; i < line_len && num_tabs; i++) {
2054 if (line[i] == '\t') {
2055 len = i - src;
2056 memcpy(&new_line[dst], &line[src], len);
2057 dst += len;
2058 new_line[dst++] = ' ';
2059 while (dst % 8 != 0)
2060 new_line[dst++] = ' ';
2061 src = i + 1;
2062 num_tabs--;
2063 }
2064 }
2065
2066 /* Expand the last region. */
2067 len = line_len - src;
2068 memcpy(&new_line[dst], &line[src], len);
2069 dst += len;
2070 new_line[dst] = '\0';
2071
2072 free(*storage);
2073 *storage = new_line;
2074 *storage_len = new_storage_len;
2075 return new_line;
2076 }
2077
2078 static int symbol__disassemble_objdump(const char *filename, struct symbol *sym,
2079 struct annotate_args *args)
2080 {
2081 struct annotation_options *opts = &annotate_opts;
2082 struct map *map = args->ms.map;
2083 struct dso *dso = map__dso(map);
2084 char *command;
2085 FILE *file;
2086 int lineno = 0;
2087 char *fileloc = NULL;
2088 int nline;
2089 char *line;
2090 size_t line_len;
2091 const char *objdump_argv[] = {
2092 "/bin/sh",
2093 "-c",
2094 NULL, /* Will be the objdump command to run. */
2095 "--",
2096 NULL, /* Will be the symfs path. */
2097 NULL,
2098 };
2099 struct child_process objdump_process;
2100 int err;
2101
2102 err = asprintf(&command,
2103 "%s %s%s --start-address=0x%016" PRIx64
2104 " --stop-address=0x%016" PRIx64
2105 " %s -d %s %s %s %c%s%c %s%s -C \"$1\"",
2106 opts->objdump_path ?: "objdump",
2107 opts->disassembler_style ? "-M " : "",
2108 opts->disassembler_style ?: "",
2109 map__rip_2objdump(map, sym->start),
2110 map__rip_2objdump(map, sym->end),
2111 opts->show_linenr ? "-l" : "",
2112 opts->show_asm_raw ? "" : "--no-show-raw-insn",
2113 opts->annotate_src ? "-S" : "",
2114 opts->prefix ? "--prefix " : "",
2115 opts->prefix ? '"' : ' ',
2116 opts->prefix ?: "",
2117 opts->prefix ? '"' : ' ',
2118 opts->prefix_strip ? "--prefix-strip=" : "",
2119 opts->prefix_strip ?: "");
2120
2121 if (err < 0) {
2122 pr_err("Failure allocating memory for the command to run\n");
2123 return err;
2124 }
2125
2126 pr_debug("Executing: %s\n", command);
2127
2128 objdump_argv[2] = command;
2129 objdump_argv[4] = filename;
2130
2131 /* Create a pipe to read from for stdout */
2132 memset(&objdump_process, 0, sizeof(objdump_process));
2133 objdump_process.argv = objdump_argv;
2134 objdump_process.out = -1;
2135 objdump_process.err = -1;
2136 objdump_process.no_stderr = 1;
2137 if (start_command(&objdump_process)) {
2138 pr_err("Failure starting to run %s\n", command);
2139 err = -1;
2140 goto out_free_command;
2141 }
2142
2143 file = fdopen(objdump_process.out, "r");
2144 if (!file) {
2145 pr_err("Failure creating FILE stream for %s\n", command);
2146 /*
2147 * If we were using debug info should retry with
2148 * original binary.
2149 */
2150 err = -1;
2151 goto out_close_stdout;
2152 }
2153
2154 /* Storage for getline. */
2155 line = NULL;
2156 line_len = 0;
2157
2158 nline = 0;
2159 while (!feof(file)) {
2160 const char *match;
2161 char *expanded_line;
2162
2163 if (getline(&line, &line_len, file) < 0 || !line)
2164 break;
2165
2166 /* Skip lines containing "filename:" */
2167 match = strstr(line, filename);
2168 if (match && match[strlen(filename)] == ':')
2169 continue;
2170
2171 expanded_line = strim(line);
2172 expanded_line = expand_tabs(expanded_line, &line, &line_len);
2173 if (!expanded_line)
2174 break;
2175
2176 /*
2177 * The source code line number (lineno) needs to be kept in
2178 * across calls to symbol__parse_objdump_line(), so that it
2179 * can associate it with the instructions till the next one.
2180 * See disasm_line__new() and struct disasm_line::line_nr.
2181 */
2182 if (symbol__parse_objdump_line(sym, args, expanded_line,
2183 &lineno, &fileloc) < 0)
2184 break;
2185 nline++;
2186 }
2187 free(line);
2188 free(fileloc);
2189
2190 err = finish_command(&objdump_process);
2191 if (err)
2192 pr_err("Error running %s\n", command);
2193
2194 if (nline == 0) {
2195 err = -1;
2196 pr_err("No output from %s\n", command);
2197 }
2198
2199 /*
2200 * kallsyms does not have symbol sizes so there may a nop at the end.
2201 * Remove it.
2202 */
2203 if (dso__is_kcore(dso))
2204 delete_last_nop(sym);
2205
2206 fclose(file);
2207
2208 out_close_stdout:
2209 close(objdump_process.out);
2210
2211 out_free_command:
2212 free(command);
2213 return err;
2214 }
2215
2216 static int annotation_options__init_disassemblers(struct annotation_options *options)
2217 {
2218 char *disassembler;
2219
2220 if (options->disassemblers_str == NULL) {
2221 const char *default_disassemblers_str =
2222 #ifdef HAVE_LIBLLVM_SUPPORT
2223 "llvm,"
2224 #endif
2225 #ifdef HAVE_LIBCAPSTONE_SUPPORT
2226 "capstone,"
2227 #endif
2228 "objdump";
2229
2230 options->disassemblers_str = strdup(default_disassemblers_str);
2231 if (!options->disassemblers_str)
2232 goto out_enomem;
2233 }
2234
2235 disassembler = strdup(options->disassemblers_str);
2236 if (disassembler == NULL)
2237 goto out_enomem;
2238
2239 while (1) {
2240 char *comma = strchr(disassembler, ',');
2241
2242 if (comma != NULL)
2243 *comma = '\0';
2244
2245 options->disassemblers[options->nr_disassemblers++] = strim(disassembler);
2246
2247 if (comma == NULL)
2248 break;
2249
2250 disassembler = comma + 1;
2251
2252 if (options->nr_disassemblers >= MAX_DISASSEMBLERS) {
2253 pr_debug("annotate.disassemblers can have at most %d entries, ignoring \"%s\"\n",
2254 MAX_DISASSEMBLERS, disassembler);
2255 break;
2256 }
2257 }
2258
2259 return 0;
2260
2261 out_enomem:
2262 pr_err("Not enough memory for annotate.disassemblers\n");
2263 return -1;
2264 }
2265
2266 int symbol__disassemble(struct symbol *sym, struct annotate_args *args)
2267 {
2268 struct annotation_options *options = args->options;
2269 struct map *map = args->ms.map;
2270 struct dso *dso = map__dso(map);
2271 char symfs_filename[PATH_MAX];
2272 bool delete_extract = false;
2273 struct kcore_extract kce;
2274 const char *disassembler;
2275 bool decomp = false;
2276 int err = dso__disassemble_filename(dso, symfs_filename, sizeof(symfs_filename));
2277
2278 if (err)
2279 return err;
2280
2281 pr_debug("%s: filename=%s, sym=%s, start=%#" PRIx64 ", end=%#" PRIx64 "\n", __func__,
2282 symfs_filename, sym->name, map__unmap_ip(map, sym->start),
2283 map__unmap_ip(map, sym->end));
2284
2285 pr_debug("annotating [%p] %30s : [%p] %30s\n", dso, dso__long_name(dso), sym, sym->name);
2286
2287 if (dso__binary_type(dso) == DSO_BINARY_TYPE__BPF_PROG_INFO) {
2288 return symbol__disassemble_bpf(sym, args);
2289 } else if (dso__binary_type(dso) == DSO_BINARY_TYPE__BPF_IMAGE) {
2290 return symbol__disassemble_bpf_image(sym, args);
2291 } else if (dso__binary_type(dso) == DSO_BINARY_TYPE__NOT_FOUND) {
2292 return -1;
2293 } else if (dso__is_kcore(dso)) {
2294 kce.addr = map__rip_2objdump(map, sym->start);
2295 kce.kcore_filename = symfs_filename;
2296 kce.len = sym->end - sym->start;
2297 kce.offs = sym->start;
2298
2299 if (!kcore_extract__create(&kce)) {
2300 delete_extract = true;
2301 strlcpy(symfs_filename, kce.extract_filename, sizeof(symfs_filename));
2302 }
2303 } else if (dso__needs_decompress(dso)) {
2304 char tmp[KMOD_DECOMP_LEN];
2305
2306 if (dso__decompress_kmodule_path(dso, symfs_filename, tmp, sizeof(tmp)) < 0)
2307 return -1;
2308
2309 decomp = true;
2310 strcpy(symfs_filename, tmp);
2311 }
2312
2313 /*
2314 * For powerpc data type profiling, use the dso__data_read_offset to
2315 * read raw instruction directly and interpret the binary code to
2316 * understand instructions and register fields. For sort keys as type
2317 * and typeoff, disassemble to mnemonic notation is not required in
2318 * case of powerpc.
2319 */
2320 if (arch__is(args->arch, "powerpc")) {
2321 extern const char *sort_order;
2322
2323 if (sort_order && !strstr(sort_order, "sym")) {
2324 err = symbol__disassemble_raw(symfs_filename, sym, args);
2325 if (err == 0)
2326 goto out_remove_tmp;
2327
2328 err = symbol__disassemble_capstone_powerpc(symfs_filename, sym, args);
2329 if (err == 0)
2330 goto out_remove_tmp;
2331 }
2332 }
2333
2334 err = annotation_options__init_disassemblers(options);
2335 if (err)
2336 goto out_remove_tmp;
2337
2338 err = -1;
2339
2340 for (int i = 0; i < options->nr_disassemblers && err != 0; ++i) {
2341 disassembler = options->disassemblers[i];
2342
2343 if (!strcmp(disassembler, "llvm"))
2344 err = symbol__disassemble_llvm(symfs_filename, sym, args);
2345 else if (!strcmp(disassembler, "capstone"))
2346 err = symbol__disassemble_capstone(symfs_filename, sym, args);
2347 else if (!strcmp(disassembler, "objdump"))
2348 err = symbol__disassemble_objdump(symfs_filename, sym, args);
2349 else
2350 pr_debug("Unknown disassembler %s, skipping...\n", disassembler);
2351 }
2352
2353 if (err == 0) {
2354 pr_debug("Disassembled with %s\nannotate.disassemblers=%s\n",
2355 disassembler, options->disassemblers_str);
2356 }
2357 out_remove_tmp:
2358 if (decomp)
2359 unlink(symfs_filename);
2360
2361 if (delete_extract)
2362 kcore_extract__delete(&kce);
2363
2364 return err;
2365 }
Kernel DRM miscellaneous fixes and cross-tree changes