1829 lines · c
1/* SPDX-License-Identifier: GPL-2.0 */2/*3 * Convert sample address to data type using DWARF debug info.4 *5 * Written by Namhyung Kim <namhyung@kernel.org>6 */7 8#include <stdio.h>9#include <stdlib.h>10#include <inttypes.h>11#include <linux/zalloc.h>12 13#include "annotate.h"14#include "annotate-data.h"15#include "debuginfo.h"16#include "debug.h"17#include "dso.h"18#include "dwarf-regs.h"19#include "evsel.h"20#include "evlist.h"21#include "map.h"22#include "map_symbol.h"23#include "sort.h"24#include "strbuf.h"25#include "symbol.h"26#include "symbol_conf.h"27#include "thread.h"28 29/* register number of the stack pointer */30#define X86_REG_SP 731 32static void delete_var_types(struct die_var_type *var_types);33 34#define pr_debug_dtp(fmt, ...) \35do { \36 if (debug_type_profile) \37 pr_info(fmt, ##__VA_ARGS__); \38 else \39 pr_debug3(fmt, ##__VA_ARGS__); \40} while (0)41 42void pr_debug_type_name(Dwarf_Die *die, enum type_state_kind kind)43{44 struct strbuf sb;45 char *str;46 Dwarf_Word size = 0;47 48 if (!debug_type_profile && verbose < 3)49 return;50 51 switch (kind) {52 case TSR_KIND_INVALID:53 pr_info("\n");54 return;55 case TSR_KIND_PERCPU_BASE:56 pr_info(" percpu base\n");57 return;58 case TSR_KIND_CONST:59 pr_info(" constant\n");60 return;61 case TSR_KIND_POINTER:62 pr_info(" pointer");63 /* it also prints the type info */64 break;65 case TSR_KIND_CANARY:66 pr_info(" stack canary\n");67 return;68 case TSR_KIND_TYPE:69 default:70 break;71 }72 73 dwarf_aggregate_size(die, &size);74 75 strbuf_init(&sb, 32);76 die_get_typename_from_type(die, &sb);77 str = strbuf_detach(&sb, NULL);78 pr_info(" type='%s' size=%#lx (die:%#lx)\n",79 str, (long)size, (long)dwarf_dieoffset(die));80 free(str);81}82 83static void pr_debug_location(Dwarf_Die *die, u64 pc, int reg)84{85 ptrdiff_t off = 0;86 Dwarf_Attribute attr;87 Dwarf_Addr base, start, end;88 Dwarf_Op *ops;89 size_t nops;90 91 if (!debug_type_profile && verbose < 3)92 return;93 94 if (dwarf_attr(die, DW_AT_location, &attr) == NULL)95 return;96 97 while ((off = dwarf_getlocations(&attr, off, &base, &start, &end, &ops, &nops)) > 0) {98 if (reg != DWARF_REG_PC && end <= pc)99 continue;100 if (reg != DWARF_REG_PC && start > pc)101 break;102 103 pr_info(" variable location: ");104 switch (ops->atom) {105 case DW_OP_reg0 ...DW_OP_reg31:106 pr_info("reg%d\n", ops->atom - DW_OP_reg0);107 break;108 case DW_OP_breg0 ...DW_OP_breg31:109 pr_info("base=reg%d, offset=%#lx\n",110 ops->atom - DW_OP_breg0, (long)ops->number);111 break;112 case DW_OP_regx:113 pr_info("reg%ld\n", (long)ops->number);114 break;115 case DW_OP_bregx:116 pr_info("base=reg%ld, offset=%#lx\n",117 (long)ops->number, (long)ops->number2);118 break;119 case DW_OP_fbreg:120 pr_info("use frame base, offset=%#lx\n", (long)ops->number);121 break;122 case DW_OP_addr:123 pr_info("address=%#lx\n", (long)ops->number);124 break;125 default:126 pr_info("unknown: code=%#x, number=%#lx\n",127 ops->atom, (long)ops->number);128 break;129 }130 break;131 }132}133 134static void pr_debug_scope(Dwarf_Die *scope_die)135{136 int tag;137 138 if (!debug_type_profile && verbose < 3)139 return;140 141 pr_info("(die:%lx) ", (long)dwarf_dieoffset(scope_die));142 143 tag = dwarf_tag(scope_die);144 if (tag == DW_TAG_subprogram)145 pr_info("[function] %s\n", dwarf_diename(scope_die));146 else if (tag == DW_TAG_inlined_subroutine)147 pr_info("[inlined] %s\n", dwarf_diename(scope_die));148 else if (tag == DW_TAG_lexical_block)149 pr_info("[block]\n");150 else151 pr_info("[unknown] tag=%x\n", tag);152}153 154bool has_reg_type(struct type_state *state, int reg)155{156 return (unsigned)reg < ARRAY_SIZE(state->regs);157}158 159static void init_type_state(struct type_state *state, struct arch *arch)160{161 memset(state, 0, sizeof(*state));162 INIT_LIST_HEAD(&state->stack_vars);163 164 if (arch__is(arch, "x86")) {165 state->regs[0].caller_saved = true;166 state->regs[1].caller_saved = true;167 state->regs[2].caller_saved = true;168 state->regs[4].caller_saved = true;169 state->regs[5].caller_saved = true;170 state->regs[8].caller_saved = true;171 state->regs[9].caller_saved = true;172 state->regs[10].caller_saved = true;173 state->regs[11].caller_saved = true;174 state->ret_reg = 0;175 state->stack_reg = X86_REG_SP;176 }177}178 179static void exit_type_state(struct type_state *state)180{181 struct type_state_stack *stack, *tmp;182 183 list_for_each_entry_safe(stack, tmp, &state->stack_vars, list) {184 list_del(&stack->list);185 free(stack);186 }187}188 189/*190 * Compare type name and size to maintain them in a tree.191 * I'm not sure if DWARF would have information of a single type in many192 * different places (compilation units). If not, it could compare the193 * offset of the type entry in the .debug_info section.194 */195static int data_type_cmp(const void *_key, const struct rb_node *node)196{197 const struct annotated_data_type *key = _key;198 struct annotated_data_type *type;199 200 type = rb_entry(node, struct annotated_data_type, node);201 202 if (key->self.size != type->self.size)203 return key->self.size - type->self.size;204 return strcmp(key->self.type_name, type->self.type_name);205}206 207static bool data_type_less(struct rb_node *node_a, const struct rb_node *node_b)208{209 struct annotated_data_type *a, *b;210 211 a = rb_entry(node_a, struct annotated_data_type, node);212 b = rb_entry(node_b, struct annotated_data_type, node);213 214 if (a->self.size != b->self.size)215 return a->self.size < b->self.size;216 return strcmp(a->self.type_name, b->self.type_name) < 0;217}218 219/* Recursively add new members for struct/union */220static int __add_member_cb(Dwarf_Die *die, void *arg)221{222 struct annotated_member *parent = arg;223 struct annotated_member *member;224 Dwarf_Die member_type, die_mem;225 Dwarf_Word size, loc, bit_size = 0;226 Dwarf_Attribute attr;227 struct strbuf sb;228 int tag;229 230 if (dwarf_tag(die) != DW_TAG_member)231 return DIE_FIND_CB_SIBLING;232 233 member = zalloc(sizeof(*member));234 if (member == NULL)235 return DIE_FIND_CB_END;236 237 strbuf_init(&sb, 32);238 die_get_typename(die, &sb);239 240 __die_get_real_type(die, &member_type);241 if (dwarf_tag(&member_type) == DW_TAG_typedef)242 die_get_real_type(&member_type, &die_mem);243 else244 die_mem = member_type;245 246 if (dwarf_aggregate_size(&die_mem, &size) < 0)247 size = 0;248 249 if (dwarf_attr_integrate(die, DW_AT_data_member_location, &attr))250 dwarf_formudata(&attr, &loc);251 else {252 /* bitfield member */253 if (dwarf_attr_integrate(die, DW_AT_data_bit_offset, &attr) &&254 dwarf_formudata(&attr, &loc) == 0)255 loc /= 8;256 else257 loc = 0;258 259 if (dwarf_attr_integrate(die, DW_AT_bit_size, &attr) &&260 dwarf_formudata(&attr, &bit_size) == 0)261 size = (bit_size + 7) / 8;262 }263 264 member->type_name = strbuf_detach(&sb, NULL);265 /* member->var_name can be NULL */266 if (dwarf_diename(die)) {267 if (bit_size) {268 if (asprintf(&member->var_name, "%s:%ld",269 dwarf_diename(die), (long)bit_size) < 0)270 member->var_name = NULL;271 } else {272 member->var_name = strdup(dwarf_diename(die));273 }274 275 if (member->var_name == NULL) {276 free(member);277 return DIE_FIND_CB_END;278 }279 }280 member->size = size;281 member->offset = loc + parent->offset;282 INIT_LIST_HEAD(&member->children);283 list_add_tail(&member->node, &parent->children);284 285 tag = dwarf_tag(&die_mem);286 switch (tag) {287 case DW_TAG_structure_type:288 case DW_TAG_union_type:289 die_find_child(&die_mem, __add_member_cb, member, &die_mem);290 break;291 default:292 break;293 }294 return DIE_FIND_CB_SIBLING;295}296 297static void add_member_types(struct annotated_data_type *parent, Dwarf_Die *type)298{299 Dwarf_Die die_mem;300 301 die_find_child(type, __add_member_cb, &parent->self, &die_mem);302}303 304static void delete_members(struct annotated_member *member)305{306 struct annotated_member *child, *tmp;307 308 list_for_each_entry_safe(child, tmp, &member->children, node) {309 list_del(&child->node);310 delete_members(child);311 zfree(&child->type_name);312 zfree(&child->var_name);313 free(child);314 }315}316 317static struct annotated_data_type *dso__findnew_data_type(struct dso *dso,318 Dwarf_Die *type_die)319{320 struct annotated_data_type *result = NULL;321 struct annotated_data_type key;322 struct rb_node *node;323 struct strbuf sb;324 char *type_name;325 Dwarf_Word size;326 327 strbuf_init(&sb, 32);328 if (die_get_typename_from_type(type_die, &sb) < 0)329 strbuf_add(&sb, "(unknown type)", 14);330 type_name = strbuf_detach(&sb, NULL);331 332 if (dwarf_tag(type_die) == DW_TAG_typedef)333 die_get_real_type(type_die, type_die);334 335 dwarf_aggregate_size(type_die, &size);336 337 /* Check existing nodes in dso->data_types tree */338 key.self.type_name = type_name;339 key.self.size = size;340 node = rb_find(&key, dso__data_types(dso), data_type_cmp);341 if (node) {342 result = rb_entry(node, struct annotated_data_type, node);343 free(type_name);344 return result;345 }346 347 /* If not, add a new one */348 result = zalloc(sizeof(*result));349 if (result == NULL) {350 free(type_name);351 return NULL;352 }353 354 result->self.type_name = type_name;355 result->self.size = size;356 INIT_LIST_HEAD(&result->self.children);357 358 if (symbol_conf.annotate_data_member)359 add_member_types(result, type_die);360 361 rb_add(&result->node, dso__data_types(dso), data_type_less);362 return result;363}364 365static bool find_cu_die(struct debuginfo *di, u64 pc, Dwarf_Die *cu_die)366{367 Dwarf_Off off, next_off;368 size_t header_size;369 370 if (dwarf_addrdie(di->dbg, pc, cu_die) != NULL)371 return cu_die;372 373 /*374 * There are some kernels don't have full aranges and contain only a few375 * aranges entries. Fallback to iterate all CU entries in .debug_info376 * in case it's missing.377 */378 off = 0;379 while (dwarf_nextcu(di->dbg, off, &next_off, &header_size,380 NULL, NULL, NULL) == 0) {381 if (dwarf_offdie(di->dbg, off + header_size, cu_die) &&382 dwarf_haspc(cu_die, pc))383 return true;384 385 off = next_off;386 }387 return false;388}389 390enum type_match_result {391 PERF_TMR_UNKNOWN = 0,392 PERF_TMR_OK,393 PERF_TMR_NO_TYPE,394 PERF_TMR_NO_POINTER,395 PERF_TMR_NO_SIZE,396 PERF_TMR_BAD_OFFSET,397 PERF_TMR_BAIL_OUT,398};399 400static const char *match_result_str(enum type_match_result tmr)401{402 switch (tmr) {403 case PERF_TMR_OK:404 return "Good!";405 case PERF_TMR_NO_TYPE:406 return "no type information";407 case PERF_TMR_NO_POINTER:408 return "no/void pointer";409 case PERF_TMR_NO_SIZE:410 return "type size is unknown";411 case PERF_TMR_BAD_OFFSET:412 return "offset bigger than size";413 case PERF_TMR_UNKNOWN:414 case PERF_TMR_BAIL_OUT:415 default:416 return "invalid state";417 }418}419 420static bool is_pointer_type(Dwarf_Die *type_die)421{422 int tag = dwarf_tag(type_die);423 424 return tag == DW_TAG_pointer_type || tag == DW_TAG_array_type;425}426 427static bool is_compound_type(Dwarf_Die *type_die)428{429 int tag = dwarf_tag(type_die);430 431 return tag == DW_TAG_structure_type || tag == DW_TAG_union_type;432}433 434/* returns if Type B has better information than Type A */435static bool is_better_type(Dwarf_Die *type_a, Dwarf_Die *type_b)436{437 Dwarf_Word size_a, size_b;438 Dwarf_Die die_a, die_b;439 440 /* pointer type is preferred */441 if (is_pointer_type(type_a) != is_pointer_type(type_b))442 return is_pointer_type(type_b);443 444 if (is_pointer_type(type_b)) {445 /*446 * We want to compare the target type, but 'void *' can fail to447 * get the target type.448 */449 if (die_get_real_type(type_a, &die_a) == NULL)450 return true;451 if (die_get_real_type(type_b, &die_b) == NULL)452 return false;453 454 type_a = &die_a;455 type_b = &die_b;456 }457 458 /* bigger type is preferred */459 if (dwarf_aggregate_size(type_a, &size_a) < 0 ||460 dwarf_aggregate_size(type_b, &size_b) < 0)461 return false;462 463 if (size_a != size_b)464 return size_a < size_b;465 466 /* struct or union is preferred */467 if (is_compound_type(type_a) != is_compound_type(type_b))468 return is_compound_type(type_b);469 470 /* typedef is preferred */471 if (dwarf_tag(type_b) == DW_TAG_typedef)472 return true;473 474 return false;475}476 477/* The type info will be saved in @type_die */478static enum type_match_result check_variable(struct data_loc_info *dloc,479 Dwarf_Die *var_die,480 Dwarf_Die *type_die, int reg,481 int offset, bool is_fbreg)482{483 Dwarf_Word size;484 bool needs_pointer = true;485 Dwarf_Die sized_type;486 487 if (reg == DWARF_REG_PC)488 needs_pointer = false;489 else if (reg == dloc->fbreg || is_fbreg)490 needs_pointer = false;491 else if (arch__is(dloc->arch, "x86") && reg == X86_REG_SP)492 needs_pointer = false;493 494 /* Get the type of the variable */495 if (__die_get_real_type(var_die, type_die) == NULL)496 return PERF_TMR_NO_TYPE;497 498 /*499 * Usually it expects a pointer type for a memory access.500 * Convert to a real type it points to. But global variables501 * and local variables are accessed directly without a pointer.502 */503 if (needs_pointer) {504 if (!is_pointer_type(type_die) ||505 __die_get_real_type(type_die, type_die) == NULL)506 return PERF_TMR_NO_POINTER;507 }508 509 if (dwarf_tag(type_die) == DW_TAG_typedef)510 die_get_real_type(type_die, &sized_type);511 else512 sized_type = *type_die;513 514 /* Get the size of the actual type */515 if (dwarf_aggregate_size(&sized_type, &size) < 0)516 return PERF_TMR_NO_SIZE;517 518 /* Minimal sanity check */519 if ((unsigned)offset >= size)520 return PERF_TMR_BAD_OFFSET;521 522 return PERF_TMR_OK;523}524 525struct type_state_stack *find_stack_state(struct type_state *state,526 int offset)527{528 struct type_state_stack *stack;529 530 list_for_each_entry(stack, &state->stack_vars, list) {531 if (offset == stack->offset)532 return stack;533 534 if (stack->compound && stack->offset < offset &&535 offset < stack->offset + stack->size)536 return stack;537 }538 return NULL;539}540 541void set_stack_state(struct type_state_stack *stack, int offset, u8 kind,542 Dwarf_Die *type_die)543{544 int tag;545 Dwarf_Word size;546 547 if (dwarf_aggregate_size(type_die, &size) < 0)548 size = 0;549 550 tag = dwarf_tag(type_die);551 552 stack->type = *type_die;553 stack->size = size;554 stack->offset = offset;555 stack->kind = kind;556 557 switch (tag) {558 case DW_TAG_structure_type:559 case DW_TAG_union_type:560 stack->compound = (kind != TSR_KIND_POINTER);561 break;562 default:563 stack->compound = false;564 break;565 }566}567 568struct type_state_stack *findnew_stack_state(struct type_state *state,569 int offset, u8 kind,570 Dwarf_Die *type_die)571{572 struct type_state_stack *stack = find_stack_state(state, offset);573 574 if (stack) {575 set_stack_state(stack, offset, kind, type_die);576 return stack;577 }578 579 stack = malloc(sizeof(*stack));580 if (stack) {581 set_stack_state(stack, offset, kind, type_die);582 list_add(&stack->list, &state->stack_vars);583 }584 return stack;585}586 587/* Maintain a cache for quick global variable lookup */588struct global_var_entry {589 struct rb_node node;590 char *name;591 u64 start;592 u64 end;593 u64 die_offset;594};595 596static int global_var_cmp(const void *_key, const struct rb_node *node)597{598 const u64 addr = (uintptr_t)_key;599 struct global_var_entry *gvar;600 601 gvar = rb_entry(node, struct global_var_entry, node);602 603 if (gvar->start <= addr && addr < gvar->end)604 return 0;605 return gvar->start > addr ? -1 : 1;606}607 608static bool global_var_less(struct rb_node *node_a, const struct rb_node *node_b)609{610 struct global_var_entry *gvar_a, *gvar_b;611 612 gvar_a = rb_entry(node_a, struct global_var_entry, node);613 gvar_b = rb_entry(node_b, struct global_var_entry, node);614 615 return gvar_a->start < gvar_b->start;616}617 618static struct global_var_entry *global_var__find(struct data_loc_info *dloc, u64 addr)619{620 struct dso *dso = map__dso(dloc->ms->map);621 struct rb_node *node;622 623 node = rb_find((void *)(uintptr_t)addr, dso__global_vars(dso), global_var_cmp);624 if (node == NULL)625 return NULL;626 627 return rb_entry(node, struct global_var_entry, node);628}629 630static bool global_var__add(struct data_loc_info *dloc, u64 addr,631 const char *name, Dwarf_Die *type_die)632{633 struct dso *dso = map__dso(dloc->ms->map);634 struct global_var_entry *gvar;635 Dwarf_Word size;636 637 if (dwarf_aggregate_size(type_die, &size) < 0)638 return false;639 640 gvar = malloc(sizeof(*gvar));641 if (gvar == NULL)642 return false;643 644 gvar->name = name ? strdup(name) : NULL;645 if (name && gvar->name == NULL) {646 free(gvar);647 return false;648 }649 650 gvar->start = addr;651 gvar->end = addr + size;652 gvar->die_offset = dwarf_dieoffset(type_die);653 654 rb_add(&gvar->node, dso__global_vars(dso), global_var_less);655 return true;656}657 658void global_var_type__tree_delete(struct rb_root *root)659{660 struct global_var_entry *gvar;661 662 while (!RB_EMPTY_ROOT(root)) {663 struct rb_node *node = rb_first(root);664 665 rb_erase(node, root);666 gvar = rb_entry(node, struct global_var_entry, node);667 zfree(&gvar->name);668 free(gvar);669 }670}671 672bool get_global_var_info(struct data_loc_info *dloc, u64 addr,673 const char **var_name, int *var_offset)674{675 struct addr_location al;676 struct symbol *sym;677 u64 mem_addr;678 679 /* Kernel symbols might be relocated */680 mem_addr = addr + map__reloc(dloc->ms->map);681 682 addr_location__init(&al);683 sym = thread__find_symbol_fb(dloc->thread, dloc->cpumode,684 mem_addr, &al);685 if (sym) {686 *var_name = sym->name;687 /* Calculate type offset from the start of variable */688 *var_offset = mem_addr - map__unmap_ip(al.map, sym->start);689 } else {690 *var_name = NULL;691 }692 addr_location__exit(&al);693 if (*var_name == NULL)694 return false;695 696 return true;697}698 699static void global_var__collect(struct data_loc_info *dloc)700{701 Dwarf *dwarf = dloc->di->dbg;702 Dwarf_Off off, next_off;703 Dwarf_Die cu_die, type_die;704 size_t header_size;705 706 /* Iterate all CU and collect global variables that have no location in a register. */707 off = 0;708 while (dwarf_nextcu(dwarf, off, &next_off, &header_size,709 NULL, NULL, NULL) == 0) {710 struct die_var_type *var_types = NULL;711 struct die_var_type *pos;712 713 if (dwarf_offdie(dwarf, off + header_size, &cu_die) == NULL) {714 off = next_off;715 continue;716 }717 718 die_collect_global_vars(&cu_die, &var_types);719 720 for (pos = var_types; pos; pos = pos->next) {721 const char *var_name = NULL;722 int var_offset = 0;723 724 if (pos->reg != -1)725 continue;726 727 if (!dwarf_offdie(dwarf, pos->die_off, &type_die))728 continue;729 730 if (!get_global_var_info(dloc, pos->addr, &var_name,731 &var_offset))732 continue;733 734 if (var_offset != 0)735 continue;736 737 global_var__add(dloc, pos->addr, var_name, &type_die);738 }739 740 delete_var_types(var_types);741 742 off = next_off;743 }744}745 746bool get_global_var_type(Dwarf_Die *cu_die, struct data_loc_info *dloc,747 u64 ip, u64 var_addr, int *var_offset,748 Dwarf_Die *type_die)749{750 u64 pc;751 int offset;752 const char *var_name = NULL;753 struct global_var_entry *gvar;754 struct dso *dso = map__dso(dloc->ms->map);755 Dwarf_Die var_die;756 757 if (RB_EMPTY_ROOT(dso__global_vars(dso)))758 global_var__collect(dloc);759 760 gvar = global_var__find(dloc, var_addr);761 if (gvar) {762 if (!dwarf_offdie(dloc->di->dbg, gvar->die_offset, type_die))763 return false;764 765 *var_offset = var_addr - gvar->start;766 return true;767 }768 769 /* Try to get the variable by address first */770 if (die_find_variable_by_addr(cu_die, var_addr, &var_die, &offset) &&771 check_variable(dloc, &var_die, type_die, DWARF_REG_PC, offset,772 /*is_fbreg=*/false) == PERF_TMR_OK) {773 var_name = dwarf_diename(&var_die);774 *var_offset = offset;775 goto ok;776 }777 778 if (!get_global_var_info(dloc, var_addr, &var_name, var_offset))779 return false;780 781 pc = map__rip_2objdump(dloc->ms->map, ip);782 783 /* Try to get the name of global variable */784 if (die_find_variable_at(cu_die, var_name, pc, &var_die) &&785 check_variable(dloc, &var_die, type_die, DWARF_REG_PC, *var_offset,786 /*is_fbreg=*/false) == PERF_TMR_OK)787 goto ok;788 789 return false;790 791ok:792 /* The address should point to the start of the variable */793 global_var__add(dloc, var_addr - *var_offset, var_name, type_die);794 return true;795}796 797static bool die_is_same(Dwarf_Die *die_a, Dwarf_Die *die_b)798{799 return (die_a->cu == die_b->cu) && (die_a->addr == die_b->addr);800}801 802/**803 * update_var_state - Update type state using given variables804 * @state: type state table805 * @dloc: data location info806 * @addr: instruction address to match with variable807 * @insn_offset: instruction offset (for debug)808 * @var_types: list of variables with type info809 *810 * This function fills the @state table using @var_types info. Each variable811 * is used only at the given location and updates an entry in the table.812 */813static void update_var_state(struct type_state *state, struct data_loc_info *dloc,814 u64 addr, u64 insn_offset, struct die_var_type *var_types)815{816 Dwarf_Die mem_die;817 struct die_var_type *var;818 int fbreg = dloc->fbreg;819 int fb_offset = 0;820 821 if (dloc->fb_cfa) {822 if (die_get_cfa(dloc->di->dbg, addr, &fbreg, &fb_offset) < 0)823 fbreg = -1;824 }825 826 for (var = var_types; var != NULL; var = var->next) {827 if (var->addr != addr)828 continue;829 /* Get the type DIE using the offset */830 if (!dwarf_offdie(dloc->di->dbg, var->die_off, &mem_die))831 continue;832 833 if (var->reg == DWARF_REG_FB || var->reg == fbreg) {834 int offset = var->offset;835 struct type_state_stack *stack;836 837 if (var->reg != DWARF_REG_FB)838 offset -= fb_offset;839 840 stack = find_stack_state(state, offset);841 if (stack && stack->kind == TSR_KIND_TYPE &&842 !is_better_type(&stack->type, &mem_die))843 continue;844 845 findnew_stack_state(state, offset, TSR_KIND_TYPE,846 &mem_die);847 848 pr_debug_dtp("var [%"PRIx64"] -%#x(stack)",849 insn_offset, -offset);850 pr_debug_type_name(&mem_die, TSR_KIND_TYPE);851 } else if (has_reg_type(state, var->reg) && var->offset == 0) {852 struct type_state_reg *reg;853 Dwarf_Die orig_type;854 855 reg = &state->regs[var->reg];856 857 if (reg->ok && reg->kind == TSR_KIND_TYPE &&858 !is_better_type(®->type, &mem_die))859 continue;860 861 orig_type = reg->type;862 863 reg->type = mem_die;864 reg->kind = TSR_KIND_TYPE;865 reg->ok = true;866 867 pr_debug_dtp("var [%"PRIx64"] reg%d",868 insn_offset, var->reg);869 pr_debug_type_name(&mem_die, TSR_KIND_TYPE);870 871 /*872 * If this register is directly copied from another and it gets a873 * better type, also update the type of the source register. This874 * is usually the case of container_of() macro with offset of 0.875 */876 if (has_reg_type(state, reg->copied_from)) {877 struct type_state_reg *copy_reg;878 879 copy_reg = &state->regs[reg->copied_from];880 881 /* TODO: check if type is compatible or embedded */882 if (!copy_reg->ok || (copy_reg->kind != TSR_KIND_TYPE) ||883 !die_is_same(©_reg->type, &orig_type) ||884 !is_better_type(©_reg->type, &mem_die))885 continue;886 887 copy_reg->type = mem_die;888 889 pr_debug_dtp("var [%"PRIx64"] copyback reg%d",890 insn_offset, reg->copied_from);891 pr_debug_type_name(&mem_die, TSR_KIND_TYPE);892 }893 }894 }895}896 897/**898 * update_insn_state - Update type state for an instruction899 * @state: type state table900 * @dloc: data location info901 * @cu_die: compile unit debug entry902 * @dl: disasm line for the instruction903 *904 * This function updates the @state table for the target operand of the905 * instruction at @dl if it transfers the type like MOV on x86. Since it906 * tracks the type, it won't care about the values like in arithmetic907 * instructions like ADD/SUB/MUL/DIV and INC/DEC.908 *909 * Note that ops->reg2 is only available when both mem_ref and multi_regs910 * are true.911 */912static void update_insn_state(struct type_state *state, struct data_loc_info *dloc,913 Dwarf_Die *cu_die, struct disasm_line *dl)914{915 if (dloc->arch->update_insn_state)916 dloc->arch->update_insn_state(state, dloc, cu_die, dl);917}918 919/*920 * Prepend this_blocks (from the outer scope) to full_blocks, removing921 * duplicate disasm line.922 */923static void prepend_basic_blocks(struct list_head *this_blocks,924 struct list_head *full_blocks)925{926 struct annotated_basic_block *first_bb, *last_bb;927 928 last_bb = list_last_entry(this_blocks, typeof(*last_bb), list);929 first_bb = list_first_entry(full_blocks, typeof(*first_bb), list);930 931 if (list_empty(full_blocks))932 goto out;933 934 /* Last insn in this_blocks should be same as first insn in full_blocks */935 if (last_bb->end != first_bb->begin) {936 pr_debug("prepend basic blocks: mismatched disasm line %"PRIx64" -> %"PRIx64"\n",937 last_bb->end->al.offset, first_bb->begin->al.offset);938 goto out;939 }940 941 /* Is the basic block have only one disasm_line? */942 if (last_bb->begin == last_bb->end) {943 list_del(&last_bb->list);944 free(last_bb);945 goto out;946 }947 948 /* Point to the insn before the last when adding this block to full_blocks */949 last_bb->end = list_prev_entry(last_bb->end, al.node);950 951out:952 list_splice(this_blocks, full_blocks);953}954 955static void delete_basic_blocks(struct list_head *basic_blocks)956{957 struct annotated_basic_block *bb, *tmp;958 959 list_for_each_entry_safe(bb, tmp, basic_blocks, list) {960 list_del(&bb->list);961 free(bb);962 }963}964 965/* Make sure all variables have a valid start address */966static void fixup_var_address(struct die_var_type *var_types, u64 addr)967{968 while (var_types) {969 /*970 * Some variables have no address range meaning it's always971 * available in the whole scope. Let's adjust the start972 * address to the start of the scope.973 */974 if (var_types->addr == 0)975 var_types->addr = addr;976 977 var_types = var_types->next;978 }979}980 981static void delete_var_types(struct die_var_type *var_types)982{983 while (var_types) {984 struct die_var_type *next = var_types->next;985 986 free(var_types);987 var_types = next;988 }989}990 991/* should match to is_stack_canary() in util/annotate.c */992static void setup_stack_canary(struct data_loc_info *dloc)993{994 if (arch__is(dloc->arch, "x86")) {995 dloc->op->segment = INSN_SEG_X86_GS;996 dloc->op->imm = true;997 dloc->op->offset = 40;998 }999}1000 1001/*1002 * It's at the target address, check if it has a matching type.1003 * It returns PERF_TMR_BAIL_OUT when it looks up per-cpu variables which1004 * are similar to global variables and no additional info is needed.1005 */1006static enum type_match_result check_matching_type(struct type_state *state,1007 struct data_loc_info *dloc,1008 Dwarf_Die *cu_die,1009 struct disasm_line *dl,1010 Dwarf_Die *type_die)1011{1012 Dwarf_Word size;1013 u32 insn_offset = dl->al.offset;1014 int reg = dloc->op->reg1;1015 int offset = dloc->op->offset;1016 const char *offset_sign = "";1017 bool retry = true;1018 1019 if (offset < 0) {1020 offset = -offset;1021 offset_sign = "-";1022 }1023 1024again:1025 pr_debug_dtp("chk [%x] reg%d offset=%s%#x ok=%d kind=%d ",1026 insn_offset, reg, offset_sign, offset,1027 state->regs[reg].ok, state->regs[reg].kind);1028 1029 if (!state->regs[reg].ok)1030 goto check_non_register;1031 1032 if (state->regs[reg].kind == TSR_KIND_TYPE) {1033 Dwarf_Die sized_type;1034 struct strbuf sb;1035 1036 strbuf_init(&sb, 32);1037 die_get_typename_from_type(&state->regs[reg].type, &sb);1038 pr_debug_dtp("(%s)", sb.buf);1039 strbuf_release(&sb);1040 1041 /*1042 * Normal registers should hold a pointer (or array) to1043 * dereference a memory location.1044 */1045 if (!is_pointer_type(&state->regs[reg].type)) {1046 if (dloc->op->offset < 0 && reg != state->stack_reg)1047 goto check_kernel;1048 1049 return PERF_TMR_NO_POINTER;1050 }1051 1052 /* Remove the pointer and get the target type */1053 if (__die_get_real_type(&state->regs[reg].type, type_die) == NULL)1054 return PERF_TMR_NO_POINTER;1055 1056 dloc->type_offset = dloc->op->offset;1057 1058 if (dwarf_tag(type_die) == DW_TAG_typedef)1059 die_get_real_type(type_die, &sized_type);1060 else1061 sized_type = *type_die;1062 1063 /* Get the size of the actual type */1064 if (dwarf_aggregate_size(&sized_type, &size) < 0 ||1065 (unsigned)dloc->type_offset >= size)1066 return PERF_TMR_BAD_OFFSET;1067 1068 return PERF_TMR_OK;1069 }1070 1071 if (state->regs[reg].kind == TSR_KIND_POINTER) {1072 pr_debug_dtp("percpu ptr");1073 1074 /*1075 * It's actaully pointer but the address was calculated using1076 * some arithmetic. So it points to the actual type already.1077 */1078 *type_die = state->regs[reg].type;1079 1080 dloc->type_offset = dloc->op->offset;1081 1082 /* Get the size of the actual type */1083 if (dwarf_aggregate_size(type_die, &size) < 0 ||1084 (unsigned)dloc->type_offset >= size)1085 return PERF_TMR_BAIL_OUT;1086 1087 return PERF_TMR_OK;1088 }1089 1090 if (state->regs[reg].kind == TSR_KIND_CANARY) {1091 pr_debug_dtp("stack canary");1092 1093 /*1094 * This is a saved value of the stack canary which will be handled1095 * in the outer logic when it returns failure here. Pretend it's1096 * from the stack canary directly.1097 */1098 setup_stack_canary(dloc);1099 1100 return PERF_TMR_BAIL_OUT;1101 }1102 1103 if (state->regs[reg].kind == TSR_KIND_PERCPU_BASE) {1104 u64 var_addr = dloc->op->offset;1105 int var_offset;1106 1107 pr_debug_dtp("percpu var");1108 1109 if (dloc->op->multi_regs) {1110 int reg2 = dloc->op->reg2;1111 1112 if (dloc->op->reg2 == reg)1113 reg2 = dloc->op->reg1;1114 1115 if (has_reg_type(state, reg2) && state->regs[reg2].ok &&1116 state->regs[reg2].kind == TSR_KIND_CONST)1117 var_addr += state->regs[reg2].imm_value;1118 }1119 1120 if (get_global_var_type(cu_die, dloc, dloc->ip, var_addr,1121 &var_offset, type_die)) {1122 dloc->type_offset = var_offset;1123 return PERF_TMR_OK;1124 }1125 /* No need to retry per-cpu (global) variables */1126 return PERF_TMR_BAIL_OUT;1127 }1128 1129check_non_register:1130 if (reg == dloc->fbreg) {1131 struct type_state_stack *stack;1132 1133 pr_debug_dtp("fbreg");1134 1135 stack = find_stack_state(state, dloc->type_offset);1136 if (stack == NULL) {1137 if (retry) {1138 pr_debug_dtp(" : retry\n");1139 retry = false;1140 1141 /* update type info it's the first store to the stack */1142 update_insn_state(state, dloc, cu_die, dl);1143 goto again;1144 }1145 return PERF_TMR_NO_TYPE;1146 }1147 1148 if (stack->kind == TSR_KIND_CANARY) {1149 setup_stack_canary(dloc);1150 return PERF_TMR_BAIL_OUT;1151 }1152 1153 if (stack->kind != TSR_KIND_TYPE)1154 return PERF_TMR_NO_TYPE;1155 1156 *type_die = stack->type;1157 /* Update the type offset from the start of slot */1158 dloc->type_offset -= stack->offset;1159 1160 return PERF_TMR_OK;1161 }1162 1163 if (dloc->fb_cfa) {1164 struct type_state_stack *stack;1165 u64 pc = map__rip_2objdump(dloc->ms->map, dloc->ip);1166 int fbreg, fboff;1167 1168 pr_debug_dtp("cfa");1169 1170 if (die_get_cfa(dloc->di->dbg, pc, &fbreg, &fboff) < 0)1171 fbreg = -1;1172 1173 if (reg != fbreg)1174 return PERF_TMR_NO_TYPE;1175 1176 stack = find_stack_state(state, dloc->type_offset - fboff);1177 if (stack == NULL) {1178 if (retry) {1179 pr_debug_dtp(" : retry\n");1180 retry = false;1181 1182 /* update type info it's the first store to the stack */1183 update_insn_state(state, dloc, cu_die, dl);1184 goto again;1185 }1186 return PERF_TMR_NO_TYPE;1187 }1188 1189 if (stack->kind == TSR_KIND_CANARY) {1190 setup_stack_canary(dloc);1191 return PERF_TMR_BAIL_OUT;1192 }1193 1194 if (stack->kind != TSR_KIND_TYPE)1195 return PERF_TMR_NO_TYPE;1196 1197 *type_die = stack->type;1198 /* Update the type offset from the start of slot */1199 dloc->type_offset -= fboff + stack->offset;1200 1201 return PERF_TMR_OK;1202 }1203 1204check_kernel:1205 if (dso__kernel(map__dso(dloc->ms->map))) {1206 u64 addr;1207 1208 /* Direct this-cpu access like "%gs:0x34740" */1209 if (dloc->op->segment == INSN_SEG_X86_GS && dloc->op->imm &&1210 arch__is(dloc->arch, "x86")) {1211 pr_debug_dtp("this-cpu var");1212 1213 addr = dloc->op->offset;1214 1215 if (get_global_var_type(cu_die, dloc, dloc->ip, addr,1216 &offset, type_die)) {1217 dloc->type_offset = offset;1218 return PERF_TMR_OK;1219 }1220 return PERF_TMR_BAIL_OUT;1221 }1222 1223 /* Access to global variable like "-0x7dcf0500(,%rdx,8)" */1224 if (dloc->op->offset < 0 && reg != state->stack_reg) {1225 addr = (s64) dloc->op->offset;1226 1227 if (get_global_var_type(cu_die, dloc, dloc->ip, addr,1228 &offset, type_die)) {1229 pr_debug_dtp("global var");1230 1231 dloc->type_offset = offset;1232 return PERF_TMR_OK;1233 }1234 return PERF_TMR_BAIL_OUT;1235 }1236 }1237 1238 return PERF_TMR_UNKNOWN;1239}1240 1241/* Iterate instructions in basic blocks and update type table */1242static enum type_match_result find_data_type_insn(struct data_loc_info *dloc,1243 struct list_head *basic_blocks,1244 struct die_var_type *var_types,1245 Dwarf_Die *cu_die,1246 Dwarf_Die *type_die)1247{1248 struct type_state state;1249 struct symbol *sym = dloc->ms->sym;1250 struct annotation *notes = symbol__annotation(sym);1251 struct annotated_basic_block *bb;1252 enum type_match_result ret = PERF_TMR_UNKNOWN;1253 1254 init_type_state(&state, dloc->arch);1255 1256 list_for_each_entry(bb, basic_blocks, list) {1257 struct disasm_line *dl = bb->begin;1258 1259 BUG_ON(bb->begin->al.offset == -1 || bb->end->al.offset == -1);1260 1261 pr_debug_dtp("bb: [%"PRIx64" - %"PRIx64"]\n",1262 bb->begin->al.offset, bb->end->al.offset);1263 1264 list_for_each_entry_from(dl, ¬es->src->source, al.node) {1265 u64 this_ip = sym->start + dl->al.offset;1266 u64 addr = map__rip_2objdump(dloc->ms->map, this_ip);1267 1268 /* Skip comment or debug info lines */1269 if (dl->al.offset == -1)1270 continue;1271 1272 /* Update variable type at this address */1273 update_var_state(&state, dloc, addr, dl->al.offset, var_types);1274 1275 if (this_ip == dloc->ip) {1276 ret = check_matching_type(&state, dloc,1277 cu_die, dl, type_die);1278 pr_debug_dtp(" : %s\n", match_result_str(ret));1279 goto out;1280 }1281 1282 /* Update type table after processing the instruction */1283 update_insn_state(&state, dloc, cu_die, dl);1284 if (dl == bb->end)1285 break;1286 }1287 }1288 1289out:1290 exit_type_state(&state);1291 return ret;1292}1293 1294static int arch_supports_insn_tracking(struct data_loc_info *dloc)1295{1296 if ((arch__is(dloc->arch, "x86")) || (arch__is(dloc->arch, "powerpc")))1297 return 1;1298 return 0;1299}1300 1301/*1302 * Construct a list of basic blocks for each scope with variables and try to find1303 * the data type by updating a type state table through instructions.1304 */1305static enum type_match_result find_data_type_block(struct data_loc_info *dloc,1306 Dwarf_Die *cu_die,1307 Dwarf_Die *scopes,1308 int nr_scopes,1309 Dwarf_Die *type_die)1310{1311 LIST_HEAD(basic_blocks);1312 struct die_var_type *var_types = NULL;1313 u64 src_ip, dst_ip, prev_dst_ip;1314 enum type_match_result ret = PERF_TMR_UNKNOWN;1315 1316 /* TODO: other architecture support */1317 if (!arch_supports_insn_tracking(dloc))1318 return PERF_TMR_BAIL_OUT;1319 1320 prev_dst_ip = dst_ip = dloc->ip;1321 for (int i = nr_scopes - 1; i >= 0; i--) {1322 Dwarf_Addr base, start, end;1323 LIST_HEAD(this_blocks);1324 1325 if (dwarf_ranges(&scopes[i], 0, &base, &start, &end) < 0)1326 break;1327 1328 pr_debug_dtp("scope: [%d/%d] ", i + 1, nr_scopes);1329 pr_debug_scope(&scopes[i]);1330 1331 src_ip = map__objdump_2rip(dloc->ms->map, start);1332 1333again:1334 /* Get basic blocks for this scope */1335 if (annotate_get_basic_blocks(dloc->ms->sym, src_ip, dst_ip,1336 &this_blocks) < 0) {1337 /* Try previous block if they are not connected */1338 if (prev_dst_ip != dst_ip) {1339 dst_ip = prev_dst_ip;1340 goto again;1341 }1342 1343 pr_debug_dtp("cannot find a basic block from %"PRIx64" to %"PRIx64"\n",1344 src_ip - dloc->ms->sym->start,1345 dst_ip - dloc->ms->sym->start);1346 continue;1347 }1348 prepend_basic_blocks(&this_blocks, &basic_blocks);1349 1350 /* Get variable info for this scope and add to var_types list */1351 die_collect_vars(&scopes[i], &var_types);1352 fixup_var_address(var_types, start);1353 1354 /* Find from start of this scope to the target instruction */1355 ret = find_data_type_insn(dloc, &basic_blocks, var_types,1356 cu_die, type_die);1357 if (ret == PERF_TMR_OK) {1358 char buf[64];1359 int offset = dloc->op->offset;1360 const char *offset_sign = "";1361 1362 if (offset < 0) {1363 offset = -offset;1364 offset_sign = "-";1365 }1366 1367 if (dloc->op->multi_regs)1368 snprintf(buf, sizeof(buf), "reg%d, reg%d",1369 dloc->op->reg1, dloc->op->reg2);1370 else1371 snprintf(buf, sizeof(buf), "reg%d", dloc->op->reg1);1372 1373 pr_debug_dtp("found by insn track: %s%#x(%s) type-offset=%#x\n",1374 offset_sign, offset, buf, dloc->type_offset);1375 break;1376 }1377 1378 if (ret == PERF_TMR_BAIL_OUT)1379 break;1380 1381 /* Go up to the next scope and find blocks to the start */1382 prev_dst_ip = dst_ip;1383 dst_ip = src_ip;1384 }1385 1386 delete_basic_blocks(&basic_blocks);1387 delete_var_types(var_types);1388 return ret;1389}1390 1391/* The result will be saved in @type_die */1392static int find_data_type_die(struct data_loc_info *dloc, Dwarf_Die *type_die)1393{1394 struct annotated_op_loc *loc = dloc->op;1395 Dwarf_Die cu_die, var_die;1396 Dwarf_Die *scopes = NULL;1397 int reg, offset = loc->offset;1398 int ret = -1;1399 int i, nr_scopes;1400 int fbreg = -1;1401 int fb_offset = 0;1402 bool is_fbreg = false;1403 bool found = false;1404 u64 pc;1405 char buf[64];1406 enum type_match_result result = PERF_TMR_UNKNOWN;1407 const char *offset_sign = "";1408 1409 if (dloc->op->multi_regs)1410 snprintf(buf, sizeof(buf), "reg%d, reg%d", dloc->op->reg1, dloc->op->reg2);1411 else if (dloc->op->reg1 == DWARF_REG_PC)1412 snprintf(buf, sizeof(buf), "PC");1413 else1414 snprintf(buf, sizeof(buf), "reg%d", dloc->op->reg1);1415 1416 if (offset < 0) {1417 offset = -offset;1418 offset_sign = "-";1419 }1420 1421 pr_debug_dtp("-----------------------------------------------------------\n");1422 pr_debug_dtp("find data type for %s%#x(%s) at %s+%#"PRIx64"\n",1423 offset_sign, offset, buf,1424 dloc->ms->sym->name, dloc->ip - dloc->ms->sym->start);1425 1426 /*1427 * IP is a relative instruction address from the start of the map, as1428 * it can be randomized/relocated, it needs to translate to PC which is1429 * a file address for DWARF processing.1430 */1431 pc = map__rip_2objdump(dloc->ms->map, dloc->ip);1432 1433 /* Get a compile_unit for this address */1434 if (!find_cu_die(dloc->di, pc, &cu_die)) {1435 pr_debug_dtp("cannot find CU for address %"PRIx64"\n", pc);1436 ann_data_stat.no_cuinfo++;1437 return -1;1438 }1439 1440 reg = loc->reg1;1441 offset = loc->offset;1442 1443 pr_debug_dtp("CU for %s (die:%#lx)\n",1444 dwarf_diename(&cu_die), (long)dwarf_dieoffset(&cu_die));1445 1446 if (reg == DWARF_REG_PC) {1447 if (get_global_var_type(&cu_die, dloc, dloc->ip, dloc->var_addr,1448 &offset, type_die)) {1449 dloc->type_offset = offset;1450 1451 pr_debug_dtp("found by addr=%#"PRIx64" type_offset=%#x\n",1452 dloc->var_addr, offset);1453 pr_debug_type_name(type_die, TSR_KIND_TYPE);1454 found = true;1455 goto out;1456 }1457 }1458 1459 /* Get a list of nested scopes - i.e. (inlined) functions and blocks. */1460 nr_scopes = die_get_scopes(&cu_die, pc, &scopes);1461 1462 if (reg != DWARF_REG_PC && dwarf_hasattr(&scopes[0], DW_AT_frame_base)) {1463 Dwarf_Attribute attr;1464 Dwarf_Block block;1465 1466 /* Check if the 'reg' is assigned as frame base register */1467 if (dwarf_attr(&scopes[0], DW_AT_frame_base, &attr) != NULL &&1468 dwarf_formblock(&attr, &block) == 0 && block.length == 1) {1469 switch (*block.data) {1470 case DW_OP_reg0 ... DW_OP_reg31:1471 fbreg = dloc->fbreg = *block.data - DW_OP_reg0;1472 break;1473 case DW_OP_call_frame_cfa:1474 dloc->fb_cfa = true;1475 if (die_get_cfa(dloc->di->dbg, pc, &fbreg,1476 &fb_offset) < 0)1477 fbreg = -1;1478 break;1479 default:1480 break;1481 }1482 1483 pr_debug_dtp("frame base: cfa=%d fbreg=%d\n",1484 dloc->fb_cfa, fbreg);1485 }1486 }1487 1488retry:1489 is_fbreg = (reg == fbreg);1490 if (is_fbreg)1491 offset = loc->offset - fb_offset;1492 1493 /* Search from the inner-most scope to the outer */1494 for (i = nr_scopes - 1; i >= 0; i--) {1495 Dwarf_Die mem_die;1496 int type_offset = offset;1497 1498 if (reg == DWARF_REG_PC) {1499 if (!die_find_variable_by_addr(&scopes[i], dloc->var_addr,1500 &var_die, &type_offset))1501 continue;1502 } else {1503 /* Look up variables/parameters in this scope */1504 if (!die_find_variable_by_reg(&scopes[i], pc, reg,1505 &type_offset, is_fbreg, &var_die))1506 continue;1507 }1508 1509 pr_debug_dtp("found \"%s\" (die: %#lx) in scope=%d/%d (die: %#lx) ",1510 dwarf_diename(&var_die), (long)dwarf_dieoffset(&var_die),1511 i+1, nr_scopes, (long)dwarf_dieoffset(&scopes[i]));1512 1513 /* Found a variable, see if it's correct */1514 result = check_variable(dloc, &var_die, &mem_die, reg, type_offset, is_fbreg);1515 if (result == PERF_TMR_OK) {1516 if (reg == DWARF_REG_PC) {1517 pr_debug_dtp("addr=%#"PRIx64" type_offset=%#x\n",1518 dloc->var_addr, type_offset);1519 } else if (reg == DWARF_REG_FB || is_fbreg) {1520 pr_debug_dtp("stack_offset=%#x type_offset=%#x\n",1521 fb_offset, type_offset);1522 } else {1523 pr_debug_dtp("type_offset=%#x\n", type_offset);1524 }1525 1526 if (!found || is_better_type(type_die, &mem_die)) {1527 *type_die = mem_die;1528 dloc->type_offset = type_offset;1529 found = true;1530 }1531 } else {1532 pr_debug_dtp("failed: %s\n", match_result_str(result));1533 }1534 1535 pr_debug_location(&var_die, pc, reg);1536 pr_debug_type_name(&mem_die, TSR_KIND_TYPE);1537 }1538 1539 if (!found && loc->multi_regs && reg == loc->reg1 && loc->reg1 != loc->reg2) {1540 reg = loc->reg2;1541 goto retry;1542 }1543 1544 if (!found && reg != DWARF_REG_PC) {1545 result = find_data_type_block(dloc, &cu_die, scopes,1546 nr_scopes, type_die);1547 if (result == PERF_TMR_OK) {1548 ann_data_stat.insn_track++;1549 found = true;1550 }1551 }1552 1553out:1554 pr_debug_dtp("final result: ");1555 if (found) {1556 pr_debug_type_name(type_die, TSR_KIND_TYPE);1557 ret = 0;1558 } else {1559 switch (result) {1560 case PERF_TMR_NO_TYPE:1561 case PERF_TMR_NO_POINTER:1562 pr_debug_dtp("%s\n", match_result_str(result));1563 ann_data_stat.no_typeinfo++;1564 break;1565 case PERF_TMR_NO_SIZE:1566 pr_debug_dtp("%s\n", match_result_str(result));1567 ann_data_stat.invalid_size++;1568 break;1569 case PERF_TMR_BAD_OFFSET:1570 pr_debug_dtp("%s\n", match_result_str(result));1571 ann_data_stat.bad_offset++;1572 break;1573 case PERF_TMR_UNKNOWN:1574 case PERF_TMR_BAIL_OUT:1575 case PERF_TMR_OK: /* should not reach here */1576 default:1577 pr_debug_dtp("no variable found\n");1578 ann_data_stat.no_var++;1579 break;1580 }1581 ret = -1;1582 }1583 1584 free(scopes);1585 return ret;1586}1587 1588/**1589 * find_data_type - Return a data type at the location1590 * @dloc: data location1591 *1592 * This functions searches the debug information of the binary to get the data1593 * type it accesses. The exact location is expressed by (ip, reg, offset)1594 * for pointer variables or (ip, addr) for global variables. Note that global1595 * variables might update the @dloc->type_offset after finding the start of the1596 * variable. If it cannot find a global variable by address, it tried to find1597 * a declaration of the variable using var_name. In that case, @dloc->offset1598 * won't be updated.1599 *1600 * It return %NULL if not found.1601 */1602struct annotated_data_type *find_data_type(struct data_loc_info *dloc)1603{1604 struct dso *dso = map__dso(dloc->ms->map);1605 Dwarf_Die type_die;1606 1607 /*1608 * The type offset is the same as instruction offset by default.1609 * But when finding a global variable, the offset won't be valid.1610 */1611 dloc->type_offset = dloc->op->offset;1612 1613 dloc->fbreg = -1;1614 1615 if (find_data_type_die(dloc, &type_die) < 0)1616 return NULL;1617 1618 return dso__findnew_data_type(dso, &type_die);1619}1620 1621static int alloc_data_type_histograms(struct annotated_data_type *adt, int nr_entries)1622{1623 int i;1624 size_t sz = sizeof(struct type_hist);1625 1626 sz += sizeof(struct type_hist_entry) * adt->self.size;1627 1628 /* Allocate a table of pointers for each event */1629 adt->histograms = calloc(nr_entries, sizeof(*adt->histograms));1630 if (adt->histograms == NULL)1631 return -ENOMEM;1632 1633 /*1634 * Each histogram is allocated for the whole size of the type.1635 * TODO: Probably we can move the histogram to members.1636 */1637 for (i = 0; i < nr_entries; i++) {1638 adt->histograms[i] = zalloc(sz);1639 if (adt->histograms[i] == NULL)1640 goto err;1641 }1642 1643 adt->nr_histograms = nr_entries;1644 return 0;1645 1646err:1647 while (--i >= 0)1648 zfree(&(adt->histograms[i]));1649 zfree(&adt->histograms);1650 return -ENOMEM;1651}1652 1653static void delete_data_type_histograms(struct annotated_data_type *adt)1654{1655 for (int i = 0; i < adt->nr_histograms; i++)1656 zfree(&(adt->histograms[i]));1657 1658 zfree(&adt->histograms);1659 adt->nr_histograms = 0;1660}1661 1662void annotated_data_type__tree_delete(struct rb_root *root)1663{1664 struct annotated_data_type *pos;1665 1666 while (!RB_EMPTY_ROOT(root)) {1667 struct rb_node *node = rb_first(root);1668 1669 rb_erase(node, root);1670 pos = rb_entry(node, struct annotated_data_type, node);1671 delete_members(&pos->self);1672 delete_data_type_histograms(pos);1673 zfree(&pos->self.type_name);1674 free(pos);1675 }1676}1677 1678/**1679 * annotated_data_type__update_samples - Update histogram1680 * @adt: Data type to update1681 * @evsel: Event to update1682 * @offset: Offset in the type1683 * @nr_samples: Number of samples at this offset1684 * @period: Event count at this offset1685 *1686 * This function updates type histogram at @ofs for @evsel. Samples are1687 * aggregated before calling this function so it can be called with more1688 * than one samples at a certain offset.1689 */1690int annotated_data_type__update_samples(struct annotated_data_type *adt,1691 struct evsel *evsel, int offset,1692 int nr_samples, u64 period)1693{1694 struct type_hist *h;1695 1696 if (adt == NULL)1697 return 0;1698 1699 if (adt->histograms == NULL) {1700 int nr = evsel->evlist->core.nr_entries;1701 1702 if (alloc_data_type_histograms(adt, nr) < 0)1703 return -1;1704 }1705 1706 if (offset < 0 || offset >= adt->self.size)1707 return -1;1708 1709 h = adt->histograms[evsel->core.idx];1710 1711 h->nr_samples += nr_samples;1712 h->addr[offset].nr_samples += nr_samples;1713 h->period += period;1714 h->addr[offset].period += period;1715 return 0;1716}1717 1718static void print_annotated_data_header(struct hist_entry *he, struct evsel *evsel)1719{1720 struct dso *dso = map__dso(he->ms.map);1721 int nr_members = 1;1722 int nr_samples = he->stat.nr_events;1723 int width = 7;1724 const char *val_hdr = "Percent";1725 1726 if (evsel__is_group_event(evsel)) {1727 struct hist_entry *pair;1728 1729 list_for_each_entry(pair, &he->pairs.head, pairs.node)1730 nr_samples += pair->stat.nr_events;1731 }1732 1733 printf("Annotate type: '%s' in %s (%d samples):\n",1734 he->mem_type->self.type_name, dso__name(dso), nr_samples);1735 1736 if (evsel__is_group_event(evsel)) {1737 struct evsel *pos;1738 int i = 0;1739 1740 nr_members = 0;1741 for_each_group_evsel(pos, evsel) {1742 if (symbol_conf.skip_empty &&1743 evsel__hists(pos)->stats.nr_samples == 0)1744 continue;1745 1746 printf(" event[%d] = %s\n", i++, pos->name);1747 nr_members++;1748 }1749 }1750 1751 if (symbol_conf.show_total_period) {1752 width = 11;1753 val_hdr = "Period";1754 } else if (symbol_conf.show_nr_samples) {1755 width = 7;1756 val_hdr = "Samples";1757 }1758 1759 printf("============================================================================\n");1760 printf("%*s %10s %10s %s\n", (width + 1) * nr_members, val_hdr,1761 "offset", "size", "field");1762}1763 1764static void print_annotated_data_value(struct type_hist *h, u64 period, int nr_samples)1765{1766 double percent = h->period ? (100.0 * period / h->period) : 0;1767 const char *color = get_percent_color(percent);1768 1769 if (symbol_conf.show_total_period)1770 color_fprintf(stdout, color, " %11" PRIu64, period);1771 else if (symbol_conf.show_nr_samples)1772 color_fprintf(stdout, color, " %7d", nr_samples);1773 else1774 color_fprintf(stdout, color, " %7.2f", percent);1775}1776 1777static void print_annotated_data_type(struct annotated_data_type *mem_type,1778 struct annotated_member *member,1779 struct evsel *evsel, int indent)1780{1781 struct annotated_member *child;1782 struct type_hist *h = mem_type->histograms[evsel->core.idx];1783 int i, nr_events = 0, samples = 0;1784 u64 period = 0;1785 int width = symbol_conf.show_total_period ? 11 : 7;1786 struct evsel *pos;1787 1788 for_each_group_evsel(pos, evsel) {1789 h = mem_type->histograms[pos->core.idx];1790 1791 if (symbol_conf.skip_empty &&1792 evsel__hists(pos)->stats.nr_samples == 0)1793 continue;1794 1795 samples = 0;1796 period = 0;1797 for (i = 0; i < member->size; i++) {1798 samples += h->addr[member->offset + i].nr_samples;1799 period += h->addr[member->offset + i].period;1800 }1801 print_annotated_data_value(h, period, samples);1802 nr_events++;1803 }1804 1805 printf(" %#10x %#10x %*s%s\t%s",1806 member->offset, member->size, indent, "", member->type_name,1807 member->var_name ?: "");1808 1809 if (!list_empty(&member->children))1810 printf(" {\n");1811 1812 list_for_each_entry(child, &member->children, node)1813 print_annotated_data_type(mem_type, child, evsel, indent + 4);1814 1815 if (!list_empty(&member->children))1816 printf("%*s}", (width + 1) * nr_events + 24 + indent, "");1817 printf(";\n");1818}1819 1820int hist_entry__annotate_data_tty(struct hist_entry *he, struct evsel *evsel)1821{1822 print_annotated_data_header(he, evsel);1823 print_annotated_data_type(he->mem_type, &he->mem_type->self, evsel, 0);1824 printf("\n");1825 1826 /* move to the next entry */1827 return '>';1828}1829