File Manager

003 File Manager

Current Path: /usr/src/contrib/llvm-project/lldb/source/Core

usr / src / contrib / llvm-project / lldb / source / Core /

📁 ..
📄 Address.cpp(34.46 KB)
📄 AddressRange.cpp(6.35 KB)
📄 AddressResolver.cpp(1.15 KB)
📄 AddressResolverFileLine.cpp(2.99 KB)
📄 AddressResolverName.cpp(6.52 KB)
📄 Communication.cpp(14.89 KB)
📄 CoreProperties.td(9.46 KB)
📄 Debugger.cpp(56.35 KB)
📄 Disassembler.cpp(45.47 KB)
📄 DumpDataExtractor.cpp(26.28 KB)
📄 DumpRegisterValue.cpp(2.88 KB)
📄 DynamicLoader.cpp(8.11 KB)
📄 EmulateInstruction.cpp(19.28 KB)
📄 FileLineResolver.cpp(2.85 KB)
📄 FileSpecList.cpp(4.02 KB)
📄 FormatEntity.cpp(83.74 KB)
📄 Highlighter.cpp(2.91 KB)
📄 IOHandler.cpp(18.81 KB)
📄 IOHandlerCursesGUI.cpp(126.73 KB)
📄 Mangled.cpp(14.82 KB)
📄 Module.cpp(60.79 KB)
📄 ModuleChild.cpp(872 B)
📄 ModuleList.cpp(35.29 KB)
📄 Opcode.cpp(3.79 KB)
📄 PluginManager.cpp(52.59 KB)
📄 RichManglingContext.cpp(5.2 KB)
📄 SearchFilter.cpp(27.24 KB)
📄 Section.cpp(19.21 KB)
📄 SourceManager.cpp(23.03 KB)
📄 StreamAsynchronousIO.cpp(1.11 KB)
📄 StreamFile.cpp(1.71 KB)
📄 UserSettingsController.cpp(3.76 KB)
📄 Value.cpp(22.68 KB)
📄 ValueObject.cpp(115.6 KB)
📄 ValueObjectCast.cpp(3.12 KB)
📄 ValueObjectChild.cpp(9.28 KB)
📄 ValueObjectConstResult.cpp(11.81 KB)
📄 ValueObjectConstResultCast.cpp(2.05 KB)
📄 ValueObjectConstResultChild.cpp(2.65 KB)
📄 ValueObjectConstResultImpl.cpp(6.26 KB)
📄 ValueObjectDynamicValue.cpp(12.25 KB)
📄 ValueObjectList.cpp(3.31 KB)
📄 ValueObjectMemory.cpp(8.3 KB)
📄 ValueObjectRegister.cpp(9.77 KB)
📄 ValueObjectSyntheticFilter.cpp(13.73 KB)
📄 ValueObjectVariable.cpp(14.44 KB)

Editing: AddressResolverName.cpp

//===-- AddressResolverName.cpp -------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include "lldb/Core/AddressResolverName.h"

#include "lldb/Core/Address.h"
#include "lldb/Core/AddressRange.h"
#include "lldb/Core/Module.h"
#include "lldb/Symbol/Function.h"
#include "lldb/Symbol/Symbol.h"
#include "lldb/Symbol/SymbolContext.h"
#include "lldb/Utility/Log.h"
#include "lldb/Utility/Logging.h"
#include "lldb/Utility/Stream.h"
#include "lldb/lldb-enumerations.h"
#include "lldb/lldb-forward.h"
#include "lldb/lldb-types.h"
#include "llvm/ADT/StringRef.h"

#include <memory>
#include <string>
#include <vector>

#include <stdint.h>

using namespace lldb;
using namespace lldb_private;

