Address.cpp | Explore in Territory

//===-- Address.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/Core/Address.h"
#include "lldb/Core/Debugger.h"
#include "lldb/Core/Declaration.h"
#include "lldb/Core/DumpDataExtractor.h"
#include "lldb/Core/Module.h"
#include "lldb/Core/ModuleList.h"
#include "lldb/Core/Section.h"
#include "lldb/Symbol/Block.h"
#include "lldb/Symbol/LineEntry.h"
#include "lldb/Symbol/ObjectFile.h"
#include "lldb/Symbol/Symbol.h"
#include "lldb/Symbol/SymbolContext.h"
#include "lldb/Symbol/SymbolVendor.h"
#include "lldb/Symbol/Symtab.h"
#include "lldb/Symbol/Type.h"
#include "lldb/Symbol/Variable.h"
#include "lldb/Symbol/VariableList.h"
#include "lldb/Target/ABI.h"
#include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/ExecutionContextScope.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/SectionLoadList.h"
#include "lldb/Target/Target.h"
#include "lldb/Utility/AnsiTerminal.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/DataExtractor.h"
#include "lldb/Utility/Endian.h"
#include "lldb/Utility/FileSpec.h"
#include "lldb/Utility/Status.h"
#include "lldb/Utility/Stream.h"
#include "lldb/Utility/StreamString.h"

#include "llvm/ADT/StringRef.h"
#include "llvm/Support/Compiler.h"
#include "llvm/TargetParser/Triple.h"

#include <cstdint>
#include <memory>
#include <vector>

#include <cassert>
#include <cinttypes>
#include <cstring>

namespace lldb_private {
class CompileUnit;
}
namespace lldb_private {
class Function;
}

usingnamespacelldb;
usingnamespacelldb_private;

static size_t ReadBytes(ExecutionContextScope *exe_scope,
                        const Address &address, void *dst, size_t dst_len) { … }

static bool GetByteOrderAndAddressSize(ExecutionContextScope *exe_scope,
                                       const Address &address,
                                       ByteOrder &byte_order,
                                       uint32_t &addr_size) { … }

static uint64_t ReadUIntMax64(ExecutionContextScope *exe_scope,
                              const Address &address, uint32_t byte_size,
                              bool &success) { … }

static bool ReadAddress(ExecutionContextScope *exe_scope,
                        const Address &address, uint32_t pointer_size,
                        Address &deref_so_addr) { … }

static bool DumpUInt(ExecutionContextScope *exe_scope, const Address &address,
                     uint32_t byte_size, Stream *strm) { … }

static size_t ReadCStringFromMemory(ExecutionContextScope *exe_scope,
                                    const Address &address, Stream *strm) { … }

Address::Address(lldb::addr_t abs_addr) : … { … }

Address::Address(addr_t address, const SectionList *section_list)
    : … { … }

const Address &Address::operator=(const Address &rhs) { … }

bool Address::ResolveAddressUsingFileSections(addr_t file_addr,
                                              const SectionList *section_list) { … }

/// if "addr_range_ptr" is not NULL, then fill in with the address range of the function.
bool Address::ResolveFunctionScope(SymbolContext &sym_ctx,
                                   AddressRange *addr_range_ptr) { … }

ModuleSP Address::GetModule() const { … }

addr_t Address::GetFileAddress() const { … }

addr_t Address::GetLoadAddress(Target *target) const { … }

addr_t Address::GetCallableLoadAddress(Target *target, bool is_indirect) const { … }

bool Address::SetCallableLoadAddress(lldb::addr_t load_addr, Target *target) { … }

addr_t Address::GetOpcodeLoadAddress(Target *target,
                                     AddressClass addr_class) const { … }

bool Address::SetOpcodeLoadAddress(lldb::addr_t load_addr, Target *target,
                                   AddressClass addr_class,
                                   bool allow_section_end) { … }

bool Address::GetDescription(Stream &s, Target &target,
                             DescriptionLevel level) const { … }

bool Address::Dump(Stream *s, ExecutionContextScope *exe_scope, DumpStyle style,
                   DumpStyle fallback_style, uint32_t addr_size,
                   bool all_ranges,
                   std::optional<Stream::HighlightSettings> settings) const { … }

bool Address::SectionWasDeleted() const { … }

bool Address::SectionWasDeletedPrivate() const { … }

uint32_t
Address::CalculateSymbolContext(SymbolContext *sc,
                                SymbolContextItem resolve_scope) const { … }

ModuleSP Address::CalculateSymbolContextModule() const { … }

CompileUnit *Address::CalculateSymbolContextCompileUnit() const { … }

Function *Address::CalculateSymbolContextFunction() const { … }

Block *Address::CalculateSymbolContextBlock() const { … }

Symbol *Address::CalculateSymbolContextSymbol() const { … }

bool Address::CalculateSymbolContextLineEntry(LineEntry &line_entry) const { … }

int Address::CompareFileAddress(const Address &a, const Address &b) { … }

int Address::CompareLoadAddress(const Address &a, const Address &b,
                                Target *target) { … }

int Address::CompareModulePointerAndOffset(const Address &a, const Address &b) { … }

size_t Address::MemorySize() const { … }

// NOTE: Be careful using this operator. It can correctly compare two
// addresses from the same Module correctly. It can't compare two addresses
// from different modules in any meaningful way, but it will compare the module
// pointers.
//
// To sum things up:
// - works great for addresses within the same module - it works for addresses
// across multiple modules, but don't expect the
//   address results to make much sense
//
// This basically lets Address objects be used in ordered collection classes.

bool lldb_private::operator<(const Address &lhs, const Address &rhs) { … }

bool lldb_private::operator>(const Address &lhs, const Address &rhs) { … }

// The operator == checks for exact equality only (same section, same offset)
bool lldb_private::operator==(const Address &a, const Address &rhs) { … }

// The operator != checks for exact inequality only (differing section, or
// different offset)
bool lldb_private::operator!=(const Address &a, const Address &rhs) { … }

AddressClass Address::GetAddressClass() const { … }

bool Address::SetLoadAddress(lldb::addr_t load_addr, Target *target,
                             bool allow_section_end) { … }
llvm/lldb/source/Core/Address.cpp
