contrib/llvm/tools/lldb/source/Core/AddressRange.cpp

   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 &section, 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 //}