llvm/lldb/source/Symbol/Block.cpp

//===-- Block.cpp ---------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include "lldb/Symbol/Block.h"

#include "lldb/Core/Module.h"
#include "lldb/Core/Section.h"
#include "lldb/Symbol/Function.h"
#include "lldb/Symbol/SymbolFile.h"
#include "lldb/Symbol/VariableList.h"
#include "lldb/Utility/LLDBLog.h"
#include "lldb/Utility/Log.h"

#include <memory>

usingnamespacelldb;
usingnamespacelldb_private;

Block::Block(lldb::user_id_t uid)
    : … { … }

Block::~Block() = default;

void Block::GetDescription(Stream *s, Function *function,
                           lldb::DescriptionLevel level, Target *target) const { … }

void Block::Dump(Stream *s, addr_t base_addr, int32_t depth,
                 bool show_context) const { … }

Block *Block::FindBlockByID(user_id_t block_id) { … }

Block *Block::FindInnermostBlockByOffset(const lldb::addr_t offset) { … }

void Block::CalculateSymbolContext(SymbolContext *sc) { … }

lldb::ModuleSP Block::CalculateSymbolContextModule() { … }

CompileUnit *Block::CalculateSymbolContextCompileUnit() { … }

Function *Block::CalculateSymbolContextFunction() { … }

Block *Block::CalculateSymbolContextBlock() { … }

void Block::DumpSymbolContext(Stream *s) { … }

void Block::DumpAddressRanges(Stream *s, lldb::addr_t base_addr) { … }

bool Block::Contains(addr_t range_offset) const { … }

bool Block::Contains(const Block *block) const { … }

bool Block::Contains(const Range &range) const { … }

Block *Block::GetParent() const { … }

Block *Block::GetContainingInlinedBlock() { … }

Block *Block::GetInlinedParent() { … }

Block *Block::GetContainingInlinedBlockWithCallSite(
    const Declaration &find_call_site) { … }

bool Block::GetRangeContainingOffset(const addr_t offset, Range &range) { … }

bool Block::GetRangeContainingAddress(const Address &addr,
                                      AddressRange &range) { … }

bool Block::GetRangeContainingLoadAddress(lldb::addr_t load_addr,
                                          Target &target, AddressRange &range) { … }

uint32_t Block::GetRangeIndexContainingAddress(const Address &addr) { … }

bool Block::GetRangeAtIndex(uint32_t range_idx, AddressRange &range) { … }

AddressRanges Block::GetRanges() { … }

bool Block::GetStartAddress(Address &addr) { … }

void Block::FinalizeRanges() { … }

void Block::AddRange(const Range &range) { … }

// Return the current number of bytes that this object occupies in memory
size_t Block::MemorySize() const { … }

void Block::AddChild(const BlockSP &child_block_sp) { … }

void Block::SetInlinedFunctionInfo(const char *name, const char *mangled,
                                   const Declaration *decl_ptr,
                                   const Declaration *call_decl_ptr) { … }

VariableListSP Block::GetBlockVariableList(bool can_create) { … }

uint32_t
Block::AppendBlockVariables(bool can_create, bool get_child_block_variables,
                            bool stop_if_child_block_is_inlined_function,
                            const std::function<bool(Variable *)> &filter,
                            VariableList *variable_list) { … }

uint32_t Block::AppendVariables(bool can_create, bool get_parent_variables,
                                bool stop_if_block_is_inlined_function,
                                const std::function<bool(Variable *)> &filter,
                                VariableList *variable_list) { … }

SymbolFile *Block::GetSymbolFile() { … }

CompilerDeclContext Block::GetDeclContext() { … }

void Block::SetBlockInfoHasBeenParsed(bool b, bool set_children) { … }

void Block::SetDidParseVariables(bool b, bool set_children) { … }

Block *Block::GetSibling() const { … }
// A parent of child blocks can be asked to find a sibling block given
// one of its child blocks
Block *Block::GetSiblingForChild(const Block *child_block) const { … }