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