llvm/lldb/source/Symbol/SymbolContext.cpp

//===-- SymbolContext.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/SymbolContext.h"

#include "lldb/Core/Address.h"
#include "lldb/Core/Debugger.h"
#include "lldb/Core/Module.h"
#include "lldb/Core/ModuleSpec.h"
#include "lldb/Host/Host.h"
#include "lldb/Symbol/Block.h"
#include "lldb/Symbol/CompileUnit.h"
#include "lldb/Symbol/ObjectFile.h"
#include "lldb/Symbol/Symbol.h"
#include "lldb/Symbol/SymbolFile.h"
#include "lldb/Symbol/SymbolVendor.h"
#include "lldb/Symbol/Variable.h"
#include "lldb/Target/Language.h"
#include "lldb/Target/Target.h"
#include "lldb/Utility/LLDBLog.h"
#include "lldb/Utility/Log.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Utility/StreamString.h"
#include "lldb/lldb-enumerations.h"

usingnamespacelldb;
usingnamespacelldb_private;

SymbolContext::SymbolContext() : … { … }

SymbolContext::SymbolContext(const ModuleSP &m, CompileUnit *cu, Function *f,
                             Block *b, LineEntry *le, Symbol *s)
    : … { … }

SymbolContext::SymbolContext(const TargetSP &t, const ModuleSP &m,
                             CompileUnit *cu, Function *f, Block *b,
                             LineEntry *le, Symbol *s)
    : … { … }

SymbolContext::SymbolContext(SymbolContextScope *sc_scope)
    : … { … }

SymbolContext::~SymbolContext() = default;

void SymbolContext::Clear(bool clear_target) { … }

bool SymbolContext::DumpStopContext(
    Stream *s, ExecutionContextScope *exe_scope, const Address &addr,
    bool show_fullpaths, bool show_module, bool show_inlined_frames,
    bool show_function_arguments, bool show_function_name,
    bool show_function_display_name,
    std::optional<Stream::HighlightSettings> settings) const { … }

void SymbolContext::GetDescription(
    Stream *s, lldb::DescriptionLevel level, Target *target,
    std::optional<Stream::HighlightSettings> settings) const { … }

uint32_t SymbolContext::GetResolvedMask() const { … }

void SymbolContext::Dump(Stream *s, Target *target) const { … }

bool lldb_private::operator==(const SymbolContext &lhs,
                              const SymbolContext &rhs) { … }

bool lldb_private::operator!=(const SymbolContext &lhs,
                              const SymbolContext &rhs) { … }

bool SymbolContext::GetAddressRange(uint32_t scope, uint32_t range_idx,
                                    bool use_inline_block_range,
                                    AddressRange &range) const { … }

LanguageType SymbolContext::GetLanguage() const { … }

bool SymbolContext::GetParentOfInlinedScope(const Address &curr_frame_pc,
                                            SymbolContext &next_frame_sc,
                                            Address &next_frame_pc) const { … }

Block *SymbolContext::GetFunctionBlock() { … }

llvm::StringRef SymbolContext::GetInstanceVariableName() { … }

void SymbolContext::SortTypeList(TypeMap &type_map, TypeList &type_list) const { … }

ConstString
SymbolContext::GetFunctionName(Mangled::NamePreference preference) const { … }

LineEntry SymbolContext::GetFunctionStartLineEntry() const { … }

bool SymbolContext::GetAddressRangeFromHereToEndLine(uint32_t end_line,
                                                     AddressRange &range,
                                                     Status &error) { … }

const Symbol *SymbolContext::FindBestGlobalDataSymbol(ConstString name,
                                                      Status &error) { … }

//
//  SymbolContextSpecifier
//

SymbolContextSpecifier::SymbolContextSpecifier(const TargetSP &target_sp)
    : … { … }

SymbolContextSpecifier::~SymbolContextSpecifier() = default;

bool SymbolContextSpecifier::AddLineSpecification(uint32_t line_no,
                                                  SpecificationType type) { … }

bool SymbolContextSpecifier::AddSpecification(const char *spec_string,
                                              SpecificationType type) { … }

void SymbolContextSpecifier::Clear() { … }

bool SymbolContextSpecifier::SymbolContextMatches(const SymbolContext &sc) { … }

bool SymbolContextSpecifier::AddressMatches(lldb::addr_t addr) { … }

void SymbolContextSpecifier::GetDescription(
    Stream *s, lldb::DescriptionLevel level) const { … }

//
//  SymbolContextList
//

SymbolContextList::SymbolContextList() : … { … }

SymbolContextList::~SymbolContextList() = default;

void SymbolContextList::Append(const SymbolContext &sc) { … }

void SymbolContextList::Append(const SymbolContextList &sc_list) { … }

uint32_t SymbolContextList::AppendIfUnique(const SymbolContextList &sc_list,
                                           bool merge_symbol_into_function) { … }

bool SymbolContextList::AppendIfUnique(const SymbolContext &sc,
                                       bool merge_symbol_into_function) { … }

void SymbolContextList::Clear() { … }

void SymbolContextList::Dump(Stream *s, Target *target) const { … }

bool SymbolContextList::GetContextAtIndex(size_t idx, SymbolContext &sc) const { … }

bool SymbolContextList::RemoveContextAtIndex(size_t idx) { … }

uint32_t SymbolContextList::GetSize() const { … }

bool SymbolContextList::IsEmpty() const { … }

uint32_t SymbolContextList::NumLineEntriesWithLine(uint32_t line) const { … }

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

bool lldb_private::operator==(const SymbolContextList &lhs,
                              const SymbolContextList &rhs) { … }

bool lldb_private::operator!=(const SymbolContextList &lhs,
                              const SymbolContextList &rhs) { … }