contrib/llvm/tools/lldb/source/API/SBAddress.cpp

   1 //===-- SBAddress.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/API/SBAddress.h"
  11 #include "lldb/API/SBProcess.h"
  12 #include "lldb/API/SBSection.h"
  13 #include "lldb/API/SBStream.h"
  14 #include "lldb/Core/Address.h"
  15 #include "lldb/Core/Module.h"
  16 #include "lldb/Symbol/LineEntry.h"
  17 #include "lldb/Target/Target.h"
  18 #include "lldb/Utility/Log.h"
  19 #include "lldb/Utility/StreamString.h"
  20
  21 using namespace lldb;
  22 using namespace lldb_private;
  23
  24 SBAddress::SBAddress() : m_opaque_ap(new Address()) {}
  25
  26 SBAddress::SBAddress(const Address *lldb_object_ptr)
  27     : m_opaque_ap(new Address()) {
  28   if (lldb_object_ptr)
  29     ref() = *lldb_object_ptr;
  30 }
  31
  32 SBAddress::SBAddress(const SBAddress &rhs) : m_opaque_ap(new Address()) {
  33   if (rhs.IsValid())
  34     ref() = rhs.ref();
  35 }
  36
  37 SBAddress::SBAddress(lldb::SBSection section, lldb::addr_t offset)
  38     : m_opaque_ap(new Address(section.GetSP(), offset)) {}
  39
  40 // Create an address by resolving a load address using the supplied target
  41 SBAddress::SBAddress(lldb::addr_t load_addr, lldb::SBTarget &target)
  42     : m_opaque_ap(new Address()) {
  43   SetLoadAddress(load_addr, target);
  44 }
  45
  46 SBAddress::~SBAddress() {}
  47
  48 const SBAddress &SBAddress::operator=(const SBAddress &rhs) {
  49   if (this != &rhs) {
  50     if (rhs.IsValid())
  51       ref() = rhs.ref();
  52     else
  53       m_opaque_ap.reset(new Address());
  54   }
  55   return *this;
  56 }
  57
  58 bool lldb::operator==(const SBAddress &lhs, const SBAddress &rhs) {
  59   if (lhs.IsValid() && rhs.IsValid())
  60     return lhs.ref() == rhs.ref();
  61   return false;
  62 }
  63
  64 bool SBAddress::IsValid() const {
  65   return m_opaque_ap.get() != NULL && m_opaque_ap->IsValid();
  66 }
  67
  68 void SBAddress::Clear() { m_opaque_ap.reset(new Address()); }
  69
  70 void SBAddress::SetAddress(lldb::SBSection section, lldb::addr_t offset) {
  71   Address &addr = ref();
  72   addr.SetSection(section.GetSP());
  73   addr.SetOffset(offset);
  74 }
  75
  76 void SBAddress::SetAddress(const Address *lldb_object_ptr) {
  77   if (lldb_object_ptr)
  78     ref() = *lldb_object_ptr;
  79   else
  80     m_opaque_ap.reset(new Address());
  81 }
  82
  83 lldb::addr_t SBAddress::GetFileAddress() const {
  84   if (m_opaque_ap->IsValid())
  85     return m_opaque_ap->GetFileAddress();
  86   else
  87     return LLDB_INVALID_ADDRESS;
  88 }
  89
  90 lldb::addr_t SBAddress::GetLoadAddress(const SBTarget &target) const {
  91   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
  92
  93   lldb::addr_t addr = LLDB_INVALID_ADDRESS;
  94   TargetSP target_sp(target.GetSP());
  95   if (target_sp) {
  96     if (m_opaque_ap->IsValid()) {
  97       std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
  98       addr = m_opaque_ap->GetLoadAddress(target_sp.get());
  99     }
 100   }
 101
 102   if (log) {
 103     if (addr == LLDB_INVALID_ADDRESS)
 104       log->Printf(
 105           "SBAddress::GetLoadAddress (SBTarget(%p)) => LLDB_INVALID_ADDRESS",
 106           static_cast<void *>(target_sp.get()));
 107     else
 108       log->Printf("SBAddress::GetLoadAddress (SBTarget(%p)) => 0x%" PRIx64,
 109                   static_cast<void *>(target_sp.get()), addr);
 110   }
 111
 112   return addr;
 113 }
 114
 115 void SBAddress::SetLoadAddress(lldb::addr_t load_addr, lldb::SBTarget &target) {
 116   // Create the address object if we don't already have one
 117   ref();
 118   if (target.IsValid())
 119     *this = target.ResolveLoadAddress(load_addr);
 120   else
 121     m_opaque_ap->Clear();
 122
 123   // Check if we weren't were able to resolve a section offset address. If we
 124   // weren't it is ok, the load address might be a location on the stack or
 125   // heap, so we should just have an address with no section and a valid offset
 126   if (!m_opaque_ap->IsValid())
 127     m_opaque_ap->SetOffset(load_addr);
 128 }
 129
 130 bool SBAddress::OffsetAddress(addr_t offset) {
 131   if (m_opaque_ap->IsValid()) {
 132     addr_t addr_offset = m_opaque_ap->GetOffset();
 133     if (addr_offset != LLDB_INVALID_ADDRESS) {
 134       m_opaque_ap->SetOffset(addr_offset + offset);
 135       return true;
 136     }
 137   }
 138   return false;
 139 }
 140
 141 lldb::SBSection SBAddress::GetSection() {
 142   lldb::SBSection sb_section;
 143   if (m_opaque_ap->IsValid())
 144     sb_section.SetSP(m_opaque_ap->GetSection());
 145   return sb_section;
 146 }
 147
 148 lldb::addr_t SBAddress::GetOffset() {
 149   if (m_opaque_ap->IsValid())
 150     return m_opaque_ap->GetOffset();
 151   return 0;
 152 }
 153
 154 Address *SBAddress::operator->() { return m_opaque_ap.get(); }
 155
 156 const Address *SBAddress::operator->() const { return m_opaque_ap.get(); }
 157
 158 Address &SBAddress::ref() {
 159   if (m_opaque_ap.get() == NULL)
 160     m_opaque_ap.reset(new Address());
 161   return *m_opaque_ap;
 162 }
 163
 164 const Address &SBAddress::ref() const {
 165   // This object should already have checked with "IsValid()" prior to calling
 166   // this function. In case you didn't we will assert and die to let you know.
 167   assert(m_opaque_ap.get());
 168   return *m_opaque_ap;
 169 }
 170
 171 Address *SBAddress::get() { return m_opaque_ap.get(); }
 172
 173 bool SBAddress::GetDescription(SBStream &description) {
 174   // Call "ref()" on the stream to make sure it creates a backing stream in
 175   // case there isn't one already...
 176   Stream &strm = description.ref();
 177   if (m_opaque_ap->IsValid()) {
 178     m_opaque_ap->Dump(&strm, NULL, Address::DumpStyleResolvedDescription,
 179                       Address::DumpStyleModuleWithFileAddress, 4);
 180     StreamString sstrm;
 181     //        m_opaque_ap->Dump (&sstrm, NULL,
 182     //        Address::DumpStyleResolvedDescription, Address::DumpStyleInvalid,
 183     //        4);
 184     //        if (sstrm.GetData())
 185     //            strm.Printf (" (%s)", sstrm.GetData());
 186   } else
 187     strm.PutCString("No value");
 188
 189   return true;
 190 }
 191
 192 SBModule SBAddress::GetModule() {
 193   SBModule sb_module;
 194   if (m_opaque_ap->IsValid())
 195     sb_module.SetSP(m_opaque_ap->GetModule());
 196   return sb_module;
 197 }
 198
 199 SBSymbolContext SBAddress::GetSymbolContext(uint32_t resolve_scope) {
 200   SBSymbolContext sb_sc;
 201   if (m_opaque_ap->IsValid())
 202     m_opaque_ap->CalculateSymbolContext(&sb_sc.ref(), resolve_scope);
 203   return sb_sc;
 204 }
 205
 206 SBCompileUnit SBAddress::GetCompileUnit() {
 207   SBCompileUnit sb_comp_unit;
 208   if (m_opaque_ap->IsValid())
 209     sb_comp_unit.reset(m_opaque_ap->CalculateSymbolContextCompileUnit());
 210   return sb_comp_unit;
 211 }
 212
 213 SBFunction SBAddress::GetFunction() {
 214   SBFunction sb_function;
 215   if (m_opaque_ap->IsValid())
 216     sb_function.reset(m_opaque_ap->CalculateSymbolContextFunction());
 217   return sb_function;
 218 }
 219
 220 SBBlock SBAddress::GetBlock() {
 221   SBBlock sb_block;
 222   if (m_opaque_ap->IsValid())
 223     sb_block.SetPtr(m_opaque_ap->CalculateSymbolContextBlock());
 224   return sb_block;
 225 }
 226
 227 SBSymbol SBAddress::GetSymbol() {
 228   SBSymbol sb_symbol;
 229   if (m_opaque_ap->IsValid())
 230     sb_symbol.reset(m_opaque_ap->CalculateSymbolContextSymbol());
 231   return sb_symbol;
 232 }
 233
 234 SBLineEntry SBAddress::GetLineEntry() {
 235   SBLineEntry sb_line_entry;
 236   if (m_opaque_ap->IsValid()) {
 237     LineEntry line_entry;
 238     if (m_opaque_ap->CalculateSymbolContextLineEntry(line_entry))
 239       sb_line_entry.SetLineEntry(line_entry);
 240   }
 241   return sb_line_entry;
 242 }