llvm-project/lldb/source/Symbol/Symbol.cpp

//===-- Symbol.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/Symbol/Symbol.h"

#include "lldb/Core/Module.h"
#include "lldb/Core/ModuleSpec.h"
#include "lldb/Core/Section.h"
#include "lldb/Core/Stream.h"
#include "lldb/Symbol/ObjectFile.h"
#include "lldb/Symbol/Symtab.h"
#include "lldb/Symbol/Function.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/Target.h"
#include "lldb/Symbol/SymbolVendor.h"

using namespace lldb;
using namespace lldb_private;


Symbol::Symbol() :
    SymbolContextScope (),
    m_uid (UINT32_MAX),
    m_type_data (0),
    m_type_data_resolved (false),
    m_is_synthetic (false),
    m_is_debug (false),
    m_is_external (false),
    m_size_is_sibling (false),
    m_size_is_synthesized (false),
    m_size_is_valid (false),
    m_demangled_is_synthesized (false),
    m_type (eSymbolTypeInvalid),
    m_mangled (),
    m_addr_range (),
    m_flags ()
{
}

Symbol::Symbol
(
    uint32_t symID,
    const char *name,
    bool name_is_mangled,
    SymbolType type,
    bool external,
    bool is_debug,
    bool is_trampoline,
    bool is_artificial,
    const lldb::SectionSP &section_sp,
    addr_t offset,
    addr_t size,
    bool size_is_valid,
    uint32_t flags
) :
    SymbolContextScope (),
    m_uid (symID),
    m_type_data (0),
    m_type_data_resolved (false),
    m_is_synthetic (is_artificial),
    m_is_debug (is_debug),
    m_is_external (external),
    m_size_is_sibling (false),
    m_size_is_synthesized (false),
    m_size_is_valid (size_is_valid || size > 0),
    m_demangled_is_synthesized (false),
    m_type (type),
    m_mangled (ConstString(name), name_is_mangled),
    m_addr_range (section_sp, offset, size),
    m_flags (flags)
{
}

Symbol::Symbol
(
    uint32_t symID,
    const char *name,
    bool name_is_mangled,
    SymbolType type,
    bool external,
    bool is_debug,
    bool is_trampoline,
    bool is_artificial,
    const AddressRange &range,
    bool size_is_valid,
    uint32_t flags
) :
    SymbolContextScope (),
    m_uid (symID),
    m_type_data (0),
    m_type_data_resolved (false),
    m_is_synthetic (is_artificial),
    m_is_debug (is_debug),
    m_is_external (external),
    m_size_is_sibling (false),
    m_size_is_synthesized (false),
    m_size_is_valid (size_is_valid || range.GetByteSize() > 0),
    m_demangled_is_synthesized (false),
    m_type (type),
    m_mangled (ConstString(name), name_is_mangled),
    m_addr_range (range),
    m_flags (flags)
{
}

Symbol::Symbol(const Symbol& rhs):
    SymbolContextScope (rhs),
    m_uid (rhs.m_uid),
    m_type_data (rhs.m_type_data),
    m_type_data_resolved (rhs.m_type_data_resolved),
    m_is_synthetic (rhs.m_is_synthetic),
    m_is_debug (rhs.m_is_debug),
    m_is_external (rhs.m_is_external),
    m_size_is_sibling (rhs.m_size_is_sibling),
    m_size_is_synthesized (false),
    m_size_is_valid (rhs.m_size_is_valid),
    m_demangled_is_synthesized (rhs.m_demangled_is_synthesized),
    m_type (rhs.m_type),
    m_mangled (rhs.m_mangled),
    m_addr_range (rhs.m_addr_range),
    m_flags (rhs.m_flags)
{
}

const Symbol&
Symbol::operator= (const Symbol& rhs)
{
    if (this != &rhs)
    {
        SymbolContextScope::operator= (rhs);
        m_uid = rhs.m_uid;
        m_type_data = rhs.m_type_data;
        m_type_data_resolved = rhs.m_type_data_resolved;
        m_is_synthetic = rhs.m_is_synthetic;
        m_is_debug = rhs.m_is_debug;
        m_is_external = rhs.m_is_external;
        m_size_is_sibling = rhs.m_size_is_sibling;
        m_size_is_synthesized = rhs.m_size_is_sibling;
        m_size_is_valid = rhs.m_size_is_valid;
        m_demangled_is_synthesized = rhs.m_demangled_is_synthesized;
        m_type = rhs.m_type;
        m_mangled = rhs.m_mangled;
        m_addr_range = rhs.m_addr_range;
        m_flags = rhs.m_flags;
    }
    return *this;
}

