lldb/source/API/SBSymbolContext.cpp

   1 //===-- SBSymbolContext.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/SBSymbolContext.h"
  10 #include "SBReproducerPrivate.h"
  11 #include "Utils.h"
  12 #include "lldb/API/SBStream.h"
  13 #include "lldb/Core/Module.h"
  14 #include "lldb/Symbol/Function.h"
  15 #include "lldb/Symbol/Symbol.h"
  16 #include "lldb/Symbol/SymbolContext.h"
  17
  18 using namespace lldb;
  19 using namespace lldb_private;
  20
  21 SBSymbolContext::SBSymbolContext() : m_opaque_up() {
  22   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBSymbolContext);
  23 }
  24
  25 SBSymbolContext::SBSymbolContext(const SymbolContext *sc_ptr) : m_opaque_up() {
  26   LLDB_RECORD_CONSTRUCTOR(SBSymbolContext,
  27                           (const lldb_private::SymbolContext *), sc_ptr);
  28
  29   if (sc_ptr)
  30     m_opaque_up = std::make_unique<SymbolContext>(*sc_ptr);
  31 }
  32
  33 SBSymbolContext::SBSymbolContext(const SBSymbolContext &rhs) : m_opaque_up() {
  34   LLDB_RECORD_CONSTRUCTOR(SBSymbolContext, (const lldb::SBSymbolContext &),
  35                           rhs);
  36
  37   m_opaque_up = clone(rhs.m_opaque_up);
  38 }
  39
  40 SBSymbolContext::~SBSymbolContext() {}
  41
  42 const SBSymbolContext &SBSymbolContext::operator=(const SBSymbolContext &rhs) {
  43   LLDB_RECORD_METHOD(const lldb::SBSymbolContext &,
  44                      SBSymbolContext, operator=,(const lldb::SBSymbolContext &),
  45                      rhs);
  46
  47   if (this != &rhs)
  48     m_opaque_up = clone(rhs.m_opaque_up);
  49   return LLDB_RECORD_RESULT(*this);
  50 }
  51
  52 void SBSymbolContext::SetSymbolContext(const SymbolContext *sc_ptr) {
  53   if (sc_ptr)
  54     m_opaque_up = std::make_unique<SymbolContext>(*sc_ptr);
  55   else
  56     m_opaque_up->Clear(true);
  57 }
  58
  59 bool SBSymbolContext::IsValid() const {
  60   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbolContext, IsValid);
  61   return this->operator bool();
  62 }
  63 SBSymbolContext::operator bool() const {
  64   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBSymbolContext, operator bool);
  65
  66   return m_opaque_up != nullptr;
  67 }
  68
  69 SBModule SBSymbolContext::GetModule() {
  70   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBModule, SBSymbolContext, GetModule);
  71
  72   SBModule sb_module;
  73   ModuleSP module_sp;
  74   if (m_opaque_up) {
  75     module_sp = m_opaque_up->module_sp;
  76     sb_module.SetSP(module_sp);
  77   }
  78
  79   return LLDB_RECORD_RESULT(sb_module);
  80 }
  81
  82 SBCompileUnit SBSymbolContext::GetCompileUnit() {
  83   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBCompileUnit, SBSymbolContext,
  84                              GetCompileUnit);
  85
  86   return LLDB_RECORD_RESULT(
  87       SBCompileUnit(m_opaque_up ? m_opaque_up->comp_unit : nullptr));
  88 }
  89
  90 SBFunction SBSymbolContext::GetFunction() {
  91   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBFunction, SBSymbolContext, GetFunction);
  92
  93   Function *function = nullptr;
  94
  95   if (m_opaque_up)
  96     function = m_opaque_up->function;
  97
  98   SBFunction sb_function(function);
  99
 100   return LLDB_RECORD_RESULT(sb_function);
 101 }
 102
 103 SBBlock SBSymbolContext::GetBlock() {
 104   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBlock, SBSymbolContext, GetBlock);
 105
 106   return LLDB_RECORD_RESULT(
 107       SBBlock(m_opaque_up ? m_opaque_up->block : nullptr));
 108 }
 109
 110 SBLineEntry SBSymbolContext::GetLineEntry() {
 111   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBLineEntry, SBSymbolContext, GetLineEntry);
 112
 113   SBLineEntry sb_line_entry;
 114   if (m_opaque_up)
 115     sb_line_entry.SetLineEntry(m_opaque_up->line_entry);
 116
 117   return LLDB_RECORD_RESULT(sb_line_entry);
 118 }
 119
 120 SBSymbol SBSymbolContext::GetSymbol() {
 121   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSymbol, SBSymbolContext, GetSymbol);
 122
 123   Symbol *symbol = nullptr;
 124
 125   if (m_opaque_up)
 126     symbol = m_opaque_up->symbol;
 127
 128   SBSymbol sb_symbol(symbol);
 129
 130   return LLDB_RECORD_RESULT(sb_symbol);
 131 }
 132
 133 void SBSymbolContext::SetModule(lldb::SBModule module) {
 134   LLDB_RECORD_METHOD(void, SBSymbolContext, SetModule, (lldb::SBModule),
 135                      module);
 136
 137   ref().module_sp = module.GetSP();
 138 }
 139
 140 void SBSymbolContext::SetCompileUnit(lldb::SBCompileUnit compile_unit) {
 141   LLDB_RECORD_METHOD(void, SBSymbolContext, SetCompileUnit,
 142                      (lldb::SBCompileUnit), compile_unit);
 143
 144   ref().comp_unit = compile_unit.get();
 145 }
 146
 147 void SBSymbolContext::SetFunction(lldb::SBFunction function) {
 148   LLDB_RECORD_METHOD(void, SBSymbolContext, SetFunction, (lldb::SBFunction),
 149                      function);
 150
 151   ref().function = function.get();
 152 }
 153
 154 void SBSymbolContext::SetBlock(lldb::SBBlock block) {
 155   LLDB_RECORD_METHOD(void, SBSymbolContext, SetBlock, (lldb::SBBlock), block);
 156
 157   ref().block = block.GetPtr();
 158 }
 159
 160 void SBSymbolContext::SetLineEntry(lldb::SBLineEntry line_entry) {
 161   LLDB_RECORD_METHOD(void, SBSymbolContext, SetLineEntry, (lldb::SBLineEntry),
 162                      line_entry);
 163
 164   if (line_entry.IsValid())
 165     ref().line_entry = line_entry.ref();
 166   else
 167     ref().line_entry.Clear();
 168 }
 169
 170 void SBSymbolContext::SetSymbol(lldb::SBSymbol symbol) {
 171   LLDB_RECORD_METHOD(void, SBSymbolContext, SetSymbol, (lldb::SBSymbol),
 172                      symbol);
 173
 174   ref().symbol = symbol.get();
 175 }
 176
 177 lldb_private::SymbolContext *SBSymbolContext::operator->() const {
 178   return m_opaque_up.get();
 179 }
 180
 181 const lldb_private::SymbolContext &SBSymbolContext::operator*() const {
 182   assert(m_opaque_up.get());
 183   return *m_opaque_up;
 184 }
 185
 186 lldb_private::SymbolContext &SBSymbolContext::operator*() {
 187   if (m_opaque_up == nullptr)
 188     m_opaque_up.reset(new SymbolContext);
 189   return *m_opaque_up;
 190 }
 191
 192 lldb_private::SymbolContext &SBSymbolContext::ref() {
 193   if (m_opaque_up == nullptr)
 194     m_opaque_up.reset(new SymbolContext);
 195   return *m_opaque_up;
 196 }
 197
 198 lldb_private::SymbolContext *SBSymbolContext::get() const {
 199   return m_opaque_up.get();
 200 }
 201
 202 bool SBSymbolContext::GetDescription(SBStream &description) {
 203   LLDB_RECORD_METHOD(bool, SBSymbolContext, GetDescription, (lldb::SBStream &),
 204                      description);
 205
 206   Stream &strm = description.ref();
 207
 208   if (m_opaque_up) {
 209     m_opaque_up->GetDescription(&strm, lldb::eDescriptionLevelFull, nullptr);
 210   } else
 211     strm.PutCString("No value");
 212
 213   return true;
 214 }
 215
 216 SBSymbolContext
 217 SBSymbolContext::GetParentOfInlinedScope(const SBAddress &curr_frame_pc,
 218                                          SBAddress &parent_frame_addr) const {
 219   LLDB_RECORD_METHOD_CONST(lldb::SBSymbolContext, SBSymbolContext,
 220                            GetParentOfInlinedScope,
 221                            (const lldb::SBAddress &, lldb::SBAddress &),
 222                            curr_frame_pc, parent_frame_addr);
 223
 224   SBSymbolContext sb_sc;
 225   if (m_opaque_up.get() && curr_frame_pc.IsValid()) {
 226     if (m_opaque_up->GetParentOfInlinedScope(curr_frame_pc.ref(), sb_sc.ref(),
 227                                              parent_frame_addr.ref()))
 228       return LLDB_RECORD_RESULT(sb_sc);
 229   }
 230   return LLDB_RECORD_RESULT(SBSymbolContext());
 231 }
 232
 233 namespace lldb_private {
 234 namespace repro {
 235
 236 template <>
 237 void RegisterMethods<SBSymbolContext>(Registry &R) {
 238   LLDB_REGISTER_CONSTRUCTOR(SBSymbolContext, ());
 239   LLDB_REGISTER_CONSTRUCTOR(SBSymbolContext,
 240                             (const lldb_private::SymbolContext *));
 241   LLDB_REGISTER_CONSTRUCTOR(SBSymbolContext, (const lldb::SBSymbolContext &));
 242   LLDB_REGISTER_METHOD(
 243       const lldb::SBSymbolContext &,
 244       SBSymbolContext, operator=,(const lldb::SBSymbolContext &));
 245   LLDB_REGISTER_METHOD_CONST(bool, SBSymbolContext, IsValid, ());
 246   LLDB_REGISTER_METHOD_CONST(bool, SBSymbolContext, operator bool, ());
 247   LLDB_REGISTER_METHOD(lldb::SBModule, SBSymbolContext, GetModule, ());
 248   LLDB_REGISTER_METHOD(lldb::SBCompileUnit, SBSymbolContext, GetCompileUnit,
 249                        ());
 250   LLDB_REGISTER_METHOD(lldb::SBFunction, SBSymbolContext, GetFunction, ());
 251   LLDB_REGISTER_METHOD(lldb::SBBlock, SBSymbolContext, GetBlock, ());
 252   LLDB_REGISTER_METHOD(lldb::SBLineEntry, SBSymbolContext, GetLineEntry, ());
 253   LLDB_REGISTER_METHOD(lldb::SBSymbol, SBSymbolContext, GetSymbol, ());
 254   LLDB_REGISTER_METHOD(void, SBSymbolContext, SetModule, (lldb::SBModule));
 255   LLDB_REGISTER_METHOD(void, SBSymbolContext, SetCompileUnit,
 256                        (lldb::SBCompileUnit));
 257   LLDB_REGISTER_METHOD(void, SBSymbolContext, SetFunction,
 258                        (lldb::SBFunction));
 259   LLDB_REGISTER_METHOD(void, SBSymbolContext, SetBlock, (lldb::SBBlock));
 260   LLDB_REGISTER_METHOD(void, SBSymbolContext, SetLineEntry,
 261                        (lldb::SBLineEntry));
 262   LLDB_REGISTER_METHOD(void, SBSymbolContext, SetSymbol, (lldb::SBSymbol));
 263   LLDB_REGISTER_METHOD(bool, SBSymbolContext, GetDescription,
 264                        (lldb::SBStream &));
 265   LLDB_REGISTER_METHOD_CONST(lldb::SBSymbolContext, SBSymbolContext,
 266                              GetParentOfInlinedScope,
 267                              (const lldb::SBAddress &, lldb::SBAddress &));
 268 }
 269
 270 }
 271 }