llvm/lldb/source/Breakpoint/BreakpointResolverName.cpp

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

// C Includes
// C++ Includes
// Other libraries and framework includes
// Project includes
#include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Core/Log.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Target/Target.h"

using namespace lldb;
using namespace lldb_private;

BreakpointResolverName::BreakpointResolverName
(
    Breakpoint *bkpt,
    const char *func_name,
    uint32_t func_name_type_mask,
    Breakpoint::MatchType type
) :
    BreakpointResolver (bkpt, BreakpointResolver::NameResolver),
    m_func_name (),
    m_basename_filter (),
    m_func_name_type_mask (func_name_type_mask),
    m_class_name (),
    m_regex (),
    m_match_type (type)
{
    if (func_name_type_mask == eFunctionNameTypeAuto)
    {
        if ((::strchr (func_name, '(' ) != NULL) ||
            (::strstr (func_name, "-[") == func_name) || 
            (::strstr (func_name, "+[") == func_name))
        {
            // We have a name that contains an open parens, or starts with 
            // "+[" or "-[", so this looks like a complete function prototype
            m_func_name_type_mask = eFunctionNameTypeFull;
        }
        else
        {
            // We don't have a full function name, but we might have a partial
            // function basename with namespaces or classes
            if (::strstr (func_name, "::") != NULL)
            {
                // Keep the full name in "m_basename_filter"
                m_basename_filter = func_name;
                // Now set "m_func_name" to just the function basename
                m_func_name.SetCString(m_basename_filter.c_str() + m_basename_filter.rfind("::") + 2);
                // We have a name with a double colon which means we have a
                // function name that is a C++ method or a function in a C++ 
                // namespace
                m_func_name_type_mask = eFunctionNameTypeBase | eFunctionNameTypeMethod;
            }
            else if (::strstr (func_name, ":") != NULL)
            {
                // Single colon => selector
                m_func_name_type_mask = eFunctionNameTypeSelector;
            }
            else
            {
                // just a  basename by default
                m_func_name_type_mask = eFunctionNameTypeBase;
            }
        }
    }

    if (!m_func_name)
        m_func_name.SetCString(func_name);
    
    if (m_match_type == Breakpoint::Regexp)
    {
        if (!m_regex.Compile (m_func_name.AsCString()))
        {
            LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));

            if (log)
                log->Warning ("function name regexp: \"%s\" did not compile.", m_func_name.AsCString());
        }
    }
}

BreakpointResolverName::BreakpointResolverName
(
    Breakpoint *bkpt,
    RegularExpression &func_regex
) :
    BreakpointResolver (bkpt, BreakpointResolver::NameResolver),
    m_func_name (NULL),
    m_class_name (NULL),
    m_regex (func_regex),
    m_match_type (Breakpoint::Regexp)
{

}

BreakpointResolverName::BreakpointResolverName
(
    Breakpoint *bkpt,
    const char *class_name,
    const char *method,
    Breakpoint::MatchType type
) :
    BreakpointResolver (bkpt, BreakpointResolver::NameResolver),
    m_func_name (method),
    m_class_name (class_name),
    m_regex (),
    m_match_type (type)
{

}

BreakpointResolverName::~BreakpointResolverName ()
{
}

// FIXME: Right now we look at the module level, and call the module's "FindFunctions".
// Greg says he will add function tables, maybe at the CompileUnit level to accelerate function
// lookup.  At that point, we should switch the depth to CompileUnit, and look in these tables.

