kevin/linux
1
Fork 0
Code

perf annotate: Add annotate_get_basic_blocks()

Browse Source 
The annotate_get_basic_blocks() is to find a list of basic blocks from
the source instruction to the destination instruction in a function.

It'll be used to find variables in a scope.  Use BFS (Breadth First
Search) to find a shortest path to carry the variable/register state
minimally.

Also change find_disasm_line() to be used in annotate_get_basic_blocks()
and add 'allow_update' argument to control if it can update the IP.

Signed-off-by: Namhyung Kim <namhyung@kernel.org>
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Ian Rogers <irogers@google.com>
Cc: Ingo Molnar <mingo@kernel.org>
Cc: Jiri Olsa <jolsa@kernel.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Masami Hiramatsu <mhiramat@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Stephane Eranian <eranian@google.com>
Link: https://lore.kernel.org/r/20240319055115.4063940-8-namhyung@kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
This commit is contained in:
Namhyung Kim 2024-03-18 22:50:59 -07:00 committed by Arnaldo Carvalho de Melo
parent a3f4d5b57d
commit 5cdd3fd799
2 changed files with 235 additions and 3 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

222
tools/perf/util/annotate.c
View File

@ -3714,7 +3714,8 @@ static void symbol__ensure_annotate(struct map_symbol *ms, struct evsel *evsel)
}
}
static struct disasm_line *find_disasm_line(struct symbol *sym, u64 ip)
static struct disasm_line *find_disasm_line(struct symbol *sym, u64 ip,
bool allow_update)
{
struct disasm_line *dl;
struct annotation *notes;
@ -3727,7 +3728,8 @@ static struct disasm_line *find_disasm_line(struct symbol *sym, u64 ip)
* llvm-objdump places "lock" in a separate line and
* in that case, we want to get the next line.
*/
if (!strcmp(dl->ins.name, "lock") && *dl->ops.raw == '\0') {
if (!strcmp(dl->ins.name, "lock") &&
*dl->ops.raw == '\0' && allow_update) {
ip++;
continue;
}
@ -3843,7 +3845,7 @@ struct annotated_data_type *hist_entry__get_data_type(struct hist_entry *he)
* Get a disasm to extract the location from the insn.
* This is too slow...
*/
dl = find_disasm_line(ms->sym, ip);
dl = find_disasm_line(ms->sym, ip, /*allow_update=*/true);
if (dl == NULL) {
ann_data_stat.no_insn++;
return NULL;
@ -3937,3 +3939,217 @@ retry:
istat->bad++;
return NULL;
}
/* Basic block traversal (BFS) data structure */
struct basic_block_data {
struct list_head queue;
struct list_head visited;
};
/*
* During the traversal, it needs to know the parent block where the current
* block block started from. Note that single basic block can be parent of
* two child basic blocks (in case of condition jump).
*/
struct basic_block_link {
struct list_head node;
struct basic_block_link *parent;
struct annotated_basic_block *bb;
};
/* Check any of basic block in the list already has the offset */
static bool basic_block_has_offset(struct list_head *head, s64 offset)
{
struct basic_block_link *link;
list_for_each_entry(link, head, node) {
s64 begin_offset = link->bb->begin->al.offset;
s64 end_offset = link->bb->end->al.offset;
if (begin_offset <= offset && offset <= end_offset)
return true;
}
return false;
}
static bool is_new_basic_block(struct basic_block_data *bb_data,
struct disasm_line *dl)
{
s64 offset = dl->al.offset;
if (basic_block_has_offset(&bb_data->visited, offset))
return false;
if (basic_block_has_offset(&bb_data->queue, offset))
return false;
return true;
}
/* Add a basic block starting from dl and link it to the parent */
static int add_basic_block(struct basic_block_data *bb_data,
struct basic_block_link *parent,
struct disasm_line *dl)
{
struct annotated_basic_block *bb;
struct basic_block_link *link;
if (dl == NULL)
return -1;
if (!is_new_basic_block(bb_data, dl))
return 0;
bb = zalloc(sizeof(*bb));
if (bb == NULL)
return -1;
bb->begin = dl;
bb->end = dl;
INIT_LIST_HEAD(&bb->list);
link = malloc(sizeof(*link));
if (link == NULL) {
free(bb);
return -1;
}
link->bb = bb;
link->parent = parent;
list_add_tail(&link->node, &bb_data->queue);
return 0;
}
/* Returns true when it finds the target in the current basic block */
static bool process_basic_block(struct basic_block_data *bb_data,
struct basic_block_link *link,
struct symbol *sym, u64 target)
{
struct disasm_line *dl, *next_dl, *last_dl;
struct annotation *notes = symbol__annotation(sym);
bool found = false;
dl = link->bb->begin;
/* Check if it's already visited */
if (basic_block_has_offset(&bb_data->visited, dl->al.offset))
return false;
last_dl = list_last_entry(&notes->src->source,
struct disasm_line, al.node);
list_for_each_entry_from(dl, &notes->src->source, al.node) {
/* Found the target instruction */
if (sym->start + dl->al.offset == target) {
found = true;
break;
}
/* End of the function, finish the block */
if (dl == last_dl)
break;
/* 'return' instruction finishes the block */
if (dl->ins.ops == &ret_ops)
break;
/* normal instructions are part of the basic block */
if (dl->ins.ops != &jump_ops)
continue;
/* jump to a different function, tail call or return */
if (dl->ops.target.outside)
break;
/* jump instruction creates new basic block(s) */
next_dl = find_disasm_line(sym, sym->start + dl->ops.target.offset,
/*allow_update=*/false);
add_basic_block(bb_data, link, next_dl);
/*
* FIXME: determine conditional jumps properly.
* Conditional jumps create another basic block with the
* next disasm line.
*/
if (!strstr(dl->ins.name, "jmp")) {
next_dl = list_next_entry(dl, al.node);
add_basic_block(bb_data, link, next_dl);
}
break;
}
link->bb->end = dl;
return found;
}
/*
* It founds a target basic block, build a proper linked list of basic blocks
* by following the link recursively.
*/
static void link_found_basic_blocks(struct basic_block_link *link,
struct list_head *head)
{
while (link) {
struct basic_block_link *parent = link->parent;
list_move(&link->bb->list, head);
list_del(&link->node);
free(link);
link = parent;
}
}
static void delete_basic_blocks(struct basic_block_data *bb_data)
{
struct basic_block_link *link, *tmp;
list_for_each_entry_safe(link, tmp, &bb_data->queue, node) {
list_del(&link->node);
free(link->bb);
free(link);
}
list_for_each_entry_safe(link, tmp, &bb_data->visited, node) {
list_del(&link->node);
free(link->bb);
free(link);
}
}
/**
* annotate_get_basic_blocks - Get basic blocks for given address range
* @sym: symbol to annotate
* @src: source address
* @dst: destination address
* @head: list head to save basic blocks
*
* This function traverses disasm_lines from @src to @dst and save them in a
* list of annotated_basic_block to @head. It uses BFS to find the shortest
* path between two. The basic_block_link is to maintain parent links so
* that it can build a list of blocks from the start.
*/
int annotate_get_basic_blocks(struct symbol *sym, s64 src, s64 dst,
struct list_head *head)
{
struct basic_block_data bb_data = {
.queue = LIST_HEAD_INIT(bb_data.queue),
.visited = LIST_HEAD_INIT(bb_data.visited),
};
struct basic_block_link *link;
struct disasm_line *dl;
int ret = -1;
dl = find_disasm_line(sym, src, /*allow_update=*/false);
if (dl == NULL)
return -1;
if (add_basic_block(&bb_data, /*parent=*/NULL, dl) < 0)
return -1;
/* Find shortest path from src to dst using BFS */
while (!list_empty(&bb_data.queue)) {
link = list_first_entry(&bb_data.queue, struct basic_block_link, node);
if (process_basic_block(&bb_data, link, sym, dst)) {
link_found_basic_blocks(link, head);
ret = 0;
break;
}
list_move(&link->node, &bb_data.visited);
}
delete_basic_blocks(&bb_data);
return ret;
}

16
tools/perf/util/annotate.h
View File

@ -561,4 +561,20 @@ extern struct list_head ann_insn_stat;
u64 annotate_calc_pcrel(struct map_symbol *ms, u64 ip, int offset,
struct disasm_line *dl);
/**
* struct annotated_basic_block - Basic block of instructions
* @list: List node
* @begin: start instruction in the block
* @end: end instruction in the block
*/
struct annotated_basic_block {
struct list_head list;
struct disasm_line *begin;
struct disasm_line *end;
};
/* Get a list of basic blocks from src to dst addresses */
int annotate_get_basic_blocks(struct symbol *sym, s64 src, s64 dst,
struct list_head *head);
#endif /* __PERF_ANNOTATE_H */