Initial import of lldb

Change-Id: Ib244e837bee349effa12b2ff6ffffbe3d730e929

external/bsd/llvm/dist/lldb/source/API/SBAddress.cpp

@@ -0,0 +1,326 @@
+//===-- SBAddress.cpp -------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/API/SBAddress.h"
+#include "lldb/API/SBProcess.h"
+#include "lldb/API/SBSection.h"
+#include "lldb/API/SBStream.h"
+#include "lldb/Core/Address.h"
+#include "lldb/Core/Log.h"
+#include "lldb/Core/Module.h"
+#include "lldb/Host/Mutex.h"
+#include "lldb/Target/Target.h"
+
+
+using namespace lldb;
+using namespace lldb_private;
+
+
+SBAddress::SBAddress () :
+    m_opaque_ap ()
+{
+}
+
+SBAddress::SBAddress (const Address *lldb_object_ptr) :
+    m_opaque_ap ()
+{
+    if (lldb_object_ptr)
+        ref() = *lldb_object_ptr;
+}
+
+SBAddress::SBAddress (const SBAddress &rhs) :
+    m_opaque_ap ()
+{
+    if (rhs.IsValid())
+        ref() = rhs.ref();
+}
+
+
+SBAddress::SBAddress (lldb::SBSection section, lldb::addr_t offset) :
+    m_opaque_ap(new Address (section.GetSP(), offset))
+{
+}
+
+// Create an address by resolving a load address using the supplied target
+SBAddress::SBAddress (lldb::addr_t load_addr, lldb::SBTarget &target) :
+    m_opaque_ap()
+{    
+    SetLoadAddress (load_addr, target);
+}
+
+
+
+SBAddress::~SBAddress ()
+{
+}
+
+const SBAddress &
+SBAddress::operator = (const SBAddress &rhs)
+{
+    if (this != &rhs)
+    {
+        if (rhs.IsValid())
+            ref() = rhs.ref();
+        else
+            m_opaque_ap.reset();
+    }
+    return *this;
+}
+
+bool
+SBAddress::IsValid () const
+{
+    return m_opaque_ap.get() != NULL && m_opaque_ap->IsValid();
+}
+
+void
+SBAddress::Clear ()
+{
+    m_opaque_ap.reset();
+}
+
+void
+SBAddress::SetAddress (lldb::SBSection section, lldb::addr_t offset)
+{
+    Address &addr = ref();
+    addr.SetSection (section.GetSP());
+    addr.SetOffset (offset);
+}
+
+
+void
+SBAddress::SetAddress (const Address *lldb_object_ptr)
+{
+    if (lldb_object_ptr)
+        ref() =  *lldb_object_ptr;
+    else
+        m_opaque_ap.reset();
+}
+
+lldb::addr_t
+SBAddress::GetFileAddress () const
+{
+    if (m_opaque_ap.get())
+        return m_opaque_ap->GetFileAddress();
+    else
+        return LLDB_INVALID_ADDRESS;
+}
+
+lldb::addr_t
+SBAddress::GetLoadAddress (const SBTarget &target) const
+{
+    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
+
+    lldb::addr_t addr = LLDB_INVALID_ADDRESS;
+    TargetSP target_sp (target.GetSP());
+    if (target_sp)
+    {
+        if (m_opaque_ap.get())
+        {
+            Mutex::Locker api_locker (target_sp->GetAPIMutex());
+            addr = m_opaque_ap->GetLoadAddress (target_sp.get());
+        }
+    }
+    
+    if (log)
+    {
+        if (addr == LLDB_INVALID_ADDRESS)
+            log->Printf ("SBAddress::GetLoadAddress (SBTarget(%p)) => LLDB_INVALID_ADDRESS", target_sp.get());
+        else
+            log->Printf ("SBAddress::GetLoadAddress (SBTarget(%p)) => 0x%" PRIx64, target_sp.get(), addr);
+    }
+
+    return addr;
+}
+
+void
+SBAddress::SetLoadAddress (lldb::addr_t load_addr, lldb::SBTarget &target)
+{
+    // Create the address object if we don't already have one
+    ref();
+    if (target.IsValid())
+        *this = target.ResolveLoadAddress(load_addr);
+    else
+        m_opaque_ap->Clear();
+
+    // Check if we weren't were able to resolve a section offset address.
+    // If we weren't it is ok, the load address might be a location on the
+    // stack or heap, so we should just have an address with no section and
+    // a valid offset
+    if (!m_opaque_ap->IsValid())
+        m_opaque_ap->SetOffset(load_addr);
+}
+
+bool
+SBAddress::OffsetAddress (addr_t offset)
+{
+    if (m_opaque_ap.get())
+    {
+        addr_t addr_offset = m_opaque_ap->GetOffset();
+        if (addr_offset != LLDB_INVALID_ADDRESS)
+        {
+            m_opaque_ap->SetOffset(addr_offset + offset);
+            return true;
+        }
+    }
+    return false;
+}
+
+lldb::SBSection
+SBAddress::GetSection ()
+{
+    lldb::SBSection sb_section;
+    if (m_opaque_ap.get())
+        sb_section.SetSP (m_opaque_ap->GetSection());
+    return sb_section;
+}
+
+lldb::addr_t
+SBAddress::GetOffset ()
+{
+    if (m_opaque_ap.get())
+        return m_opaque_ap->GetOffset();
+    return 0;
+}
+
+Address *
+SBAddress::operator->()
+{
+    return m_opaque_ap.get();
+}
+
+const Address *
+SBAddress::operator->() const
+{
+    return m_opaque_ap.get();
+}
+
+Address &
+SBAddress::ref ()
+{
+    if (m_opaque_ap.get() == NULL)
+        m_opaque_ap.reset (new Address());
+    return *m_opaque_ap;
+}
+
+const Address &
+SBAddress::ref () const
+{
+    // This object should already have checked with "IsValid()" 
+    // prior to calling this function. In case you didn't we will assert
+    // and die to let you know.
+    assert (m_opaque_ap.get());
+    return *m_opaque_ap;
+}
+
+Address *
+SBAddress::get ()
+{
+    return m_opaque_ap.get();
+}
+
+bool
+SBAddress::GetDescription (SBStream &description)
+{
+    // Call "ref()" on the stream to make sure it creates a backing stream in
+    // case there isn't one already...
+    Stream &strm = description.ref();
+    if (m_opaque_ap.get())
+    {
+        m_opaque_ap->Dump (&strm,
+                           NULL,
+                           Address::DumpStyleResolvedDescription,
+                           Address::DumpStyleModuleWithFileAddress,
+                           4);
+        StreamString sstrm;
+//        m_opaque_ap->Dump (&sstrm, NULL, Address::DumpStyleResolvedDescription, Address::DumpStyleInvalid, 4);
+//        if (sstrm.GetData())
+//            strm.Printf (" (%s)", sstrm.GetData());
+    }
+    else
+        strm.PutCString ("No value");
+
+    return true;
+}
+
+SBModule
+SBAddress::GetModule ()
+{
+    SBModule sb_module;
+    if (m_opaque_ap.get())
+        sb_module.SetSP (m_opaque_ap->GetModule());
+    return sb_module;
+}
+
+SBSymbolContext
+SBAddress::GetSymbolContext (uint32_t resolve_scope)
+{
+    SBSymbolContext sb_sc;
+    if (m_opaque_ap.get())
+        m_opaque_ap->CalculateSymbolContext (&sb_sc.ref(), resolve_scope);
+    return sb_sc;
+}
+
+SBCompileUnit
+SBAddress::GetCompileUnit ()
+{
+    SBCompileUnit sb_comp_unit;
+    if (m_opaque_ap.get())
+        sb_comp_unit.reset(m_opaque_ap->CalculateSymbolContextCompileUnit());
+    return sb_comp_unit;
+}
+
+SBFunction
+SBAddress::GetFunction ()
+{
+    SBFunction sb_function;
+    if (m_opaque_ap.get())
+        sb_function.reset(m_opaque_ap->CalculateSymbolContextFunction());
+    return sb_function;
+}
+
+SBBlock
+SBAddress::GetBlock ()
+{
+    SBBlock sb_block;
+    if (m_opaque_ap.get())
+        sb_block.SetPtr(m_opaque_ap->CalculateSymbolContextBlock());
+    return sb_block;
+}
+
+SBSymbol
+SBAddress::GetSymbol ()
+{
+    SBSymbol sb_symbol;
+    if (m_opaque_ap.get())
+        sb_symbol.reset(m_opaque_ap->CalculateSymbolContextSymbol());
+    return sb_symbol;
+}
+
+SBLineEntry
+SBAddress::GetLineEntry ()
+{
+    SBLineEntry sb_line_entry;
+    if (m_opaque_ap.get())
+    {
+        LineEntry line_entry;
+        if (m_opaque_ap->CalculateSymbolContextLineEntry (line_entry))
+            sb_line_entry.SetLineEntry (line_entry);
+    }
+    return sb_line_entry;
+}
+
+AddressClass
+SBAddress::GetAddressClass ()
+{
+    if (m_opaque_ap.get())
+        return m_opaque_ap->GetAddressClass();
+    return eAddressClassInvalid;
+}
+