lldb/source/API/SBSymbolContext.cpp

   1 //===-- SBSymbolContext.cpp -----------------------------------------------===//
   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/SBSymbolContext.h"
  10 #include "Utils.h"
  11 #include "lldb/API/SBStream.h"
  12 #include "lldb/Core/Module.h"
  13 #include "lldb/Symbol/Function.h"
  14 #include "lldb/Symbol/Symbol.h"
  15 #include "lldb/Symbol/SymbolContext.h"
  16 #include "lldb/Utility/Instrumentation.h"
  17
  18 using namespace lldb;
  19 using namespace lldb_private;
  20
  21 SBSymbolContext::SBSymbolContext() { LLDB_INSTRUMENT_VA(this); }
  22
  23 SBSymbolContext::SBSymbolContext(const SymbolContext &sc)
  24     : m_opaque_up(std::make_unique<SymbolContext>(sc)) {
  25   LLDB_INSTRUMENT_VA(this, sc);
  26 }
  27
  28 SBSymbolContext::SBSymbolContext(const SBSymbolContext &rhs) {
  29   LLDB_INSTRUMENT_VA(this, rhs);
  30
  31   m_opaque_up = clone(rhs.m_opaque_up);
  32 }
  33
  34 SBSymbolContext::~SBSymbolContext() = default;
  35
  36 const SBSymbolContext &SBSymbolContext::operator=(const SBSymbolContext &rhs) {
  37   LLDB_INSTRUMENT_VA(this, rhs);
  38
  39   if (this != &rhs)
  40     m_opaque_up = clone(rhs.m_opaque_up);
  41   return *this;
  42 }
  43
  44 bool SBSymbolContext::IsValid() const {
  45   LLDB_INSTRUMENT_VA(this);
  46   return this->operator bool();
  47 }
  48 SBSymbolContext::operator bool() const {
  49   LLDB_INSTRUMENT_VA(this);
  50
  51   return m_opaque_up != nullptr;
  52 }
  53
  54 SBModule SBSymbolContext::GetModule() {
  55   LLDB_INSTRUMENT_VA(this);
  56
  57   SBModule sb_module;
  58   ModuleSP module_sp;
  59   if (m_opaque_up) {
  60     module_sp = m_opaque_up->module_sp;
  61     sb_module.SetSP(module_sp);
  62   }
  63
  64   return sb_module;
  65 }
  66
  67 SBCompileUnit SBSymbolContext::GetCompileUnit() {
  68   LLDB_INSTRUMENT_VA(this);
  69
  70   return SBCompileUnit(m_opaque_up ? m_opaque_up->comp_unit : nullptr);
  71 }
  72
  73 SBFunction SBSymbolContext::GetFunction() {
  74   LLDB_INSTRUMENT_VA(this);
  75
  76   Function *function = nullptr;
  77
  78   if (m_opaque_up)
  79     function = m_opaque_up->function;
  80
  81   SBFunction sb_function(function);
  82
  83   return sb_function;
  84 }
  85
  86 SBBlock SBSymbolContext::GetBlock() {
  87   LLDB_INSTRUMENT_VA(this);
  88
  89   return SBBlock(m_opaque_up ? m_opaque_up->block : nullptr);
  90 }
  91
  92 SBLineEntry SBSymbolContext::GetLineEntry() {
  93   LLDB_INSTRUMENT_VA(this);
  94
  95   SBLineEntry sb_line_entry;
  96   if (m_opaque_up)
  97     sb_line_entry.SetLineEntry(m_opaque_up->line_entry);
  98
  99   return sb_line_entry;
 100 }
 101
 102 SBSymbol SBSymbolContext::GetSymbol() {
 103   LLDB_INSTRUMENT_VA(this);
 104
 105   Symbol *symbol = nullptr;
 106
 107   if (m_opaque_up)
 108     symbol = m_opaque_up->symbol;
 109
 110   SBSymbol sb_symbol(symbol);
 111
 112   return sb_symbol;
 113 }
 114
 115 void SBSymbolContext::SetModule(lldb::SBModule module) {
 116   LLDB_INSTRUMENT_VA(this, module);
 117
 118   ref().module_sp = module.GetSP();
 119 }
 120
 121 void SBSymbolContext::SetCompileUnit(lldb::SBCompileUnit compile_unit) {
 122   LLDB_INSTRUMENT_VA(this, compile_unit);
 123
 124   ref().comp_unit = compile_unit.get();
 125 }
 126
 127 void SBSymbolContext::SetFunction(lldb::SBFunction function) {
 128   LLDB_INSTRUMENT_VA(this, function);
 129
 130   ref().function = function.get();
 131 }
 132
 133 void SBSymbolContext::SetBlock(lldb::SBBlock block) {
 134   LLDB_INSTRUMENT_VA(this, block);
 135
 136   ref().block = block.GetPtr();
 137 }
 138
 139 void SBSymbolContext::SetLineEntry(lldb::SBLineEntry line_entry) {
 140   LLDB_INSTRUMENT_VA(this, line_entry);
 141
 142   if (line_entry.IsValid())
 143     ref().line_entry = line_entry.ref();
 144   else
 145     ref().line_entry.Clear();
 146 }
 147
 148 void SBSymbolContext::SetSymbol(lldb::SBSymbol symbol) {
 149   LLDB_INSTRUMENT_VA(this, symbol);
 150
 151   ref().symbol = symbol.get();
 152 }
 153
 154 lldb_private::SymbolContext *SBSymbolContext::operator->() const {
 155   return m_opaque_up.get();
 156 }
 157
 158 const lldb_private::SymbolContext &SBSymbolContext::operator*() const {
 159   assert(m_opaque_up.get());
 160   return *m_opaque_up;
 161 }
 162
 163 lldb_private::SymbolContext &SBSymbolContext::operator*() {
 164   if (m_opaque_up == nullptr)
 165     m_opaque_up = std::make_unique<SymbolContext>();
 166   return *m_opaque_up;
 167 }
 168
 169 lldb_private::SymbolContext &SBSymbolContext::ref() {
 170   if (m_opaque_up == nullptr)
 171     m_opaque_up = std::make_unique<SymbolContext>();
 172   return *m_opaque_up;
 173 }
 174
 175 lldb_private::SymbolContext *SBSymbolContext::get() const {
 176   return m_opaque_up.get();
 177 }
 178
 179 bool SBSymbolContext::GetDescription(SBStream &description) {
 180   LLDB_INSTRUMENT_VA(this, description);
 181
 182   Stream &strm = description.ref();
 183
 184   if (m_opaque_up) {
 185     m_opaque_up->GetDescription(&strm, lldb::eDescriptionLevelFull, nullptr);
 186   } else
 187     strm.PutCString("No value");
 188
 189   return true;
 190 }
 191
 192 SBSymbolContext
 193 SBSymbolContext::GetParentOfInlinedScope(const SBAddress &curr_frame_pc,
 194                                          SBAddress &parent_frame_addr) const {
 195   LLDB_INSTRUMENT_VA(this, curr_frame_pc, parent_frame_addr);
 196
 197   SBSymbolContext sb_sc;
 198   if (m_opaque_up.get() && curr_frame_pc.IsValid()) {
 199     if (m_opaque_up->GetParentOfInlinedScope(curr_frame_pc.ref(), sb_sc.ref(),
 200                                              parent_frame_addr.ref()))
 201       return sb_sc;
 202   }
 203   return SBSymbolContext();
 204 }