void
Symbol::Clear()
{
    m_uid = UINT32_MAX;
    m_mangled.Clear();
    m_type_data = 0;
    m_type_data_resolved = false;
    m_is_synthetic = false;
    m_is_debug = false;
    m_is_external = false;
    m_size_is_sibling = false;
    m_size_is_synthesized = false;
    m_size_is_valid = false;
    m_demangled_is_synthesized = false;
    m_type = eSymbolTypeInvalid;
    m_flags = 0;
    m_addr_range.Clear();
}

bool
Symbol::ValueIsAddress() const
{
    return m_addr_range.GetBaseAddress().GetSection().get() != nullptr;
}

ConstString
Symbol::GetReExportedSymbolName() const
{
    if (m_type == eSymbolTypeReExported)
    {
        // For eSymbolTypeReExported, the "const char *" from a ConstString
        // is used as the offset in the address range base address. We can
        // then make this back into a string that is the re-exported name.
        intptr_t str_ptr = m_addr_range.GetBaseAddress().GetOffset();
        if (str_ptr != 0)
            return ConstString((const char *)str_ptr);
        else
            return GetName();
    }
    return ConstString();
}

FileSpec
Symbol::GetReExportedSymbolSharedLibrary() const
{
    if (m_type == eSymbolTypeReExported)
    {
        // For eSymbolTypeReExported, the "const char *" from a ConstString
        // is used as the offset in the address range base address. We can
        // then make this back into a string that is the re-exported name.
        intptr_t str_ptr = m_addr_range.GetByteSize();
        if (str_ptr != 0)
            return FileSpec((const char *)str_ptr, false);
    }
    return FileSpec();
}

bool
Symbol::SetReExportedSymbolName(const ConstString &name)
{
    if (m_type == eSymbolTypeReExported)
    {
        // For eSymbolTypeReExported, the "const char *" from a ConstString
        // is used as the offset in the address range base address.
        m_addr_range.GetBaseAddress().SetOffset((intptr_t)name.GetCString());
        return true;
    }
    return false;
    
}

bool
Symbol::SetReExportedSymbolSharedLibrary(const FileSpec &fspec)
{
    if (m_type == eSymbolTypeReExported)
    {
        // For eSymbolTypeReExported, the "const char *" from a ConstString
        // is used as the offset in the address range base address.
        m_addr_range.SetByteSize((intptr_t)ConstString(fspec.GetPath().c_str()).GetCString());
        return true;
    }
    return false;
    
}

uint32_t
Symbol::GetSiblingIndex() const
{
    return m_size_is_sibling ? m_addr_range.GetByteSize() : 0;
}

bool
Symbol::IsTrampoline () const
{
    return m_type == eSymbolTypeTrampoline;
}

bool
Symbol::IsIndirect () const
{
    return m_type == eSymbolTypeResolver;
}

void
Symbol::GetDescription (Stream *s, lldb::DescriptionLevel level, Target *target) const
{
    s->Printf("id = {0x%8.8x}", m_uid);
    
    if (m_addr_range.GetBaseAddress().GetSection())
    {
        if (ValueIsAddress())
        {
            const lldb::addr_t byte_size = GetByteSize();
            if (byte_size > 0)
            {
                s->PutCString (", range = ");
                m_addr_range.Dump(s, target, Address::DumpStyleLoadAddress, Address::DumpStyleFileAddress);
            }
            else 
            {
                s->PutCString (", address = ");
                m_addr_range.GetBaseAddress().Dump(s, target, Address::DumpStyleLoadAddress, Address::DumpStyleFileAddress);
            }
        }
        else
            s->Printf (", value = 0x%16.16" PRIx64, m_addr_range.GetBaseAddress().GetOffset());
    }
    else
    {
        if (m_size_is_sibling)                
            s->Printf (", sibling = %5" PRIu64, m_addr_range.GetBaseAddress().GetOffset());
        else
            s->Printf (", value = 0x%16.16" PRIx64, m_addr_range.GetBaseAddress().GetOffset());
    }
    if (m_mangled.GetDemangledName())
        s->Printf(", name=\"%s\"", m_mangled.GetDemangledName().AsCString());
    if (m_mangled.GetMangledName())
        s->Printf(", mangled=\"%s\"", m_mangled.GetMangledName().AsCString());

}

