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