SearchFilter.cpp | Explore in Territory

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

#include "lldb/Breakpoint/Breakpoint.h"
#include "lldb/Core/Module.h"
#include "lldb/Core/ModuleList.h"
#include "lldb/Symbol/CompileUnit.h"
#include "lldb/Symbol/SymbolContext.h"
#include "lldb/Symbol/SymbolFile.h"
#include "lldb/Target/Target.h"
#include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Status.h"
#include "lldb/Utility/Stream.h"
#include "lldb/lldb-enumerations.h"

#include "llvm/ADT/StringRef.h"
#include "llvm/Support/ErrorHandling.h"

#include <memory>
#include <mutex>
#include <string>

#include <cinttypes>
#include <cstring>

namespace lldb_private {
class Address;
}
namespace lldb_private {
class Function;
}

usingnamespacelldb;
usingnamespacelldb_private;

const char *SearchFilter::g_ty_to_name[] = …;

const char
    *SearchFilter::g_option_names[SearchFilter::OptionNames::LastOptionName] = …;

const char *SearchFilter::FilterTyToName(enum FilterTy type) { … }

SearchFilter::FilterTy SearchFilter::NameToFilterTy(llvm::StringRef name) { … }

Searcher::Searcher() = default;

Searcher::~Searcher() = default;

void Searcher::GetDescription(Stream *s) { … }

SearchFilter::SearchFilter(const TargetSP &target_sp, unsigned char filterType)
    : … { … }

SearchFilter::~SearchFilter() = default;

SearchFilterSP SearchFilter::CreateFromStructuredData(
    const lldb::TargetSP& target_sp,
    const StructuredData::Dictionary &filter_dict,
    Status &error) { … }

bool SearchFilter::ModulePasses(const FileSpec &spec) { … }

bool SearchFilter::ModulePasses(const ModuleSP &module_sp) { … }

bool SearchFilter::AddressPasses(Address &address) { … }

bool SearchFilter::CompUnitPasses(FileSpec &fileSpec) { … }

bool SearchFilter::CompUnitPasses(CompileUnit &compUnit) { … }

bool SearchFilter::FunctionPasses(Function &function) { … }


uint32_t SearchFilter::GetFilterRequiredItems() { … }

void SearchFilter::GetDescription(Stream *s) { … }

void SearchFilter::Dump(Stream *s) const { … }

lldb::SearchFilterSP SearchFilter::CreateCopy(lldb::TargetSP& target_sp) { … }

// Helper functions for serialization.

StructuredData::DictionarySP
SearchFilter::WrapOptionsDict(StructuredData::DictionarySP options_dict_sp) { … }

void SearchFilter::SerializeFileSpecList(
    StructuredData::DictionarySP &options_dict_sp, OptionNames name,
    FileSpecList &file_list) { … }

// UTILITY Functions to help iterate down through the elements of the
// SymbolContext.

void SearchFilter::Search(Searcher &searcher) { … }

void SearchFilter::SearchInModuleList(Searcher &searcher, ModuleList &modules) { … }

Searcher::CallbackReturn
SearchFilter::DoModuleIteration(const lldb::ModuleSP &module_sp,
                                Searcher &searcher) { … }

Searcher::CallbackReturn
SearchFilter::DoModuleIteration(const SymbolContext &context,
                                Searcher &searcher) { … }

Searcher::CallbackReturn
SearchFilter::DoCUIteration(const ModuleSP &module_sp,
                            const SymbolContext &context, Searcher &searcher) { … }

Searcher::CallbackReturn SearchFilter::DoFunctionIteration(
    Function *function, const SymbolContext &context, Searcher &searcher) { … }

//  SearchFilterForUnconstrainedSearches:
//  Selects a shared library matching a given file spec, consulting the targets
//  "black list".
SearchFilterSP SearchFilterForUnconstrainedSearches::CreateFromStructuredData(
    const lldb::TargetSP& target_sp,
    const StructuredData::Dictionary &data_dict,
    Status &error) { … }

StructuredData::ObjectSP
SearchFilterForUnconstrainedSearches::SerializeToStructuredData() { … }

bool SearchFilterForUnconstrainedSearches::ModulePasses(
    const FileSpec &module_spec) { … }

bool SearchFilterForUnconstrainedSearches::ModulePasses(
    const lldb::ModuleSP &module_sp) { … }

