/usr/lib/llvm-3.4/include/lldb/Core/SearchFilter.h is in liblldb-3.4-dev 1:3.4.2-13.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 | //===-- SearchFilter.h ------------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef liblldb_SearchFilter_h_
#define liblldb_SearchFilter_h_
// C Includes
// C++ Includes
// Other libraries and framework includes
// Project includes
#include "lldb/lldb-private.h"
#include "lldb/Core/FileSpecList.h"
namespace lldb_private {
//----------------------------------------------------------------------
/// @class Searcher SearchFilter.h "lldb/Core/SearchFilter.h"
/// @brief Class that is driven by the SearchFilter to search the
/// SymbolContext space of the target program.
//----------------------------------------------------------------------
//----------------------------------------------------------------------
/// General Outline:
/// Provides the callback and search depth for the SearchFilter search.
//----------------------------------------------------------------------
class Searcher
{
public:
typedef enum {
eCallbackReturnStop = 0, // Stop the iteration
eCallbackReturnContinue, // Continue the iteration
eCallbackReturnPop // Pop one level up and continue iterating
} CallbackReturn;
typedef enum {
eDepthTarget,
eDepthModule,
eDepthCompUnit,
eDepthFunction,
eDepthBlock,
eDepthAddress
} Depth;
Searcher ();
virtual ~Searcher ();
virtual CallbackReturn
SearchCallback (SearchFilter &filter,
SymbolContext &context,
Address *addr,
bool complete) = 0;
virtual Depth
GetDepth () = 0;
//------------------------------------------------------------------
/// Prints a canonical description for the searcher to the stream \a s.
///
/// @param[in] s
/// Stream to which the output is copied.
//------------------------------------------------------------------
virtual void
GetDescription(Stream *s);
};
//----------------------------------------------------------------------
/// @class SearchFilter SearchFilter.h "lldb/Core/SearchFilter.h"
/// @brief Class descends through the SymbolContext space of the target,
/// applying a filter at each stage till it reaches the depth specified by
/// the GetDepth method of the searcher, and calls its callback at that point.
//----------------------------------------------------------------------
//----------------------------------------------------------------------
/// General Outline:
/// Provides the callback and search depth for the SearchFilter search.
///
/// The search is done by cooperation between the search filter and the searcher.
/// The search filter does the heavy work of recursing through the SymbolContext
/// space of the target program's symbol space. The Searcher specifies the depth
/// at which it wants its callback to be invoked. Note that since the resolution
/// of the Searcher may be greater than that of the SearchFilter, before the
/// Searcher qualifies an address it should pass it to "AddressPasses."
/// The default implementation is "Everything Passes."
//----------------------------------------------------------------------
class SearchFilter
{
public:
//------------------------------------------------------------------
/// The basic constructor takes a Target, which gives the space to search.
///
/// @param[in] target
/// The Target that provides the module list to search.
//------------------------------------------------------------------
SearchFilter (const lldb::TargetSP &target_sp);
SearchFilter (const SearchFilter& rhs);
virtual
~SearchFilter ();
const SearchFilter&
operator=(const SearchFilter& rhs);
//------------------------------------------------------------------
/// Call this method with a file spec to see if that spec passes the filter.
///
/// @param[in] spec
/// The file spec to check against the filter.
/// @return
/// \b true if \a spec passes, and \b false otherwise.
//------------------------------------------------------------------
virtual bool
ModulePasses (const FileSpec &spec);
//------------------------------------------------------------------
/// Call this method with a Module to see if that module passes the filter.
///
/// @param[in] module
/// The Module to check against the filter.
///
/// @return
/// \b true if \a module passes, and \b false otherwise.
//------------------------------------------------------------------
virtual bool
ModulePasses (const lldb::ModuleSP &module_sp);
//------------------------------------------------------------------
/// Call this method with a Address to see if \a address passes the filter.
///
/// @param[in] addr
/// The address to check against the filter.
///
/// @return
/// \b true if \a address passes, and \b false otherwise.
//------------------------------------------------------------------
virtual bool
AddressPasses (Address &addr);
//------------------------------------------------------------------
/// Call this method with a FileSpec to see if \a file spec passes the filter
/// as the name of a compilation unit.
///
/// @param[in] fileSpec
/// The file spec to check against the filter.
///
/// @return
/// \b true if \a file spec passes, and \b false otherwise.
//------------------------------------------------------------------
virtual bool
CompUnitPasses (FileSpec &fileSpec);
//------------------------------------------------------------------
/// Call this method with a CompileUnit to see if \a comp unit passes the filter.
///
/// @param[in] compUnit
/// The CompileUnit to check against the filter.
///
/// @return
/// \b true if \a Comp Unit passes, and \b false otherwise.
//------------------------------------------------------------------
virtual bool
CompUnitPasses (CompileUnit &compUnit);
//------------------------------------------------------------------
/// Call this method to do the search using the Searcher.
///
/// @param[in] searcher
/// The searcher to drive with this search.
///
//------------------------------------------------------------------
virtual void
Search (Searcher &searcher);
//------------------------------------------------------------------
/// Call this method to do the search using the Searcher in the module list
/// \a modules.
///
/// @param[in] searcher
/// The searcher to drive with this search.
///
/// @param[in] modules
/// The module list within which to restrict the search.
///
//------------------------------------------------------------------
virtual void
SearchInModuleList (Searcher &searcher, ModuleList &modules);
//------------------------------------------------------------------
/// This determines which items are REQUIRED for the filter to pass.
/// For instance, if you are filtering by Compilation Unit, obviously
/// symbols that have no compilation unit can't pass So return eSymbolContextCU
/// and search callbacks can then short cut the search to avoid looking at
/// things that obviously won't pass.
///
/// @return
/// The required elements for the search, which is an or'ed together
/// set of lldb:SearchContextItem enum's.
///
//------------------------------------------------------------------
virtual uint32_t
GetFilterRequiredItems ();
//------------------------------------------------------------------
/// Prints a canonical description for the search filter to the stream \a s.
///
/// @param[in] s
/// Stream to which the output is copied.
//------------------------------------------------------------------
virtual void
GetDescription(Stream *s);
//------------------------------------------------------------------
/// Standard "Dump" method. At present it does nothing.
//------------------------------------------------------------------
virtual void
Dump (Stream *s) const;
protected:
// These are utility functions to assist with the search iteration. They are used by the
// default Search method.
Searcher::CallbackReturn
DoModuleIteration (const SymbolContext &context,
Searcher &searcher);
Searcher::CallbackReturn
DoModuleIteration (const lldb::ModuleSP& module_sp,
Searcher &searcher);
Searcher::CallbackReturn
DoCUIteration (const lldb::ModuleSP& module_sp,
const SymbolContext &context,
Searcher &searcher);
Searcher::CallbackReturn
DoFunctionIteration (Function *function,
const SymbolContext &context,
Searcher &searcher);
lldb::TargetSP m_target_sp; // Every filter has to be associated with a target for
// now since you need a starting place for the search.
};
//----------------------------------------------------------------------
/// @class SearchFilterForNonModuleSpecificSearches SearchFilter.h "lldb/Core/SearchFilter.h"
/// @brief This is a SearchFilter that searches through all modules. It also consults the Target::ModuleIsExcludedForNonModuleSpecificSearches.
//----------------------------------------------------------------------
class SearchFilterForNonModuleSpecificSearches :
public SearchFilter
{
public:
SearchFilterForNonModuleSpecificSearches (const lldb::TargetSP &targetSP) : SearchFilter(targetSP) {}
~SearchFilterForNonModuleSpecificSearches () {}
virtual bool
ModulePasses (const FileSpec &module_spec);
virtual bool
ModulePasses (const lldb::ModuleSP &module_sp);
};
//----------------------------------------------------------------------
/// @class SearchFilterByModule SearchFilter.h "lldb/Core/SearchFilter.h"
/// @brief This is a SearchFilter that restricts the search to a given module.
//----------------------------------------------------------------------
class SearchFilterByModule :
public SearchFilter
{
public:
//------------------------------------------------------------------
/// The basic constructor takes a Target, which gives the space to search,
/// and the module to restrict the search to.
///
/// @param[in] target
/// The Target that provides the module list to search.
///
/// @param[in] module
/// The Module that limits the search.
//------------------------------------------------------------------
SearchFilterByModule (const lldb::TargetSP &targetSP,
const FileSpec &module);
SearchFilterByModule (const SearchFilterByModule& rhs);
virtual
~SearchFilterByModule ();
const SearchFilterByModule&
operator=(const SearchFilterByModule& rhs);
virtual bool
ModulePasses (const lldb::ModuleSP &module_sp);
virtual bool
ModulePasses (const FileSpec &spec);
virtual bool
AddressPasses (Address &address);
virtual bool
CompUnitPasses (FileSpec &fileSpec);
virtual bool
CompUnitPasses (CompileUnit &compUnit);
virtual void
GetDescription(Stream *s);
virtual uint32_t
GetFilterRequiredItems ();
virtual void
Dump (Stream *s) const;
virtual void
Search (Searcher &searcher);
private:
FileSpec m_module_spec;
};
class SearchFilterByModuleList :
public SearchFilter
{
public:
//------------------------------------------------------------------
/// The basic constructor takes a Target, which gives the space to search,
/// and the module list to restrict the search to.
///
/// @param[in] target
/// The Target that provides the module list to search.
///
/// @param[in] module
/// The Module that limits the search.
//------------------------------------------------------------------
SearchFilterByModuleList (const lldb::TargetSP &targetSP,
const FileSpecList &module_list);
SearchFilterByModuleList (const SearchFilterByModuleList& rhs);
virtual
~SearchFilterByModuleList ();
const SearchFilterByModuleList&
operator=(const SearchFilterByModuleList& rhs);
virtual bool
ModulePasses (const lldb::ModuleSP &module_sp);
virtual bool
ModulePasses (const FileSpec &spec);
virtual bool
AddressPasses (Address &address);
virtual bool
CompUnitPasses (FileSpec &fileSpec);
virtual bool
CompUnitPasses (CompileUnit &compUnit);
virtual void
GetDescription(Stream *s);
virtual uint32_t
GetFilterRequiredItems ();
virtual void
Dump (Stream *s) const;
virtual void
Search (Searcher &searcher);
private:
FileSpecList m_module_spec_list;
};
class SearchFilterByModuleListAndCU :
public SearchFilterByModuleList
{
public:
//------------------------------------------------------------------
/// The basic constructor takes a Target, which gives the space to search,
/// and the module list to restrict the search to.
///
/// @param[in] target
/// The Target that provides the module list to search.
///
/// @param[in] module
/// The Module that limits the search.
//------------------------------------------------------------------
SearchFilterByModuleListAndCU (const lldb::TargetSP &targetSP,
const FileSpecList &module_list,
const FileSpecList &cu_list);
SearchFilterByModuleListAndCU (const SearchFilterByModuleListAndCU& rhs);
virtual
~SearchFilterByModuleListAndCU ();
const SearchFilterByModuleListAndCU&
operator=(const SearchFilterByModuleListAndCU& rhs);
virtual bool
AddressPasses (Address &address);
virtual bool
CompUnitPasses (FileSpec &fileSpec);
virtual bool
CompUnitPasses (CompileUnit &compUnit);
virtual void
GetDescription(Stream *s);
virtual uint32_t
GetFilterRequiredItems ();
virtual void
Dump (Stream *s) const;
virtual void
Search (Searcher &searcher);
private:
FileSpecList m_module_spec_list;
FileSpecList m_cu_spec_list;
};
} // namespace lldb_private
#endif // liblldb_SearchFilter_h_
|