AddressResolverName::AddressResolverName(const char *func_name,
                                         AddressResolver::MatchType type)
    : AddressResolver(), m_func_name(func_name), m_class_name(nullptr),
      m_regex(), m_match_type(type) {
  if (m_match_type == AddressResolver::Regexp) {
    m_regex = RegularExpression(m_func_name.GetStringRef());
    if (!m_regex.IsValid()) {
      Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));

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

AddressResolverName::AddressResolverName(RegularExpression func_regex)
    : AddressResolver(), m_func_name(nullptr), m_class_name(nullptr),
      m_regex(std::move(func_regex)), m_match_type(AddressResolver::Regexp) {}

AddressResolverName::AddressResolverName(const char *class_name,
                                         const char *method,
                                         AddressResolver::MatchType type)
    : AddressResolver(), m_func_name(method), m_class_name(class_name),
      m_regex(), m_match_type(type) {}

AddressResolverName::~AddressResolverName() = default;

// 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
AddressResolverName::SearchCallback(SearchFilter &filter,
                                    SymbolContext &context, Address *addr) {
  SymbolContextList func_list;
  SymbolContextList sym_list;

bool skip_prologue = true;
  uint32_t i;
  SymbolContext sc;
  Address func_addr;

Log *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 include_inlines = true;
  switch (m_match_type) {
  case AddressResolver::Exact:
    if (context.module_sp) {
      context.module_sp->FindSymbolsWithNameAndType(m_func_name,
                                                    eSymbolTypeCode, sym_list);
      context.module_sp->FindFunctions(m_func_name, CompilerDeclContext(),
                                       eFunctionNameTypeAuto, include_symbols,
                                       include_inlines, func_list);
    }
    break;

case AddressResolver::Regexp:
    if (context.module_sp) {
      context.module_sp->FindSymbolsMatchingRegExAndType(
          m_regex, eSymbolTypeCode, sym_list);
      context.module_sp->FindFunctions(m_regex, include_symbols,
                                       include_inlines, func_list);
    }
    break;

case AddressResolver::Glob:
    if (log)
      log->Warning("glob is not supported yet.");
    break;
  }

// Remove any duplicates between the function list and the symbol list
  if (func_list.GetSize()) {
    for (i = 0; i < func_list.GetSize(); i++) {
      if (!func_list.GetContextAtIndex(i, sc))
        continue;

if (sc.function == nullptr)
        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->ValueIsAddress()) {
            if (sc.function->GetAddressRange().GetBaseAddress() ==
                symbol_sc.symbol->GetAddressRef()) {
              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.function) {
          func_addr = sc.function->GetAddressRange().GetBaseAddress();
          addr_t byte_size = sc.function->GetAddressRange().GetByteSize();
          if (skip_prologue) {
            const uint32_t prologue_byte_size =
                sc.function->GetPrologueByteSize();
            if (prologue_byte_size) {
              func_addr.SetOffset(func_addr.GetOffset() + prologue_byte_size);
              byte_size -= prologue_byte_size;
            }
          }

if (filter.AddressPasses(func_addr)) {
            AddressRange new_range(func_addr, byte_size);
            m_address_ranges.push_back(new_range);
          }
        }
      }
    }
  }

for (i = 0; i < sym_list.GetSize(); i++) {
    if (sym_list.GetContextAtIndex(i, sc)) {
      if (sc.symbol && sc.symbol->ValueIsAddress()) {
        func_addr = sc.symbol->GetAddressRef();
        addr_t byte_size = sc.symbol->GetByteSize();

if (skip_prologue) {
          const uint32_t prologue_byte_size = sc.symbol->GetPrologueByteSize();
          if (prologue_byte_size) {
            func_addr.SetOffset(func_addr.GetOffset() + prologue_byte_size);
            byte_size -= prologue_byte_size;
          }
        }

if (filter.AddressPasses(func_addr)) {
          AddressRange new_range(func_addr, byte_size);
          m_address_ranges.push_back(new_range);
        }
      }
    }
  }
  return Searcher::eCallbackReturnContinue;
}

lldb::SearchDepth AddressResolverName::GetDepth() {
  return lldb::eSearchDepthModule;
}

void AddressResolverName::GetDescription(Stream *s) {
  s->PutCString("Address by function name: ");

if (m_match_type == AddressResolver::Regexp)
    s->Printf("'%s' (regular expression)", m_regex.GetText().str().c_str());
  else
    s->Printf("'%s'", m_func_name.AsCString());
}

003 File Manager

Editing: AddressResolverName.cpp

Upload File

Create Folder