SearchFilterSP SearchFilterForUnconstrainedSearches::DoCreateCopy() { … }

//  SearchFilterByModule:
//  Selects a shared library matching a given file spec

SearchFilterByModule::SearchFilterByModule(const lldb::TargetSP &target_sp,
                                           const FileSpec &module)
    : … { … }

SearchFilterByModule::~SearchFilterByModule() = default;

bool SearchFilterByModule::ModulePasses(const ModuleSP &module_sp) { … }

bool SearchFilterByModule::ModulePasses(const FileSpec &spec) { … }

bool SearchFilterByModule::AddressPasses(Address &address) { … }

void SearchFilterByModule::Search(Searcher &searcher) { … }

void SearchFilterByModule::GetDescription(Stream *s) { … }

uint32_t SearchFilterByModule::GetFilterRequiredItems() { … }

void SearchFilterByModule::Dump(Stream *s) const { … }

SearchFilterSP SearchFilterByModule::DoCreateCopy() { … }

SearchFilterSP SearchFilterByModule::CreateFromStructuredData(
    const lldb::TargetSP& target_sp,
    const StructuredData::Dictionary &data_dict,
    Status &error) { … }

StructuredData::ObjectSP SearchFilterByModule::SerializeToStructuredData() { … }

//  SearchFilterByModuleList:
//  Selects a shared library matching a given file spec

SearchFilterByModuleList::SearchFilterByModuleList(
    const lldb::TargetSP &target_sp, const FileSpecList &module_list)
    : … { … }

SearchFilterByModuleList::SearchFilterByModuleList(
    const lldb::TargetSP &target_sp, const FileSpecList &module_list,
    enum FilterTy filter_ty)
    : … { … }

SearchFilterByModuleList::~SearchFilterByModuleList() = default;

bool SearchFilterByModuleList::ModulePasses(const ModuleSP &module_sp) { … }

bool SearchFilterByModuleList::ModulePasses(const FileSpec &spec) { … }

bool SearchFilterByModuleList::AddressPasses(Address &address) { … }

void SearchFilterByModuleList::Search(Searcher &searcher) { … }

void SearchFilterByModuleList::GetDescription(Stream *s) { … }

uint32_t SearchFilterByModuleList::GetFilterRequiredItems() { … }

void SearchFilterByModuleList::Dump(Stream *s) const { … }

lldb::SearchFilterSP SearchFilterByModuleList::DoCreateCopy() { … }

SearchFilterSP SearchFilterByModuleList::CreateFromStructuredData(
    const lldb::TargetSP& target_sp,
    const StructuredData::Dictionary &data_dict,
    Status &error) { … }

void SearchFilterByModuleList::SerializeUnwrapped(
    StructuredData::DictionarySP &options_dict_sp) { … }

StructuredData::ObjectSP SearchFilterByModuleList::SerializeToStructuredData() { … }

//  SearchFilterByModuleListAndCU:
//  Selects a shared library matching a given file spec

SearchFilterByModuleListAndCU::SearchFilterByModuleListAndCU(
    const lldb::TargetSP &target_sp, const FileSpecList &module_list,
    const FileSpecList &cu_list)
    : … { … }

SearchFilterByModuleListAndCU::~SearchFilterByModuleListAndCU() = default;

lldb::SearchFilterSP SearchFilterByModuleListAndCU::CreateFromStructuredData(
    const lldb::TargetSP& target_sp,
    const StructuredData::Dictionary &data_dict,
    Status &error) { … }

StructuredData::ObjectSP
SearchFilterByModuleListAndCU::SerializeToStructuredData() { … }

bool SearchFilterByModuleListAndCU::AddressPasses(Address &address) { … }

bool SearchFilterByModuleListAndCU::CompUnitPasses(FileSpec &fileSpec) { … }

bool SearchFilterByModuleListAndCU::CompUnitPasses(CompileUnit &compUnit) { … }

void SearchFilterByModuleListAndCU::Search(Searcher &searcher) { … }

void SearchFilterByModuleListAndCU::GetDescription(Stream *s) { … }

uint32_t SearchFilterByModuleListAndCU::GetFilterRequiredItems() { … }

void SearchFilterByModuleListAndCU::Dump(Stream *s) const { … }

SearchFilterSP SearchFilterByModuleListAndCU::DoCreateCopy() { … }
llvm/lldb/source/Core/SearchFilter.cpp
