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

   1 //===-- AddressRange.cpp ----------------------------------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "lldb/Core/AddressRange.h"
  10 #include "lldb/Core/Module.h"
  11 #include "lldb/Target/Target.h"
  12 #include "lldb/Utility/ConstString.h"
  13 #include "lldb/Utility/FileSpec.h"
  14 #include "lldb/Utility/Stream.h"
  15 #include "lldb/lldb-defines.h"
  16
  17 #include "llvm/Support/Compiler.h"
  18
  19 #include <memory>
  20
  21 #include <inttypes.h>
  22
  23 namespace lldb_private {
  24 class SectionList;
  25 }
  26
  27 using namespace lldb;
  28 using namespace lldb_private;
  29
  30 AddressRange::AddressRange() : m_base_addr(), m_byte_size(0) {}
  31
  32 AddressRange::AddressRange(addr_t file_addr, addr_t byte_size,
  33                            const SectionList *section_list)
  34     : m_base_addr(file_addr, section_list), m_byte_size(byte_size) {}
  35
  36 AddressRange::AddressRange(const lldb::SectionSP &section, addr_t offset,
  37                            addr_t byte_size)
  38     : m_base_addr(section, offset), m_byte_size(byte_size) {}
  39
  40 AddressRange::AddressRange(const Address &so_addr, addr_t byte_size)
  41     : m_base_addr(so_addr), m_byte_size(byte_size) {}
  42
  43 AddressRange::~AddressRange() {}
  44
  45 // bool
  46 // AddressRange::Contains (const Address &addr) const
  47 //{
  48 //    const addr_t byte_size = GetByteSize();
  49 //    if (byte_size)
  50 //        return addr.GetSection() == m_base_addr.GetSection() &&
  51 //        (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 AddressRange::ContainsFileAddress(const Address &addr) const {
  63   if (addr.GetSection() == m_base_addr.GetSection())
  64     return (addr.GetOffset() - m_base_addr.GetOffset()) < GetByteSize();
  65   addr_t file_base_addr = GetBaseAddress().GetFileAddress();
  66   if (file_base_addr == LLDB_INVALID_ADDRESS)
  67     return false;
  68
  69   addr_t file_addr = addr.GetFileAddress();
  70   if (file_addr == LLDB_INVALID_ADDRESS)
  71     return false;
  72
  73   if (file_base_addr <= file_addr)
  74     return (file_addr - file_base_addr) < GetByteSize();
  75
  76   return false;
  77 }
  78
  79 bool AddressRange::ContainsFileAddress(addr_t file_addr) const {
  80   if (file_addr == LLDB_INVALID_ADDRESS)
  81     return false;
  82
  83   addr_t file_base_addr = GetBaseAddress().GetFileAddress();
  84   if (file_base_addr == LLDB_INVALID_ADDRESS)
  85     return false;
  86
  87   if (file_base_addr <= file_addr)
  88     return (file_addr - file_base_addr) < GetByteSize();
  89
  90   return false;
  91 }
  92
  93 bool AddressRange::ContainsLoadAddress(const Address &addr,
  94                                        Target *target) const {
  95   if (addr.GetSection() == m_base_addr.GetSection())
  96     return (addr.GetOffset() - m_base_addr.GetOffset()) < GetByteSize();
  97   addr_t load_base_addr = GetBaseAddress().GetLoadAddress(target);
  98   if (load_base_addr == LLDB_INVALID_ADDRESS)
  99     return false;
 100
 101   addr_t load_addr = addr.GetLoadAddress(target);
 102   if (load_addr == LLDB_INVALID_ADDRESS)
 103     return false;
 104
 105   if (load_base_addr <= load_addr)
 106     return (load_addr - load_base_addr) < GetByteSize();
 107
 108   return false;
 109 }
 110
 111 bool AddressRange::ContainsLoadAddress(addr_t load_addr, Target *target) const {
 112   if (load_addr == LLDB_INVALID_ADDRESS)
 113     return false;
 114
 115   addr_t load_base_addr = GetBaseAddress().GetLoadAddress(target);
 116   if (load_base_addr == LLDB_INVALID_ADDRESS)
 117     return false;
 118
 119   if (load_base_addr <= load_addr)
 120     return (load_addr - load_base_addr) < GetByteSize();
 121
 122   return false;
 123 }
 124
 125 bool AddressRange::Extend(const AddressRange &rhs_range) {
 126   addr_t lhs_end_addr = GetBaseAddress().GetFileAddress() + GetByteSize();
 127   addr_t rhs_base_addr = rhs_range.GetBaseAddress().GetFileAddress();
 128
 129   if (!ContainsFileAddress(rhs_range.GetBaseAddress()) &&
 130       lhs_end_addr != rhs_base_addr)
 131     // The ranges don't intersect at all on the right side of this range.
 132     return false;
 133
 134   addr_t rhs_end_addr = rhs_base_addr + rhs_range.GetByteSize();
 135   if (lhs_end_addr >= rhs_end_addr)
 136     // The rhs range totally overlaps this one, nothing to add.
 137     return false;
 138
 139   m_byte_size += rhs_end_addr - lhs_end_addr;
 140   return true;
 141 }
 142
 143 void AddressRange::Clear() {
 144   m_base_addr.Clear();
 145   m_byte_size = 0;
 146 }
 147
 148 bool AddressRange::Dump(Stream *s, Target *target, Address::DumpStyle style,
 149                         Address::DumpStyle fallback_style) const {
 150   addr_t vmaddr = LLDB_INVALID_ADDRESS;
 151   int addr_size = sizeof(addr_t);
 152   if (target)
 153     addr_size = target->GetArchitecture().GetAddressByteSize();
 154
 155   bool show_module = false;
 156   switch (style) {
 157   default:
 158     break;
 159   case Address::DumpStyleSectionNameOffset:
 160   case Address::DumpStyleSectionPointerOffset:
 161     s->PutChar('[');
 162     m_base_addr.Dump(s, target, style, fallback_style);
 163     s->PutChar('-');
 164     s->Address(m_base_addr.GetOffset() + GetByteSize(), addr_size);
 165     s->PutChar(')');
 166     return true;
 167     break;
 168
 169   case Address::DumpStyleModuleWithFileAddress:
 170     show_module = true;
 171     LLVM_FALLTHROUGH;
 172   case Address::DumpStyleFileAddress:
 173     vmaddr = m_base_addr.GetFileAddress();
 174     break;
 175
 176   case Address::DumpStyleLoadAddress:
 177     vmaddr = m_base_addr.GetLoadAddress(target);
 178     break;
 179   }
 180
 181   if (vmaddr != LLDB_INVALID_ADDRESS) {
 182     if (show_module) {
 183       ModuleSP module_sp(GetBaseAddress().GetModule());
 184       if (module_sp)
 185         s->Printf("%s", module_sp->GetFileSpec().GetFilename().AsCString(
 186                             "<Unknown>"));
 187     }
 188     s->AddressRange(vmaddr, vmaddr + GetByteSize(), addr_size);
 189     return true;
 190   } else if (fallback_style != Address::DumpStyleInvalid) {
 191     return Dump(s, target, fallback_style, Address::DumpStyleInvalid);
 192   }
 193
 194   return false;
 195 }
 196
 197 void AddressRange::DumpDebug(Stream *s) const {
 198   s->Printf("%p: AddressRange section = %p, offset = 0x%16.16" PRIx64
 199             ", byte_size = 0x%16.16" PRIx64 "\n",
 200             static_cast<const void *>(this),
 201             static_cast<void *>(m_base_addr.GetSection().get()),
 202             m_base_addr.GetOffset(), GetByteSize());
 203 }
 204 //
 205 // bool
 206 // lldb::operator==    (const AddressRange& lhs, const AddressRange& rhs)
 207 //{
 208 //    if (lhs.GetBaseAddress() == rhs.GetBaseAddress())
 209 //        return lhs.GetByteSize() == rhs.GetByteSize();
 210 //    return false;
 211 //}