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