| // Copyright 2018 The Fuchsia Authors. All rights reserved. | |
| // Use of this source code is governed by a BSD-style license that can be | |
| // found in the LICENSE file. | |
| #include "src/developer/debug/zxdb/symbols/code_block.h" | |
| #include <lib/syslog/cpp/macros.h> | |
| #include "src/developer/debug/zxdb/symbols/call_site.h" | |
| #include "src/developer/debug/zxdb/symbols/call_site_parameter.h" | |
| #include "src/developer/debug/zxdb/symbols/function.h" | |
| #include "src/developer/debug/zxdb/symbols/symbol_context.h" | |
| namespace zxdb { | |
| CodeBlock::CodeBlock(DwarfTag tag) : Symbol(tag) { | |
| FX_DCHECK(tag == DwarfTag::kSubprogram || tag == DwarfTag::kInlinedSubroutine || | |
| tag == DwarfTag::kLexicalBlock); | |
| } | |
| CodeBlock::~CodeBlock() = default; | |
| fxl::RefPtr<CodeBlock> CodeBlock::GetContainingBlock() const { | |
| // Generic code blocks' containing block is just the parent. This is overridden by Function for | |
| // more specific behavior. | |
| auto owning_parent = parent().Get(); | |
| return RefPtrTo(owning_parent->As<CodeBlock>()); | |
| } | |
| const CodeBlock* CodeBlock::AsCodeBlock() const { return this; } | |
| AddressRanges CodeBlock::GetAbsoluteCodeRanges(const SymbolContext& symbol_context) const { | |
| return symbol_context.RelativeToAbsolute(code_ranges()); | |
| } | |
| AddressRange CodeBlock::GetFullRange(const SymbolContext& symbol_context) const { | |
| if (code_ranges_.empty()) | |
| return AddressRange(); | |
| return AddressRange(symbol_context.RelativeToAbsolute(code_ranges_.front().begin()), | |
| symbol_context.RelativeToAbsolute(code_ranges_.back().end())); | |
| } | |
| bool CodeBlock::ContainsAddress(const SymbolContext& symbol_context, | |
| uint64_t absolute_address) const { | |
| // Don't consider blocks with no addresses as covering anything. Consider them empty. The DWARF | |
| // spec says it will be empty when there is no corresponding machine code. | |
| // | |
| // Empty blocks can get generated, for example, in a abstract origin of an inlined function. Clang | |
| // declares the local variables inside a nesting structure identical to the inlined code, but the | |
| // abstract origin has no code associated with it. We don't want to consider these empty blocks | |
| // as containing all code of the function since using them will lose the context associated with | |
| // the inlined instance. | |
| // NOTE: According to the DWARF spec, the end of the range (aka DW_AT_high_pc) should NOT be | |
| // included in this range calculation. However, there are several cases where the PC falls | |
| // directly on the ending address for which we still are going to want to be able to do variable | |
| // lookups, for example, and will want to include this range. This is also what LLDB does: | |
| // https://github.com/llvm/llvm-project/blob/main/lldb/include/lldb/Utility/RangeMap.h#L101 | |
| for (const auto& range : code_ranges_) { | |
| if (absolute_address >= symbol_context.RelativeToAbsolute(range.begin()) && | |
| absolute_address <= symbol_context.RelativeToAbsolute(range.end())) | |
| return true; | |
| } | |
| return false; | |
| } | |
| const CodeBlock* CodeBlock::GetMostSpecificChild(const SymbolContext& symbol_context, | |
| uint64_t absolute_address, | |
| bool recurse_into_inlines) const { | |
| if (!ContainsAddress(symbol_context, absolute_address)) | |
| return nullptr; // This block doesn't contain the address. | |
| for (const auto& inner : inner_blocks_) { | |
| // Don't expect more than one inner block to cover the address, so return | |
| // the first match. Everything in the inner_blocks_ should resolve to a | |
| // CodeBlock object. | |
| const CodeBlock* inner_block = inner.Get()->As<CodeBlock>(); | |
| if (!inner_block) | |
| continue; // Corrupted symbols. | |
| if (!recurse_into_inlines && inner_block->tag() == DwarfTag::kInlinedSubroutine) | |
| continue; // Skip inlined function. | |
| const CodeBlock* found = | |
| inner_block->GetMostSpecificChild(symbol_context, absolute_address, recurse_into_inlines); | |
| if (found) | |
| return found; | |
| } | |
| // This block covers the address but no children do. | |
| return this; | |
| } | |
| fxl::RefPtr<CallSite> CodeBlock::GetCallSiteForReturnTo( | |
| const SymbolContext& symbol_context, TargetPointer absolute_return_address) const { | |
| // Generally this will be called on a symbol from a Location so |this| could be an inline | |
| // function. Because of the difference between return addresses and where the call site | |
| // definitions are (see below), the call site may be on our parent. So always go to the physical | |
| // function the address is in. | |
| fxl::RefPtr<CodeBlock> containing = GetContainingFunction(kPhysicalOnly); | |
| if (!containing) | |
| containing = RefPtrTo(this); // No function, call back on just using |this|. | |
| // We assume the call site will always be in the innermost code block containing the address. | |
| // This requirement isn't specified by DWARF but is true due to language semantics. | |
| // | |
| // We're looking up by return address which might be the instruction after the call for inlines | |
| // or lexical blocks that end in a function call. Therefore, look up the code block by the | |
| // previous address because the call sites will be assigned to blocks by their call address. | |
| const CodeBlock* inner_block = | |
| containing->GetMostSpecificChild(symbol_context, absolute_return_address - 1, true); | |
| if (!inner_block) | |
| return nullptr; | |
| TargetPointer relative_return_address = | |
| symbol_context.AbsoluteToRelative(absolute_return_address); | |
| for (const LazySymbol& lazy : inner_block->call_sites()) { | |
| const CallSite* call_site = lazy.Get()->As<CallSite>(); | |
| if (!call_site) | |
| continue; | |
| if (call_site->return_pc() && *call_site->return_pc() == relative_return_address) | |
| return RefPtrTo(call_site); | |
| } | |
| return nullptr; | |
| } | |
| fxl::RefPtr<Function> CodeBlock::GetContainingFunction(SearchFunction search) const { | |
| // Need to hold references when walking up the symbol hierarchy. | |
| fxl::RefPtr<CodeBlock> cur_block = RefPtrTo(this); | |
| while (cur_block) { | |
| if (const Function* function = cur_block->As<Function>()) { | |
| if (function && (search == kInlineOrPhysical || !function->is_inline())) | |
| return RefPtrTo(function); | |
| } | |
| cur_block = cur_block->GetContainingBlock(); | |
| } | |
| return fxl::RefPtr<Function>(); | |
| } | |
| std::vector<fxl::RefPtr<Function>> CodeBlock::GetInlineChain() const { | |
| std::vector<fxl::RefPtr<Function>> result; | |
| // Need to hold references when walking up the symbol hierarchy. | |
| fxl::RefPtr<CodeBlock> cur_block = RefPtrTo(this); | |
| while (cur_block) { | |
| if (const Function* function = cur_block->As<Function>()) { | |
| result.push_back(RefPtrTo(function)); | |
| if (function->is_inline()) { | |
| // Follow the inlined structure via containing_block() rather than the lexical structure of | |
| // the inlined function (e.g. its parent class). | |
| auto containing = function->containing_block().Get(); | |
| cur_block = RefPtrTo(containing->As<CodeBlock>()); | |
| } else { | |
| // Just added containing non-inline function so we're done. | |
| break; | |
| } | |
| } else { | |
| cur_block = cur_block->GetContainingBlock(); | |
| } | |
| } | |
| return result; | |
| } | |
| std::vector<fxl::RefPtr<Function>> CodeBlock::GetAmbiguousInlineChain( | |
| const SymbolContext& symbol_context, TargetPointer absolute_address) const { | |
| std::vector<fxl::RefPtr<Function>> result; | |
| // For simplicity this gets the inline chain and then filters for ambiguous locations. This may | |
| // throw away some work which GetInlineChain() did. | |
| std::vector<fxl::RefPtr<Function>> inline_chain = GetInlineChain(); | |
| for (size_t i = 0; i < inline_chain.size(); i++) { | |
| result.push_back(inline_chain[i]); | |
| if (!inline_chain[i]->is_inline() || | |
| inline_chain[i]->GetFullRange(symbol_context).begin() != absolute_address) { | |
| // Non-ambiguous location, we're done. | |
| break; | |
| } | |
| } | |
| return result; | |
| } | |
| } // namespace zxdb |