contrib/llvm/tools/lldb/source/API/SBSymbol.cpp

   1 //===-- SBSymbol.cpp --------------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "lldb/API/SBSymbol.h"
  11 #include "lldb/API/SBStream.h"
  12 #include "lldb/Core/Disassembler.h"
  13 #include "lldb/Core/Log.h"
  14 #include "lldb/Core/Module.h"
  15 #include "lldb/Symbol/Symbol.h"
  16 #include "lldb/Target/ExecutionContext.h"
  17 #include "lldb/Target/Target.h"
  18
  19 using namespace lldb;
  20 using namespace lldb_private;
  21
  22 SBSymbol::SBSymbol () :
  23     m_opaque_ptr (NULL)
  24 {
  25 }
  26
  27 SBSymbol::SBSymbol (lldb_private::Symbol *lldb_object_ptr) :
  28     m_opaque_ptr (lldb_object_ptr)
  29 {
  30 }
  31
  32 SBSymbol::SBSymbol (const lldb::SBSymbol &rhs) :
  33     m_opaque_ptr (rhs.m_opaque_ptr)
  34 {
  35 }
  36
  37 const SBSymbol &
  38 SBSymbol::operator = (const SBSymbol &rhs)
  39 {
  40     m_opaque_ptr = rhs.m_opaque_ptr;
  41     return *this;
  42 }
  43
  44 SBSymbol::~SBSymbol ()
  45 {
  46     m_opaque_ptr = NULL;
  47 }
  48
  49 void
  50 SBSymbol::SetSymbol (lldb_private::Symbol *lldb_object_ptr)
  51 {
  52     m_opaque_ptr = lldb_object_ptr;
  53 }
  54
  55 bool
  56 SBSymbol::IsValid () const
  57 {
  58     return m_opaque_ptr != NULL;
  59 }
  60
  61 const char *
  62 SBSymbol::GetName() const
  63 {
  64     const char *name = NULL;
  65     if (m_opaque_ptr)
  66         name = m_opaque_ptr->GetMangled().GetName().AsCString();
  67
  68     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
  69     if (log)
  70         log->Printf ("SBSymbol(%p)::GetName () => \"%s\"", m_opaque_ptr, name ? name : "");
  71     return name;
  72 }
  73
  74 const char *
  75 SBSymbol::GetMangledName () const
  76 {
  77     const char *name = NULL;
  78     if (m_opaque_ptr)
  79         name = m_opaque_ptr->GetMangled().GetMangledName().AsCString();
  80     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
  81     if (log)
  82         log->Printf ("SBSymbol(%p)::GetMangledName () => \"%s\"", m_opaque_ptr, name ? name : "");
  83
  84     return name;
  85 }
  86
  87
  88 bool
  89 SBSymbol::operator == (const SBSymbol &rhs) const
  90 {
  91     return m_opaque_ptr == rhs.m_opaque_ptr;
  92 }
  93
  94 bool
  95 SBSymbol::operator != (const SBSymbol &rhs) const
  96 {
  97     return m_opaque_ptr != rhs.m_opaque_ptr;
  98 }
  99
 100 bool
 101 SBSymbol::GetDescription (SBStream &description)
 102 {
 103     Stream &strm = description.ref();
 104
 105     if (m_opaque_ptr)
 106     {
 107         m_opaque_ptr->GetDescription (&strm,
 108                                       lldb::eDescriptionLevelFull, NULL);
 109     }
 110     else
 111         strm.PutCString ("No value");
 112
 113     return true;
 114 }
 115
 116 SBInstructionList
 117 SBSymbol::GetInstructions (SBTarget target)
 118 {
 119     return GetInstructions (target, NULL);
 120 }
 121
 122 SBInstructionList
 123 SBSymbol::GetInstructions (SBTarget target, const char *flavor_string)
 124 {
 125     SBInstructionList sb_instructions;
 126     if (m_opaque_ptr)
 127     {
 128         Mutex::Locker api_locker;
 129         ExecutionContext exe_ctx;
 130         TargetSP target_sp (target.GetSP());
 131         if (target_sp)
 132         {
 133             api_locker.Lock (target_sp->GetAPIMutex());
 134             target_sp->CalculateExecutionContext (exe_ctx);
 135         }
 136         if (m_opaque_ptr->ValueIsAddress())
 137         {
 138             ModuleSP module_sp (m_opaque_ptr->GetAddress().GetModule());
 139             if (module_sp)
 140             {
 141                 AddressRange symbol_range (m_opaque_ptr->GetAddress(), m_opaque_ptr->GetByteSize());
 142                 const bool prefer_file_cache = false;
 143                 sb_instructions.SetDisassembler (Disassembler::DisassembleRange (module_sp->GetArchitecture (),
 144                                                                                  NULL,
 145                                                                                  flavor_string,
 146                                                                                  exe_ctx,
 147                                                                                  symbol_range,
 148                                                                                  prefer_file_cache));
 149             }
 150         }
 151     }
 152     return sb_instructions;
 153 }
 154
 155 lldb_private::Symbol *
 156 SBSymbol::get ()
 157 {
 158     return m_opaque_ptr;
 159 }
 160
 161 void
 162 SBSymbol::reset (lldb_private::Symbol *symbol)
 163 {
 164     m_opaque_ptr = symbol;
 165 }
 166
 167 SBAddress
 168 SBSymbol::GetStartAddress ()
 169 {
 170     SBAddress addr;
 171     if (m_opaque_ptr && m_opaque_ptr->ValueIsAddress())
 172     {
 173         addr.SetAddress (&m_opaque_ptr->GetAddress());
 174     }
 175     return addr;
 176 }
 177
 178 SBAddress
 179 SBSymbol::GetEndAddress ()
 180 {
 181     SBAddress addr;
 182     if (m_opaque_ptr && m_opaque_ptr->ValueIsAddress())
 183     {
 184         lldb::addr_t range_size = m_opaque_ptr->GetByteSize();
 185         if (range_size > 0)
 186         {
 187             addr.SetAddress (&m_opaque_ptr->GetAddress());
 188             addr->Slide (m_opaque_ptr->GetByteSize());
 189         }
 190     }
 191     return addr;
 192 }
 193
 194 uint32_t
 195 SBSymbol::GetPrologueByteSize ()
 196 {
 197     if (m_opaque_ptr)
 198         return m_opaque_ptr->GetPrologueByteSize();
 199     return 0;
 200 }
 201
 202 SymbolType
 203 SBSymbol::GetType ()
 204 {
 205     if (m_opaque_ptr)
 206         return m_opaque_ptr->GetType();
 207     return eSymbolTypeInvalid;
 208 }
 209
 210 bool
 211 SBSymbol::IsExternal()
 212 {
 213     if (m_opaque_ptr)
 214         return m_opaque_ptr->IsExternal();
 215     return false;
 216 }
 217
 218 bool
 219 SBSymbol::IsSynthetic()
 220 {
 221     if (m_opaque_ptr)
 222         return m_opaque_ptr->IsSynthetic();
 223     return false;
 224 }
 225