upstream/opnsense-src
1
0
Fork 0
mirror of https://github.com/opnsense/src.git synced 2026-02-28 12:20:54 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions
opnsense-src/include/lldb/Core/Module.h
Ed Maste f21a844f60 Import lldb as of SVN r194122 
Sponsored by:	DARPA, AFRL
2013-11-06 16:48:53 +00:00

1152 lines
46 KiB
C++
Raw Blame History

//===-- Module.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_Module_h_
#define liblldb_Module_h_
#include "lldb/Core/ArchSpec.h"
#include "lldb/Core/UUID.h"
#include "lldb/Host/FileSpec.h"
#include "lldb/Host/Mutex.h"
#include "lldb/Host/TimeValue.h"
#include "lldb/Symbol/ClangASTContext.h"
#include "lldb/Symbol/SymbolContextScope.h"
#include "lldb/Target/PathMappingList.h"
namespace lldb_private {
//----------------------------------------------------------------------
/// @class Module Module.h "lldb/Core/Module.h"
/// @brief A class that describes an executable image and its associated
/// object and symbol files.
///
/// The module is designed to be able to select a single slice of an
/// executable image as it would appear on disk and during program
/// execution.
///
/// Modules control when and if information is parsed according to which
/// accessors are called. For example the object file (ObjectFile)
/// representation will only be parsed if the object file is requested
/// using the Module::GetObjectFile() is called. The debug symbols
/// will only be parsed if the symbol vendor (SymbolVendor) is
/// requested using the Module::GetSymbolVendor() is called.
///
/// The module will parse more detailed information as more queries are
/// made.
//----------------------------------------------------------------------
class Module :
public std::enable_shared_from_this<Module>,
public SymbolContextScope
{
public:
// Static functions that can track the lifetime of module objects.
// This is handy because we might have Module objects that are in
// shared pointers that aren't in the global module list (from
// ModuleList). If this is the case we need to know about it.
// The modules in the global list maintained by these functions
// can be viewed using the "target modules list" command using the
// "--global" (-g for short).
static size_t
GetNumberAllocatedModules ();
static Module *
GetAllocatedModuleAtIndex (size_t idx);
static Mutex *
GetAllocationModuleCollectionMutex();
//------------------------------------------------------------------
/// Construct with file specification and architecture.
///
/// Clients that wish to share modules with other targets should
/// use ModuleList::GetSharedModule().
///
/// @param[in] file_spec
/// The file specification for the on disk repesentation of
/// this executable image.
///
/// @param[in] arch
/// The architecture to set as the current architecture in
/// this module.
///
/// @param[in] object_name
/// The name of an object in a module used to extract a module
/// within a module (.a files and modules that contain multiple
/// architectures).
///
/// @param[in] object_offset
/// The offset within an existing module used to extract a
/// module within a module (.a files and modules that contain
/// multiple architectures).
//------------------------------------------------------------------
Module (const FileSpec& file_spec,
const ArchSpec& arch,
const ConstString *object_name = NULL,
off_t object_offset = 0,
const TimeValue *object_mod_time_ptr = NULL);
Module (const ModuleSpec &module_spec);
//------------------------------------------------------------------
/// Destructor.
//------------------------------------------------------------------
virtual
~Module ();
bool
MatchesModuleSpec (const ModuleSpec &module_ref);
//------------------------------------------------------------------
/// Set the load address for all sections in a module to be the
/// file address plus \a slide.
///
/// Many times a module will be loaded in a target with a constant
/// offset applied to all top level sections. This function can
/// set the load address for all top level sections to be the
/// section file address + offset.
///
/// @param[in] target
/// The target in which to apply the section load addresses.
///
/// @param[in] offset
/// The offset to apply to all file addresses for all top
/// level sections in the object file as each section load
/// address is being set.
///
/// @param[out] changed
/// If any section load addresses were changed in \a target,
/// then \a changed will be set to \b true. Else \a changed
/// will be set to false. This allows this function to be
/// called multiple times on the same module for the same
/// target. If the module hasn't moved, then \a changed will
/// be false and no module updated notification will need to
/// be sent out.
///
/// @return
/// /b True if any sections were successfully loaded in \a target,
/// /b false otherwise.
//------------------------------------------------------------------
bool
SetLoadAddress (Target &target,
lldb::addr_t offset,
bool &changed);
//------------------------------------------------------------------
/// @copydoc SymbolContextScope::CalculateSymbolContext(SymbolContext*)
///
/// @see SymbolContextScope
//------------------------------------------------------------------
virtual void
CalculateSymbolContext (SymbolContext* sc);
virtual lldb::ModuleSP
CalculateSymbolContextModule ();
void
GetDescription (Stream *s,
lldb::DescriptionLevel level = lldb::eDescriptionLevelFull);
//------------------------------------------------------------------
/// Get the module path and object name.
///
/// Modules can refer to object files. In this case the specification
/// is simple and would return the path to the file:
///
/// "/usr/lib/foo.dylib"
///
/// Modules can be .o files inside of a BSD archive (.a file). In
/// this case, the object specification will look like:
///
/// "/usr/lib/foo.a(bar.o)"
///
/// There are many places where logging wants to log this fully
/// qualified specification, so we centralize this functionality
/// here.
///
/// @return
/// The object path + object name if there is one.
//------------------------------------------------------------------
std::string
GetSpecificationDescription () const;
//------------------------------------------------------------------
/// Dump a description of this object to a Stream.
///
/// Dump a description of the contents of this object to the
/// supplied stream \a s. The dumped content will be only what has
/// been loaded or parsed up to this point at which this function
/// is called, so this is a good way to see what has been parsed
/// in a module.
///
/// @param[in] s
/// The stream to which to dump the object descripton.
//------------------------------------------------------------------
void
Dump (Stream *s);
//------------------------------------------------------------------
/// @copydoc SymbolContextScope::DumpSymbolContext(Stream*)
///
/// @see SymbolContextScope
//------------------------------------------------------------------
virtual void
DumpSymbolContext (Stream *s);
//------------------------------------------------------------------
/// Find a symbol in the object file's symbol table.
///
/// @param[in] name
/// The name of the symbol that we are looking for.
///
/// @param[in] symbol_type
/// If set to eSymbolTypeAny, find a symbol of any type that
/// has a name that matches \a name. If set to any other valid
/// SymbolType enumeration value, then search only for
/// symbols that match \a symbol_type.
///
/// @return
/// Returns a valid symbol pointer if a symbol was found,
/// NULL otherwise.
//------------------------------------------------------------------
const Symbol *
FindFirstSymbolWithNameAndType (const ConstString &name,
lldb::SymbolType symbol_type = lldb::eSymbolTypeAny);
size_t
FindSymbolsWithNameAndType (const ConstString &name,
lldb::SymbolType symbol_type,
SymbolContextList &sc_list);
size_t
FindSymbolsMatchingRegExAndType (const RegularExpression &regex,
lldb::SymbolType symbol_type,
SymbolContextList &sc_list);
//------------------------------------------------------------------
/// Find a funciton symbols in the object file's symbol table.
///
/// @param[in] name
/// The name of the symbol that we are looking for.
///
/// @param[in] name_type_mask
/// A mask that has one or more bitwise OR'ed values from the
/// lldb::FunctionNameType enumeration type that indicate what
/// kind of names we are looking for.
///
/// @param[out] sc_list
/// A list to append any matching symbol contexts to.
///
/// @return
/// The number of symbol contexts that were added to \a sc_list
//------------------------------------------------------------------
size_t
FindFunctionSymbols (const ConstString &name,
uint32_t name_type_mask,
SymbolContextList& sc_list);
//------------------------------------------------------------------
/// Find compile units by partial or full path.
///
/// Finds all compile units that match \a path in all of the modules
/// and returns the results in \a sc_list.
///
/// @param[in] path
/// The name of the function we are looking for.
///
/// @param[in] append
/// If \b true, then append any compile units that were found
/// to \a sc_list. If \b false, then the \a sc_list is cleared
/// and the contents of \a sc_list are replaced.
///
/// @param[out] sc_list
/// A symbol context list that gets filled in with all of the
/// matches.
///
/// @return
/// The number of matches added to \a sc_list.
//------------------------------------------------------------------
size_t
FindCompileUnits (const FileSpec &path,
bool append,
SymbolContextList &sc_list);
//------------------------------------------------------------------
/// Find functions by name.
///
/// If the function is an inlined function, it will have a block,
/// representing the inlined function, and the function will be the
/// containing function. If it is not inlined, then the block will
/// be NULL.
///
/// @param[in] name
/// The name of the compile unit we are looking for.
///
/// @param[in] namespace_decl
/// If valid, a namespace to search in.
///
/// @param[in] name_type_mask
/// A bit mask of bits that indicate what kind of names should
/// be used when doing the lookup. Bits include fully qualified
/// names, base names, C++ methods, or ObjC selectors.
/// See FunctionNameType for more details.
///
/// @param[in] append
/// If \b true, any matches will be appended to \a sc_list, else
/// matches replace the contents of \a sc_list.
///
/// @param[out] sc_list
/// A symbol context list that gets filled in with all of the
/// matches.
///
/// @return
/// The number of matches added to \a sc_list.
//------------------------------------------------------------------
size_t
FindFunctions (const ConstString &name,
const ClangNamespaceDecl *namespace_decl,
uint32_t name_type_mask,
bool symbols_ok,
bool inlines_ok,
bool append,
SymbolContextList& sc_list);
//------------------------------------------------------------------
/// Find functions by name.
///
/// If the function is an inlined function, it will have a block,
/// representing the inlined function, and the function will be the
/// containing function. If it is not inlined, then the block will
/// be NULL.
///
/// @param[in] regex
/// A regular expression to use when matching the name.
///
/// @param[in] append
/// If \b true, any matches will be appended to \a sc_list, else
/// matches replace the contents of \a sc_list.
///
/// @param[out] sc_list
/// A symbol context list that gets filled in with all of the
/// matches.
///
/// @return
/// The number of matches added to \a sc_list.
//------------------------------------------------------------------
size_t
FindFunctions (const RegularExpression& regex,
bool symbols_ok,
bool inlines_ok,
bool append,
SymbolContextList& sc_list);
//------------------------------------------------------------------
/// Find addresses by file/line
///
/// @param[in] target_sp
/// The target the addresses are desired for.
///
/// @param[in] file
/// Source file to locate.
///
/// @param[in] line
/// Source line to locate.
///
/// @param[in] function
/// Optional filter function. Addresses within this function will be
/// added to the 'local' list. All others will be added to the 'extern' list.
///
/// @param[out] output_local
/// All matching addresses within 'function'
///
/// @param[out] output_extern
/// All matching addresses not within 'function'
void FindAddressesForLine (const lldb::TargetSP target_sp,
const FileSpec &file, uint32_t line,
Function *function,
std::vector<Address> &output_local, std::vector<Address> &output_extern);
//------------------------------------------------------------------
/// Find global and static variables by name.
///
/// @param[in] name
/// The name of the global or static variable we are looking
/// for.
///
/// @param[in] namespace_decl
/// If valid, a namespace to search in.
///
/// @param[in] append
/// If \b true, any matches will be appended to \a
/// variable_list, else matches replace the contents of
/// \a variable_list.
///
/// @param[in] max_matches
/// Allow the number of matches to be limited to \a
/// max_matches. Specify UINT32_MAX to get all possible matches.
///
/// @param[in] variable_list
/// A list of variables that gets the matches appended to (if
/// \a append it \b true), or replace (if \a append is \b false).
///
/// @return
/// The number of matches added to \a variable_list.
//------------------------------------------------------------------
size_t
FindGlobalVariables (const ConstString &name,
const ClangNamespaceDecl *namespace_decl,
bool append,
size_t max_matches,
VariableList& variable_list);
//------------------------------------------------------------------
/// Find global and static variables by regular exression.
///
/// @param[in] regex
/// A regular expression to use when matching the name.
///
/// @param[in] append
/// If \b true, any matches will be appended to \a
/// variable_list, else matches replace the contents of
/// \a variable_list.
///
/// @param[in] max_matches
/// Allow the number of matches to be limited to \a
/// max_matches. Specify UINT32_MAX to get all possible matches.
///
/// @param[in] variable_list
/// A list of variables that gets the matches appended to (if
/// \a append it \b true), or replace (if \a append is \b false).
///
/// @return
/// The number of matches added to \a variable_list.
//------------------------------------------------------------------
size_t
FindGlobalVariables (const RegularExpression& regex,
bool append,
size_t max_matches,
VariableList& variable_list);
//------------------------------------------------------------------
/// Find types by name.
///
/// Type lookups in modules go through the SymbolVendor (which will
/// use one or more SymbolFile subclasses). The SymbolFile needs to
/// be able to lookup types by basename and not the fully qualified
/// typename. This allows the type accelerator tables to stay small,
/// even with heavily templatized C++. The type search will then
/// narrow down the search results. If "exact_match" is true, then
/// the type search will only match exact type name matches. If
/// "exact_match" is false, the type will match as long as the base
/// typename matches and as long as any immediate containing
/// namespaces/class scopes that are specified match. So to search
/// for a type "d" in "b::c", the name "b::c::d" can be specified
/// and it will match any class/namespace "b" which contains a
/// class/namespace "c" which contains type "d". We do this to
/// allow users to not always have to specify complete scoping on
/// all expressions, but it also allows for exact matching when
/// required.
///
/// @param[in] sc
/// A symbol context that scopes where to extract a type list
/// from.
///
/// @param[in] type_name
/// The name of the type we are looking for that is a fully
/// or partially qualfieid type name.
///
/// @param[in] exact_match
/// If \b true, \a type_name is fully qualifed and must match
/// exactly. If \b false, \a type_name is a partially qualfied
/// name where the leading namespaces or classes can be
/// omitted to make finding types that a user may type
/// easier.
///
/// @param[out] type_list
/// A type list gets populated with any matches.
///
/// @return
/// The number of matches added to \a type_list.
//------------------------------------------------------------------
size_t
FindTypes (const SymbolContext& sc,
const ConstString &type_name,
bool exact_match,
size_t max_matches,
TypeList& types);
lldb::TypeSP
FindFirstType (const SymbolContext& sc,
const ConstString &type_name,
bool exact_match);
//------------------------------------------------------------------
/// Find types by name that are in a namespace. This function is
/// used by the expression parser when searches need to happen in
/// an exact namespace scope.
///
/// @param[in] sc
/// A symbol context that scopes where to extract a type list
/// from.
///
/// @param[in] type_name
/// The name of a type within a namespace that should not include
/// any qualifying namespaces (just a type basename).
///
/// @param[in] namespace_decl
/// The namespace declaration that this type must exist in.
///
/// @param[out] type_list
/// A type list gets populated with any matches.
///
/// @return
/// The number of matches added to \a type_list.
//------------------------------------------------------------------
size_t
FindTypesInNamespace (const SymbolContext& sc,
const ConstString &type_name,
const ClangNamespaceDecl *namespace_decl,
size_t max_matches,
TypeList& type_list);
//------------------------------------------------------------------
/// Get const accessor for the module architecture.
///
/// @return
/// A const reference to the architecture object.
//------------------------------------------------------------------
const ArchSpec&
GetArchitecture () const;
//------------------------------------------------------------------
/// Get const accessor for the module file specification.
///
/// This function returns the file for the module on the host system
/// that is running LLDB. This can differ from the path on the
/// platform since we might be doing remote debugging.
///
/// @return
/// A const reference to the file specification object.
//------------------------------------------------------------------
const FileSpec &
GetFileSpec () const
{
return m_file;
}
//------------------------------------------------------------------
/// Get accessor for the module platform file specification.
///
/// Platform file refers to the path of the module as it is known on
/// the remote system on which it is being debugged. For local
/// debugging this is always the same as Module::GetFileSpec(). But
/// remote debugging might mention a file "/usr/lib/liba.dylib"
/// which might be locally downloaded and cached. In this case the
/// platform file could be something like:
/// "/tmp/lldb/platform-cache/remote.host.computer/usr/lib/liba.dylib"
/// The file could also be cached in a local developer kit directory.
///
/// @return
/// A const reference to the file specification object.
//------------------------------------------------------------------
const FileSpec &
GetPlatformFileSpec () const
{
if (m_platform_file)
return m_platform_file;
return m_file;
}
void
SetPlatformFileSpec (const FileSpec &file)
{
m_platform_file = file;
}
const FileSpec &
GetSymbolFileFileSpec () const
{
return m_symfile_spec;
}
void
SetSymbolFileFileSpec (const FileSpec &file);
const TimeValue &
GetModificationTime () const
{
return m_mod_time;
}
const TimeValue &
GetObjectModificationTime () const
{
return m_object_mod_time;
}
void
SetObjectModificationTime (const TimeValue &mod_time)
{
m_mod_time = mod_time;
}
//------------------------------------------------------------------
/// Tells whether this module is capable of being the main executable
/// for a process.
///
/// @return
/// \b true if it is, \b false otherwise.
//------------------------------------------------------------------
bool
IsExecutable ();
//------------------------------------------------------------------
/// Tells whether this module has been loaded in the target passed in.
/// This call doesn't distinguish between whether the module is loaded
/// by the dynamic loader, or by a "target module add" type call.
///
/// @param[in] target
/// The target to check whether this is loaded in.
///
/// @return
/// \b true if it is, \b false otherwise.
//------------------------------------------------------------------
bool
IsLoadedInTarget (Target *target);
bool
LoadScriptingResourceInTarget (Target *target,
Error& error,
Stream* feedback_stream = NULL);
//------------------------------------------------------------------
/// Get the number of compile units for this module.
///
/// @return
/// The number of compile units that the symbol vendor plug-in
/// finds.
//------------------------------------------------------------------
size_t
GetNumCompileUnits();
lldb::CompUnitSP
GetCompileUnitAtIndex (size_t idx);
const ConstString &
GetObjectName() const;
uint64_t
GetObjectOffset() const
{
return m_object_offset;
}
//------------------------------------------------------------------
/// Get the object file representation for the current architecture.
///
/// If the object file has not been located or parsed yet, this
/// function will find the best ObjectFile plug-in that can parse
/// Module::m_file.
///
/// @return
/// If Module::m_file does not exist, or no plug-in was found
/// that can parse the file, or the object file doesn't contain
/// the current architecture in Module::m_arch, NULL will be
/// returned, else a valid object file interface will be
/// returned. The returned pointer is owned by this object and
/// remains valid as long as the object is around.
//------------------------------------------------------------------
virtual ObjectFile *
GetObjectFile ();
//------------------------------------------------------------------
/// Get the unified section list for the module. This is the section
/// list created by the module's object file and any debug info and
/// symbol files created by the symbol vendor.
///
/// If the symbol vendor has not been loaded yet, this function
/// will return the section list for the object file.
///
/// @return
/// Unified module section list.
//------------------------------------------------------------------
virtual SectionList *
GetSectionList ();
uint32_t
GetVersion (uint32_t *versions, uint32_t num_versions);
// Load an object file from memory.
ObjectFile *
GetMemoryObjectFile (const lldb::ProcessSP &process_sp,
lldb::addr_t header_addr,
Error &error);
//------------------------------------------------------------------
/// Get the symbol vendor interface for the current architecture.
///
/// If the symbol vendor file has not been located yet, this
/// function will find the best SymbolVendor plug-in that can
/// use the current object file.
///
/// @return
/// If this module does not have a valid object file, or no
/// plug-in can be found that can use the object file, NULL will
/// be returned, else a valid symbol vendor plug-in interface
/// will be returned. The returned pointer is owned by this
/// object and remains valid as long as the object is around.
//------------------------------------------------------------------
virtual SymbolVendor*
GetSymbolVendor(bool can_create = true,
lldb_private::Stream *feedback_strm = NULL);
//------------------------------------------------------------------
/// Get accessor the type list for this module.
///
/// @return
/// A valid type list pointer, or NULL if there is no valid
/// symbol vendor for this module.
//------------------------------------------------------------------
TypeList*
GetTypeList ();
//------------------------------------------------------------------
/// Get a pointer to the UUID value contained in this object.
///
/// If the executable image file doesn't not have a UUID value built
/// into the file format, an MD5 checksum of the entire file, or
/// slice of the file for the current architecture should be used.
///
/// @return
/// A const pointer to the internal copy of the UUID value in
/// this module if this module has a valid UUID value, NULL
/// otherwise.
//------------------------------------------------------------------
const lldb_private::UUID &
GetUUID ();
//------------------------------------------------------------------
/// A debugging function that will cause everything in a module to
/// be parsed.
///
/// All compile units will be pasred, along with all globals and
/// static variables and all functions for those compile units.
/// All types, scopes, local variables, static variables, global
/// variables, and line tables will be parsed. This can be used
/// prior to dumping a module to see a complete list of the
/// resuling debug information that gets parsed, or as a debug
/// function to ensure that the module can consume all of the
/// debug data the symbol vendor provides.
//------------------------------------------------------------------
void
ParseAllDebugSymbols();
bool
ResolveFileAddress (lldb::addr_t vm_addr, Address& so_addr);
//------------------------------------------------------------------
/// Resolve the symbol context for the given address.
///
/// Tries to resolve the matching symbol context based on a lookup
/// from the current symbol vendor. If the lazy lookup fails,
/// an attempt is made to parse the eh_frame section to handle
/// stripped symbols. If this fails, an attempt is made to resolve
/// the symbol to the previous address to handle the case of a
/// function with a tail call.
///
/// Use properties of the modified SymbolContext to inspect any
/// resolved target, module, compilation unit, symbol, function,
/// function block or line entry. Use the return value to determine
/// which of these properties have been modified.
///
/// @param[in] so_addr
/// A load address to resolve.
///
/// @param[in] resolve_scope
/// The scope that should be resolved (see SymbolContext::Scope).
/// A combination of flags from the enumeration SymbolContextItem
/// requesting a resolution depth. Note that the flags that are
/// actually resolved may be a superset of the requested flags.
/// For instance, eSymbolContextSymbol requires resolution of
/// eSymbolContextModule, and eSymbolContextFunction requires
/// eSymbolContextSymbol.
///
/// @param[out] sc
/// The SymbolContext that is modified based on symbol resolution.
///
/// @param[in] resolve_tail_call_address
/// Determines if so_addr should resolve to a symbol in the case
/// of a function whose last instruction is a call. In this case,
/// the PC can be one past the address range of the function.
///
/// @return
/// The scope that has been resolved (see SymbolContext::Scope).
///
/// @see SymbolContext::Scope
//------------------------------------------------------------------
uint32_t
ResolveSymbolContextForAddress (const Address& so_addr, uint32_t resolve_scope,
SymbolContext& sc, bool resolve_tail_call_address = false);
//------------------------------------------------------------------
/// Resolve items in the symbol context for a given file and line.
///
/// Tries to resolve \a file_path and \a line to a list of matching
/// symbol contexts.
///
/// The line table entries contains addresses that can be used to
/// further resolve the values in each match: the function, block,
/// symbol. Care should be taken to minimize the amount of
/// information that is requested to only what is needed --
/// typically the module, compile unit, line table and line table
/// entry are sufficient.
///
/// @param[in] file_path
/// A path to a source file to match. If \a file_path does not
/// specify a directory, then this query will match all files
/// whose base filename matches. If \a file_path does specify
/// a directory, the fullpath to the file must match.
///
/// @param[in] line
/// The source line to match, or zero if just the compile unit
/// should be resolved.
///
/// @param[in] check_inlines
/// Check for inline file and line number matches. This option
/// should be used sparingly as it will cause all line tables
/// for every compile unit to be parsed and searched for
/// matching inline file entries.
///
/// @param[in] resolve_scope
/// The scope that should be resolved (see
/// SymbolContext::Scope).
///
/// @param[out] sc_list
/// A symbol context list that gets matching symbols contexts
/// appended to.
///
/// @return
/// The number of matches that were added to \a sc_list.
///
/// @see SymbolContext::Scope
//------------------------------------------------------------------
uint32_t
ResolveSymbolContextForFilePath (const char *file_path, uint32_t line, bool check_inlines, uint32_t resolve_scope, SymbolContextList& sc_list);
//------------------------------------------------------------------
/// Resolve items in the symbol context for a given file and line.
///
/// Tries to resolve \a file_spec and \a line to a list of matching
/// symbol contexts.
///
/// The line table entries contains addresses that can be used to
/// further resolve the values in each match: the function, block,
/// symbol. Care should be taken to minimize the amount of
/// information that is requested to only what is needed --
/// typically the module, compile unit, line table and line table
/// entry are sufficient.
///
/// @param[in] file_spec
/// A file spec to a source file to match. If \a file_path does
/// not specify a directory, then this query will match all
/// files whose base filename matches. If \a file_path does
/// specify a directory, the fullpath to the file must match.
///
/// @param[in] line
/// The source line to match, or zero if just the compile unit
/// should be resolved.
///
/// @param[in] check_inlines
/// Check for inline file and line number matches. This option
/// should be used sparingly as it will cause all line tables
/// for every compile unit to be parsed and searched for
/// matching inline file entries.
///
/// @param[in] resolve_scope
/// The scope that should be resolved (see
/// SymbolContext::Scope).
///
/// @param[out] sc_list
/// A symbol context list that gets filled in with all of the
/// matches.
///
/// @return
/// A integer that contains SymbolContext::Scope bits set for
/// each item that was successfully resolved.
///
/// @see SymbolContext::Scope
//------------------------------------------------------------------
uint32_t
ResolveSymbolContextsForFileSpec (const FileSpec &file_spec, uint32_t line, bool check_inlines, uint32_t resolve_scope, SymbolContextList& sc_list);
void
SetFileSpecAndObjectName (const FileSpec &file,
const ConstString &object_name);
bool
GetIsDynamicLinkEditor () const
{
return m_is_dynamic_loader_module;
}
void
SetIsDynamicLinkEditor (bool b)
{
m_is_dynamic_loader_module = b;
}
ClangASTContext &
GetClangASTContext ();
// Special error functions that can do printf style formatting that will prepend the message with
// something appropriate for this module (like the architecture, path and object name (if any)).
// This centralizes code so that everyone doesn't need to format their error and log messages on
// their own and keeps the output a bit more consistent.
void
LogMessage (Log *log, const char *format, ...) __attribute__ ((format (printf, 3, 4)));
void
LogMessageVerboseBacktrace (Log *log, const char *format, ...) __attribute__ ((format (printf, 3, 4)));
void
ReportWarning (const char *format, ...) __attribute__ ((format (printf, 2, 3)));
void
ReportError (const char *format, ...) __attribute__ ((format (printf, 2, 3)));
// Only report an error once when the module is first detected to be modified
// so we don't spam the console with many messages.
void
ReportErrorIfModifyDetected (const char *format, ...) __attribute__ ((format (printf, 2, 3)));
//------------------------------------------------------------------
// Return true if the file backing this module has changed since the
// module was originally created since we saved the intial file
// modification time when the module first gets created.
//------------------------------------------------------------------
bool
FileHasChanged () const;
//------------------------------------------------------------------
// SymbolVendor, SymbolFile and ObjectFile member objects should
// lock the module mutex to avoid deadlocks.
//------------------------------------------------------------------
Mutex &
GetMutex () const
{
return m_mutex;
}
PathMappingList &
GetSourceMappingList ()
{
return m_source_mappings;
}
const PathMappingList &
GetSourceMappingList () const
{
return m_source_mappings;
}
//------------------------------------------------------------------
/// Finds a source file given a file spec using the module source
/// path remappings (if any).
///
/// Tries to resolve \a orig_spec by checking the module source path
/// remappings. It makes sure the file exists, so this call can be
/// expensive if the remappings are on a network file system, so
/// use this function sparingly (not in a tight debug info parsing
/// loop).
///
/// @param[in] orig_spec
/// The original source file path to try and remap.
///
/// @param[out] new_spec
/// The newly remapped filespec that is guaranteed to exist.
///
/// @return
/// /b true if \a orig_spec was successfully located and
/// \a new_spec is filled in with an existing file spec,
/// \b false otherwise.
//------------------------------------------------------------------
bool
FindSourceFile (const FileSpec &orig_spec, FileSpec &new_spec) const;
//------------------------------------------------------------------
/// Remaps a source file given \a path into \a new_path.
///
/// Remaps \a path if any source remappings match. This function
/// does NOT stat the file system so it can be used in tight loops
/// where debug info is being parsed.
///
/// @param[in] path
/// The original source file path to try and remap.
///
/// @param[out] new_path
/// The newly remapped filespec that is may or may not exist.
///
/// @return
/// /b true if \a path was successfully located and \a new_path
/// is filled in with a new source path, \b false otherwise.
//------------------------------------------------------------------
bool
RemapSourceFile (const char *path, std::string &new_path) const;
//------------------------------------------------------------------
/// Prepare to do a function name lookup.
///
/// Looking up functions by name can be a tricky thing. LLDB requires
/// that accelerator tables contain full names for functions as well
/// as function basenames which include functions, class methods and
/// class functions. When the user requests that an action use a
/// function by name, we are sometimes asked to automatically figure
/// out what a name could possibly map to. A user might request a
/// breakpoint be set on "count". If no options are supplied to limit
/// the scope of where to search for count, we will by default match
/// any function names named "count", all class and instance methods
/// named "count" (no matter what the namespace or contained context)
/// and any selectors named "count". If a user specifies "a::b" we
/// will search for the basename "b", and then prune the results that
/// don't match "a::b" (note that "c::a::b" and "d::e::a::b" will
/// match a query of "a::b".
///
/// @param[in] name
/// The user supplied name to use in the lookup
///
/// @param[in] name_type_mask
/// The mask of bits from lldb::FunctionNameType enumerations
/// that tell us what kind of name we are looking for.
///
/// @param[out] lookup_name
/// The actual name that will be used when calling
/// SymbolVendor::FindFunctions() or Symtab::FindFunctionSymbols()
///
/// @param[out] lookup_name_type_mask
/// The actual name mask that should be used in the calls to
/// SymbolVendor::FindFunctions() or Symtab::FindFunctionSymbols()
///
/// @param[out] match_name_after_lookup
/// A boolean that indicates if we need to iterate through any
/// match results obtained from SymbolVendor::FindFunctions() or
/// Symtab::FindFunctionSymbols() to see if the name contains
/// \a name. For example if \a name is "a::b", this function will
/// return a \a lookup_name of "b", with \a match_name_after_lookup
/// set to true to indicate any matches will need to be checked
/// to make sure they contain \a name.
//------------------------------------------------------------------
static void
PrepareForFunctionNameLookup (const ConstString &name,
uint32_t name_type_mask,
ConstString &lookup_name,
uint32_t &lookup_name_type_mask,
bool &match_name_after_lookup);
protected:
//------------------------------------------------------------------
// Member Variables
//------------------------------------------------------------------
mutable Mutex m_mutex; ///< A mutex to keep this object happy in multi-threaded environments.
TimeValue m_mod_time; ///< The modification time for this module when it was created.
ArchSpec m_arch; ///< The architecture for this module.
lldb_private::UUID m_uuid; ///< Each module is assumed to have a unique identifier to help match it up to debug symbols.
FileSpec m_file; ///< The file representation on disk for this module (if there is one).
FileSpec m_platform_file;///< The path to the module on the platform on which it is being debugged
FileSpec m_symfile_spec; ///< If this path is valid, then this is the file that _will_ be used as the symbol file for this module
ConstString m_object_name; ///< The name an object within this module that is selected, or empty of the module is represented by \a m_file.
uint64_t m_object_offset;
TimeValue m_object_mod_time;
lldb::ObjectFileSP m_objfile_sp; ///< A shared pointer to the object file parser for this module as it may or may not be shared with the SymbolFile
std::unique_ptr<SymbolVendor> m_symfile_ap; ///< A pointer to the symbol vendor for this module.
ClangASTContext m_ast; ///< The AST context for this module.
PathMappingList m_source_mappings; ///< Module specific source remappings for when you have debug info for a module that doesn't match where the sources currently are
std::unique_ptr<lldb_private::SectionList> m_sections_ap; ///< Unified section list for module that is used by the ObjectFile and and ObjectFile instances for the debug info
bool m_did_load_objfile:1,
m_did_load_symbol_vendor:1,
m_did_parse_uuid:1,
m_did_init_ast:1,
m_is_dynamic_loader_module:1;
mutable bool m_file_has_changed:1,
m_first_file_changed_log:1; /// See if the module was modified after it was initially opened.
//------------------------------------------------------------------
/// Resolve a file or load virtual address.
///
/// Tries to resolve \a vm_addr as a file address (if \a
/// vm_addr_is_file_addr is true) or as a load address if \a
/// vm_addr_is_file_addr is false) in the symbol vendor.
/// \a resolve_scope indicates what clients wish to resolve
/// and can be used to limit the scope of what is parsed.
///
/// @param[in] vm_addr
/// The load virtual address to resolve.
///
/// @param[in] vm_addr_is_file_addr
/// If \b true, \a vm_addr is a file address, else \a vm_addr
/// if a load address.
///
/// @param[in] resolve_scope
/// The scope that should be resolved (see
/// SymbolContext::Scope).
///
/// @param[out] so_addr
/// The section offset based address that got resolved if
/// any bits are returned.
///
/// @param[out] sc
// The symbol context that has objects filled in. Each bit
/// in the \a resolve_scope pertains to a member in the \a sc.
///
/// @return
/// A integer that contains SymbolContext::Scope bits set for
/// each item that was successfully resolved.
///
/// @see SymbolContext::Scope
//------------------------------------------------------------------
uint32_t
ResolveSymbolContextForAddress (lldb::addr_t vm_addr,
bool vm_addr_is_file_addr,
uint32_t resolve_scope,
Address& so_addr,
SymbolContext& sc);
void
SymbolIndicesToSymbolContextList (Symtab *symtab,
std::vector<uint32_t> &symbol_indexes,
SymbolContextList &sc_list);
bool
SetArchitecture (const ArchSpec &new_arch);
SectionList *
GetUnifiedSectionList();
friend class ModuleList;
friend class ObjectFile;
friend class SymbolFile;
private:
size_t
FindTypes_Impl (const SymbolContext& sc,
const ConstString &name,
const ClangNamespaceDecl *namespace_decl,
bool append,
size_t max_matches,
TypeList& types);
DISALLOW_COPY_AND_ASSIGN (Module);
};
} // namespace lldb_private
#endif // liblldb_Module_h_
Reference in a new issue View git blame Copy permalink