1 //===-- SBFunction.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/SBFunction.h" 10 #include "lldb/API/SBProcess.h" 11 #include "lldb/API/SBStream.h" 12 #include "lldb/Core/Disassembler.h" 13 #include "lldb/Core/Module.h" 14 #include "lldb/Symbol/CompileUnit.h" 15 #include "lldb/Symbol/Function.h" 16 #include "lldb/Symbol/Type.h" 17 #include "lldb/Symbol/VariableList.h" 18 #include "lldb/Target/ExecutionContext.h" 19 #include "lldb/Target/Target.h" 20 #include "lldb/Utility/Instrumentation.h" 21 22 using namespace lldb; 23 using namespace lldb_private; 24 25 SBFunction::SBFunction() { LLDB_INSTRUMENT_VA(this); } 26 27 SBFunction::SBFunction(lldb_private::Function *lldb_object_ptr) 28 : m_opaque_ptr(lldb_object_ptr) {} 29 30 SBFunction::SBFunction(const lldb::SBFunction &rhs) 31 : m_opaque_ptr(rhs.m_opaque_ptr) { 32 LLDB_INSTRUMENT_VA(this, rhs); 33 } 34 35 const SBFunction &SBFunction::operator=(const SBFunction &rhs) { 36 LLDB_INSTRUMENT_VA(this, rhs); 37 38 m_opaque_ptr = rhs.m_opaque_ptr; 39 return *this; 40 } 41 42 SBFunction::~SBFunction() { m_opaque_ptr = nullptr; } 43 44 bool SBFunction::IsValid() const { 45 LLDB_INSTRUMENT_VA(this); 46 return this->operator bool(); 47 } 48 SBFunction::operator bool() const { 49 LLDB_INSTRUMENT_VA(this); 50 51 return m_opaque_ptr != nullptr; 52 } 53 54 const char *SBFunction::GetName() const { 55 LLDB_INSTRUMENT_VA(this); 56 57 const char *cstr = nullptr; 58 if (m_opaque_ptr) 59 cstr = m_opaque_ptr->GetName().AsCString(); 60 61 return cstr; 62 } 63 64 const char *SBFunction::GetDisplayName() const { 65 LLDB_INSTRUMENT_VA(this); 66 67 const char *cstr = nullptr; 68 if (m_opaque_ptr) 69 cstr = m_opaque_ptr->GetMangled().GetDisplayDemangledName().AsCString(); 70 71 return cstr; 72 } 73 74 const char *SBFunction::GetMangledName() const { 75 LLDB_INSTRUMENT_VA(this); 76 77 const char *cstr = nullptr; 78 if (m_opaque_ptr) 79 cstr = m_opaque_ptr->GetMangled().GetMangledName().AsCString(); 80 return cstr; 81 } 82 83 bool SBFunction::operator==(const SBFunction &rhs) const { 84 LLDB_INSTRUMENT_VA(this, rhs); 85 86 return m_opaque_ptr == rhs.m_opaque_ptr; 87 } 88 89 bool SBFunction::operator!=(const SBFunction &rhs) const { 90 LLDB_INSTRUMENT_VA(this, rhs); 91 92 return m_opaque_ptr != rhs.m_opaque_ptr; 93 } 94 95 bool SBFunction::GetDescription(SBStream &s) { 96 LLDB_INSTRUMENT_VA(this, s); 97 98 if (m_opaque_ptr) { 99 s.Printf("SBFunction: id = 0x%8.8" PRIx64 ", name = %s", 100 m_opaque_ptr->GetID(), m_opaque_ptr->GetName().AsCString()); 101 Type *func_type = m_opaque_ptr->GetType(); 102 if (func_type) 103 s.Printf(", type = %s", func_type->GetName().AsCString()); 104 return true; 105 } 106 s.Printf("No value"); 107 return false; 108 } 109 110 SBInstructionList SBFunction::GetInstructions(SBTarget target) { 111 LLDB_INSTRUMENT_VA(this, target); 112 113 return GetInstructions(target, nullptr); 114 } 115 116 SBInstructionList SBFunction::GetInstructions(SBTarget target, 117 const char *flavor) { 118 LLDB_INSTRUMENT_VA(this, target, flavor); 119 120 SBInstructionList sb_instructions; 121 if (m_opaque_ptr) { 122 TargetSP target_sp(target.GetSP()); 123 std::unique_lock<std::recursive_mutex> lock; 124 ModuleSP module_sp( 125 m_opaque_ptr->GetAddressRange().GetBaseAddress().GetModule()); 126 if (target_sp && module_sp) { 127 lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex()); 128 const bool force_live_memory = true; 129 sb_instructions.SetDisassembler(Disassembler::DisassembleRange( 130 module_sp->GetArchitecture(), nullptr, flavor, *target_sp, 131 m_opaque_ptr->GetAddressRange(), force_live_memory)); 132 } 133 } 134 return sb_instructions; 135 } 136 137 lldb_private::Function *SBFunction::get() { return m_opaque_ptr; } 138 139 void SBFunction::reset(lldb_private::Function *lldb_object_ptr) { 140 m_opaque_ptr = lldb_object_ptr; 141 } 142 143 SBAddress SBFunction::GetStartAddress() { 144 LLDB_INSTRUMENT_VA(this); 145 146 SBAddress addr; 147 if (m_opaque_ptr) 148 addr.SetAddress(m_opaque_ptr->GetAddressRange().GetBaseAddress()); 149 return addr; 150 } 151 152 SBAddress SBFunction::GetEndAddress() { 153 LLDB_INSTRUMENT_VA(this); 154 155 SBAddress addr; 156 if (m_opaque_ptr) { 157 addr_t byte_size = m_opaque_ptr->GetAddressRange().GetByteSize(); 158 if (byte_size > 0) { 159 addr.SetAddress(m_opaque_ptr->GetAddressRange().GetBaseAddress()); 160 addr->Slide(byte_size); 161 } 162 } 163 return addr; 164 } 165 166 const char *SBFunction::GetArgumentName(uint32_t arg_idx) { 167 LLDB_INSTRUMENT_VA(this, arg_idx); 168 169 if (m_opaque_ptr) { 170 Block &block = m_opaque_ptr->GetBlock(true); 171 VariableListSP variable_list_sp = block.GetBlockVariableList(true); 172 if (variable_list_sp) { 173 VariableList arguments; 174 variable_list_sp->AppendVariablesWithScope(eValueTypeVariableArgument, 175 arguments, true); 176 lldb::VariableSP variable_sp = arguments.GetVariableAtIndex(arg_idx); 177 if (variable_sp) 178 return variable_sp->GetName().GetCString(); 179 } 180 } 181 return nullptr; 182 } 183 184 uint32_t SBFunction::GetPrologueByteSize() { 185 LLDB_INSTRUMENT_VA(this); 186 187 if (m_opaque_ptr) 188 return m_opaque_ptr->GetPrologueByteSize(); 189 return 0; 190 } 191 192 SBType SBFunction::GetType() { 193 LLDB_INSTRUMENT_VA(this); 194 195 SBType sb_type; 196 if (m_opaque_ptr) { 197 Type *function_type = m_opaque_ptr->GetType(); 198 if (function_type) 199 sb_type.ref().SetType(function_type->shared_from_this()); 200 } 201 return sb_type; 202 } 203 204 SBBlock SBFunction::GetBlock() { 205 LLDB_INSTRUMENT_VA(this); 206 207 SBBlock sb_block; 208 if (m_opaque_ptr) 209 sb_block.SetPtr(&m_opaque_ptr->GetBlock(true)); 210 return sb_block; 211 } 212 213 lldb::LanguageType SBFunction::GetLanguage() { 214 LLDB_INSTRUMENT_VA(this); 215 216 if (m_opaque_ptr) { 217 if (m_opaque_ptr->GetCompileUnit()) 218 return m_opaque_ptr->GetCompileUnit()->GetLanguage(); 219 } 220 return lldb::eLanguageTypeUnknown; 221 } 222 223 bool SBFunction::GetIsOptimized() { 224 LLDB_INSTRUMENT_VA(this); 225 226 if (m_opaque_ptr) { 227 if (m_opaque_ptr->GetCompileUnit()) 228 return m_opaque_ptr->GetCompileUnit()->GetIsOptimized(); 229 } 230 return false; 231 } 232