class CodeBlock

Returns the block (function, inline, lexical scope) that contains this one. May return null if

this isn't inside another block.

This is different than getting the parent() because the parent() of an inline class member

function is the class it's a member of, but the containing block is the code block the inlined

function was inlined into.

See also Function::containing_block().

Retrieves the code ranges for this block in absolute addresses for the process.

Computes the full code range covering all sub-ranges. There can be multiple code ranges that

can be discontiguous so not everything in this range is guaranteed to be inside the code block.

Returns empty AddressRange if there are no code ranges.

Returns true if the block's code ranges contain the given address. A block with no specified

range will always return true.

The valid ranges of code for this block. In many cases there will be only one range (most

functions specify DW_AT_low_pc and DW_AT_high_pc), but some blocks, especially inlined

subroutines, may be at multiple discontiguous ranges in the code (DW_AT_ranges are specified).

In this case, the ranges will be in sorted order.

Some lexical blocks won't have location information in them. These are often strictly to hold

groups of variables, each of which has their own range of validity.

Function declarations will have no ranges associated with them. These aren't strictly "code

blocks" but many functions won't have a declaration/implementation split and there's so much

overlap it's more convenient to just have one type representing both.

These ranges will be RELATIVE to the module. See GetAbsoluteCodeRanges() to get absolute

addresses.

The code blocks (lexical blocks and inlines) that are children of this one.

Variables contained within this block.

Recursively searches all children of this block for the innermost block covering the given

address. Returns |this| if the current block is already the most specific, or nullptr if the

current block doesn't contain the address.

Whether this function will go into inlined subroutines is controlled by recurse_into_inlines.

In many cases the Stack will handle expanding inlined subroutines and one would use this

function to find the most specific code block in the current virtual frame.

All call sites contained within this block. In no specific order.

Searches this code block and all descendents for a call site annotation matching the given

return address. Returns null if there is no call site record for this return address.

Returns the chain of inline functions to the current code block.

The returned vector will go back in time. The [0] item will be the most specific function

containing this code block (always GetContainingFunction(), will be = |this| if this is a

function).

The back "should" be the containing non-inlined function (this depends on the symbols declaring

a function for the code block which they should do, but calling code shouldn't crash on

malformed symbols).

If the current block is not in an inline function, the returned vector will have one element.

Like GetInlineChain() but returns only those functions with ambiguous inline locations at the

given address. If the address is at the first address of an inline routine, it's ambiguous

whether the virtual location is at the first instruction of the inlined function, or at the

optimized-out "call" to the inlined function.

The returned vector will go back in time. The [0] item will be the most specific function

containing this code block (always GetContainingFunction(), will be = |this| if this is a

function).

When the [0] item is ambiguous (the address is at the beginning of it), the [1] item will

be the containing function (inlined or not). If that's also ambiguous, there will be a [2]

item, etc. The back() item will be either a non-inlined function or a non-ambiguous inlined

function.

Recursively searches the containing blocks until it finds a function (physical or inline). If

this code block is a function, returns |this| as a Function. Returns null on error, but this

should not happen for well-formed symbols (all code should be inside functions).