Lines Matching full:address
1 //===-- Address.cpp -------------------------------------------------------===//
9 #include "lldb/Core/Address.h"
64 const Address &address, void *dst, size_t dst_len) {
72 return target_sp->ReadMemory(address, dst, dst_len, error,
79 const Address &address,
94 ModuleSP module_sp(address.GetModule());
104 const Address &address, uint32_t byte_size,
113 success = ReadBytes(exe_scope, address, &buf, byte_size) == byte_size;
117 if (GetByteOrderAndAddressSize(exe_scope, address, byte_order, addr_size)) {
128 const Address &address, uint32_t pointer_size,
129 Address &deref_so_addr) {
134 addr_t deref_addr = ReadUIntMax64(exe_scope, address, pointer_size, success);
147 ModuleSP module_sp(address.GetModule());
155 // able to read the address, so we return a section offset address with no
156 // section and "deref_addr" as the offset (address).
163 static bool DumpUInt(ExecutionContextScope *exe_scope, const Address &address,
169 if (ReadBytes(exe_scope, address, &buf[0], buf.size()) == buf.size()) {
172 if (GetByteOrderAndAddressSize(exe_scope, address, byte_order, addr_size)) {
181 LLDB_INVALID_ADDRESS, // base address
192 const Address &address, Stream *strm) {
199 // Byte order and address size don't matter for C string dumping..
203 Address curr_address(address);
219 LLDB_INVALID_ADDRESS, // base address
234 Address::Address(lldb::addr_t abs_addr) : m_section_wp(), m_offset(abs_addr) {}
236 Address::Address(addr_t address, const SectionList *section_list)
238 ResolveAddressUsingFileSections(address, section_list);
241 const Address &Address::operator=(const Address &rhs) {
249 bool Address::ResolveAddressUsingFileSections(addr_t file_addr,
259 // address
263 return false; // Failed to resolve this address to a section offset value
266 /// if "addr_range_ptr" is not NULL, then fill in with the address range of the function.
267 bool Address::ResolveFunctionScope(SymbolContext &sym_ctx,
284 ModuleSP Address::GetModule() const {
292 addr_t Address::GetFileAddress() const {
297 // Section isn't resolved, we can't return a valid file address
300 // We have a valid file range, so we can return the file based address by
301 // adding the file base address to our offset
312 addr_t Address::GetLoadAddress(Target *target) const {
319 // We have a valid file range, so we can return the file based address
320 // by adding the file base address to our offset
329 // We don't have a section so the offset is the load address
333 // return a valid load address.
337 addr_t Address::GetCallableLoadAddress(Target *target, bool is_indirect) const {
360 bool Address::SetCallableLoadAddress(lldb::addr_t load_addr, Target *target) {
369 addr_t Address::GetOpcodeLoadAddress(Target *target,
380 bool Address::SetOpcodeLoadAddress(lldb::addr_t load_addr, Target *target,
394 bool Address::GetDescription(Stream &s, Target &target,
407 bool Address::Dump(Stream *s, ExecutionContextScope *exe_scope, DumpStyle style,
411 // If the section was nullptr, only load address is going to work unless we
419 // If addr_byte_size is UINT32_MAX, then determine the correct address byte
428 Address so_addr;
474 * Display address in compressed form for MIPS16 or microMIPS
475 * if the address belongs to AddressClass::eCodeAlternateISA.
565 Address cstr_addr(*this);
591 Address cfstring_data_addr(*this);
684 // address.
716 // our address. If it isn't, then we might have just found the last
717 // symbol that came before the address that we are looking up that
718 // has nothing to do with our address lookup.
786 Address dereferenced_addr;
811 bool Address::SectionWasDeleted() const {
817 bool Address::SectionWasDeletedPrivate() const {
824 // was unloaded/deleted, or if the address doesn't have a valid reference to
831 Address::CalculateSymbolContext(SymbolContext *sc,
850 ModuleSP Address::CalculateSymbolContextModule() const {
857 CompileUnit *Address::CalculateSymbolContextCompileUnit() const {
871 Function *Address::CalculateSymbolContextFunction() const {
885 Block *Address::CalculateSymbolContextBlock() const {
899 Symbol *Address::CalculateSymbolContextSymbol() const {
913 bool Address::CalculateSymbolContextLineEntry(LineEntry &line_entry) const {
931 int Address::CompareFileAddress(const Address &a, const Address &b) {
941 int Address::CompareLoadAddress(const Address &a, const Address &b,
953 int Address::CompareModulePointerAndOffset(const Address &a, const Address &b) {
962 // Modules are the same, just compare the file address since they should be
973 size_t Address::MemorySize() const {
974 // Noting special for the memory size of a single Address object, it is just
976 return sizeof(Address);
987 // address results to make much sense
989 // This basically lets Address objects be used in ordered collection classes.
991 bool lldb_private::operator<(const Address &lhs, const Address &rhs) {
1006 bool lldb_private::operator>(const Address &lhs, const Address &rhs) {
1022 bool lldb_private::operator==(const Address &a, const Address &rhs) {
1028 bool lldb_private::operator!=(const Address &a, const Address &rhs) {
1032 AddressClass Address::GetAddressClass() const {
1046 bool Address::SetLoadAddress(lldb::addr_t load_addr, Target *target,