Merge lldb r188801 to contrib/llvm/tools/lldb/

1 files changed, 655 insertions, 0 deletions

diff --git a/contrib/llvm/tools/lldb/source/API/SBModule.cpp b/contrib/llvm/tools/lldb/source/API/SBModule.cpp
new file mode 100644
index 0000000..5f5fc92
--- /dev/null
+++ b/contrib/llvm/tools/lldb/source/API/SBModule.cpp
@@ -0,0 +1,655 @@
+//===-- SBModule.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/SBModule.h"
+#include "lldb/API/SBAddress.h"
+#include "lldb/API/SBFileSpec.h"
+#include "lldb/API/SBModuleSpec.h"
+#include "lldb/API/SBProcess.h"
+#include "lldb/API/SBStream.h"
+#include "lldb/API/SBSymbolContextList.h"
+#include "lldb/Core/Module.h"
+#include "lldb/Core/Log.h"
+#include "lldb/Core/Section.h"
+#include "lldb/Core/StreamString.h"
+#include "lldb/Core/ValueObjectList.h"
+#include "lldb/Core/ValueObjectVariable.h"
+#include "lldb/Symbol/ObjectFile.h"
+#include "lldb/Symbol/SymbolVendor.h"
+#include "lldb/Symbol/Symtab.h"
+#include "lldb/Symbol/VariableList.h"
+#include "lldb/Target/Target.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+
+SBModule::SBModule () :
+    m_opaque_sp ()
+{
+}
+
+SBModule::SBModule (const lldb::ModuleSP& module_sp) :
+    m_opaque_sp (module_sp)
+{
+}
+
+SBModule::SBModule(const SBModuleSpec &module_spec) :
+    m_opaque_sp ()
+{
+    ModuleSP module_sp;
+    Error error = ModuleList::GetSharedModule (*module_spec.m_opaque_ap,
+                                               module_sp,
+                                               NULL,
+                                               NULL,
+                                               NULL);
+    if (module_sp)
+        SetSP(module_sp);
+}
+
+SBModule::SBModule(const SBModule &rhs) :
+    m_opaque_sp (rhs.m_opaque_sp)
+{
+}
+
+SBModule::SBModule (lldb::SBProcess &process, lldb::addr_t header_addr) :
+    m_opaque_sp ()
+{
+    ProcessSP process_sp (process.GetSP());
+    if (process_sp)
+    {
+        m_opaque_sp = process_sp->ReadModuleFromMemory (FileSpec(), header_addr);
+        if (m_opaque_sp)
+        {
+            Target &target = process_sp->GetTarget();
+            bool changed = false;
+            m_opaque_sp->SetLoadAddress(target, 0, changed);
+            target.GetImages().Append(m_opaque_sp);
+        }
+    }
+}
+
+const SBModule &
+SBModule::operator = (const SBModule &rhs)
+{
+    if (this != &rhs)
+        m_opaque_sp = rhs.m_opaque_sp;
+    return *this;
+}
+
+SBModule::~SBModule ()
+{
+}
+
+bool
+SBModule::IsValid () const
+{
+    return m_opaque_sp.get() != NULL;
+}
+
+void
+SBModule::Clear()
+{
+    m_opaque_sp.reset();
+}
+
+SBFileSpec
+SBModule::GetFileSpec () const
+{
+    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
+
+    SBFileSpec file_spec;
+    ModuleSP module_sp (GetSP ());
+    if (module_sp)
+        file_spec.SetFileSpec(module_sp->GetFileSpec());
+
+    if (log)
+    {
+        log->Printf ("SBModule(%p)::GetFileSpec () => SBFileSpec(%p)", 
+        module_sp.get(), file_spec.get());
+    }
+
+    return file_spec;
+}
+
+lldb::SBFileSpec
+SBModule::GetPlatformFileSpec () const
+{
+    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
+    
+    SBFileSpec file_spec;
+    ModuleSP module_sp (GetSP ());
+    if (module_sp)
+        file_spec.SetFileSpec(module_sp->GetPlatformFileSpec());
+    
+    if (log)
+    {
+        log->Printf ("SBModule(%p)::GetPlatformFileSpec () => SBFileSpec(%p)", 
+                     module_sp.get(), file_spec.get());
+    }
+    
+    return file_spec;
+    
+}
+
+bool
+SBModule::SetPlatformFileSpec (const lldb::SBFileSpec &platform_file)
+{
+    bool result = false;
+    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
+    
+    ModuleSP module_sp (GetSP ());
+    if (module_sp)
+    {
+        module_sp->SetPlatformFileSpec(*platform_file);
+        result = true;
+    }
+    
+    if (log)
+    {
+        log->Printf ("SBModule(%p)::SetPlatformFileSpec (SBFileSpec(%p (%s)) => %i", 
+                     module_sp.get(), 
+                     platform_file.get(),
+                     platform_file->GetPath().c_str(),
+                     result);
+    }
+    return result;
+}
+
+
+
+const uint8_t *
+SBModule::GetUUIDBytes () const
+{
+    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
+
+    const uint8_t *uuid_bytes = NULL;
+    ModuleSP module_sp (GetSP ());
+    if (module_sp)
+        uuid_bytes = (const uint8_t *)module_sp->GetUUID().GetBytes();
+
+    if (log)
+    {
+        if (uuid_bytes)
+        {
+            StreamString s;
+            module_sp->GetUUID().Dump (&s);
+            log->Printf ("SBModule(%p)::GetUUIDBytes () => %s", module_sp.get(), s.GetData());
+        }
+        else
+            log->Printf ("SBModule(%p)::GetUUIDBytes () => NULL", module_sp.get());
+    }
+    return uuid_bytes;
+}
+
+
+const char *
+SBModule::GetUUIDString () const
+{
+    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
+
+    static char uuid_string_buffer[80];
+    const char *uuid_c_string = NULL;
+    std::string uuid_string;
+    ModuleSP module_sp (GetSP ());
+    if (module_sp)
+        uuid_string = module_sp->GetUUID().GetAsString();
+
+    if (!uuid_string.empty())
+    {
+        strncpy (uuid_string_buffer, uuid_string.c_str(), sizeof (uuid_string_buffer));
+        uuid_c_string = uuid_string_buffer;
+    }
+
+    if (log)
+    {
+        if (!uuid_string.empty())
+        {
+            StreamString s;
+            module_sp->GetUUID().Dump (&s);
+            log->Printf ("SBModule(%p)::GetUUIDString () => %s", module_sp.get(), s.GetData());
+        }
+        else
+            log->Printf ("SBModule(%p)::GetUUIDString () => NULL", module_sp.get());
+    }
+    return uuid_c_string;
+}
+
+
+bool
+SBModule::operator == (const SBModule &rhs) const
+{
+    if (m_opaque_sp)
+        return m_opaque_sp.get() == rhs.m_opaque_sp.get();
+    return false;
+}
+
+bool
+SBModule::operator != (const SBModule &rhs) const
+{
+    if (m_opaque_sp)
+        return m_opaque_sp.get() != rhs.m_opaque_sp.get();
+    return false;
+}
+
+ModuleSP
+SBModule::GetSP () const
+{
+    return m_opaque_sp;
+}
+
+void
+SBModule::SetSP (const ModuleSP &module_sp)
+{
+    m_opaque_sp = module_sp;
+}
+
+SBAddress
+SBModule::ResolveFileAddress (lldb::addr_t vm_addr)
+{
+    lldb::SBAddress sb_addr;
+    ModuleSP module_sp (GetSP ());
+    if (module_sp)
+    {
+        Address addr;
+        if (module_sp->ResolveFileAddress (vm_addr, addr))
+            sb_addr.ref() = addr;
+    }
+    return sb_addr;
+}
+
+SBSymbolContext
+SBModule::ResolveSymbolContextForAddress (const SBAddress& addr, uint32_t resolve_scope)
+{
+    SBSymbolContext sb_sc;
+    ModuleSP module_sp (GetSP ());
+    if (module_sp && addr.IsValid())
+        module_sp->ResolveSymbolContextForAddress (addr.ref(), resolve_scope, *sb_sc);
+    return sb_sc;
+}
+
+bool
+SBModule::GetDescription (SBStream &description)
+{
+    Stream &strm = description.ref();
+
+    ModuleSP module_sp (GetSP ());
+    if (module_sp)
+    {
+        module_sp->GetDescription (&strm);
+    }
+    else
+        strm.PutCString ("No value");
+
+    return true;
+}
+
+uint32_t
+SBModule::GetNumCompileUnits()
+{
+    ModuleSP module_sp (GetSP ());
+    if (module_sp)
+    {
+        return module_sp->GetNumCompileUnits ();
+    }
+    return 0;
+}
+
+SBCompileUnit
+SBModule::GetCompileUnitAtIndex (uint32_t index)
+{
+    SBCompileUnit sb_cu;
+    ModuleSP module_sp (GetSP ());
+    if (module_sp)
+    {
+        CompUnitSP cu_sp = module_sp->GetCompileUnitAtIndex (index);
+        sb_cu.reset(cu_sp.get());
+    }
+    return sb_cu;
+}
+
+static Symtab *
+GetUnifiedSymbolTable (const lldb::ModuleSP& module_sp)
+{
+    if (module_sp)
+    {
+        SymbolVendor *symbols = module_sp->GetSymbolVendor();
+        if (symbols)
+            return symbols->GetSymtab();
+    }
+    return NULL;
+}
+
+size_t
+SBModule::GetNumSymbols ()
+{
+    ModuleSP module_sp (GetSP ());
+    if (module_sp)
+    {
+        Symtab *symtab = GetUnifiedSymbolTable (module_sp);
+        if (symtab)
+            return symtab->GetNumSymbols();
+    }
+    return 0;
+}
+
+SBSymbol
+SBModule::GetSymbolAtIndex (size_t idx)
+{
+    SBSymbol sb_symbol;
+    ModuleSP module_sp (GetSP ());
+    Symtab *symtab = GetUnifiedSymbolTable (module_sp);
+    if (symtab)
+        sb_symbol.SetSymbol(symtab->SymbolAtIndex (idx));
+    return sb_symbol;
+}
+
+lldb::SBSymbol
+SBModule::FindSymbol (const char *name,
+                      lldb::SymbolType symbol_type)
+{
+    SBSymbol sb_symbol;
+    if (name && name[0])
+    {
+        ModuleSP module_sp (GetSP ());
+        Symtab *symtab = GetUnifiedSymbolTable (module_sp);
+        if (symtab)
+            sb_symbol.SetSymbol(symtab->FindFirstSymbolWithNameAndType(ConstString(name), symbol_type, Symtab::eDebugAny, Symtab::eVisibilityAny));
+    }
+    return sb_symbol;
+}
+
+
+lldb::SBSymbolContextList
+SBModule::FindSymbols (const char *name, lldb::SymbolType symbol_type)
+{
+    SBSymbolContextList sb_sc_list;
+    if (name && name[0])
+    {
+        ModuleSP module_sp (GetSP ());
+        Symtab *symtab = GetUnifiedSymbolTable (module_sp);
+        if (symtab)
+        {
+            std::vector<uint32_t> matching_symbol_indexes;
+            const size_t num_matches = symtab->FindAllSymbolsWithNameAndType(ConstString(name), symbol_type, matching_symbol_indexes);
+            if (num_matches)
+            {
+                SymbolContext sc;
+                sc.module_sp = module_sp;
+                SymbolContextList &sc_list = *sb_sc_list;
+                for (size_t i=0; i<num_matches; ++i)
+                {
+                    sc.symbol = symtab->SymbolAtIndex (matching_symbol_indexes[i]);
+                    if (sc.symbol)
+                        sc_list.Append(sc);
+                }
+            }
+        }
+    }
+    return sb_sc_list;
+    
+}
+
+
+
+size_t
+SBModule::GetNumSections ()
+{
+    ModuleSP module_sp (GetSP ());
+    if (module_sp)
+    {
+        // Give the symbol vendor a chance to add to the unified section list.
+        module_sp->GetSymbolVendor();
+        SectionList *section_list = module_sp->GetSectionList();
+        if (section_list)
+            return section_list->GetSize();
+    }
+    return 0;
+}
+
+SBSection
+SBModule::GetSectionAtIndex (size_t idx)
+{
+    SBSection sb_section;
+    ModuleSP module_sp (GetSP ());
+    if (module_sp)
+    {
+        // Give the symbol vendor a chance to add to the unified section list.
+        module_sp->GetSymbolVendor();
+        SectionList *section_list = module_sp->GetSectionList ();
+
+        if (section_list)
+            sb_section.SetSP(section_list->GetSectionAtIndex (idx));
+    }
+    return sb_section;
+}
+
+lldb::SBSymbolContextList
+SBModule::FindFunctions (const char *name, 
+                         uint32_t name_type_mask)
+{
+    lldb::SBSymbolContextList sb_sc_list;
+    ModuleSP module_sp (GetSP ());
+    if (name && module_sp)
+    {
+        const bool append = true;
+        const bool symbols_ok = true;
+        const bool inlines_ok = true;
+        module_sp->FindFunctions (ConstString(name),
+                                  NULL,
+                                  name_type_mask, 
+                                  symbols_ok,
+                                  inlines_ok,
+                                  append, 
+                                  *sb_sc_list);
+    }
+    return sb_sc_list;
+}
+
+
+SBValueList
+SBModule::FindGlobalVariables (SBTarget &target, const char *name, uint32_t max_matches)
+{
+    SBValueList sb_value_list;
+    ModuleSP module_sp (GetSP ());
+    if (name && module_sp)
+    {
+        VariableList variable_list;
+        const uint32_t match_count = module_sp->FindGlobalVariables (ConstString (name),
+                                                                     NULL,
+                                                                     false, 
+                                                                     max_matches,
+                                                                     variable_list);
+
+        if (match_count > 0)
+        {
+            for (uint32_t i=0; i<match_count; ++i)
+            {
+                lldb::ValueObjectSP valobj_sp;
+                TargetSP target_sp (target.GetSP());
+                valobj_sp = ValueObjectVariable::Create (target_sp.get(), variable_list.GetVariableAtIndex(i));
+                if (valobj_sp)
+                    sb_value_list.Append(SBValue(valobj_sp));
+            }
+        }
+    }
+    
+    return sb_value_list;
+}
+
+lldb::SBValue
+SBModule::FindFirstGlobalVariable (lldb::SBTarget &target, const char *name)
+{
+    SBValueList sb_value_list(FindGlobalVariables(target, name, 1));
+    if (sb_value_list.IsValid() && sb_value_list.GetSize() > 0)
+        return sb_value_list.GetValueAtIndex(0);
+    return SBValue();
+}
+
+lldb::SBType
+SBModule::FindFirstType (const char *name_cstr)
+{
+    SBType sb_type;
+    ModuleSP module_sp (GetSP ());
+    if (name_cstr && module_sp)
+    {
+        SymbolContext sc;
+        const bool exact_match = false;
+        ConstString name(name_cstr);
+
+        sb_type = SBType (module_sp->FindFirstType(sc, name, exact_match));
+        
+        if (!sb_type.IsValid())
+            sb_type = SBType (ClangASTContext::GetBasicType (module_sp->GetClangASTContext().getASTContext(), name));
+    }
+    return sb_type;
+}
+
+lldb::SBType
+SBModule::GetBasicType(lldb::BasicType type)
+{
+    ModuleSP module_sp (GetSP ());
+    if (module_sp)
+        return SBType (ClangASTContext::GetBasicType (module_sp->GetClangASTContext().getASTContext(), type));
+    return SBType();
+}
+
+lldb::SBTypeList
+SBModule::FindTypes (const char *type)
+{
+    SBTypeList retval;
+    
+    ModuleSP module_sp (GetSP ());
+    if (type && module_sp)
+    {
+        SymbolContext sc;
+        TypeList type_list;
+        const bool exact_match = false;
+        ConstString name(type);
+        const uint32_t num_matches = module_sp->FindTypes (sc,
+                                                           name,
+                                                           exact_match,
+                                                           UINT32_MAX,
+                                                           type_list);
+        
+        if (num_matches > 0)
+        {
+            for (size_t idx = 0; idx < num_matches; idx++)
+            {
+                TypeSP type_sp (type_list.GetTypeAtIndex(idx));
+                if (type_sp)
+                    retval.Append(SBType(type_sp));
+            }
+        }
+        else
+        {
+            SBType sb_type(ClangASTContext::GetBasicType (module_sp->GetClangASTContext().getASTContext(), name));
+            if (sb_type.IsValid())
+                retval.Append(sb_type);
+        }
+    }
+
+    return retval;
+}
+
+lldb::SBTypeList
+SBModule::GetTypes (uint32_t type_mask)
+{
+    SBTypeList sb_type_list;
+    
+    ModuleSP module_sp (GetSP ());
+    if (module_sp)
+    {
+        SymbolVendor* vendor = module_sp->GetSymbolVendor();
+        if (vendor)
+        {
+            TypeList type_list;
+            vendor->GetTypes (NULL, type_mask, type_list);
+            sb_type_list.m_opaque_ap->Append(type_list);
+        }
+    }
+    return sb_type_list;
+}
+
+SBSection
+SBModule::FindSection (const char *sect_name)
+{
+    SBSection sb_section;
+    
+    ModuleSP module_sp (GetSP ());
+    if (sect_name && module_sp)
+    {
+        // Give the symbol vendor a chance to add to the unified section list.
+        module_sp->GetSymbolVendor();
+        SectionList *section_list = module_sp->GetSectionList();
+        if (section_list)
+        {
+            ConstString const_sect_name(sect_name);
+            SectionSP section_sp (section_list->FindSectionByName(const_sect_name));
+            if (section_sp)
+            {
+                sb_section.SetSP (section_sp);
+            }
+        }
+    }
+    return sb_section;
+}
+
+lldb::ByteOrder
+SBModule::GetByteOrder ()
+{
+    ModuleSP module_sp (GetSP ());
+    if (module_sp)
+        return module_sp->GetArchitecture().GetByteOrder();
+    return eByteOrderInvalid;
+}
+
+const char *
+SBModule::GetTriple ()
+{
+    ModuleSP module_sp (GetSP ());
+    if (module_sp)
+    {
+        std::string triple (module_sp->GetArchitecture().GetTriple().str());
+        // Unique the string so we don't run into ownership issues since
+        // the const strings put the string into the string pool once and
+        // the strings never comes out
+        ConstString const_triple (triple.c_str());
+        return const_triple.GetCString();
+    }
+    return NULL;
+}
+
+uint32_t
+SBModule::GetAddressByteSize()
+{
+    ModuleSP module_sp (GetSP ());
+    if (module_sp)
+        return module_sp->GetArchitecture().GetAddressByteSize();
+    return sizeof(void*);
+}
+
+
+uint32_t
+SBModule::GetVersion (uint32_t *versions, uint32_t num_versions)
+{
+    ModuleSP module_sp (GetSP ());
+    if (module_sp)
+        return module_sp->GetVersion(versions, num_versions);
+    else
+    {
+        if (versions && num_versions)
+        {
+            for (uint32_t i=0; i<num_versions; ++i)
+                versions[i] = UINT32_MAX;
+        }
+        return 0;
+    }
+}
+