lldb/source/API/SBMemoryRegionInfo.cpp

   1 //===-- SBMemoryRegionInfo.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/API/SBMemoryRegionInfo.h"
  10 #include "SBReproducerPrivate.h"
  11 #include "Utils.h"
  12 #include "lldb/API/SBDefines.h"
  13 #include "lldb/API/SBError.h"
  14 #include "lldb/API/SBStream.h"
  15 #include "lldb/Target/MemoryRegionInfo.h"
  16 #include "lldb/Utility/StreamString.h"
  17
  18 using namespace lldb;
  19 using namespace lldb_private;
  20
  21 SBMemoryRegionInfo::SBMemoryRegionInfo() : m_opaque_up(new MemoryRegionInfo()) {
  22   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBMemoryRegionInfo);
  23 }
  24
  25 SBMemoryRegionInfo::SBMemoryRegionInfo(const MemoryRegionInfo *lldb_object_ptr)
  26     : m_opaque_up(new MemoryRegionInfo()) {
  27   if (lldb_object_ptr)
  28     ref() = *lldb_object_ptr;
  29 }
  30
  31 SBMemoryRegionInfo::SBMemoryRegionInfo(const SBMemoryRegionInfo &rhs)
  32     : m_opaque_up() {
  33   LLDB_RECORD_CONSTRUCTOR(SBMemoryRegionInfo,
  34                           (const lldb::SBMemoryRegionInfo &), rhs);
  35   m_opaque_up = clone(rhs.m_opaque_up);
  36 }
  37
  38 const SBMemoryRegionInfo &SBMemoryRegionInfo::
  39 operator=(const SBMemoryRegionInfo &rhs) {
  40   LLDB_RECORD_METHOD(
  41       const lldb::SBMemoryRegionInfo &,
  42       SBMemoryRegionInfo, operator=,(const lldb::SBMemoryRegionInfo &), rhs);
  43
  44   if (this != &rhs)
  45     m_opaque_up = clone(rhs.m_opaque_up);
  46   return LLDB_RECORD_RESULT(*this);
  47 }
  48
  49 SBMemoryRegionInfo::~SBMemoryRegionInfo() {}
  50
  51 void SBMemoryRegionInfo::Clear() {
  52   LLDB_RECORD_METHOD_NO_ARGS(void, SBMemoryRegionInfo, Clear);
  53
  54   m_opaque_up->Clear();
  55 }
  56
  57 bool SBMemoryRegionInfo::operator==(const SBMemoryRegionInfo &rhs) const {
  58   LLDB_RECORD_METHOD_CONST(
  59       bool, SBMemoryRegionInfo, operator==,(const lldb::SBMemoryRegionInfo &),
  60       rhs);
  61
  62   return ref() == rhs.ref();
  63 }
  64
  65 bool SBMemoryRegionInfo::operator!=(const SBMemoryRegionInfo &rhs) const {
  66   LLDB_RECORD_METHOD_CONST(
  67       bool, SBMemoryRegionInfo, operator!=,(const lldb::SBMemoryRegionInfo &),
  68       rhs);
  69
  70   return ref() != rhs.ref();
  71 }
  72
  73 MemoryRegionInfo &SBMemoryRegionInfo::ref() { return *m_opaque_up; }
  74
  75 const MemoryRegionInfo &SBMemoryRegionInfo::ref() const { return *m_opaque_up; }
  76
  77 lldb::addr_t SBMemoryRegionInfo::GetRegionBase() {
  78   LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBMemoryRegionInfo, GetRegionBase);
  79
  80   return m_opaque_up->GetRange().GetRangeBase();
  81 }
  82
  83 lldb::addr_t SBMemoryRegionInfo::GetRegionEnd() {
  84   LLDB_RECORD_METHOD_NO_ARGS(lldb::addr_t, SBMemoryRegionInfo, GetRegionEnd);
  85
  86   return m_opaque_up->GetRange().GetRangeEnd();
  87 }
  88
  89 bool SBMemoryRegionInfo::IsReadable() {
  90   LLDB_RECORD_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, IsReadable);
  91
  92   return m_opaque_up->GetReadable() == MemoryRegionInfo::eYes;
  93 }
  94
  95 bool SBMemoryRegionInfo::IsWritable() {
  96   LLDB_RECORD_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, IsWritable);
  97
  98   return m_opaque_up->GetWritable() == MemoryRegionInfo::eYes;
  99 }
 100
 101 bool SBMemoryRegionInfo::IsExecutable() {
 102   LLDB_RECORD_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, IsExecutable);
 103
 104   return m_opaque_up->GetExecutable() == MemoryRegionInfo::eYes;
 105 }
 106
 107 bool SBMemoryRegionInfo::IsMapped() {
 108   LLDB_RECORD_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, IsMapped);
 109
 110   return m_opaque_up->GetMapped() == MemoryRegionInfo::eYes;
 111 }
 112
 113 const char *SBMemoryRegionInfo::GetName() {
 114   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBMemoryRegionInfo, GetName);
 115
 116   return m_opaque_up->GetName().AsCString();
 117 }
 118
 119 bool SBMemoryRegionInfo::GetDescription(SBStream &description) {
 120   LLDB_RECORD_METHOD(bool, SBMemoryRegionInfo, GetDescription,
 121                      (lldb::SBStream &), description);
 122
 123   Stream &strm = description.ref();
 124   const addr_t load_addr = m_opaque_up->GetRange().base;
 125
 126   strm.Printf("[0x%16.16" PRIx64 "-0x%16.16" PRIx64 " ", load_addr,
 127               load_addr + m_opaque_up->GetRange().size);
 128   strm.Printf(m_opaque_up->GetReadable() ? "R" : "-");
 129   strm.Printf(m_opaque_up->GetWritable() ? "W" : "-");
 130   strm.Printf(m_opaque_up->GetExecutable() ? "X" : "-");
 131   strm.Printf("]");
 132
 133   return true;
 134 }
 135
 136 namespace lldb_private {
 137 namespace repro {
 138
 139 template <>
 140 void RegisterMethods<SBMemoryRegionInfo>(Registry &R) {
 141   LLDB_REGISTER_CONSTRUCTOR(SBMemoryRegionInfo, ());
 142   LLDB_REGISTER_CONSTRUCTOR(SBMemoryRegionInfo,
 143                             (const lldb::SBMemoryRegionInfo &));
 144   LLDB_REGISTER_METHOD(
 145       const lldb::SBMemoryRegionInfo &,
 146       SBMemoryRegionInfo, operator=,(const lldb::SBMemoryRegionInfo &));
 147   LLDB_REGISTER_METHOD(void, SBMemoryRegionInfo, Clear, ());
 148   LLDB_REGISTER_METHOD_CONST(
 149       bool,
 150       SBMemoryRegionInfo, operator==,(const lldb::SBMemoryRegionInfo &));
 151   LLDB_REGISTER_METHOD_CONST(
 152       bool,
 153       SBMemoryRegionInfo, operator!=,(const lldb::SBMemoryRegionInfo &));
 154   LLDB_REGISTER_METHOD(lldb::addr_t, SBMemoryRegionInfo, GetRegionBase, ());
 155   LLDB_REGISTER_METHOD(lldb::addr_t, SBMemoryRegionInfo, GetRegionEnd, ());
 156   LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, IsReadable, ());
 157   LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, IsWritable, ());
 158   LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, IsExecutable, ());
 159   LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, IsMapped, ());
 160   LLDB_REGISTER_METHOD(const char *, SBMemoryRegionInfo, GetName, ());
 161   LLDB_REGISTER_METHOD(bool, SBMemoryRegionInfo, GetDescription,
 162                        (lldb::SBStream &));
 163 }
 164
 165 }
 166 }