diff options
Diffstat (limited to 'gdb/btrace.h')
| -rw-r--r-- | gdb/btrace.h | 237 |
1 files changed, 203 insertions, 34 deletions
diff --git a/gdb/btrace.h b/gdb/btrace.h index 9bd7176..d219f69 100644 --- a/gdb/btrace.h +++ b/gdb/btrace.h @@ -29,63 +29,128 @@ #include "btrace-common.h" struct thread_info; +struct btrace_function; /* A branch trace instruction. This represents a single instruction in a branch trace. */ -struct btrace_inst +struct btrace_insn { /* The address of this instruction. */ CORE_ADDR pc; }; -/* A branch trace function. +/* A vector of branch trace instructions. */ +typedef struct btrace_insn btrace_insn_s; +DEF_VEC_O (btrace_insn_s); + +/* A doubly-linked list of branch trace function segments. */ +struct btrace_func_link +{ + struct btrace_function *prev; + struct btrace_function *next; +}; + +/* Flags for btrace function segments. */ +enum btrace_function_flag +{ + /* The 'up' link interpretation. + If set, it points to the function segment we returned to. + If clear, it points to the function segment we called from. */ + BFUN_UP_LINKS_TO_RET = (1 << 0), + + /* The 'up' link points to a tail call. This obviously only makes sense + if bfun_up_links_to_ret is clear. */ + BFUN_UP_LINKS_TO_TAILCALL = (1 << 1) +}; + +/* A branch trace function segment. This represents a function segment in a branch trace, i.e. a consecutive - number of instructions belonging to the same function. */ -struct btrace_func + number of instructions belonging to the same function. + + We do not allow function segments without any instructions. */ +struct btrace_function { - /* The full and minimal symbol for the function. One of them may be NULL. */ + /* The full and minimal symbol for the function. Both may be NULL. */ struct minimal_symbol *msym; struct symbol *sym; + /* The previous and next segment belonging to the same function. + If a function calls another function, the former will have at least + two segments: one before the call and another after the return. */ + struct btrace_func_link segment; + + /* The previous and next function in control flow order. */ + struct btrace_func_link flow; + + /* The directly preceding function segment in a (fake) call stack. */ + struct btrace_function *up; + + /* The instructions in this function segment. + The instruction vector will never be empty. */ + VEC (btrace_insn_s) *insn; + + /* The instruction number offset for the first instruction in this + function segment. */ + unsigned int insn_offset; + + /* The function number in control-flow order. */ + unsigned int number; + + /* The function level in a back trace across the entire branch trace. + A caller's level is one lower than the level of its callee. + + Levels can be negative if we see returns for which we have not seen + the corresponding calls. The branch trace thread information provides + a fixup to normalize function levels so the smallest level is zero. */ + int level; + /* The source line range of this function segment (both inclusive). */ int lbegin, lend; - /* The instruction number range in the instruction trace corresponding - to this function segment (both inclusive). */ - unsigned int ibegin, iend; + /* A bit-vector of btrace_function_flag. */ + enum btrace_function_flag flags; }; -/* Branch trace may also be represented as a vector of: +/* A branch trace instruction iterator. */ +struct btrace_insn_iterator +{ + /* The branch trace function segment containing the instruction. + Will never be NULL. */ + const struct btrace_function *function; - - branch trace instructions starting with the oldest instruction. - - branch trace functions starting with the oldest function. */ -typedef struct btrace_inst btrace_inst_s; -typedef struct btrace_func btrace_func_s; + /* The index into the function segment's instruction vector. */ + unsigned int index; +}; -/* Define functions operating on branch trace vectors. */ -DEF_VEC_O (btrace_inst_s); -DEF_VEC_O (btrace_func_s); +/* A branch trace function call iterator. */ +struct btrace_call_iterator +{ + /* The branch trace information for this thread. Will never be NULL. */ + const struct btrace_thread_info *btinfo; + + /* The branch trace function segment. + This will be NULL for the iterator pointing to the end of the trace. */ + const struct btrace_function *function; +}; /* Branch trace iteration state for "record instruction-history". */ -struct btrace_insn_iterator +struct btrace_insn_history { - /* The instruction index range from begin (inclusive) to end (exclusive) - that has been covered last time. - If end < begin, the branch trace has just been updated. */ - unsigned int begin; - unsigned int end; + /* The branch trace instruction range from BEGIN (inclusive) to + END (exclusive) that has been covered last time. */ + struct btrace_insn_iterator begin; + struct btrace_insn_iterator end; }; /* Branch trace iteration state for "record function-call-history". */ -struct btrace_func_iterator +struct btrace_call_history { - /* The function index range from begin (inclusive) to end (exclusive) - that has been covered last time. - If end < begin, the branch trace has just been updated. */ - unsigned int begin; - unsigned int end; + /* The branch trace function range from BEGIN (inclusive) to END (exclusive) + that has been covered last time. */ + struct btrace_call_iterator begin; + struct btrace_call_iterator end; }; /* Branch trace information per thread. @@ -103,16 +168,25 @@ struct btrace_thread_info the underlying architecture. */ struct btrace_target_info *target; - /* The current branch trace for this thread. */ - VEC (btrace_block_s) *btrace; - VEC (btrace_inst_s) *itrace; - VEC (btrace_func_s) *ftrace; + /* The current branch trace for this thread (both inclusive). + + The last instruction of END is the current instruction, which is not + part of the execution history. + Both will be NULL if there is no branch trace available. If there is + branch trace available, both will be non-NULL. */ + struct btrace_function *begin; + struct btrace_function *end; + + /* The function level offset. When added to each function's LEVEL, + this normalizes the function levels such that the smallest level + becomes zero. */ + int level; /* The instruction history iterator. */ - struct btrace_insn_iterator insn_iterator; + struct btrace_insn_history *insn_history; /* The function call history iterator. */ - struct btrace_func_iterator func_iterator; + struct btrace_call_history *call_history; }; /* Enable branch tracing for a thread. */ @@ -139,4 +213,99 @@ extern void btrace_free_objfile (struct objfile *); /* Parse a branch trace xml document into a block vector. */ extern VEC (btrace_block_s) *parse_xml_btrace (const char*); +/* Dereference a branch trace instruction iterator. Return a pointer to the + instruction the iterator points to. */ +extern const struct btrace_insn * + btrace_insn_get (const struct btrace_insn_iterator *); + +/* Return the instruction number for a branch trace iterator. + Returns one past the maximum instruction number for the end iterator. + Returns zero if the iterator does not point to a valid instruction. */ +extern unsigned int btrace_insn_number (const struct btrace_insn_iterator *); + +/* Initialize a branch trace instruction iterator to point to the begin/end of + the branch trace. Throws an error if there is no branch trace. */ +extern void btrace_insn_begin (struct btrace_insn_iterator *, + const struct btrace_thread_info *); +extern void btrace_insn_end (struct btrace_insn_iterator *, + const struct btrace_thread_info *); + +/* Increment/decrement a branch trace instruction iterator by at most STRIDE + instructions. Return the number of instructions by which the instruction + iterator has been advanced. + Returns zero, if the operation failed or STRIDE had been zero. */ +extern unsigned int btrace_insn_next (struct btrace_insn_iterator *, + unsigned int stride); +extern unsigned int btrace_insn_prev (struct btrace_insn_iterator *, + unsigned int stride); + +/* Compare two branch trace instruction iterators. + Return a negative number if LHS < RHS. + Return zero if LHS == RHS. + Return a positive number if LHS > RHS. */ +extern int btrace_insn_cmp (const struct btrace_insn_iterator *lhs, + const struct btrace_insn_iterator *rhs); + +/* Find an instruction in the function branch trace by its number. + If the instruction is found, initialize the branch trace instruction + iterator to point to this instruction and return non-zero. + Return zero otherwise. */ +extern int btrace_find_insn_by_number (struct btrace_insn_iterator *, + const struct btrace_thread_info *, + unsigned int number); + +/* Dereference a branch trace call iterator. Return a pointer to the + function the iterator points to or NULL if the interator points past + the end of the branch trace. */ +extern const struct btrace_function * + btrace_call_get (const struct btrace_call_iterator *); + +/* Return the function number for a branch trace call iterator. + Returns one past the maximum function number for the end iterator. + Returns zero if the iterator does not point to a valid function. */ +extern unsigned int btrace_call_number (const struct btrace_call_iterator *); + +/* Initialize a branch trace call iterator to point to the begin/end of + the branch trace. Throws an error if there is no branch trace. */ +extern void btrace_call_begin (struct btrace_call_iterator *, + const struct btrace_thread_info *); +extern void btrace_call_end (struct btrace_call_iterator *, + const struct btrace_thread_info *); + +/* Increment/decrement a branch trace call iterator by at most STRIDE function + segments. Return the number of function segments by which the call + iterator has been advanced. + Returns zero, if the operation failed or STRIDE had been zero. */ +extern unsigned int btrace_call_next (struct btrace_call_iterator *, + unsigned int stride); +extern unsigned int btrace_call_prev (struct btrace_call_iterator *, + unsigned int stride); + +/* Compare two branch trace call iterators. + Return a negative number if LHS < RHS. + Return zero if LHS == RHS. + Return a positive number if LHS > RHS. */ +extern int btrace_call_cmp (const struct btrace_call_iterator *lhs, + const struct btrace_call_iterator *rhs); + +/* Find a function in the function branch trace by its NUMBER. + If the function is found, initialize the branch trace call + iterator to point to this function and return non-zero. + Return zero otherwise. */ +extern int btrace_find_call_by_number (struct btrace_call_iterator *, + const struct btrace_thread_info *, + unsigned int number); + +/* Set the branch trace instruction history from BEGIN (inclusive) to + END (exclusive). */ +extern void btrace_set_insn_history (struct btrace_thread_info *, + const struct btrace_insn_iterator *begin, + const struct btrace_insn_iterator *end); + +/* Set the branch trace function call history from BEGIN (inclusive) to + END (exclusive). */ +extern void btrace_set_call_history (struct btrace_thread_info *, + const struct btrace_call_iterator *begin, + const struct btrace_call_iterator *end); + #endif /* BTRACE_H */ |