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/Target/Target.h"
  13 #include "lldb/Utility/ConstString.h"
  14 #include "lldb/Utility/FileSpec.h"
  15 #include "lldb/Utility/Stream.h"
  16 #include "lldb/lldb-defines.h"
  17
  18 #include "llvm/Support/Compiler.h"
  19
  20 #include <memory>
  21
  22 #include <inttypes.h>
  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 &section, 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 //}