| //===-- 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 moodule 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 ®ex, |
| 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 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 (); |
| |
| 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); |
| |
| uint32_t |
| ResolveSymbolContextForAddress (const Address& so_addr, uint32_t resolve_scope, SymbolContext& sc); |
| |
| //------------------------------------------------------------------ |
| /// 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 |
| |
| 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); |
| |
| |
| friend class ModuleList; |
| friend class ObjectFile; |
| |
| 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_ |