void
Symbol::Dump(Stream *s, Target *target, uint32_t index) const
{
//  s->Printf("%.*p: ", (int)sizeof(void*) * 2, this);
//  s->Indent();
//  s->Printf("Symbol[%5u] %6u %c%c %-12s ",
    s->Printf("[%5u] %6u %c%c%c %-12s ",
              index,
              GetID(),
              m_is_debug ? 'D' : ' ',
              m_is_synthetic ? 'S' : ' ',
              m_is_external ? 'X' : ' ',
              GetTypeAsString());

    // Make sure the size of the symbol is up to date before dumping
    GetByteSize();

    if (ValueIsAddress())
    {
        if (!m_addr_range.GetBaseAddress().Dump(s, nullptr, Address::DumpStyleFileAddress))
            s->Printf("%*s", 18, "");

        s->PutChar(' ');

        if (!m_addr_range.GetBaseAddress().Dump(s, target, Address::DumpStyleLoadAddress))
            s->Printf("%*s", 18, "");

        const char *format = m_size_is_sibling ?
                            " Sibling -> [%5llu] 0x%8.8x %s\n":
                            " 0x%16.16" PRIx64 " 0x%8.8x %s\n";
        s->Printf(  format,
                    GetByteSize(),
                    m_flags,
                    m_mangled.GetName().AsCString(""));
    }
    else if (m_type == eSymbolTypeReExported)
    {
        s->Printf ("                                                         0x%8.8x %s",
                   m_flags,
                   m_mangled.GetName().AsCString(""));
        
        ConstString reexport_name = GetReExportedSymbolName();
        intptr_t shlib = m_addr_range.GetByteSize();
        if (shlib)
            s->Printf(" -> %s`%s\n", (const char *)shlib, reexport_name.GetCString());
        else
            s->Printf(" -> %s\n", reexport_name.GetCString());
    }
    else
    {
        const char *format = m_size_is_sibling ?
                            "0x%16.16" PRIx64 "                    Sibling -> [%5llu] 0x%8.8x %s\n":
                            "0x%16.16" PRIx64 "                    0x%16.16" PRIx64 " 0x%8.8x %s\n";
        s->Printf(  format,
                    m_addr_range.GetBaseAddress().GetOffset(),
                    GetByteSize(),
                    m_flags,
                    m_mangled.GetName().AsCString(""));
    }
}

uint32_t
Symbol::GetPrologueByteSize ()
{
    if (m_type == eSymbolTypeCode || m_type == eSymbolTypeResolver)
    {
        if (!m_type_data_resolved)
        {
            m_type_data_resolved = true;

            const Address &base_address = m_addr_range.GetBaseAddress();
            Function *function = base_address.CalculateSymbolContextFunction();
            if (function)
            {
                // Functions have line entries which can also potentially have end of prologue information.
                // So if this symbol points to a function, use the prologue information from there.
                m_type_data = function->GetPrologueByteSize();
            }
            else
            {
                ModuleSP module_sp (base_address.GetModule());
                SymbolContext sc;
                if (module_sp)
                {
                    uint32_t resolved_flags = module_sp->ResolveSymbolContextForAddress (base_address,
                                                                                         eSymbolContextLineEntry,
                                                                                         sc);
                    if (resolved_flags & eSymbolContextLineEntry)
                    {
                        // Default to the end of the first line entry.
                        m_type_data = sc.line_entry.range.GetByteSize();

                        // Set address for next line.
                        Address addr (base_address);
                        addr.Slide (m_type_data);

                        // Check the first few instructions and look for one that has a line number that is
                        // different than the first entry. This is also done in Function::GetPrologueByteSize().
                        uint16_t total_offset = m_type_data;
                        for (int idx = 0; idx < 6; ++idx)
                        {
                            SymbolContext sc_temp;
                            resolved_flags = module_sp->ResolveSymbolContextForAddress (addr, eSymbolContextLineEntry, sc_temp);
                            // Make sure we got line number information...
                            if (!(resolved_flags & eSymbolContextLineEntry))
                                break;

                            // If this line number is different than our first one, use it and we're done.
                            if (sc_temp.line_entry.line != sc.line_entry.line)
                            {
                                m_type_data = total_offset;
                                break;
                            }

                            // Slide addr up to the next line address.
                            addr.Slide (sc_temp.line_entry.range.GetByteSize());
                            total_offset += sc_temp.line_entry.range.GetByteSize();
                            // If we've gone too far, bail out.
                            if (total_offset >= m_addr_range.GetByteSize())
                                break;
                        }

                        // Sanity check - this may be a function in the middle of code that has debug information, but
                        // not for this symbol.  So the line entries surrounding us won't lie inside our function.
                        // In that case, the line entry will be bigger than we are, so we do that quick check and
                        // if that is true, we just return 0.
                        if (m_type_data >= m_addr_range.GetByteSize())
                            m_type_data = 0;
                    }
                    else
                    {
                        // TODO: expose something in Process to figure out the
                        // size of a function prologue.
                        m_type_data = 0;
                    }
                }
            }
        }
        return m_type_data;
    }
    return 0;
}

