317 lines
12 KiB
C++
317 lines
12 KiB
C++
//===-- SBModule.h ----------------------------------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLDB_SBModule_h_
|
|
#define LLDB_SBModule_h_
|
|
|
|
#include "lldb/API/SBDefines.h"
|
|
#include "lldb/API/SBError.h"
|
|
#include "lldb/API/SBSection.h"
|
|
#include "lldb/API/SBSymbolContext.h"
|
|
#include "lldb/API/SBValueList.h"
|
|
|
|
namespace lldb {
|
|
|
|
class LLDB_API SBModule {
|
|
public:
|
|
SBModule();
|
|
|
|
SBModule(const SBModule &rhs);
|
|
|
|
SBModule(const SBModuleSpec &module_spec);
|
|
|
|
const SBModule &operator=(const SBModule &rhs);
|
|
|
|
SBModule(lldb::SBProcess &process, lldb::addr_t header_addr);
|
|
|
|
~SBModule();
|
|
|
|
bool IsValid() const;
|
|
|
|
void Clear();
|
|
|
|
//------------------------------------------------------------------
|
|
/// 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.
|
|
//------------------------------------------------------------------
|
|
lldb::SBFileSpec GetFileSpec() const;
|
|
|
|
//------------------------------------------------------------------
|
|
/// 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.
|
|
//------------------------------------------------------------------
|
|
lldb::SBFileSpec GetPlatformFileSpec() const;
|
|
|
|
bool SetPlatformFileSpec(const lldb::SBFileSpec &platform_file);
|
|
|
|
//------------------------------------------------------------------
|
|
/// Get accessor for the remote install path for a module.
|
|
///
|
|
/// When debugging to a remote platform by connecting to a remote
|
|
/// platform, the install path of the module can be set. If the
|
|
/// install path is set, every time the process is about to launch
|
|
/// the target will install this module on the remote platform prior
|
|
/// to launching.
|
|
///
|
|
/// @return
|
|
/// A file specification object.
|
|
//------------------------------------------------------------------
|
|
lldb::SBFileSpec GetRemoteInstallFileSpec();
|
|
|
|
//------------------------------------------------------------------
|
|
/// Set accessor for the remote install path for a module.
|
|
///
|
|
/// When debugging to a remote platform by connecting to a remote
|
|
/// platform, the install path of the module can be set. If the
|
|
/// install path is set, every time the process is about to launch
|
|
/// the target will install this module on the remote platform prior
|
|
/// to launching.
|
|
///
|
|
/// If \a file specifies a full path to an install location, the
|
|
/// module will be installed to this path. If the path is relative
|
|
/// (no directory specified, or the path is partial like "usr/lib"
|
|
/// or "./usr/lib", then the install path will be resolved using
|
|
/// the platform's current working directory as the base path.
|
|
///
|
|
/// @param[in] file
|
|
/// A file specification object.
|
|
//------------------------------------------------------------------
|
|
bool SetRemoteInstallFileSpec(lldb::SBFileSpec &file);
|
|
|
|
lldb::ByteOrder GetByteOrder();
|
|
|
|
uint32_t GetAddressByteSize();
|
|
|
|
const char *GetTriple();
|
|
|
|
const uint8_t *GetUUIDBytes() const;
|
|
|
|
const char *GetUUIDString() const;
|
|
|
|
bool operator==(const lldb::SBModule &rhs) const;
|
|
|
|
bool operator!=(const lldb::SBModule &rhs) const;
|
|
|
|
lldb::SBSection FindSection(const char *sect_name);
|
|
|
|
lldb::SBAddress ResolveFileAddress(lldb::addr_t vm_addr);
|
|
|
|
lldb::SBSymbolContext
|
|
ResolveSymbolContextForAddress(const lldb::SBAddress &addr,
|
|
uint32_t resolve_scope);
|
|
|
|
bool GetDescription(lldb::SBStream &description);
|
|
|
|
uint32_t GetNumCompileUnits();
|
|
|
|
lldb::SBCompileUnit GetCompileUnitAtIndex(uint32_t);
|
|
|
|
size_t GetNumSymbols();
|
|
|
|
lldb::SBSymbol GetSymbolAtIndex(size_t idx);
|
|
|
|
lldb::SBSymbol FindSymbol(const char *name,
|
|
lldb::SymbolType type = eSymbolTypeAny);
|
|
|
|
lldb::SBSymbolContextList FindSymbols(const char *name,
|
|
lldb::SymbolType type = eSymbolTypeAny);
|
|
|
|
size_t GetNumSections();
|
|
|
|
lldb::SBSection GetSectionAtIndex(size_t idx);
|
|
//------------------------------------------------------------------
|
|
/// Find functions by name.
|
|
///
|
|
/// @param[in] name
|
|
/// The name of the function we are looking for.
|
|
///
|
|
/// @param[in] name_type_mask
|
|
/// A logical OR of one or more FunctionNameType enum 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.
|
|
///
|
|
/// @return
|
|
/// A lldb::SBSymbolContextList that gets filled in with all of
|
|
/// the symbol contexts for all the matches.
|
|
//------------------------------------------------------------------
|
|
lldb::SBSymbolContextList
|
|
FindFunctions(const char *name,
|
|
uint32_t name_type_mask = lldb::eFunctionNameTypeAny);
|
|
|
|
//------------------------------------------------------------------
|
|
/// Find global and static variables by name.
|
|
///
|
|
/// @param[in] target
|
|
/// A valid SBTarget instance representing the debuggee.
|
|
///
|
|
/// @param[in] name
|
|
/// The name of the global or static variable we are looking
|
|
/// for.
|
|
///
|
|
/// @param[in] max_matches
|
|
/// Allow the number of matches to be limited to \a max_matches.
|
|
///
|
|
/// @return
|
|
/// A list of matched variables in an SBValueList.
|
|
//------------------------------------------------------------------
|
|
lldb::SBValueList FindGlobalVariables(lldb::SBTarget &target,
|
|
const char *name, uint32_t max_matches);
|
|
|
|
//------------------------------------------------------------------
|
|
/// Find the first global (or static) variable by name.
|
|
///
|
|
/// @param[in] target
|
|
/// A valid SBTarget instance representing the debuggee.
|
|
///
|
|
/// @param[in] name
|
|
/// The name of the global or static variable we are looking
|
|
/// for.
|
|
///
|
|
/// @return
|
|
/// An SBValue that gets filled in with the found variable (if any).
|
|
//------------------------------------------------------------------
|
|
lldb::SBValue FindFirstGlobalVariable(lldb::SBTarget &target,
|
|
const char *name);
|
|
|
|
lldb::SBType FindFirstType(const char *name);
|
|
|
|
lldb::SBTypeList FindTypes(const char *type);
|
|
|
|
//------------------------------------------------------------------
|
|
/// Get a type using its type ID.
|
|
///
|
|
/// Each symbol file reader will assign different user IDs to their
|
|
/// types, but it is sometimes useful when debugging type issues to
|
|
/// be able to grab a type using its type ID.
|
|
///
|
|
/// For DWARF debug info, the type ID is the DIE offset.
|
|
///
|
|
/// @param[in] uid
|
|
/// The type user ID.
|
|
///
|
|
/// @return
|
|
/// An SBType for the given type ID, or an empty SBType if the
|
|
/// type was not found.
|
|
//------------------------------------------------------------------
|
|
lldb::SBType GetTypeByID(lldb::user_id_t uid);
|
|
|
|
lldb::SBType GetBasicType(lldb::BasicType type);
|
|
|
|
//------------------------------------------------------------------
|
|
/// Get all types matching \a type_mask from debug info in this
|
|
/// module.
|
|
///
|
|
/// @param[in] type_mask
|
|
/// A bitfield that consists of one or more bits logically OR'ed
|
|
/// together from the lldb::TypeClass enumeration. This allows
|
|
/// you to request only structure types, or only class, struct
|
|
/// and union types. Passing in lldb::eTypeClassAny will return
|
|
/// all types found in the debug information for this module.
|
|
///
|
|
/// @return
|
|
/// A list of types in this module that match \a type_mask
|
|
//------------------------------------------------------------------
|
|
lldb::SBTypeList GetTypes(uint32_t type_mask = lldb::eTypeClassAny);
|
|
|
|
//------------------------------------------------------------------
|
|
/// Get the module version numbers.
|
|
///
|
|
/// Many object files have a set of version numbers that describe
|
|
/// the version of the executable or shared library. Typically there
|
|
/// are major, minor and build, but there may be more. This function
|
|
/// will extract the versions from object files if they are available.
|
|
///
|
|
/// If \a versions is NULL, or if \a num_versions is 0, the return
|
|
/// value will indicate how many version numbers are available in
|
|
/// this object file. Then a subsequent call can be made to this
|
|
/// function with a value of \a versions and \a num_versions that
|
|
/// has enough storage to store some or all version numbers.
|
|
///
|
|
/// @param[out] versions
|
|
/// A pointer to an array of uint32_t types that is \a num_versions
|
|
/// long. If this value is NULL, the return value will indicate
|
|
/// how many version numbers are required for a subsequent call
|
|
/// to this function so that all versions can be retrieved. If
|
|
/// the value is non-NULL, then at most \a num_versions of the
|
|
/// existing versions numbers will be filled into \a versions.
|
|
/// If there is no version information available, \a versions
|
|
/// will be filled with \a num_versions UINT32_MAX values
|
|
/// and zero will be returned.
|
|
///
|
|
/// @param[in] num_versions
|
|
/// The maximum number of entries to fill into \a versions. If
|
|
/// this value is zero, then the return value will indicate
|
|
/// how many version numbers there are in total so another call
|
|
/// to this function can be make with adequate storage in
|
|
/// \a versions to get all of the version numbers. If \a
|
|
/// num_versions is less than the actual number of version
|
|
/// numbers in this object file, only \a num_versions will be
|
|
/// filled into \a versions (if \a versions is non-NULL).
|
|
///
|
|
/// @return
|
|
/// This function always returns the number of version numbers
|
|
/// that this object file has regardless of the number of
|
|
/// version numbers that were copied into \a versions.
|
|
//------------------------------------------------------------------
|
|
uint32_t GetVersion(uint32_t *versions, uint32_t num_versions);
|
|
|
|
//------------------------------------------------------------------
|
|
/// Get accessor for the symbol file specification.
|
|
///
|
|
/// When debugging an object file an additional debug information can
|
|
/// be provided in separate file. Therefore if you debugging something
|
|
/// like '/usr/lib/liba.dylib' then debug information can be located
|
|
/// in folder like '/usr/lib/liba.dylib.dSYM/'.
|
|
///
|
|
/// @return
|
|
/// A const reference to the file specification object.
|
|
//------------------------------------------------------------------
|
|
lldb::SBFileSpec GetSymbolFileSpec() const;
|
|
|
|
lldb::SBAddress GetObjectFileHeaderAddress() const;
|
|
|
|
private:
|
|
friend class SBAddress;
|
|
friend class SBFrame;
|
|
friend class SBSection;
|
|
friend class SBSymbolContext;
|
|
friend class SBTarget;
|
|
|
|
explicit SBModule(const lldb::ModuleSP &module_sp);
|
|
|
|
ModuleSP GetSP() const;
|
|
|
|
void SetSP(const ModuleSP &module_sp);
|
|
|
|
lldb::ModuleSP m_opaque_sp;
|
|
};
|
|
|
|
} // namespace lldb
|
|
|
|
#endif // LLDB_SBModule_h_
|