blob: 30c4d19fcf112f5a7354711e30cd84f682fab9f0 [file] [log] [blame]
/* SPDX-License-Identifier: GPL-2.0 */
/*
* Convert sample address to data type using DWARF debug info.
*
* Written by Namhyung Kim <namhyung@kernel.org>
*/
#include <stdio.h>
#include <stdlib.h>
#include <inttypes.h>
#include "annotate.h"
#include "annotate-data.h"
#include "debuginfo.h"
#include "debug.h"
#include "dso.h"
#include "dwarf-regs.h"
#include "evsel.h"
#include "evlist.h"
#include "map.h"
#include "map_symbol.h"
#include "strbuf.h"
#include "symbol.h"
#include "symbol_conf.h"
/*
* Compare type name and size to maintain them in a tree.
* I'm not sure if DWARF would have information of a single type in many
* different places (compilation units). If not, it could compare the
* offset of the type entry in the .debug_info section.
*/
static int data_type_cmp(const void *_key, const struct rb_node *node)
{
const struct annotated_data_type *key = _key;
struct annotated_data_type *type;
type = rb_entry(node, struct annotated_data_type, node);
if (key->self.size != type->self.size)
return key->self.size - type->self.size;
return strcmp(key->self.type_name, type->self.type_name);
}
static bool data_type_less(struct rb_node *node_a, const struct rb_node *node_b)
{
struct annotated_data_type *a, *b;
a = rb_entry(node_a, struct annotated_data_type, node);
b = rb_entry(node_b, struct annotated_data_type, node);
if (a->self.size != b->self.size)
return a->self.size < b->self.size;
return strcmp(a->self.type_name, b->self.type_name) < 0;
}
/* Recursively add new members for struct/union */
static int __add_member_cb(Dwarf_Die *die, void *arg)
{
struct annotated_member *parent = arg;
struct annotated_member *member;
Dwarf_Die member_type, die_mem;
Dwarf_Word size, loc;
Dwarf_Attribute attr;
struct strbuf sb;
int tag;
if (dwarf_tag(die) != DW_TAG_member)
return DIE_FIND_CB_SIBLING;
member = zalloc(sizeof(*member));
if (member == NULL)
return DIE_FIND_CB_END;
strbuf_init(&sb, 32);
die_get_typename(die, &sb);
die_get_real_type(die, &member_type);
if (dwarf_aggregate_size(&member_type, &size) < 0)
size = 0;
if (!dwarf_attr_integrate(die, DW_AT_data_member_location, &attr))
loc = 0;
else
dwarf_formudata(&attr, &loc);
member->type_name = strbuf_detach(&sb, NULL);
/* member->var_name can be NULL */
if (dwarf_diename(die))
member->var_name = strdup(dwarf_diename(die));
member->size = size;
member->offset = loc + parent->offset;
INIT_LIST_HEAD(&member->children);
list_add_tail(&member->node, &parent->children);
tag = dwarf_tag(&member_type);
switch (tag) {
case DW_TAG_structure_type:
case DW_TAG_union_type:
die_find_child(&member_type, __add_member_cb, member, &die_mem);
break;
default:
break;
}
return DIE_FIND_CB_SIBLING;
}
static void add_member_types(struct annotated_data_type *parent, Dwarf_Die *type)
{
Dwarf_Die die_mem;
die_find_child(type, __add_member_cb, &parent->self, &die_mem);
}
static void delete_members(struct annotated_member *member)
{
struct annotated_member *child, *tmp;
list_for_each_entry_safe(child, tmp, &member->children, node) {
list_del(&child->node);
delete_members(child);
free(child->type_name);
free(child->var_name);
free(child);
}
}
static struct annotated_data_type *dso__findnew_data_type(struct dso *dso,
Dwarf_Die *type_die)
{
struct annotated_data_type *result = NULL;
struct annotated_data_type key;
struct rb_node *node;
struct strbuf sb;
char *type_name;
Dwarf_Word size;
strbuf_init(&sb, 32);
if (die_get_typename_from_type(type_die, &sb) < 0)
strbuf_add(&sb, "(unknown type)", 14);
type_name = strbuf_detach(&sb, NULL);
dwarf_aggregate_size(type_die, &size);
/* Check existing nodes in dso->data_types tree */
key.self.type_name = type_name;
key.self.size = size;
node = rb_find(&key, &dso->data_types, data_type_cmp);
if (node) {
result = rb_entry(node, struct annotated_data_type, node);
free(type_name);
return result;
}
/* If not, add a new one */
result = zalloc(sizeof(*result));
if (result == NULL) {
free(type_name);
return NULL;
}
result->self.type_name = type_name;
result->self.size = size;
INIT_LIST_HEAD(&result->self.children);
if (symbol_conf.annotate_data_member)
add_member_types(result, type_die);
rb_add(&result->node, &dso->data_types, data_type_less);
return result;
}
static bool find_cu_die(struct debuginfo *di, u64 pc, Dwarf_Die *cu_die)
{
Dwarf_Off off, next_off;
size_t header_size;
if (dwarf_addrdie(di->dbg, pc, cu_die) != NULL)
return cu_die;
/*
* There are some kernels don't have full aranges and contain only a few
* aranges entries. Fallback to iterate all CU entries in .debug_info
* in case it's missing.
*/
off = 0;
while (dwarf_nextcu(di->dbg, off, &next_off, &header_size,
NULL, NULL, NULL) == 0) {
if (dwarf_offdie(di->dbg, off + header_size, cu_die) &&
dwarf_haspc(cu_die, pc))
return true;
off = next_off;
}
return false;
}
/* The type info will be saved in @type_die */
static int check_variable(Dwarf_Die *var_die, Dwarf_Die *type_die, int offset,
bool is_pointer)
{
Dwarf_Word size;
/* Get the type of the variable */
if (die_get_real_type(var_die, type_die) == NULL) {
pr_debug("variable has no type\n");
ann_data_stat.no_typeinfo++;
return -1;
}
/*
* Usually it expects a pointer type for a memory access.
* Convert to a real type it points to. But global variables
* and local variables are accessed directly without a pointer.
*/
if (is_pointer) {
if ((dwarf_tag(type_die) != DW_TAG_pointer_type &&
dwarf_tag(type_die) != DW_TAG_array_type) ||
die_get_real_type(type_die, type_die) == NULL) {
pr_debug("no pointer or no type\n");
ann_data_stat.no_typeinfo++;
return -1;
}
}
/* Get the size of the actual type */
if (dwarf_aggregate_size(type_die, &size) < 0) {
pr_debug("type size is unknown\n");
ann_data_stat.invalid_size++;
return -1;
}
/* Minimal sanity check */
if ((unsigned)offset >= size) {
pr_debug("offset: %d is bigger than size: %" PRIu64 "\n", offset, size);
ann_data_stat.bad_offset++;
return -1;
}
return 0;
}
/* The result will be saved in @type_die */
static int find_data_type_die(struct debuginfo *di, u64 pc, u64 addr,
const char *var_name, struct annotated_op_loc *loc,
Dwarf_Die *type_die)
{
Dwarf_Die cu_die, var_die;
Dwarf_Die *scopes = NULL;
int reg, offset;
int ret = -1;
int i, nr_scopes;
int fbreg = -1;
bool is_fbreg = false;
int fb_offset = 0;
/* Get a compile_unit for this address */
if (!find_cu_die(di, pc, &cu_die)) {
pr_debug("cannot find CU for address %" PRIx64 "\n", pc);
ann_data_stat.no_cuinfo++;
return -1;
}
reg = loc->reg1;
offset = loc->offset;
if (reg == DWARF_REG_PC) {
if (die_find_variable_by_addr(&cu_die, pc, addr, &var_die, &offset)) {
ret = check_variable(&var_die, type_die, offset,
/*is_pointer=*/false);
loc->offset = offset;
goto out;
}
if (var_name && die_find_variable_at(&cu_die, var_name, pc,
&var_die)) {
ret = check_variable(&var_die, type_die, 0,
/*is_pointer=*/false);
/* loc->offset will be updated by the caller */
goto out;
}
}
/* Get a list of nested scopes - i.e. (inlined) functions and blocks. */
nr_scopes = die_get_scopes(&cu_die, pc, &scopes);
if (reg != DWARF_REG_PC && dwarf_hasattr(&scopes[0], DW_AT_frame_base)) {
Dwarf_Attribute attr;
Dwarf_Block block;
/* Check if the 'reg' is assigned as frame base register */
if (dwarf_attr(&scopes[0], DW_AT_frame_base, &attr) != NULL &&
dwarf_formblock(&attr, &block) == 0 && block.length == 1) {
switch (*block.data) {
case DW_OP_reg0 ... DW_OP_reg31:
fbreg = *block.data - DW_OP_reg0;
break;
case DW_OP_call_frame_cfa:
if (die_get_cfa(di->dbg, pc, &fbreg,
&fb_offset) < 0)
fbreg = -1;
break;
default:
break;
}
}
}
retry:
is_fbreg = (reg == fbreg);
if (is_fbreg)
offset = loc->offset - fb_offset;
/* Search from the inner-most scope to the outer */
for (i = nr_scopes - 1; i >= 0; i--) {
if (reg == DWARF_REG_PC) {
if (!die_find_variable_by_addr(&scopes[i], pc, addr,
&var_die, &offset))
continue;
} else {
/* Look up variables/parameters in this scope */
if (!die_find_variable_by_reg(&scopes[i], pc, reg,
&offset, is_fbreg, &var_die))
continue;
}
/* Found a variable, see if it's correct */
ret = check_variable(&var_die, type_die, offset,
reg != DWARF_REG_PC && !is_fbreg);
loc->offset = offset;
goto out;
}
if (loc->multi_regs && reg == loc->reg1 && loc->reg1 != loc->reg2) {
reg = loc->reg2;
goto retry;
}
if (ret < 0)
ann_data_stat.no_var++;
out:
free(scopes);
return ret;
}
/**
* find_data_type - Return a data type at the location
* @ms: map and symbol at the location
* @ip: instruction address of the memory access
* @loc: instruction operand location
* @addr: data address of the memory access
* @var_name: global variable name
*
* This functions searches the debug information of the binary to get the data
* type it accesses. The exact location is expressed by (@ip, reg, offset)
* for pointer variables or (@ip, @addr) for global variables. Note that global
* variables might update the @loc->offset after finding the start of the variable.
* If it cannot find a global variable by address, it tried to fine a declaration
* of the variable using @var_name. In that case, @loc->offset won't be updated.
*
* It return %NULL if not found.
*/
struct annotated_data_type *find_data_type(struct map_symbol *ms, u64 ip,
struct annotated_op_loc *loc, u64 addr,
const char *var_name)
{
struct annotated_data_type *result = NULL;
struct dso *dso = map__dso(ms->map);
struct debuginfo *di;
Dwarf_Die type_die;
u64 pc;
di = debuginfo__new(dso->long_name);
if (di == NULL) {
pr_debug("cannot get the debug info\n");
return NULL;
}
/*
* IP is a relative instruction address from the start of the map, as
* it can be randomized/relocated, it needs to translate to PC which is
* a file address for DWARF processing.
*/
pc = map__rip_2objdump(ms->map, ip);
if (find_data_type_die(di, pc, addr, var_name, loc, &type_die) < 0)
goto out;
result = dso__findnew_data_type(dso, &type_die);
out:
debuginfo__delete(di);
return result;
}
static int alloc_data_type_histograms(struct annotated_data_type *adt, int nr_entries)
{
int i;
size_t sz = sizeof(struct type_hist);
sz += sizeof(struct type_hist_entry) * adt->self.size;
/* Allocate a table of pointers for each event */
adt->nr_histograms = nr_entries;
adt->histograms = calloc(nr_entries, sizeof(*adt->histograms));
if (adt->histograms == NULL)
return -ENOMEM;
/*
* Each histogram is allocated for the whole size of the type.
* TODO: Probably we can move the histogram to members.
*/
for (i = 0; i < nr_entries; i++) {
adt->histograms[i] = zalloc(sz);
if (adt->histograms[i] == NULL)
goto err;
}
return 0;
err:
while (--i >= 0)
free(adt->histograms[i]);
free(adt->histograms);
return -ENOMEM;
}
static void delete_data_type_histograms(struct annotated_data_type *adt)
{
for (int i = 0; i < adt->nr_histograms; i++)
free(adt->histograms[i]);
free(adt->histograms);
}
void annotated_data_type__tree_delete(struct rb_root *root)
{
struct annotated_data_type *pos;
while (!RB_EMPTY_ROOT(root)) {
struct rb_node *node = rb_first(root);
rb_erase(node, root);
pos = rb_entry(node, struct annotated_data_type, node);
delete_members(&pos->self);
delete_data_type_histograms(pos);
free(pos->self.type_name);
free(pos);
}
}
/**
* annotated_data_type__update_samples - Update histogram
* @adt: Data type to update
* @evsel: Event to update
* @offset: Offset in the type
* @nr_samples: Number of samples at this offset
* @period: Event count at this offset
*
* This function updates type histogram at @ofs for @evsel. Samples are
* aggregated before calling this function so it can be called with more
* than one samples at a certain offset.
*/
int annotated_data_type__update_samples(struct annotated_data_type *adt,
struct evsel *evsel, int offset,
int nr_samples, u64 period)
{
struct type_hist *h;
if (adt == NULL)
return 0;
if (adt->histograms == NULL) {
int nr = evsel->evlist->core.nr_entries;
if (alloc_data_type_histograms(adt, nr) < 0)
return -1;
}
if (offset < 0 || offset >= adt->self.size)
return -1;
h = adt->histograms[evsel->core.idx];
h->nr_samples += nr_samples;
h->addr[offset].nr_samples += nr_samples;
h->period += period;
h->addr[offset].period += period;
return 0;
}