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