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 22using namespace lldb; 23using namespace lldb_private; 24 25SBFunction::SBFunction() : m_opaque_ptr(nullptr) { 26 LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBFunction); 27} 28 29SBFunction::SBFunction(lldb_private::Function *lldb_object_ptr) 30 : m_opaque_ptr(lldb_object_ptr) {} 31 32SBFunction::SBFunction(const lldb::SBFunction &rhs) 33 : m_opaque_ptr(rhs.m_opaque_ptr) { 34 LLDB_RECORD_CONSTRUCTOR(SBFunction, (const lldb::SBFunction &), rhs); 35} 36 37const 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 45SBFunction::~SBFunction() { m_opaque_ptr = nullptr; } 46 47bool SBFunction::IsValid() const { 48 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFunction, IsValid); 49 return this->operator bool(); 50} 51SBFunction::operator bool() const { 52 LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBFunction, operator bool); 53 54 return m_opaque_ptr != nullptr; 55} 56 57const 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 67const 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 77const 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 86bool 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 93bool 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 100bool 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 115SBInstructionList 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 122SBInstructionList 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 144lldb_private::Function *SBFunction::get() { return m_opaque_ptr; } 145 146void SBFunction::reset(lldb_private::Function *lldb_object_ptr) { 147 m_opaque_ptr = lldb_object_ptr; 148} 149 150SBAddress 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 159SBAddress 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 173const 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 192uint32_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 200SBType 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 212SBBlock 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 221lldb::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 231bool 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 241namespace lldb_private { 242namespace repro { 243 244template <> 245void 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