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/Core/Stream.h" 13 #include "lldb/Target/Process.h" 14 15 using namespace lldb; 16 using namespace lldb_private; 17 18 AddressRange::AddressRange () : 19 m_base_addr(), 20 m_byte_size(0) 21 { 22 } 23 24 AddressRange::AddressRange (addr_t file_addr, addr_t byte_size, const SectionList *section_list) : 25 m_base_addr(file_addr, section_list), 26 m_byte_size(byte_size) 27 { 28 } 29 30 AddressRange::AddressRange (const Section* section, addr_t offset, addr_t byte_size) : 31 m_base_addr(section, offset), 32 m_byte_size(byte_size) 33 { 34 } 35 36 AddressRange::AddressRange (const Address& so_addr, addr_t byte_size) : 37 m_base_addr(so_addr), 38 m_byte_size(byte_size) 39 { 40 } 41 42 AddressRange::~AddressRange () 43 { 44 } 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() && (addr.GetOffset() - m_base_addr.GetOffset()) < byte_size; 52 //} 53 // 54 //bool 55 //AddressRange::Contains (const Address *addr) const 56 //{ 57 // if (addr) 58 // return Contains (*addr); 59 // return false; 60 //} 61 62 bool 63 AddressRange::ContainsFileAddress (const Address &addr) const 64 { 65 if (addr.GetSection() == m_base_addr.GetSection()) 66 return (addr.GetOffset() - m_base_addr.GetOffset()) < GetByteSize(); 67 addr_t file_base_addr = GetBaseAddress().GetFileAddress(); 68 if (file_base_addr == LLDB_INVALID_ADDRESS) 69 return false; 70 71 addr_t file_addr = addr.GetFileAddress(); 72 if (file_addr == LLDB_INVALID_ADDRESS) 73 return false; 74 75 if (file_base_addr <= file_addr) 76 return (file_addr - file_base_addr) < GetByteSize(); 77 78 return false; 79 } 80 81 bool 82 AddressRange::ContainsFileAddress (addr_t file_addr) const 83 { 84 if (file_addr == LLDB_INVALID_ADDRESS) 85 return false; 86 87 addr_t file_base_addr = GetBaseAddress().GetFileAddress(); 88 if (file_base_addr == LLDB_INVALID_ADDRESS) 89 return false; 90 91 if (file_base_addr <= file_addr) 92 return (file_addr - file_base_addr) < GetByteSize(); 93 94 return false; 95 } 96 97 98 bool 99 AddressRange::ContainsLoadAddress (const Address &addr, Process *process) const 100 { 101 if (addr.GetSection() == m_base_addr.GetSection()) 102 return (addr.GetOffset() - m_base_addr.GetOffset()) < GetByteSize(); 103 addr_t load_base_addr = GetBaseAddress().GetLoadAddress(process); 104 if (load_base_addr == LLDB_INVALID_ADDRESS) 105 return false; 106 107 addr_t load_addr = addr.GetLoadAddress(process); 108 if (load_addr == LLDB_INVALID_ADDRESS) 109 return false; 110 111 if (load_base_addr <= load_addr) 112 return (load_addr - load_base_addr) < GetByteSize(); 113 114 return false; 115 } 116 117 bool 118 AddressRange::ContainsLoadAddress (addr_t load_addr, Process *process) const 119 { 120 if (load_addr == LLDB_INVALID_ADDRESS) 121 return false; 122 123 addr_t load_base_addr = GetBaseAddress().GetLoadAddress(process); 124 if (load_base_addr == LLDB_INVALID_ADDRESS) 125 return false; 126 127 if (load_base_addr <= load_addr) 128 return (load_addr - load_base_addr) < GetByteSize(); 129 130 return false; 131 } 132 133 void 134 AddressRange::Clear() 135 { 136 m_base_addr.Clear(); 137 m_byte_size = 0; 138 } 139 140 bool 141 AddressRange::Dump(Stream *s, Process *process, Address::DumpStyle style, Address::DumpStyle fallback_style) const 142 { 143 addr_t vmaddr = LLDB_INVALID_ADDRESS; 144 int addr_size = sizeof (addr_t); 145 if (process) 146 addr_size = process->GetAddressByteSize (); 147 148 bool show_module = false; 149 switch (style) 150 { 151 default: 152 break; 153 case Address::DumpStyleSectionNameOffset: 154 case Address::DumpStyleSectionPointerOffset: 155 s->PutChar ('['); 156 m_base_addr.Dump(s, process, style, fallback_style); 157 s->PutChar ('-'); 158 s->Address (m_base_addr.GetOffset() + GetByteSize(), addr_size); 159 s->PutChar (')'); 160 return true; 161 break; 162 163 case Address::DumpStyleModuleWithFileAddress: 164 show_module = true; 165 // fall through 166 case Address::DumpStyleFileAddress: 167 vmaddr = m_base_addr.GetFileAddress(); 168 break; 169 170 case Address::DumpStyleLoadAddress: 171 vmaddr = m_base_addr.GetLoadAddress(process); 172 break; 173 } 174 175 if (vmaddr != LLDB_INVALID_ADDRESS) 176 { 177 if (show_module) 178 { 179 Module *module = GetBaseAddress().GetModule(); 180 if (module) 181 s->Printf("%s", module->GetFileSpec().GetFilename().AsCString()); 182 } 183 s->AddressRange(vmaddr, vmaddr + GetByteSize(), addr_size); 184 return true; 185 } 186 else if (fallback_style != Address::DumpStyleInvalid) 187 { 188 return Dump(s, process, fallback_style, Address::DumpStyleInvalid); 189 } 190 191 return false; 192 } 193 194 195 void 196 AddressRange::DumpDebug (Stream *s) const 197 { 198 s->Printf("%.*p: AddressRange section = %*p, offset = 0x%16.16llx, byte_size = 0x%16.16llx\n", (int)sizeof(void*) * 2, this, (int)sizeof(void*) * 2, m_base_addr.GetSection(), m_base_addr.GetOffset(), GetByteSize()); 199 } 200 // 201 //bool 202 //lldb::operator== (const AddressRange& lhs, const AddressRange& rhs) 203 //{ 204 // if (lhs.GetBaseAddress() == rhs.GetBaseAddress()) 205 // return lhs.GetByteSize() == rhs.GetByteSize(); 206 // return false; 207 //} 208