1 //===-- AddressRange.cpp ----------------------------------------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "lldb/Core/AddressRange.h" 11 #include "lldb/Core/Module.h" 12 #include "lldb/Target/Target.h" 13 #include "lldb/Utility/ConstString.h" // for ConstString 14 #include "lldb/Utility/FileSpec.h" // for FileSpec 15 #include "lldb/Utility/Stream.h" 16 #include "lldb/lldb-defines.h" // for LLDB_INVALID_ADDRESS 17 18 #include "llvm/Support/Compiler.h" // for LLVM_FALLTHROUGH 19 20 #include <memory> // for shared_ptr 21 22 #include <inttypes.h> // for PRIx64 23 24 namespace lldb_private { 25 class SectionList; 26 } 27 28 using namespace lldb; 29 using namespace lldb_private; 30 31 AddressRange::AddressRange() : m_base_addr(), m_byte_size(0) {} 32 33 AddressRange::AddressRange(addr_t file_addr, addr_t byte_size, 34 const SectionList *section_list) 35 : m_base_addr(file_addr, section_list), m_byte_size(byte_size) {} 36 37 AddressRange::AddressRange(const lldb::SectionSP §ion, addr_t offset, 38 addr_t byte_size) 39 : m_base_addr(section, offset), m_byte_size(byte_size) {} 40 41 AddressRange::AddressRange(const Address &so_addr, addr_t byte_size) 42 : m_base_addr(so_addr), m_byte_size(byte_size) {} 43 44 AddressRange::~AddressRange() {} 45 46 // bool 47 // AddressRange::Contains (const Address &addr) const 48 //{ 49 // const addr_t byte_size = GetByteSize(); 50 // if (byte_size) 51 // return addr.GetSection() == m_base_addr.GetSection() && 52 // (addr.GetOffset() - m_base_addr.GetOffset()) < byte_size; 53 //} 54 // 55 // bool 56 // AddressRange::Contains (const Address *addr) const 57 //{ 58 // if (addr) 59 // return Contains (*addr); 60 // return false; 61 //} 62 63 bool AddressRange::ContainsFileAddress(const Address &addr) const { 64 if (addr.GetSection() == m_base_addr.GetSection()) 65 return (addr.GetOffset() - m_base_addr.GetOffset()) < GetByteSize(); 66 addr_t file_base_addr = GetBaseAddress().GetFileAddress(); 67 if (file_base_addr == LLDB_INVALID_ADDRESS) 68 return false; 69 70 addr_t file_addr = addr.GetFileAddress(); 71 if (file_addr == LLDB_INVALID_ADDRESS) 72 return false; 73 74 if (file_base_addr <= file_addr) 75 return (file_addr - file_base_addr) < GetByteSize(); 76 77 return false; 78 } 79 80 bool AddressRange::ContainsFileAddress(addr_t file_addr) const { 81 if (file_addr == LLDB_INVALID_ADDRESS) 82 return false; 83 84 addr_t file_base_addr = GetBaseAddress().GetFileAddress(); 85 if (file_base_addr == LLDB_INVALID_ADDRESS) 86 return false; 87 88 if (file_base_addr <= file_addr) 89 return (file_addr - file_base_addr) < GetByteSize(); 90 91 return false; 92 } 93 94 bool AddressRange::ContainsLoadAddress(const Address &addr, 95 Target *target) const { 96 if (addr.GetSection() == m_base_addr.GetSection()) 97 return (addr.GetOffset() - m_base_addr.GetOffset()) < GetByteSize(); 98 addr_t load_base_addr = GetBaseAddress().GetLoadAddress(target); 99 if (load_base_addr == LLDB_INVALID_ADDRESS) 100 return false; 101 102 addr_t load_addr = addr.GetLoadAddress(target); 103 if (load_addr == LLDB_INVALID_ADDRESS) 104 return false; 105 106 if (load_base_addr <= load_addr) 107 return (load_addr - load_base_addr) < GetByteSize(); 108 109 return false; 110 } 111 112 bool AddressRange::ContainsLoadAddress(addr_t load_addr, Target *target) const { 113 if (load_addr == LLDB_INVALID_ADDRESS) 114 return false; 115 116 addr_t load_base_addr = GetBaseAddress().GetLoadAddress(target); 117 if (load_base_addr == LLDB_INVALID_ADDRESS) 118 return false; 119 120 if (load_base_addr <= load_addr) 121 return (load_addr - load_base_addr) < GetByteSize(); 122 123 return false; 124 } 125 126 void AddressRange::Clear() { 127 m_base_addr.Clear(); 128 m_byte_size = 0; 129 } 130 131 bool AddressRange::Dump(Stream *s, Target *target, Address::DumpStyle style, 132 Address::DumpStyle fallback_style) const { 133 addr_t vmaddr = LLDB_INVALID_ADDRESS; 134 int addr_size = sizeof(addr_t); 135 if (target) 136 addr_size = target->GetArchitecture().GetAddressByteSize(); 137 138 bool show_module = false; 139 switch (style) { 140 default: 141 break; 142 case Address::DumpStyleSectionNameOffset: 143 case Address::DumpStyleSectionPointerOffset: 144 s->PutChar('['); 145 m_base_addr.Dump(s, target, style, fallback_style); 146 s->PutChar('-'); 147 s->Address(m_base_addr.GetOffset() + GetByteSize(), addr_size); 148 s->PutChar(')'); 149 return true; 150 break; 151 152 case Address::DumpStyleModuleWithFileAddress: 153 show_module = true; 154 LLVM_FALLTHROUGH; 155 case Address::DumpStyleFileAddress: 156 vmaddr = m_base_addr.GetFileAddress(); 157 break; 158 159 case Address::DumpStyleLoadAddress: 160 vmaddr = m_base_addr.GetLoadAddress(target); 161 break; 162 } 163 164 if (vmaddr != LLDB_INVALID_ADDRESS) { 165 if (show_module) { 166 ModuleSP module_sp(GetBaseAddress().GetModule()); 167 if (module_sp) 168 s->Printf("%s", module_sp->GetFileSpec().GetFilename().AsCString( 169 "<Unknown>")); 170 } 171 s->AddressRange(vmaddr, vmaddr + GetByteSize(), addr_size); 172 return true; 173 } else if (fallback_style != Address::DumpStyleInvalid) { 174 return Dump(s, target, fallback_style, Address::DumpStyleInvalid); 175 } 176 177 return false; 178 } 179 180 void AddressRange::DumpDebug(Stream *s) const { 181 s->Printf("%p: AddressRange section = %p, offset = 0x%16.16" PRIx64 182 ", byte_size = 0x%16.16" PRIx64 "\n", 183 static_cast<const void *>(this), 184 static_cast<void *>(m_base_addr.GetSection().get()), 185 m_base_addr.GetOffset(), GetByteSize()); 186 } 187 // 188 // bool 189 // lldb::operator== (const AddressRange& lhs, const AddressRange& rhs) 190 //{ 191 // if (lhs.GetBaseAddress() == rhs.GetBaseAddress()) 192 // return lhs.GetByteSize() == rhs.GetByteSize(); 193 // return false; 194 //} 195