lldb/source/API/SBFunction.cpp

   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   if (m_opaque_ptr)
  58     return m_opaque_ptr->GetName().AsCString();
  59
  60   return nullptr;
  61 }
  62
  63 const char *SBFunction::GetDisplayName() const {
  64   LLDB_INSTRUMENT_VA(this);
  65
  66   if (m_opaque_ptr)
  67     return m_opaque_ptr->GetMangled().GetDisplayDemangledName().AsCString();
  68
  69   return nullptr;
  70 }
  71
  72 const char *SBFunction::GetMangledName() const {
  73   LLDB_INSTRUMENT_VA(this);
  74
  75   if (m_opaque_ptr)
  76     return m_opaque_ptr->GetMangled().GetMangledName().AsCString();
  77   return nullptr;
  78 }
  79
  80 bool SBFunction::operator==(const SBFunction &rhs) const {
  81   LLDB_INSTRUMENT_VA(this, rhs);
  82
  83   return m_opaque_ptr == rhs.m_opaque_ptr;
  84 }
  85
  86 bool SBFunction::operator!=(const SBFunction &rhs) const {
  87   LLDB_INSTRUMENT_VA(this, rhs);
  88
  89   return m_opaque_ptr != rhs.m_opaque_ptr;
  90 }
  91
  92 bool SBFunction::GetDescription(SBStream &s) {
  93   LLDB_INSTRUMENT_VA(this, s);
  94
  95   if (m_opaque_ptr) {
  96     s.Printf("SBFunction: id = 0x%8.8" PRIx64 ", name = %s",
  97              m_opaque_ptr->GetID(), m_opaque_ptr->GetName().AsCString());
  98     Type *func_type = m_opaque_ptr->GetType();
  99     if (func_type)
 100       s.Printf(", type = %s", func_type->GetName().AsCString());
 101     return true;
 102   }
 103   s.Printf("No value");
 104   return false;
 105 }
 106
 107 SBInstructionList SBFunction::GetInstructions(SBTarget target) {
 108   LLDB_INSTRUMENT_VA(this, target);
 109
 110   return GetInstructions(target, nullptr);
 111 }
 112
 113 SBInstructionList SBFunction::GetInstructions(SBTarget target,
 114                                               const char *flavor) {
 115   LLDB_INSTRUMENT_VA(this, target, flavor);
 116
 117   SBInstructionList sb_instructions;
 118   if (m_opaque_ptr) {
 119     TargetSP target_sp(target.GetSP());
 120     std::unique_lock<std::recursive_mutex> lock;
 121     ModuleSP module_sp(
 122         m_opaque_ptr->GetAddressRange().GetBaseAddress().GetModule());
 123     if (target_sp && module_sp) {
 124       lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
 125       const bool force_live_memory = true;
 126       sb_instructions.SetDisassembler(Disassembler::DisassembleRange(
 127           module_sp->GetArchitecture(), nullptr, flavor, *target_sp,
 128           m_opaque_ptr->GetAddressRange(), force_live_memory));
 129     }
 130   }
 131   return sb_instructions;
 132 }
 133
 134 lldb_private::Function *SBFunction::get() { return m_opaque_ptr; }
 135
 136 void SBFunction::reset(lldb_private::Function *lldb_object_ptr) {
 137   m_opaque_ptr = lldb_object_ptr;
 138 }
 139
 140 SBAddress SBFunction::GetStartAddress() {
 141   LLDB_INSTRUMENT_VA(this);
 142
 143   SBAddress addr;
 144   if (m_opaque_ptr)
 145     addr.SetAddress(m_opaque_ptr->GetAddressRange().GetBaseAddress());
 146   return addr;
 147 }
 148
 149 SBAddress SBFunction::GetEndAddress() {
 150   LLDB_INSTRUMENT_VA(this);
 151
 152   SBAddress addr;
 153   if (m_opaque_ptr) {
 154     addr_t byte_size = m_opaque_ptr->GetAddressRange().GetByteSize();
 155     if (byte_size > 0) {
 156       addr.SetAddress(m_opaque_ptr->GetAddressRange().GetBaseAddress());
 157       addr->Slide(byte_size);
 158     }
 159   }
 160   return addr;
 161 }
 162
 163 const char *SBFunction::GetArgumentName(uint32_t arg_idx) {
 164   LLDB_INSTRUMENT_VA(this, arg_idx);
 165
 166   if (!m_opaque_ptr)
 167     return nullptr;
 168
 169   Block &block = m_opaque_ptr->GetBlock(true);
 170   VariableListSP variable_list_sp = block.GetBlockVariableList(true);
 171   if (!variable_list_sp)
 172     return nullptr;
 173
 174   VariableList arguments;
 175   variable_list_sp->AppendVariablesWithScope(eValueTypeVariableArgument,
 176                                              arguments, true);
 177   lldb::VariableSP variable_sp = arguments.GetVariableAtIndex(arg_idx);
 178   if (!variable_sp)
 179     return nullptr;
 180
 181   return variable_sp->GetName().GetCString();
 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 }