This is an archive of the discontinued LLVM Phabricator instance.

Differential D97760

[lldb][NFC] Delete unused AddressResolverName
ClosedPublic

Authored by teemperor on Mar 2 2021, 2:42 AM.

Details

Reviewers
JDevlieghere
Group Reviewers
Restricted Project
Commits
rG820a8466097c: [lldb][NFC] Delete unused AddressResolverName
Summary

That's all just dead code that hasn't been changed in years.

Diff Detail

Event Timeline

teemperor created this revision.Mar 2 2021, 2:42 AM
Herald added subscribers: JDevlieghere, mgorny. · View Herald TranscriptMar 2 2021, 2:42 AM
teemperor requested review of this revision.Mar 2 2021, 2:42 AM
Harbormaster completed remote builds in B91532: Diff 327395.Mar 2 2021, 4:17 AM
JDevlieghere accepted this revision as: JDevlieghere.Mar 2 2021, 8:56 AM

LGTM

This revision is now accepted and ready to land.Mar 2 2021, 8:56 AM
Closed by commit rG820a8466097c: [lldb][NFC] Delete unused AddressResolverName (authored by teemperor). · Explain WhyMar 3 2021, 4:30 AM
This revision was automatically updated to reflect the committed changes.
teemperor added a commit: rG820a8466097c: [lldb][NFC] Delete unused AddressResolverName.
Herald added a subscriber: lldb-commits. · View Herald TranscriptMar 3 2021, 4:30 AM

Revision Contents

PathSize
lldb/
include/
lldb/
Core/
source/
API/
1 line
Core/
1 line

Diff 327740

lldb/include/lldb/Core/AddressResolverName.h

  • This file was deleted.
//===-- AddressResolverName.h -----------------------------------*- C++ -*-===//
//
// 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
//
//===----------------------------------------------------------------------===//
#ifndef LLDB_CORE_ADDRESSRESOLVERNAME_H
#define LLDB_CORE_ADDRESSRESOLVERNAME_H
#include "lldb/Core/AddressResolver.h"
#include "lldb/Core/SearchFilter.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/RegularExpression.h"
#include "lldb/lldb-defines.h"
namespace lldb_private {
class Address;
class Stream;
class SymbolContext;
/// \class AddressResolverName AddressResolverName.h
/// "lldb/Core/AddressResolverName.h" This class finds addresses for a given
/// function name, either by exact match or by regular expression.
class AddressResolverName : public AddressResolver {
public:
AddressResolverName(const char *func_name,
AddressResolver::MatchType type = Exact);
// Creates a function breakpoint by regular expression. Takes over control
// of the lifespan of func_regex.
AddressResolverName(RegularExpression func_regex);
AddressResolverName(const char *class_name, const char *method,
AddressResolver::MatchType type);
~AddressResolverName() override;
Searcher::CallbackReturn SearchCallback(SearchFilter &filter,
SymbolContext &context,
Address *addr) override;
lldb::SearchDepth GetDepth() override;
void GetDescription(Stream *s) override;
protected:
ConstString m_func_name;
ConstString m_class_name; // FIXME: Not used yet. The idea would be to stop
// on methods of this class.
RegularExpression m_regex;
AddressResolver::MatchType m_match_type;
private:
AddressResolverName(const AddressResolverName &) = delete;
const AddressResolverName &operator=(const AddressResolverName &) = delete;
};
} // namespace lldb_private
#endif // LLDB_CORE_ADDRESSRESOLVERNAME_H

lldb/source/API/SBTarget.cpp

Show All 26 Lines
#include "lldb/API/SBStructuredData.h" #include "lldb/API/SBStructuredData.h"
#include "lldb/API/SBSymbolContextList.h" #include "lldb/API/SBSymbolContextList.h"
#include "lldb/Breakpoint/BreakpointID.h" #include "lldb/Breakpoint/BreakpointID.h"
#include "lldb/Breakpoint/BreakpointIDList.h" #include "lldb/Breakpoint/BreakpointIDList.h"
#include "lldb/Breakpoint/BreakpointList.h" #include "lldb/Breakpoint/BreakpointList.h"
#include "lldb/Breakpoint/BreakpointLocation.h" #include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Core/Address.h" #include "lldb/Core/Address.h"
#include "lldb/Core/AddressResolver.h" #include "lldb/Core/AddressResolver.h"
#include "lldb/Core/AddressResolverName.h"
#include "lldb/Core/Debugger.h" #include "lldb/Core/Debugger.h"
#include "lldb/Core/Disassembler.h" #include "lldb/Core/Disassembler.h"
#include "lldb/Core/Module.h" #include "lldb/Core/Module.h"
#include "lldb/Core/ModuleSpec.h" #include "lldb/Core/ModuleSpec.h"
#include "lldb/Core/SearchFilter.h" #include "lldb/Core/SearchFilter.h"
#include "lldb/Core/Section.h" #include "lldb/Core/Section.h"
#include "lldb/Core/StructuredDataImpl.h" #include "lldb/Core/StructuredDataImpl.h"
#include "lldb/Core/ValueObjectConstResult.h" #include "lldb/Core/ValueObjectConstResult.h"
▲ Show 20 Lines • Show All 2,679 Lines • Show Last 20 Lines

lldb/source/Core/AddressResolverName.cpp

  • This file was deleted.
//===-- 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());
}

lldb/source/Core/CMakeLists.txt

Show All 18 Linesif (LLDB_ENABLE_CURSES)
endif() endif()
endif() endif()
add_lldb_library(lldbCore add_lldb_library(lldbCore
Address.cpp Address.cpp
AddressRange.cpp AddressRange.cpp
AddressResolver.cpp AddressResolver.cpp
AddressResolverFileLine.cpp AddressResolverFileLine.cpp
AddressResolverName.cpp
Communication.cpp Communication.cpp
Debugger.cpp Debugger.cpp
Disassembler.cpp Disassembler.cpp
DumpDataExtractor.cpp DumpDataExtractor.cpp
DumpRegisterValue.cpp DumpRegisterValue.cpp
DynamicLoader.cpp DynamicLoader.cpp
EmulateInstruction.cpp EmulateInstruction.cpp
FileLineResolver.cpp FileLineResolver.cpp
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines
lldb/include/lldb/Core/AddressResolverName.h