bool
Symbol::Compare(const ConstString& name, SymbolType type) const
{
    if (type == eSymbolTypeAny || m_type == type)
        return m_mangled.GetMangledName() == name || m_mangled.GetDemangledName() == name;
    return false;
}

#define ENUM_TO_CSTRING(x)  case eSymbolType##x: return #x;

const char *
Symbol::GetTypeAsString() const
{
    switch (m_type)
    {
    ENUM_TO_CSTRING(Invalid);
    ENUM_TO_CSTRING(Absolute);
    ENUM_TO_CSTRING(Code);
    ENUM_TO_CSTRING(Resolver);
    ENUM_TO_CSTRING(Data);
    ENUM_TO_CSTRING(Trampoline);
    ENUM_TO_CSTRING(Runtime);
    ENUM_TO_CSTRING(Exception);
    ENUM_TO_CSTRING(SourceFile);
    ENUM_TO_CSTRING(HeaderFile);
    ENUM_TO_CSTRING(ObjectFile);
    ENUM_TO_CSTRING(CommonBlock);
    ENUM_TO_CSTRING(Block);
    ENUM_TO_CSTRING(Local);
    ENUM_TO_CSTRING(Param);
    ENUM_TO_CSTRING(Variable);
    ENUM_TO_CSTRING(VariableType);
    ENUM_TO_CSTRING(LineEntry);
    ENUM_TO_CSTRING(LineHeader);
    ENUM_TO_CSTRING(ScopeBegin);
    ENUM_TO_CSTRING(ScopeEnd);
    ENUM_TO_CSTRING(Additional);
    ENUM_TO_CSTRING(Compiler);
    ENUM_TO_CSTRING(Instrumentation);
    ENUM_TO_CSTRING(Undefined);
    ENUM_TO_CSTRING(ObjCClass);
    ENUM_TO_CSTRING(ObjCMetaClass);
    ENUM_TO_CSTRING(ObjCIVar);
    ENUM_TO_CSTRING(ReExported);
    default:
        break;
    }
    return "<unknown SymbolType>";
}

void
Symbol::CalculateSymbolContext (SymbolContext *sc)
{
    // Symbols can reconstruct the symbol and the module in the symbol context
    sc->symbol = this;
    if (ValueIsAddress())
        sc->module_sp = GetAddress().GetModule();
    else
        sc->module_sp.reset();
}

ModuleSP
Symbol::CalculateSymbolContextModule ()
{
    if (ValueIsAddress())
        return GetAddress().GetModule();
    return ModuleSP();
}

Symbol *
Symbol::CalculateSymbolContextSymbol ()
{
    return this;
}

void
Symbol::DumpSymbolContext (Stream *s)
{
    bool dumped_module = false;
    if (ValueIsAddress())
    {
        ModuleSP module_sp (GetAddress().GetModule());
        if (module_sp)
        {
            dumped_module = true;
            module_sp->DumpSymbolContext(s);
        }
    }
    if (dumped_module)
        s->PutCString(", ");
    
    s->Printf("Symbol{0x%8.8x}", GetID());
}

lldb::addr_t
Symbol::GetByteSize () const
{
    return m_addr_range.GetByteSize();
}