Searcher::CallbackReturn
BreakpointResolverName::SearchCallback
(
    SearchFilter &filter,
    SymbolContext &context,
    Address *addr,
    bool containing
)
{
    SymbolContextList func_list;
    SymbolContextList sym_list;
    
    bool skip_prologue = true;
    uint32_t i;
    bool new_location;
    SymbolContext sc;
    Address break_addr;
    assert (m_breakpoint != NULL);
    
    if (context.target_sp)
    {
        skip_prologue = context.target_sp->GetSkipPrologue();
    }

    LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));
    
    if (m_class_name)
    {
        if (log)
            log->Warning ("Class/method function specification not supported yet.\n");
        return Searcher::eCallbackReturnStop;
    }
    
    const bool include_symbols = false;
    const bool append = false;
    switch (m_match_type)
    {
        case Breakpoint::Exact:
            if (context.module_sp)
            {
                if (m_func_name_type_mask & (eFunctionNameTypeBase | eFunctionNameTypeFull))
                    context.module_sp->FindSymbolsWithNameAndType (m_func_name, eSymbolTypeCode, sym_list);
                context.module_sp->FindFunctions (m_func_name, 
                                                  m_func_name_type_mask, 
                                                  include_symbols, 
                                                  append, 
                                                  func_list);
            }
            break;
        case Breakpoint::Regexp:
            if (context.module_sp)
            {
                context.module_sp->FindSymbolsMatchingRegExAndType (m_regex, eSymbolTypeCode, sym_list);
                context.module_sp->FindFunctions (m_regex, 
                                                  include_symbols, 
                                                  append, 
                                                  func_list);
            }
            break;
        case Breakpoint::Glob:
            if (log)
                log->Warning ("glob is not supported yet.");
            break;
    }
    
    if (!m_basename_filter.empty())
    {
        // Filter out any matches whose names don't contain the basename filter
        const char *basename_filter = m_basename_filter.c_str();
        if (func_list.GetSize())
        {
            bool remove = false;
            for (i = 0; i < func_list.GetSize(); remove = false)
            {
                if (func_list.GetContextAtIndex(i, sc) == false)
                    remove = true;
                else if (sc.function == NULL)
                    remove = true;
                else
                {
                    const InlineFunctionInfo* inlined_info = NULL;
                    
                    if (sc.block)
                        inlined_info = sc.block->GetInlinedFunctionInfo();

                    if (inlined_info)
                    {
                        if (::strstr (inlined_info->GetName().AsCString(), basename_filter) == NULL)
                            remove = true;
                    }
                    else if (::strstr (sc.function->GetName().AsCString(), basename_filter) == NULL)
                        remove = true;
                }

                if (remove)
                {
                    func_list.RemoveContextAtIndex(i);
                    continue;
                }
                i++;
            }
        }

        if (sym_list.GetSize())
        {
            bool remove = false;
            for (i = 0; i < sym_list.GetSize(); remove = false)
            {
                if (sym_list.GetContextAtIndex(i, sc) == false)
                    remove = true;
                else if (sc.symbol == NULL)
                    remove = true;
                else if (::strstr (sc.symbol->GetName().AsCString(), basename_filter) == NULL)
                    remove = true;

                if (remove)
                {
                    sym_list.RemoveContextAtIndex(i);
                    continue;
                }
                i++;
            }
        }
    }
    
    // Remove any duplicates between the funcion list and the symbol list
    if (func_list.GetSize())
    {
        for (i = 0; i < func_list.GetSize(); i++)
        {
            if (func_list.GetContextAtIndex(i, sc) == false)
                continue;
            
            if (sc.function == NULL)
                continue;
            uint32_t j = 0;
            while (j < sym_list.GetSize())
            {
                SymbolContext symbol_sc;
                if (sym_list.GetContextAtIndex(j, symbol_sc))
                {
                    if (symbol_sc.symbol && symbol_sc.symbol->GetAddressRangePtr())
                    {
                        if (sc.function->GetAddressRange().GetBaseAddress() == symbol_sc.symbol->GetAddressRangePtr()->GetBaseAddress())
                        {
                            sym_list.RemoveContextAtIndex(j);
                            continue;   // Don't increment j
                        }
                    }
                }
                
                j++;
            }
        }
        
        for (i = 0; i < func_list.GetSize(); i++)
        {
            if (func_list.GetContextAtIndex(i, sc))
            {
                if (sc.block && sc.block->GetInlinedFunctionInfo())
                {
                    if (!sc.block->GetStartAddress(break_addr))
                        break_addr.Clear();
                }
                else if (sc.function)
                {
                    break_addr = sc.function->GetAddressRange().GetBaseAddress();
                    if (skip_prologue)
                    {
                        if (break_addr.IsValid())
                        {
                            const uint32_t prologue_byte_size = sc.function->GetPrologueByteSize();
                            if (prologue_byte_size)
                                break_addr.SetOffset(break_addr.GetOffset() + prologue_byte_size);
                        }
                    }
                }
                
                if (break_addr.IsValid())
                {
                    if (filter.AddressPasses(break_addr))
                    {
                        BreakpointLocationSP bp_loc_sp (m_breakpoint->AddLocation(break_addr, &new_location));
                        if (bp_loc_sp && new_location && !m_breakpoint->IsInternal())
                        {
                            if (log)
                            {
                                StreamString s;
                                bp_loc_sp->GetDescription(&s, lldb::eDescriptionLevelVerbose);
                                log->Printf ("Added location: %s\n", s.GetData());
                            }
                        }
                    }
                }
            }
        }
    }
    
    for (i = 0; i < sym_list.GetSize(); i++)
    {
        if (sym_list.GetContextAtIndex(i, sc))
        {
            if (sc.symbol && sc.symbol->GetAddressRangePtr())
            {
                break_addr = sc.symbol->GetAddressRangePtr()->GetBaseAddress();
                
                if (skip_prologue)
                {
                    const uint32_t prologue_byte_size = sc.symbol->GetPrologueByteSize();
                    if (prologue_byte_size)
                        break_addr.SetOffset(break_addr.GetOffset() + prologue_byte_size);
                }
                
                if (filter.AddressPasses(break_addr))
                {
                    BreakpointLocationSP bp_loc_sp (m_breakpoint->AddLocation(break_addr, &new_location));
                    if (bp_loc_sp && new_location && !m_breakpoint->IsInternal())
                    {
                        StreamString s;
                        bp_loc_sp->GetDescription(&s, lldb::eDescriptionLevelVerbose);
                        if (log) 
                            log->Printf ("Added location: %s\n", s.GetData());
                    }
                }
            }
        }
    }
    return Searcher::eCallbackReturnContinue;
}

Searcher::Depth
BreakpointResolverName::GetDepth()
{
    return Searcher::eDepthModule;
}

void
BreakpointResolverName::GetDescription (Stream *s)
{
    if (m_match_type == Breakpoint::Regexp)
        s->Printf("regex = '%s'", m_regex.GetText());
    else if (m_basename_filter.empty())
        s->Printf("name = '%s'", m_func_name.AsCString());
    else
        s->Printf("name = '%s'", m_basename_filter.c_str());
}

void
BreakpointResolverName::Dump (Stream *s) const
{

}