Symbol *
Symbol::ResolveReExportedSymbolInModuleSpec (Target &target,
                                             ConstString &reexport_name,
                                             ModuleSpec &module_spec,
                                             ModuleList &seen_modules) const
{
    ModuleSP module_sp;
    if (module_spec.GetFileSpec())
    {
        // Try searching for the module file spec first using the full path
        module_sp = target.GetImages().FindFirstModule(module_spec);
        if (!module_sp)
        {
            // Next try and find the module by basename in case environment
            // variables or other runtime trickery causes shared libraries
            // to be loaded from alternate paths
            module_spec.GetFileSpec().GetDirectory().Clear();
            module_sp = target.GetImages().FindFirstModule(module_spec);
        }
    }

    if (module_sp)
    {
        // There should not be cycles in the reexport list, but we don't want to crash if there are so make sure
        // we haven't seen this before:
        if (!seen_modules.AppendIfNeeded(module_sp))
            return nullptr;
        
        lldb_private::SymbolContextList sc_list;
        module_sp->FindSymbolsWithNameAndType(reexport_name, eSymbolTypeAny, sc_list);
        const size_t num_scs = sc_list.GetSize();
        if (num_scs > 0)
        {
            for (size_t i=0; i<num_scs; ++i)
            {
                lldb_private::SymbolContext sc;
                if (sc_list.GetContextAtIndex(i, sc))
                {
                    if (sc.symbol->IsExternal())
                        return sc.symbol;
                }
            }
        }
        // If we didn't find the symbol in this module, it may be because this module re-exports some
        // whole other library.  We have to search those as well:
        seen_modules.Append(module_sp);
        
        FileSpecList reexported_libraries = module_sp->GetObjectFile()->GetReExportedLibraries();
        size_t num_reexported_libraries = reexported_libraries.GetSize();
        for (size_t idx = 0; idx < num_reexported_libraries; idx++)
        {
            ModuleSpec reexported_module_spec;
            reexported_module_spec.GetFileSpec() = reexported_libraries.GetFileSpecAtIndex(idx);
            Symbol *result_symbol = ResolveReExportedSymbolInModuleSpec(target,
                                                                        reexport_name,
                                                                        reexported_module_spec,
                                                                        seen_modules);
            if (result_symbol)
                return result_symbol;
        }
    }
    return nullptr;
}

Symbol *
Symbol::ResolveReExportedSymbol (Target &target) const
{
    ConstString reexport_name (GetReExportedSymbolName());
    if (reexport_name)
    {
        ModuleSpec module_spec;
        ModuleList seen_modules;
        module_spec.GetFileSpec() = GetReExportedSymbolSharedLibrary();
        if (module_spec.GetFileSpec())
        {
            return ResolveReExportedSymbolInModuleSpec(target, reexport_name, module_spec, seen_modules);
        }
    }
    return nullptr;
}

lldb::addr_t
Symbol::ResolveCallableAddress(Target &target) const
{
    if (GetType() == lldb::eSymbolTypeUndefined)
        return LLDB_INVALID_ADDRESS;
    
    Address func_so_addr;
    
    bool is_indirect;
    if (GetType() == eSymbolTypeReExported)
    {
        Symbol *reexported_symbol = ResolveReExportedSymbol(target);
        if (reexported_symbol)
        {
            func_so_addr = reexported_symbol->GetAddress();
            is_indirect = reexported_symbol->IsIndirect();
        }
    }
    else
    {
        func_so_addr = GetAddress();
        is_indirect = IsIndirect();
    }

    if (func_so_addr.IsValid())
    {
        if (!target.GetProcessSP() && is_indirect)
        {
            // can't resolve indirect symbols without calling a function...
            return LLDB_INVALID_ADDRESS;
        }
        
        lldb::addr_t load_addr = func_so_addr.GetCallableLoadAddress (&target, is_indirect);
        
        if (load_addr != LLDB_INVALID_ADDRESS)
        {
            return load_addr;
        }
    }
    
    return LLDB_INVALID_ADDRESS;
}


lldb::DisassemblerSP
Symbol::GetInstructions (const ExecutionContext &exe_ctx,
                         const char *flavor,
                         bool prefer_file_cache)
{
    ModuleSP module_sp (m_addr_range.GetBaseAddress().GetModule());
    if (module_sp)
    {
        const bool prefer_file_cache = false;
        return Disassembler::DisassembleRange (module_sp->GetArchitecture(),
                                               nullptr,
                                               flavor,
                                               exe_ctx,
                                               m_addr_range,
                                               prefer_file_cache);
    }
    return lldb::DisassemblerSP();
}

bool
Symbol::GetDisassembly (const ExecutionContext &exe_ctx,
                        const char *flavor,
                        bool prefer_file_cache,
                        Stream &strm)
{
    lldb::DisassemblerSP disassembler_sp = GetInstructions (exe_ctx, flavor, prefer_file_cache);
    if (disassembler_sp)
    {
        const bool show_address = true;
        const bool show_bytes = false;
        disassembler_sp->GetInstructionList().Dump (&strm, show_address, show_bytes, &exe_ctx);
        return true;
    }
    return false;
}