This is an archive of the discontinued LLVM Phabricator instance.

Differential D59030

Pass ConstString by value
ClosedPublic

Authored by aprantl on Mar 6 2019, 9:29 AM.

Details

Reviewers
clayborg
shafik
jasonmolenda
• espindola
Commits
rG0e4c482124f0: Pass ConstString by value (NFC)
rLLDB355553: Pass ConstString by value (NFC)
rL355553: Pass ConstString by value (NFC)
Summary

My apologies for the large patch. With the exception of ConstString.h itself it was entirely produced by sed.

I technically only need one of these changes to fix a taking-reference-of-local-object bug that Jason discovered on the swift-lldb branch, but while I'm at it I thought I might as well do all at once.

ConstString has exactly one const char * data member, so passing a ConstString by reference is not any more efficient than copying it by value. In both cases a single pointer is passed. But passing it by value makes it harder to accidentally return the address of a local object.

(This fixes rdar://problem/48640859 for the Apple folks)

Diff Detail

Event Timeline

aprantl created this revision.Mar 6 2019, 9:29 AM
Herald added a reviewer: • espindola. · View Herald TranscriptMar 6 2019, 9:29 AM
Herald added a project: Restricted Project. · View Herald Transcript
Herald added subscribers: jdoerfert, arphaman, MaskRay and 2 others. · View Herald Transcript
aprantl edited the summary of this revision. (Show Details)Mar 6 2019, 9:33 AM
jasonmolenda accepted this revision.Mar 6 2019, 1:14 PM

Looks good to me.

lldb/www/architecture/varformats.html
121

big bug! :)

This revision is now accepted and ready to land.Mar 6 2019, 1:14 PM
Closed by commit rL355553: Pass ConstString by value (NFC) (authored by adrian). · Explain WhyMar 6 2019, 1:22 PM
This revision was automatically updated to reflect the committed changes.
Herald added a project: Restricted Project. · View Herald TranscriptMar 6 2019, 1:22 PM
Herald added a subscriber: llvm-commits. · View Herald Transcript
clayborg added a comment.Mar 6 2019, 2:23 PM

LGTM!

Revision Contents

PathSize
lldb/
docs/
structured_data/
4 lines
include/
lldb/
Breakpoint/
8 lines
8 lines
2 lines
4 lines
Core/
4 lines
2 lines
18 lines
32 lines
10 lines
2 lines
122 lines
4 lines
8 lines
2 lines
16 lines
4 lines
2 lines
16 lines
2 lines
2 lines
4 lines
4 lines
DataFormatters/
18 lines
18 lines
14 lines
4 lines
8 lines
2 lines
Expression/
10 lines
6 lines
Interpreter/
8 lines
6 lines
12 lines
2 lines
Symbol/
16 lines
2 lines
4 lines
2 lines
4 lines
4 lines
2 lines
8 lines
8 lines
16 lines
18 lines
2 lines
2 lines
4 lines
2 lines
4 lines
Target/
2 lines
2 lines
14 lines
18 lines
14 lines
10 lines
4 lines
6 lines
14 lines
4 lines
Utility/
2 lines
8 lines
16 lines
14 lines
4 lines
3 lines
source/
API/
2 lines
Breakpoint/
8 lines
2 lines
2 lines
4 lines
Commands/
12 lines
2 lines
Core/
2 lines
2 lines
14 lines
26 lines
10 lines
144 lines
4 lines
6 lines
2 lines
16 lines
4 lines
2 lines
16 lines
2 lines
2 lines
4 lines
6 lines
DataFormatters/
18 lines
18 lines
4 lines
4 lines
2 lines
Expression/
2 lines
14 lines
Host/
common/
4 lines
Interpreter/
6 lines
14 lines
2 lines
Plugins/
DynamicLoader/
Hexagon-DYLD/
2 lines
MacOSX-DYLD/
2 lines
6 lines
ExpressionParser/
Clang/
2 lines
2 lines
10 lines
10 lines
4 lines
4 lines
4 lines
6 lines
6 lines
2 lines
JITLoader/
GDB/
2 lines
2 lines
Language/
CPlusPlus/
2 lines
4 lines
4 lines
4 lines
4 lines
2 lines
4 lines
2 lines
4 lines
2 lines
2 lines
2 lines
4 lines
2 lines
8 lines
10 lines
4 lines
4 lines
ObjC/
2 lines
16 lines
16 lines
2 lines
2 lines
2 lines
10 lines
10 lines
14 lines
LanguageRuntime/
ObjC/
AppleObjCRuntime/
2 lines
4 lines
2 lines
2 lines
RenderScript/
RenderScriptRuntime/
14 lines
14 lines
ObjectContainer/
BSD-Archive/
2 lines
2 lines
ObjectFile/
ELF/
4 lines
Mach-O/
16 lines
28 lines
Process/
Utility/
2 lines
2 lines
gdb-remote/
2 lines
2 lines
2 lines
2 lines
StructuredData/
DarwinLog/
8 lines
26 lines
SymbolFile/
Breakpad/
8 lines
4 lines
DWARF/
4 lines
4 lines
14 lines
14 lines
12 lines
16 lines
2 lines
2 lines
4 lines
NativePDB/
8 lines
8 lines
PDB/
8 lines
8 lines
Symbol/
12 lines
2 lines
4 lines
2 lines
4 lines
2 lines
6 lines
8 lines
16 lines
10 lines
2 lines
2 lines
2 lines
2 lines
4 lines
Target/
2 lines
6 lines
28 lines
6 lines
10 lines
6 lines
2 lines
14 lines
4 lines
Utility/
2 lines
10 lines
8 lines
4 lines
2 lines
unittests/
Core/
4 lines
www/
architecture/
2 lines

Diff 189523

lldb/docs/structured_data/StructuredDataPlugins.md

Show All 16 Lines
if one exists. if one exists.
* Plugins can request that the Process instance forward on * Plugins can request that the Process instance forward on
configuration data to the process monitor if the plugin needs/wants configuration data to the process monitor if the plugin needs/wants
to configure the feature. Plugins may call the new Process method to configure the feature. Plugins may call the new Process method
```C++ ```C++
virtual Error virtual Error
ConfigureStructuredData(const ConstString &type_name, ConfigureStructuredData(ConstString type_name,
const StructuredData::ObjectSP &config_sp) const StructuredData::ObjectSP &config_sp)
``` ```
where `type_name` is the feature name and `config_sp` points to the where `type_name` is the feature name and `config_sp` points to the
configuration structured data, which may be nullptr. configuration structured data, which may be nullptr.
* Plugins for features present in a process are notified when modules * Plugins for features present in a process are notified when modules
are loaded into the Process instance via this StructuredDataPlugin are loaded into the Process instance via this StructuredDataPlugin
Show All 32 Lines
* Provide a way to forward on configuration data for a feature type * Provide a way to forward on configuration data for a feature type
to the process monitor. This is the manner by which LLDB can to the process monitor. This is the manner by which LLDB can
configure a feature, perhaps based on settings or commands from configure a feature, perhaps based on settings or commands from
the user. The following virtual method on Process (described the user. The following virtual method on Process (described
earlier) does the job: earlier) does the job:
```C++ ```C++
virtual Error virtual Error
ConfigureStructuredData(const ConstString &type_name, ConfigureStructuredData(ConstString type_name,
const StructuredData::ObjectSP &config_sp) const StructuredData::ObjectSP &config_sp)
``` ```
* Listen for asynchronous structured data packets from the process * Listen for asynchronous structured data packets from the process
monitor, and forward them on to Process via this new Process monitor, and forward them on to Process via this new Process
member method: member method:
```C++ ```C++
Show All 15 Lines

lldb/include/lldb/Breakpoint/Breakpoint.h

Show All 16 Lines
/// then we will check the location for whether to actually stop or not. One /// then we will check the location for whether to actually stop or not. One
/// subtle point worth observing here is that you don't actually stop at a /// subtle point worth observing here is that you don't actually stop at a
/// Breakpoint, you always stop at one of its locations. So the "should stop" /// Breakpoint, you always stop at one of its locations. So the "should stop"
/// tests are done by the location, not by the breakpoint. /// tests are done by the location, not by the breakpoint.
//---------------------------------------------------------------------- //----------------------------------------------------------------------
class Breakpoint : public std::enable_shared_from_this<Breakpoint>, class Breakpoint : public std::enable_shared_from_this<Breakpoint>,
public Stoppoint { public Stoppoint {
public: public:
static const ConstString &GetEventIdentifier(); static ConstString GetEventIdentifier();
//------------------------------------------------------------------ //------------------------------------------------------------------
/// An enum specifying the match style for breakpoint settings. At present /// An enum specifying the match style for breakpoint settings. At present
/// only used for function name style breakpoints. /// only used for function name style breakpoints.
//------------------------------------------------------------------ //------------------------------------------------------------------
typedef enum { Exact, Regexp, Glob } MatchType; typedef enum { Exact, Regexp, Glob } MatchType;
private: private:
Show All 9 Lines
public: public:
class BreakpointEventData : public EventData { class BreakpointEventData : public EventData {
public: public:
BreakpointEventData(lldb::BreakpointEventType sub_type, BreakpointEventData(lldb::BreakpointEventType sub_type,
const lldb::BreakpointSP &new_breakpoint_sp); const lldb::BreakpointSP &new_breakpoint_sp);
~BreakpointEventData() override; ~BreakpointEventData() override;
static const ConstString &GetFlavorString(); static ConstString GetFlavorString();
const ConstString &GetFlavor() const override; ConstString GetFlavor() const override;
lldb::BreakpointEventType GetBreakpointEventType() const; lldb::BreakpointEventType GetBreakpointEventType() const;
lldb::BreakpointSP &GetBreakpoint(); lldb::BreakpointSP &GetBreakpoint();
BreakpointLocationCollection &GetBreakpointLocationCollection() { BreakpointLocationCollection &GetBreakpointLocationCollection() {
return m_locations; return m_locations;
} }
Show All 32 Lines
/// True if there is a match /// True if there is a match
/// ///
/// The locations which match the filename and line_number in loc_coll. /// The locations which match the filename and line_number in loc_coll.
/// If its /// If its
/// size is 0 and true is returned, it means the breakpoint fully matches /// size is 0 and true is returned, it means the breakpoint fully matches
/// the /// the
/// description. /// description.
//------------------------------------------------------------------ //------------------------------------------------------------------
bool GetMatchingFileLine(const ConstString &filename, uint32_t line_number, bool GetMatchingFileLine(ConstString filename, uint32_t line_number,
BreakpointLocationCollection &loc_coll); BreakpointLocationCollection &loc_coll);
void GetFilterDescription(Stream *s); void GetFilterDescription(Stream *s);
//------------------------------------------------------------------ //------------------------------------------------------------------
/// Returns the BreakpointOptions structure set at the breakpoint level. /// Returns the BreakpointOptions structure set at the breakpoint level.
/// ///
/// Meant to be used by the BreakpointLocation class. /// Meant to be used by the BreakpointLocation class.
Show All 16 Lines

lldb/include/lldb/Breakpoint/BreakpointName.h

Show All 16 Lines
if (incoming.IsSet(permission)) if (incoming.IsSet(permission))
{ {
SetPermission(permission, !(m_permissions[permission] | SetPermission(permission, !(m_permissions[permission] |
incoming.m_permissions[permission])); incoming.m_permissions[permission]));
} }
} }
}; };
BreakpointName(const ConstString &name, const char *help = nullptr) : BreakpointName(ConstString name, const char *help = nullptr) :
m_name(name), m_options(false) m_name(name), m_options(false)
{ {
SetHelp(help); SetHelp(help);
} }
BreakpointName(const ConstString &name, BreakpointName(ConstString name,
BreakpointOptions &options, BreakpointOptions &options,
const Permissions &permissions = Permissions(), const Permissions &permissions = Permissions(),
const char *help = nullptr) : const char *help = nullptr) :
m_name(name), m_options(options), m_name(name), m_options(options),
m_permissions(permissions) { m_permissions(permissions) {
SetHelp(help); SetHelp(help);
}; };
BreakpointName(const BreakpointName &rhs) : BreakpointName(const BreakpointName &rhs) :
m_name(rhs.m_name), m_options(rhs.m_options), m_name(rhs.m_name), m_options(rhs.m_options),
m_permissions(rhs.m_permissions), m_help(rhs.m_help) m_permissions(rhs.m_permissions), m_help(rhs.m_help)
{} {}
BreakpointName(const ConstString &name, const Breakpoint &bkpt, BreakpointName(ConstString name, const Breakpoint &bkpt,
const char *help); const char *help);
const ConstString &GetName() const { return m_name; } ConstString GetName() const { return m_name; }
BreakpointOptions &GetOptions() { return m_options; } BreakpointOptions &GetOptions() { return m_options; }
const BreakpointOptions &GetOptions() const { return m_options; } const BreakpointOptions &GetOptions() const { return m_options; }
void SetOptions(const BreakpointOptions &options) { void SetOptions(const BreakpointOptions &options) {
m_options = options; m_options = options;
} }
Permissions &GetPermissions() { return m_permissions; } Permissions &GetPermissions() { return m_permissions; }
Show All 16 Lines

lldb/include/lldb/Breakpoint/BreakpointResolverName.h

Show All 16 Lines
std::vector<Module::LookupInfo> m_lookups; std::vector<Module::LookupInfo> m_lookups;
ConstString m_class_name; ConstString m_class_name;
RegularExpression m_regex; RegularExpression m_regex;
Breakpoint::MatchType m_match_type; Breakpoint::MatchType m_match_type;
lldb::LanguageType m_language; lldb::LanguageType m_language;
bool m_skip_prologue; bool m_skip_prologue;
void AddNameLookup(const ConstString &name, void AddNameLookup(ConstString name,
lldb::FunctionNameType name_type_mask); lldb::FunctionNameType name_type_mask);
}; };
} // namespace lldb_private } // namespace lldb_private
#endif // liblldb_BreakpointResolverName_h_ #endif // liblldb_BreakpointResolverName_h_
Context not available.

lldb/include/lldb/Breakpoint/Watchpoint.h

Show All 16 Lines
public: public:
class WatchpointEventData : public EventData { class WatchpointEventData : public EventData {
public: public:
WatchpointEventData(lldb::WatchpointEventType sub_type, WatchpointEventData(lldb::WatchpointEventType sub_type,
const lldb::WatchpointSP &new_watchpoint_sp); const lldb::WatchpointSP &new_watchpoint_sp);
~WatchpointEventData() override; ~WatchpointEventData() override;
static const ConstString &GetFlavorString(); static ConstString GetFlavorString();
const ConstString &GetFlavor() const override; ConstString GetFlavor() const override;
lldb::WatchpointEventType GetWatchpointEventType() const; lldb::WatchpointEventType GetWatchpointEventType() const;
lldb::WatchpointSP &GetWatchpoint(); lldb::WatchpointSP &GetWatchpoint();
void Dump(Stream *s) const override; void Dump(Stream *s) const override;
static lldb::WatchpointEventType static lldb::WatchpointEventType
Show All 16 Lines

lldb/include/lldb/Core/Debugger.h

Show All 16 Lines
static void SettingsTerminate(); static void SettingsTerminate();
static void Destroy(lldb::DebuggerSP &debugger_sp); static void Destroy(lldb::DebuggerSP &debugger_sp);
static lldb::DebuggerSP FindDebuggerWithID(lldb::user_id_t id); static lldb::DebuggerSP FindDebuggerWithID(lldb::user_id_t id);
static lldb::DebuggerSP static lldb::DebuggerSP
FindDebuggerWithInstanceName(const ConstString &instance_name); FindDebuggerWithInstanceName(ConstString instance_name);
static size_t GetNumDebuggers(); static size_t GetNumDebuggers();
static lldb::DebuggerSP GetDebuggerAtIndex(size_t index); static lldb::DebuggerSP GetDebuggerAtIndex(size_t index);
static bool FormatDisassemblerAddress(const FormatEntity::Entry *format, static bool FormatDisassemblerAddress(const FormatEntity::Entry *format,
const SymbolContext *sc, const SymbolContext *sc,
const SymbolContext *prev_sc, const SymbolContext *prev_sc,
Show All 32 Lines
uint32_t GetTabSize() const; uint32_t GetTabSize() const;
bool SetTabSize(uint32_t tab_size); bool SetTabSize(uint32_t tab_size);
bool GetEscapeNonPrintables() const; bool GetEscapeNonPrintables() const;
bool GetNotifyVoid() const; bool GetNotifyVoid() const;
const ConstString &GetInstanceName() { return m_instance_name; } ConstString GetInstanceName() { return m_instance_name; }
bool LoadPlugin(const FileSpec &spec, Status &error); bool LoadPlugin(const FileSpec &spec, Status &error);
void ExecuteIOHandlers(); void ExecuteIOHandlers();
bool IsForwardingEvents(); bool IsForwardingEvents();
void EnableForwardEvents(const lldb::ListenerSP &listener_sp); void EnableForwardEvents(const lldb::ListenerSP &listener_sp);
Show All 16 Lines

lldb/include/lldb/Core/Disassembler.h

Show All 16 Lines
const char *flavor, const ExecutionContext &exe_ctx, const char *flavor, const ExecutionContext &exe_ctx,
SymbolContextList &sc_list, uint32_t num_instructions, SymbolContextList &sc_list, uint32_t num_instructions,
bool mixed_source_and_assembly, uint32_t num_mixed_context_lines, bool mixed_source_and_assembly, uint32_t num_mixed_context_lines,
uint32_t options, Stream &strm); uint32_t options, Stream &strm);
static bool static bool
Disassemble(Debugger &debugger, const ArchSpec &arch, const char *plugin_name, Disassemble(Debugger &debugger, const ArchSpec &arch, const char *plugin_name,
const char *flavor, const ExecutionContext &exe_ctx, const char *flavor, const ExecutionContext &exe_ctx,
const ConstString &name, Module *module, ConstString name, Module *module,
uint32_t num_instructions, bool mixed_source_and_assembly, uint32_t num_instructions, bool mixed_source_and_assembly,
uint32_t num_mixed_context_lines, uint32_t options, Stream &strm); uint32_t num_mixed_context_lines, uint32_t options, Stream &strm);
static bool static bool
Disassemble(Debugger &debugger, const ArchSpec &arch, const char *plugin_name, Disassemble(Debugger &debugger, const ArchSpec &arch, const char *plugin_name,
const char *flavor, const ExecutionContext &exe_ctx, const char *flavor, const ExecutionContext &exe_ctx,
uint32_t num_instructions, bool mixed_source_and_assembly, uint32_t num_instructions, bool mixed_source_and_assembly,
uint32_t num_mixed_context_lines, uint32_t options, Stream &strm); uint32_t num_mixed_context_lines, uint32_t options, Stream &strm);
Show All 16 Lines

lldb/include/lldb/Core/Mangled.h

Show All 16 Lines
/// ///
/// @param[in] name /// @param[in] name
/// The already const name to copy into this object. /// The already const name to copy into this object.
/// ///
/// @param[in] is_mangled /// @param[in] is_mangled
/// If \b true then \a name is a mangled name, if \b false then /// If \b true then \a name is a mangled name, if \b false then
/// \a name is demangled. /// \a name is demangled.
//---------------------------------------------------------------------- //----------------------------------------------------------------------
Mangled(const ConstString &name, bool is_mangled); Mangled(ConstString name, bool is_mangled);
Mangled(llvm::StringRef name, bool is_mangled); Mangled(llvm::StringRef name, bool is_mangled);
//---------------------------------------------------------------------- //----------------------------------------------------------------------
/// Construct with name. /// Construct with name.
/// ///
/// Constructor with an optional string and auto-detect if \a name is /// Constructor with an optional string and auto-detect if \a name is
/// mangled or not. /// mangled or not.
/// ///
/// @param[in] name /// @param[in] name
/// The already const name to copy into this object. /// The already const name to copy into this object.
//---------------------------------------------------------------------- //----------------------------------------------------------------------
explicit Mangled(const ConstString &name); explicit Mangled(ConstString name);
explicit Mangled(llvm::StringRef name); explicit Mangled(llvm::StringRef name);
//---------------------------------------------------------------------- //----------------------------------------------------------------------
/// Destructor /// Destructor
/// ///
/// Releases its ref counts on the mangled and demangled strings that live /// Releases its ref counts on the mangled and demangled strings that live
/// in the global string pool. /// in the global string pool.
Show All 32 Lines
void DumpDebug(Stream *s) const; void DumpDebug(Stream *s) const;
//---------------------------------------------------------------------- //----------------------------------------------------------------------
/// Demangled name get accessor. /// Demangled name get accessor.
/// ///
/// @return /// @return
/// A const reference to the demangled name string object. /// A const reference to the demangled name string object.
//---------------------------------------------------------------------- //----------------------------------------------------------------------
const ConstString &GetDemangledName(lldb::LanguageType language) const; ConstString GetDemangledName(lldb::LanguageType language) const;
//---------------------------------------------------------------------- //----------------------------------------------------------------------
/// Display demangled name get accessor. /// Display demangled name get accessor.
/// ///
/// @return /// @return
/// A const reference to the display demangled name string object. /// A const reference to the display demangled name string object.
//---------------------------------------------------------------------- //----------------------------------------------------------------------
ConstString GetDisplayDemangledName(lldb::LanguageType language) const; ConstString GetDisplayDemangledName(lldb::LanguageType language) const;
void SetDemangledName(const ConstString &name) { m_demangled = name; } void SetDemangledName(ConstString name) { m_demangled = name; }
void SetMangledName(const ConstString &name) { m_mangled = name; } void SetMangledName(ConstString name) { m_mangled = name; }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
/// Mangled name get accessor. /// Mangled name get accessor.
/// ///
/// @return /// @return
/// A reference to the mangled name string object. /// A reference to the mangled name string object.
//---------------------------------------------------------------------- //----------------------------------------------------------------------
ConstString &GetMangledName() { return m_mangled; } ConstString &GetMangledName() { return m_mangled; }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
/// Mangled name get accessor. /// Mangled name get accessor.
/// ///
/// @return /// @return
/// A const reference to the mangled name string object. /// A const reference to the mangled name string object.
//---------------------------------------------------------------------- //----------------------------------------------------------------------
const ConstString &GetMangledName() const { return m_mangled; } ConstString GetMangledName() const { return m_mangled; }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
/// Best name get accessor. /// Best name get accessor.
/// ///
/// @param[in] preference /// @param[in] preference
/// Which name would you prefer to get? /// Which name would you prefer to get?
/// ///
/// @return /// @return
/// A const reference to the preferred name string object if this /// A const reference to the preferred name string object if this
/// object has a valid name of that kind, else a const reference to the /// object has a valid name of that kind, else a const reference to the
/// other name is returned. /// other name is returned.
//---------------------------------------------------------------------- //----------------------------------------------------------------------
ConstString GetName(lldb::LanguageType language, ConstString GetName(lldb::LanguageType language,
NamePreference preference = ePreferDemangled) const; NamePreference preference = ePreferDemangled) const;
//---------------------------------------------------------------------- //----------------------------------------------------------------------
/// Check if "name" matches either the mangled or demangled name. /// Check if "name" matches either the mangled or demangled name.
/// ///
/// @param[in] name /// @param[in] name
/// A name to match against both strings. /// A name to match against both strings.
/// ///
/// @return /// @return
/// \b True if \a name matches either name, \b false otherwise. /// \b True if \a name matches either name, \b false otherwise.
//---------------------------------------------------------------------- //----------------------------------------------------------------------
bool NameMatches(const ConstString &name, lldb::LanguageType language) const { bool NameMatches(ConstString name, lldb::LanguageType language) const {
if (m_mangled == name) if (m_mangled == name)
return true; return true;
return GetDemangledName(language) == name; return GetDemangledName(language) == name;
} }
bool NameMatches(const RegularExpression &regex, bool NameMatches(const RegularExpression &regex,
lldb::LanguageType language) const; lldb::LanguageType language) const;
//---------------------------------------------------------------------- //----------------------------------------------------------------------
Show All 18 Lines
/// ///
/// @param[in] name /// @param[in] name
/// The already const version of the name for this object. /// The already const version of the name for this object.
/// ///
/// @param[in] is_mangled /// @param[in] is_mangled
/// If \b true then \a name is a mangled name, if \b false then /// If \b true then \a name is a mangled name, if \b false then
/// \a name is demangled. /// \a name is demangled.
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void SetValue(const ConstString &name, bool is_mangled); void SetValue(ConstString name, bool is_mangled);
//---------------------------------------------------------------------- //----------------------------------------------------------------------
/// Set the string value in this object. /// Set the string value in this object.
/// ///
/// This version auto detects if the string is mangled by inspecting the /// This version auto detects if the string is mangled by inspecting the
/// string value and looking for common mangling prefixes. /// string value and looking for common mangling prefixes.
/// ///
/// @param[in] name /// @param[in] name
/// The already const version of the name for this object. /// The already const version of the name for this object.
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void SetValue(const ConstString &name); void SetValue(ConstString name);
//---------------------------------------------------------------------- //----------------------------------------------------------------------
/// Try to guess the language from the mangling. /// Try to guess the language from the mangling.
/// ///
/// For a mangled name to have a language it must have both a mangled and a /// For a mangled name to have a language it must have both a mangled and a
/// demangled name and it can be guessed from the mangling what the language /// demangled name and it can be guessed from the mangling what the language
/// is. Note: this will return C++ for any language that uses Itanium ABI /// is. Note: this will return C++ for any language that uses Itanium ABI
/// mangling. /// mangling.
Show All 16 Lines

lldb/include/lldb/Core/Module.h

Show All 16 Lines
/// SymbolType enumeration value, then search only for /// SymbolType enumeration value, then search only for
/// symbols that match \a symbol_type. /// symbols that match \a symbol_type.
/// ///
/// @return /// @return
/// Returns a valid symbol pointer if a symbol was found, /// Returns a valid symbol pointer if a symbol was found,
/// nullptr otherwise. /// nullptr otherwise.
//------------------------------------------------------------------ //------------------------------------------------------------------
const Symbol *FindFirstSymbolWithNameAndType( const Symbol *FindFirstSymbolWithNameAndType(
const ConstString &name, ConstString name,
lldb::SymbolType symbol_type = lldb::eSymbolTypeAny); lldb::SymbolType symbol_type = lldb::eSymbolTypeAny);
size_t FindSymbolsWithNameAndType(const ConstString &name, size_t FindSymbolsWithNameAndType(ConstString name,
lldb::SymbolType symbol_type, lldb::SymbolType symbol_type,
SymbolContextList &sc_list); SymbolContextList &sc_list);
size_t FindSymbolsMatchingRegExAndType(const RegularExpression &regex, size_t FindSymbolsMatchingRegExAndType(const RegularExpression &regex,
lldb::SymbolType symbol_type, lldb::SymbolType symbol_type,
SymbolContextList &sc_list); SymbolContextList &sc_list);
//------------------------------------------------------------------ //------------------------------------------------------------------
/// Find a function symbols in the object file's symbol table. /// Find a function symbols in the object file's symbol table.
/// ///
/// @param[in] name /// @param[in] name
/// The name of the symbol that we are looking for. /// The name of the symbol that we are looking for.
/// ///
/// @param[in] name_type_mask /// @param[in] name_type_mask
/// A mask that has one or more bitwise OR'ed values from the /// A mask that has one or more bitwise OR'ed values from the
/// lldb::FunctionNameType enumeration type that indicate what /// lldb::FunctionNameType enumeration type that indicate what
/// kind of names we are looking for. /// kind of names we are looking for.
/// ///
/// @param[out] sc_list /// @param[out] sc_list
/// A list to append any matching symbol contexts to. /// A list to append any matching symbol contexts to.
/// ///
/// @return /// @return
/// The number of symbol contexts that were added to \a sc_list /// The number of symbol contexts that were added to \a sc_list
//------------------------------------------------------------------ //------------------------------------------------------------------
size_t FindFunctionSymbols(const ConstString &name, uint32_t name_type_mask, size_t FindFunctionSymbols(ConstString name, uint32_t name_type_mask,
SymbolContextList &sc_list); SymbolContextList &sc_list);
//------------------------------------------------------------------ //------------------------------------------------------------------
/// Find compile units by partial or full path. /// Find compile units by partial or full path.
/// ///
/// Finds all compile units that match \a path in all of the modules and /// Finds all compile units that match \a path in all of the modules and
/// returns the results in \a sc_list. /// returns the results in \a sc_list.
/// ///
Show All 32 Lines
/// ///
/// @param[out] sc_list /// @param[out] sc_list
/// A symbol context list that gets filled in with all of the /// A symbol context list that gets filled in with all of the
/// matches. /// matches.
/// ///
/// @return /// @return
/// The number of matches added to \a sc_list. /// The number of matches added to \a sc_list.
//------------------------------------------------------------------ //------------------------------------------------------------------
size_t FindFunctions(const ConstString &name, size_t FindFunctions(ConstString name,
const CompilerDeclContext *parent_decl_ctx, const CompilerDeclContext *parent_decl_ctx,
lldb::FunctionNameType name_type_mask, bool symbols_ok, lldb::FunctionNameType name_type_mask, bool symbols_ok,
bool inlines_ok, bool append, bool inlines_ok, bool append,
SymbolContextList &sc_list); SymbolContextList &sc_list);
//------------------------------------------------------------------ //------------------------------------------------------------------
/// Find functions by name. /// Find functions by name.
/// ///
Show All 32 Lines
/// max_matches. Specify UINT32_MAX to get all possible matches. /// max_matches. Specify UINT32_MAX to get all possible matches.
/// ///
/// @param[in] variable_list /// @param[in] variable_list
/// A list of variables that gets the matches appended to. /// A list of variables that gets the matches appended to.
/// ///
/// @return /// @return
/// The number of matches added to \a variable_list. /// The number of matches added to \a variable_list.
//------------------------------------------------------------------ //------------------------------------------------------------------
size_t FindGlobalVariables(const ConstString &name, size_t FindGlobalVariables(ConstString name,
const CompilerDeclContext *parent_decl_ctx, const CompilerDeclContext *parent_decl_ctx,
size_t max_matches, VariableList &variable_list); size_t max_matches, VariableList &variable_list);
//------------------------------------------------------------------ //------------------------------------------------------------------
/// Find global and static variables by regular expression. /// Find global and static variables by regular expression.
/// ///
/// @param[in] regex /// @param[in] regex
/// A regular expression to use when matching the name. /// A regular expression to use when matching the name.
Show All 32 Lines
/// ///
/// @param[out] type_list /// @param[out] type_list
/// A type list gets populated with any matches. /// A type list gets populated with any matches.
/// ///
/// @return /// @return
/// The number of matches added to \a type_list. /// The number of matches added to \a type_list.
//------------------------------------------------------------------ //------------------------------------------------------------------
size_t size_t
FindTypes(const ConstString &type_name, bool exact_match, size_t max_matches, FindTypes(ConstString type_name, bool exact_match, size_t max_matches,
llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files, llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
TypeList &types); TypeList &types);
lldb::TypeSP FindFirstType(const SymbolContext &sc, lldb::TypeSP FindFirstType(const SymbolContext &sc,
const ConstString &type_name, bool exact_match); ConstString type_name, bool exact_match);
//------------------------------------------------------------------ //------------------------------------------------------------------
/// Find types by name that are in a namespace. This function is used by the /// 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 /// expression parser when searches need to happen in an exact namespace
/// scope. /// scope.
/// ///
/// @param[in] type_name /// @param[in] type_name
/// The name of a type within a namespace that should not include /// The name of a type within a namespace that should not include
/// any qualifying namespaces (just a type basename). /// any qualifying namespaces (just a type basename).
/// ///
/// @param[in] namespace_decl /// @param[in] namespace_decl
/// The namespace declaration that this type must exist in. /// The namespace declaration that this type must exist in.
/// ///
/// @param[out] type_list /// @param[out] type_list
/// A type list gets populated with any matches. /// A type list gets populated with any matches.
/// ///
/// @return /// @return
/// The number of matches added to \a type_list. /// The number of matches added to \a type_list.
//------------------------------------------------------------------ //------------------------------------------------------------------
size_t FindTypesInNamespace(const ConstString &type_name, size_t FindTypesInNamespace(ConstString type_name,
const CompilerDeclContext *parent_decl_ctx, const CompilerDeclContext *parent_decl_ctx,
size_t max_matches, TypeList &type_list); size_t max_matches, TypeList &type_list);
//------------------------------------------------------------------ //------------------------------------------------------------------
/// Get const accessor for the module architecture. /// Get const accessor for the module architecture.
/// ///
/// @return /// @return
/// A const reference to the architecture object. /// A const reference to the architecture object.
Show All 32 Lines
/// @return /// @return
/// The number of compile units that the symbol vendor plug-in /// The number of compile units that the symbol vendor plug-in
/// finds. /// finds.
//------------------------------------------------------------------ //------------------------------------------------------------------
size_t GetNumCompileUnits(); size_t GetNumCompileUnits();
lldb::CompUnitSP GetCompileUnitAtIndex(size_t idx); lldb::CompUnitSP GetCompileUnitAtIndex(size_t idx);
const ConstString &GetObjectName() const; ConstString GetObjectName() const;
uint64_t GetObjectOffset() const { return m_object_offset; } uint64_t GetObjectOffset() const { return m_object_offset; }
//------------------------------------------------------------------ //------------------------------------------------------------------
/// Get the object file representation for the current architecture. /// Get the object file representation for the current architecture.
/// ///
/// If the object file has not been located or parsed yet, this function /// 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. /// will find the best ObjectFile plug-in that can parse Module::m_file.
Show All 32 Lines
/// ///
/// @see SymbolContext::Scope /// @see SymbolContext::Scope
//------------------------------------------------------------------ //------------------------------------------------------------------
uint32_t ResolveSymbolContextsForFileSpec( uint32_t ResolveSymbolContextsForFileSpec(
const FileSpec &file_spec, uint32_t line, bool check_inlines, const FileSpec &file_spec, uint32_t line, bool check_inlines,
lldb::SymbolContextItem resolve_scope, SymbolContextList &sc_list); lldb::SymbolContextItem resolve_scope, SymbolContextList &sc_list);
void SetFileSpecAndObjectName(const FileSpec &file, void SetFileSpecAndObjectName(const FileSpec &file,
const ConstString &object_name); ConstString object_name);
bool GetIsDynamicLinkEditor(); bool GetIsDynamicLinkEditor();
TypeSystem *GetTypeSystemForLanguage(lldb::LanguageType language); TypeSystem *GetTypeSystemForLanguage(lldb::LanguageType language);
// Special error functions that can do printf style formatting that will // Special error functions that can do printf style formatting that will
// prepend the message with something appropriate for this module (like the // prepend the message with something appropriate for this module (like the
// architecture, path and object name (if any)). This centralizes code so // architecture, path and object name (if any)). This centralizes code so
Show All 32 Lines
//---------------------------------------------------------------------- //----------------------------------------------------------------------
class LookupInfo { class LookupInfo {
public: public:
LookupInfo() LookupInfo()
: m_name(), m_lookup_name(), m_language(lldb::eLanguageTypeUnknown), : m_name(), m_lookup_name(), m_language(lldb::eLanguageTypeUnknown),
m_name_type_mask(lldb::eFunctionNameTypeNone), m_name_type_mask(lldb::eFunctionNameTypeNone),
m_match_name_after_lookup(false) {} m_match_name_after_lookup(false) {}
LookupInfo(const ConstString &name, lldb::FunctionNameType name_type_mask, LookupInfo(ConstString name, lldb::FunctionNameType name_type_mask,
lldb::LanguageType language); lldb::LanguageType language);
const ConstString &GetName() const { return m_name; } ConstString GetName() const { return m_name; }
void SetName(const ConstString &name) { m_name = name; } void SetName(ConstString name) { m_name = name; }
const ConstString &GetLookupName() const { return m_lookup_name; } ConstString GetLookupName() const { return m_lookup_name; }
void SetLookupName(const ConstString &name) { m_lookup_name = name; } void SetLookupName(ConstString name) { m_lookup_name = name; }
lldb::FunctionNameType GetNameTypeMask() const { return m_name_type_mask; } lldb::FunctionNameType GetNameTypeMask() const { return m_name_type_mask; }
void SetNameTypeMask(lldb::FunctionNameType mask) { void SetNameTypeMask(lldb::FunctionNameType mask) {
m_name_type_mask = mask; m_name_type_mask = mask;
} }
void Prune(SymbolContextList &sc_list, size_t start_idx) const; void Prune(SymbolContextList &sc_list, size_t start_idx) const;
Show All 32 Lines
friend class ModuleList; friend class ModuleList;
friend class ObjectFile; friend class ObjectFile;
friend class SymbolFile; friend class SymbolFile;
private: private:
Module(); // Only used internally by CreateJITModule () Module(); // Only used internally by CreateJITModule ()
size_t FindTypes_Impl( size_t FindTypes_Impl(
const ConstString &name, const CompilerDeclContext *parent_decl_ctx, ConstString name, const CompilerDeclContext *parent_decl_ctx,
bool append, size_t max_matches, bool append, size_t max_matches,
llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files, llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
TypeMap &types); TypeMap &types);
DISALLOW_COPY_AND_ASSIGN(Module); DISALLOW_COPY_AND_ASSIGN(Module);
}; };
} // namespace lldb_private } // namespace lldb_private
#endif // liblldb_Module_h_ #endif // liblldb_Module_h_
Context not available.

lldb/include/lldb/Core/ModuleList.h

Show All 16 Lines
/// The number of matches added to \a sc_list. /// The number of matches added to \a sc_list.
//------------------------------------------------------------------ //------------------------------------------------------------------
size_t FindCompileUnits(const FileSpec &path, bool append, size_t FindCompileUnits(const FileSpec &path, bool append,
SymbolContextList &sc_list) const; SymbolContextList &sc_list) const;
//------------------------------------------------------------------ //------------------------------------------------------------------
/// @see Module::FindFunctions () /// @see Module::FindFunctions ()
//------------------------------------------------------------------ //------------------------------------------------------------------
size_t FindFunctions(const ConstString &name, size_t FindFunctions(ConstString name,
lldb::FunctionNameType name_type_mask, lldb::FunctionNameType name_type_mask,
bool include_symbols, bool include_inlines, bool append, bool include_symbols, bool include_inlines, bool append,
SymbolContextList &sc_list) const; SymbolContextList &sc_list) const;
//------------------------------------------------------------------ //------------------------------------------------------------------
/// @see Module::FindFunctionSymbols () /// @see Module::FindFunctionSymbols ()
//------------------------------------------------------------------ //------------------------------------------------------------------
size_t FindFunctionSymbols(const ConstString &name, size_t FindFunctionSymbols(ConstString name,
lldb::FunctionNameType name_type_mask, lldb::FunctionNameType name_type_mask,
SymbolContextList &sc_list); SymbolContextList &sc_list);
//------------------------------------------------------------------ //------------------------------------------------------------------
/// @see Module::FindFunctions () /// @see Module::FindFunctions ()
//------------------------------------------------------------------ //------------------------------------------------------------------
size_t FindFunctions(const RegularExpression &name, bool include_symbols, size_t FindFunctions(const RegularExpression &name, bool include_symbols,
bool include_inlines, bool append, bool include_inlines, bool append,
Show All 11 Lines
/// max_matches. Specify UINT32_MAX to get all possible matches. /// max_matches. Specify UINT32_MAX to get all possible matches.
/// ///
/// @param[in] variable_list /// @param[in] variable_list
/// A list of variables that gets the matches appended to. /// A list of variables that gets the matches appended to.
/// ///
/// @return /// @return
/// The number of matches added to \a variable_list. /// The number of matches added to \a variable_list.
//------------------------------------------------------------------ //------------------------------------------------------------------
size_t FindGlobalVariables(const ConstString &name, size_t max_matches, size_t FindGlobalVariables(ConstString name, size_t max_matches,
VariableList &variable_list) const; VariableList &variable_list) const;
//------------------------------------------------------------------ //------------------------------------------------------------------
/// Find global and static variables by regular expression. /// Find global and static variables by regular expression.
/// ///
/// @param[in] regex /// @param[in] regex
/// A regular expression to use when matching the name. /// A regular expression to use when matching the name.
/// ///
Show All 32 Lines
// The UUID value for a module is extracted from the ObjectFile and is the // The UUID value for a module is extracted from the ObjectFile and is the
// MD5 checksum, or a smarter object file equivalent, so finding modules by // MD5 checksum, or a smarter object file equivalent, so finding modules by
// UUID values is very efficient and accurate. // UUID values is very efficient and accurate.
//------------------------------------------------------------------ //------------------------------------------------------------------
lldb::ModuleSP FindModule(const UUID &uuid) const; lldb::ModuleSP FindModule(const UUID &uuid) const;
lldb::ModuleSP FindFirstModule(const ModuleSpec &module_spec) const; lldb::ModuleSP FindFirstModule(const ModuleSpec &module_spec) const;
size_t FindSymbolsWithNameAndType(const ConstString &name, size_t FindSymbolsWithNameAndType(ConstString name,
lldb::SymbolType symbol_type, lldb::SymbolType symbol_type,
SymbolContextList &sc_list, SymbolContextList &sc_list,
bool append = false) const; bool append = false) const;
size_t FindSymbolsMatchingRegExAndType(const RegularExpression &regex, size_t FindSymbolsMatchingRegExAndType(const RegularExpression &regex,
lldb::SymbolType symbol_type, lldb::SymbolType symbol_type,
SymbolContextList &sc_list, SymbolContextList &sc_list,
bool append = false) const; bool append = false) const;
Show All 26 Lines
/// of the user defined type ("struct", "union", "class", etc). /// of the user defined type ("struct", "union", "class", etc).
/// ///
/// @param[out] type_list /// @param[out] type_list
/// A type list gets populated with any matches. /// A type list gets populated with any matches.
/// ///
/// @return /// @return
/// The number of matches added to \a type_list. /// The number of matches added to \a type_list.
//------------------------------------------------------------------ //------------------------------------------------------------------
size_t FindTypes(Module *search_first, const ConstString &name, size_t FindTypes(Module *search_first, ConstString name,
bool name_is_fully_qualified, size_t max_matches, bool name_is_fully_qualified, size_t max_matches,
llvm::DenseSet<SymbolFile *> &searched_symbol_files, llvm::DenseSet<SymbolFile *> &searched_symbol_files,
TypeList &types) const; TypeList &types) const;
bool FindSourceFile(const FileSpec &orig_spec, FileSpec &new_spec) const; bool FindSourceFile(const FileSpec &orig_spec, FileSpec &new_spec) const;
//------------------------------------------------------------------ //------------------------------------------------------------------
/// Find addresses by file/line /// Find addresses by file/line
Show All 16 Lines

lldb/include/lldb/Core/ModuleSpec.h

Show All 16 Lines
} }
UUID &GetUUID() { return m_uuid; } UUID &GetUUID() { return m_uuid; }
const UUID &GetUUID() const { return m_uuid; } const UUID &GetUUID() const { return m_uuid; }
ConstString &GetObjectName() { return m_object_name; } ConstString &GetObjectName() { return m_object_name; }
const ConstString &GetObjectName() const { return m_object_name; } ConstString GetObjectName() const { return m_object_name; }
uint64_t GetObjectOffset() const { return m_object_offset; } uint64_t GetObjectOffset() const { return m_object_offset; }
void SetObjectOffset(uint64_t object_offset) { void SetObjectOffset(uint64_t object_offset) {
m_object_offset = object_offset; m_object_offset = object_offset;
} }
uint64_t GetObjectSize() const { return m_object_size; } uint64_t GetObjectSize() const { return m_object_size; }
Show All 16 Lines

lldb/include/lldb/Core/PluginManager.h

Show All 16 Lines
public: public:
static void Initialize(); static void Initialize();
static void Terminate(); static void Terminate();
//------------------------------------------------------------------ //------------------------------------------------------------------
// ABI // ABI
//------------------------------------------------------------------ //------------------------------------------------------------------
static bool RegisterPlugin(const ConstString &name, const char *description, static bool RegisterPlugin(ConstString name, const char *description,
ABICreateInstance create_callback); ABICreateInstance create_callback);
static bool UnregisterPlugin(ABICreateInstance create_callback); static bool UnregisterPlugin(ABICreateInstance create_callback);
static ABICreateInstance GetABICreateCallbackAtIndex(uint32_t idx); static ABICreateInstance GetABICreateCallbackAtIndex(uint32_t idx);
static ABICreateInstance static ABICreateInstance
GetABICreateCallbackForPluginName(const ConstString &name); GetABICreateCallbackForPluginName(ConstString name);
//------------------------------------------------------------------ //------------------------------------------------------------------
// Architecture // Architecture
//------------------------------------------------------------------ //------------------------------------------------------------------
using ArchitectureCreateInstance = using ArchitectureCreateInstance =
std::unique_ptr<Architecture> (*)(const ArchSpec &); std::unique_ptr<Architecture> (*)(const ArchSpec &);
static void RegisterPlugin(const ConstString &name, static void RegisterPlugin(ConstString name,
llvm::StringRef description, llvm::StringRef description,
ArchitectureCreateInstance create_callback); ArchitectureCreateInstance create_callback);
static void UnregisterPlugin(ArchitectureCreateInstance create_callback); static void UnregisterPlugin(ArchitectureCreateInstance create_callback);
static std::unique_ptr<Architecture> static std::unique_ptr<Architecture>
CreateArchitectureInstance(const ArchSpec &arch); CreateArchitectureInstance(const ArchSpec &arch);
//------------------------------------------------------------------ //------------------------------------------------------------------
// Disassembler // Disassembler
//------------------------------------------------------------------ //------------------------------------------------------------------
static bool RegisterPlugin(const ConstString &name, const char *description, static bool RegisterPlugin(ConstString name, const char *description,
DisassemblerCreateInstance create_callback); DisassemblerCreateInstance create_callback);
static bool UnregisterPlugin(DisassemblerCreateInstance create_callback); static bool UnregisterPlugin(DisassemblerCreateInstance create_callback);
static DisassemblerCreateInstance static DisassemblerCreateInstance
GetDisassemblerCreateCallbackAtIndex(uint32_t idx); GetDisassemblerCreateCallbackAtIndex(uint32_t idx);
static DisassemblerCreateInstance static DisassemblerCreateInstance
GetDisassemblerCreateCallbackForPluginName(const ConstString &name); GetDisassemblerCreateCallbackForPluginName(ConstString name);
//------------------------------------------------------------------ //------------------------------------------------------------------
// DynamicLoader // DynamicLoader
//------------------------------------------------------------------ //------------------------------------------------------------------
static bool static bool
RegisterPlugin(const ConstString &name, const char *description, RegisterPlugin(ConstString name, const char *description,
DynamicLoaderCreateInstance create_callback, DynamicLoaderCreateInstance create_callback,
DebuggerInitializeCallback debugger_init_callback = nullptr); DebuggerInitializeCallback debugger_init_callback = nullptr);
static bool UnregisterPlugin(DynamicLoaderCreateInstance create_callback); static bool UnregisterPlugin(DynamicLoaderCreateInstance create_callback);
static DynamicLoaderCreateInstance static DynamicLoaderCreateInstance
GetDynamicLoaderCreateCallbackAtIndex(uint32_t idx); GetDynamicLoaderCreateCallbackAtIndex(uint32_t idx);
static DynamicLoaderCreateInstance static DynamicLoaderCreateInstance
GetDynamicLoaderCreateCallbackForPluginName(const ConstString &name); GetDynamicLoaderCreateCallbackForPluginName(ConstString name);
//------------------------------------------------------------------ //------------------------------------------------------------------
// JITLoader // JITLoader
//------------------------------------------------------------------ //------------------------------------------------------------------
static bool static bool
RegisterPlugin(const ConstString &name, const char *description, RegisterPlugin(ConstString name, const char *description,
JITLoaderCreateInstance create_callback, JITLoaderCreateInstance create_callback,
DebuggerInitializeCallback debugger_init_callback = nullptr); DebuggerInitializeCallback debugger_init_callback = nullptr);
static bool UnregisterPlugin(JITLoaderCreateInstance create_callback); static bool UnregisterPlugin(JITLoaderCreateInstance create_callback);
static JITLoaderCreateInstance static JITLoaderCreateInstance
GetJITLoaderCreateCallbackAtIndex(uint32_t idx); GetJITLoaderCreateCallbackAtIndex(uint32_t idx);
static JITLoaderCreateInstance static JITLoaderCreateInstance
GetJITLoaderCreateCallbackForPluginName(const ConstString &name); GetJITLoaderCreateCallbackForPluginName(ConstString name);
//------------------------------------------------------------------ //------------------------------------------------------------------
// EmulateInstruction // EmulateInstruction
//------------------------------------------------------------------ //------------------------------------------------------------------
static bool RegisterPlugin(const ConstString &name, const char *description, static bool RegisterPlugin(ConstString name, const char *description,
EmulateInstructionCreateInstance create_callback); EmulateInstructionCreateInstance create_callback);
static bool static bool
UnregisterPlugin(EmulateInstructionCreateInstance create_callback); UnregisterPlugin(EmulateInstructionCreateInstance create_callback);
static EmulateInstructionCreateInstance static EmulateInstructionCreateInstance
GetEmulateInstructionCreateCallbackAtIndex(uint32_t idx); GetEmulateInstructionCreateCallbackAtIndex(uint32_t idx);
static EmulateInstructionCreateInstance static EmulateInstructionCreateInstance
GetEmulateInstructionCreateCallbackForPluginName(const ConstString &name); GetEmulateInstructionCreateCallbackForPluginName(ConstString name);
//------------------------------------------------------------------ //------------------------------------------------------------------
// OperatingSystem // OperatingSystem
//------------------------------------------------------------------ //------------------------------------------------------------------
static bool RegisterPlugin(const ConstString &name, const char *description, static bool RegisterPlugin(ConstString name, const char *description,
OperatingSystemCreateInstance create_callback, OperatingSystemCreateInstance create_callback,
DebuggerInitializeCallback debugger_init_callback); DebuggerInitializeCallback debugger_init_callback);
static bool UnregisterPlugin(OperatingSystemCreateInstance create_callback); static bool UnregisterPlugin(OperatingSystemCreateInstance create_callback);
static OperatingSystemCreateInstance static OperatingSystemCreateInstance
GetOperatingSystemCreateCallbackAtIndex(uint32_t idx); GetOperatingSystemCreateCallbackAtIndex(uint32_t idx);
static OperatingSystemCreateInstance static OperatingSystemCreateInstance
GetOperatingSystemCreateCallbackForPluginName(const ConstString &name); GetOperatingSystemCreateCallbackForPluginName(ConstString name);
//------------------------------------------------------------------ //------------------------------------------------------------------
// Language // Language
//------------------------------------------------------------------ //------------------------------------------------------------------
static bool RegisterPlugin(const ConstString &name, const char *description, static bool RegisterPlugin(ConstString name, const char *description,
LanguageCreateInstance create_callback); LanguageCreateInstance create_callback);
static bool UnregisterPlugin(LanguageCreateInstance create_callback); static bool UnregisterPlugin(LanguageCreateInstance create_callback);
static LanguageCreateInstance GetLanguageCreateCallbackAtIndex(uint32_t idx); static LanguageCreateInstance GetLanguageCreateCallbackAtIndex(uint32_t idx);
static LanguageCreateInstance static LanguageCreateInstance
GetLanguageCreateCallbackForPluginName(const ConstString &name); GetLanguageCreateCallbackForPluginName(ConstString name);
//------------------------------------------------------------------ //------------------------------------------------------------------
// LanguageRuntime // LanguageRuntime
//------------------------------------------------------------------ //------------------------------------------------------------------
static bool static bool
RegisterPlugin(const ConstString &name, const char *description, RegisterPlugin(ConstString name, const char *description,
LanguageRuntimeCreateInstance create_callback, LanguageRuntimeCreateInstance create_callback,
LanguageRuntimeGetCommandObject command_callback = nullptr); LanguageRuntimeGetCommandObject command_callback = nullptr);
static bool UnregisterPlugin(LanguageRuntimeCreateInstance create_callback); static bool UnregisterPlugin(LanguageRuntimeCreateInstance create_callback);
static LanguageRuntimeCreateInstance static LanguageRuntimeCreateInstance
GetLanguageRuntimeCreateCallbackAtIndex(uint32_t idx); GetLanguageRuntimeCreateCallbackAtIndex(uint32_t idx);
static LanguageRuntimeGetCommandObject static LanguageRuntimeGetCommandObject
GetLanguageRuntimeGetCommandObjectAtIndex(uint32_t idx); GetLanguageRuntimeGetCommandObjectAtIndex(uint32_t idx);
static LanguageRuntimeCreateInstance static LanguageRuntimeCreateInstance
GetLanguageRuntimeCreateCallbackForPluginName(const ConstString &name); GetLanguageRuntimeCreateCallbackForPluginName(ConstString name);
//------------------------------------------------------------------ //------------------------------------------------------------------
// SystemRuntime // SystemRuntime
//------------------------------------------------------------------ //------------------------------------------------------------------
static bool RegisterPlugin(const ConstString &name, const char *description, static bool RegisterPlugin(ConstString name, const char *description,
SystemRuntimeCreateInstance create_callback); SystemRuntimeCreateInstance create_callback);
static bool UnregisterPlugin(SystemRuntimeCreateInstance create_callback); static bool UnregisterPlugin(SystemRuntimeCreateInstance create_callback);
static SystemRuntimeCreateInstance static SystemRuntimeCreateInstance
GetSystemRuntimeCreateCallbackAtIndex(uint32_t idx); GetSystemRuntimeCreateCallbackAtIndex(uint32_t idx);
static SystemRuntimeCreateInstance static SystemRuntimeCreateInstance
GetSystemRuntimeCreateCallbackForPluginName(const ConstString &name); GetSystemRuntimeCreateCallbackForPluginName(ConstString name);
//------------------------------------------------------------------ //------------------------------------------------------------------
// ObjectFile // ObjectFile
//------------------------------------------------------------------ //------------------------------------------------------------------
static bool static bool
RegisterPlugin(const ConstString &name, const char *description, RegisterPlugin(ConstString name, const char *description,
ObjectFileCreateInstance create_callback, ObjectFileCreateInstance create_callback,
ObjectFileCreateMemoryInstance create_memory_callback, ObjectFileCreateMemoryInstance create_memory_callback,
ObjectFileGetModuleSpecifications get_module_specifications, ObjectFileGetModuleSpecifications get_module_specifications,
ObjectFileSaveCore save_core = nullptr); ObjectFileSaveCore save_core = nullptr);
static bool UnregisterPlugin(ObjectFileCreateInstance create_callback); static bool UnregisterPlugin(ObjectFileCreateInstance create_callback);
static ObjectFileCreateInstance static ObjectFileCreateInstance
GetObjectFileCreateCallbackAtIndex(uint32_t idx); GetObjectFileCreateCallbackAtIndex(uint32_t idx);
static ObjectFileCreateMemoryInstance static ObjectFileCreateMemoryInstance
GetObjectFileCreateMemoryCallbackAtIndex(uint32_t idx); GetObjectFileCreateMemoryCallbackAtIndex(uint32_t idx);
static ObjectFileGetModuleSpecifications static ObjectFileGetModuleSpecifications
GetObjectFileGetModuleSpecificationsCallbackAtIndex(uint32_t idx); GetObjectFileGetModuleSpecificationsCallbackAtIndex(uint32_t idx);
static ObjectFileCreateInstance static ObjectFileCreateInstance
GetObjectFileCreateCallbackForPluginName(const ConstString &name); GetObjectFileCreateCallbackForPluginName(ConstString name);
static ObjectFileCreateMemoryInstance static ObjectFileCreateMemoryInstance
GetObjectFileCreateMemoryCallbackForPluginName(const ConstString &name); GetObjectFileCreateMemoryCallbackForPluginName(ConstString name);
static Status SaveCore(const lldb::ProcessSP &process_sp, static Status SaveCore(const lldb::ProcessSP &process_sp,
const FileSpec &outfile); const FileSpec &outfile);
//------------------------------------------------------------------ //------------------------------------------------------------------
// ObjectContainer // ObjectContainer
//------------------------------------------------------------------ //------------------------------------------------------------------
static bool static bool
RegisterPlugin(const ConstString &name, const char *description, RegisterPlugin(ConstString name, const char *description,
ObjectContainerCreateInstance create_callback, ObjectContainerCreateInstance create_callback,
ObjectFileGetModuleSpecifications get_module_specifications); ObjectFileGetModuleSpecifications get_module_specifications);
static bool UnregisterPlugin(ObjectContainerCreateInstance create_callback); static bool UnregisterPlugin(ObjectContainerCreateInstance create_callback);
static ObjectContainerCreateInstance static ObjectContainerCreateInstance
GetObjectContainerCreateCallbackAtIndex(uint32_t idx); GetObjectContainerCreateCallbackAtIndex(uint32_t idx);
static ObjectContainerCreateInstance static ObjectContainerCreateInstance
GetObjectContainerCreateCallbackForPluginName(const ConstString &name); GetObjectContainerCreateCallbackForPluginName(ConstString name);
static ObjectFileGetModuleSpecifications static ObjectFileGetModuleSpecifications
GetObjectContainerGetModuleSpecificationsCallbackAtIndex(uint32_t idx); GetObjectContainerGetModuleSpecificationsCallbackAtIndex(uint32_t idx);
//------------------------------------------------------------------ //------------------------------------------------------------------
// Platform // Platform
//------------------------------------------------------------------ //------------------------------------------------------------------
static bool static bool
RegisterPlugin(const ConstString &name, const char *description, RegisterPlugin(ConstString name, const char *description,
PlatformCreateInstance create_callback, PlatformCreateInstance create_callback,
DebuggerInitializeCallback debugger_init_callback = nullptr); DebuggerInitializeCallback debugger_init_callback = nullptr);
static bool UnregisterPlugin(PlatformCreateInstance create_callback); static bool UnregisterPlugin(PlatformCreateInstance create_callback);
static PlatformCreateInstance GetPlatformCreateCallbackAtIndex(uint32_t idx); static PlatformCreateInstance GetPlatformCreateCallbackAtIndex(uint32_t idx);
static PlatformCreateInstance static PlatformCreateInstance
GetPlatformCreateCallbackForPluginName(const ConstString &name); GetPlatformCreateCallbackForPluginName(ConstString name);
static const char *GetPlatformPluginNameAtIndex(uint32_t idx); static const char *GetPlatformPluginNameAtIndex(uint32_t idx);
static const char *GetPlatformPluginDescriptionAtIndex(uint32_t idx); static const char *GetPlatformPluginDescriptionAtIndex(uint32_t idx);
static size_t AutoCompletePlatformName(llvm::StringRef partial_name, static size_t AutoCompletePlatformName(llvm::StringRef partial_name,
StringList &matches); StringList &matches);
//------------------------------------------------------------------ //------------------------------------------------------------------
// Process // Process
//------------------------------------------------------------------ //------------------------------------------------------------------
static bool static bool
RegisterPlugin(const ConstString &name, const char *description, RegisterPlugin(ConstString name, const char *description,
ProcessCreateInstance create_callback, ProcessCreateInstance create_callback,
DebuggerInitializeCallback debugger_init_callback = nullptr); DebuggerInitializeCallback debugger_init_callback = nullptr);
static bool UnregisterPlugin(ProcessCreateInstance create_callback); static bool UnregisterPlugin(ProcessCreateInstance create_callback);
static ProcessCreateInstance GetProcessCreateCallbackAtIndex(uint32_t idx); static ProcessCreateInstance GetProcessCreateCallbackAtIndex(uint32_t idx);
static ProcessCreateInstance static ProcessCreateInstance
GetProcessCreateCallbackForPluginName(const ConstString &name); GetProcessCreateCallbackForPluginName(ConstString name);
static const char *GetProcessPluginNameAtIndex(uint32_t idx); static const char *GetProcessPluginNameAtIndex(uint32_t idx);
static const char *GetProcessPluginDescriptionAtIndex(uint32_t idx); static const char *GetProcessPluginDescriptionAtIndex(uint32_t idx);
//------------------------------------------------------------------ //------------------------------------------------------------------
// ScriptInterpreter // ScriptInterpreter
//------------------------------------------------------------------ //------------------------------------------------------------------
static bool RegisterPlugin(const ConstString &name, const char *description, static bool RegisterPlugin(ConstString name, const char *description,
lldb::ScriptLanguage script_lang, lldb::ScriptLanguage script_lang,
ScriptInterpreterCreateInstance create_callback); ScriptInterpreterCreateInstance create_callback);
static bool UnregisterPlugin(ScriptInterpreterCreateInstance create_callback); static bool UnregisterPlugin(ScriptInterpreterCreateInstance create_callback);
static ScriptInterpreterCreateInstance static ScriptInterpreterCreateInstance
GetScriptInterpreterCreateCallbackAtIndex(uint32_t idx); GetScriptInterpreterCreateCallbackAtIndex(uint32_t idx);
Show All 32 Lines
/// provided in read-write mode, and may be modified by the /// provided in read-write mode, and may be modified by the
/// plugin if, for instance, additional environment variables /// plugin if, for instance, additional environment variables
/// are needed to support the feature when enabled. /// are needed to support the feature when enabled.
/// ///
/// @return /// @return
/// Returns true upon success; otherwise, false. /// Returns true upon success; otherwise, false.
//------------------------------------------------------------------ //------------------------------------------------------------------
static bool static bool
RegisterPlugin(const ConstString &name, const char *description, RegisterPlugin(ConstString name, const char *description,
StructuredDataPluginCreateInstance create_callback, StructuredDataPluginCreateInstance create_callback,
DebuggerInitializeCallback debugger_init_callback = nullptr, DebuggerInitializeCallback debugger_init_callback = nullptr,
StructuredDataFilterLaunchInfo filter_callback = nullptr); StructuredDataFilterLaunchInfo filter_callback = nullptr);
static bool static bool
UnregisterPlugin(StructuredDataPluginCreateInstance create_callback); UnregisterPlugin(StructuredDataPluginCreateInstance create_callback);
static StructuredDataPluginCreateInstance static StructuredDataPluginCreateInstance
GetStructuredDataPluginCreateCallbackAtIndex(uint32_t idx); GetStructuredDataPluginCreateCallbackAtIndex(uint32_t idx);
static StructuredDataPluginCreateInstance static StructuredDataPluginCreateInstance
GetStructuredDataPluginCreateCallbackForPluginName(const ConstString &name); GetStructuredDataPluginCreateCallbackForPluginName(ConstString name);
static StructuredDataFilterLaunchInfo static StructuredDataFilterLaunchInfo
GetStructuredDataFilterCallbackAtIndex(uint32_t idx, GetStructuredDataFilterCallbackAtIndex(uint32_t idx,
bool &iteration_complete); bool &iteration_complete);
//------------------------------------------------------------------ //------------------------------------------------------------------
// SymbolFile // SymbolFile
//------------------------------------------------------------------ //------------------------------------------------------------------
static bool static bool
RegisterPlugin(const ConstString &name, const char *description, RegisterPlugin(ConstString name, const char *description,
SymbolFileCreateInstance create_callback, SymbolFileCreateInstance create_callback,
DebuggerInitializeCallback debugger_init_callback = nullptr); DebuggerInitializeCallback debugger_init_callback = nullptr);
static bool UnregisterPlugin(SymbolFileCreateInstance create_callback); static bool UnregisterPlugin(SymbolFileCreateInstance create_callback);
static SymbolFileCreateInstance static SymbolFileCreateInstance
GetSymbolFileCreateCallbackAtIndex(uint32_t idx); GetSymbolFileCreateCallbackAtIndex(uint32_t idx);
static SymbolFileCreateInstance static SymbolFileCreateInstance
GetSymbolFileCreateCallbackForPluginName(const ConstString &name); GetSymbolFileCreateCallbackForPluginName(ConstString name);
//------------------------------------------------------------------ //------------------------------------------------------------------
// SymbolVendor // SymbolVendor
//------------------------------------------------------------------ //------------------------------------------------------------------
static bool RegisterPlugin(const ConstString &name, const char *description, static bool RegisterPlugin(ConstString name, const char *description,
SymbolVendorCreateInstance create_callback); SymbolVendorCreateInstance create_callback);
static bool UnregisterPlugin(SymbolVendorCreateInstance create_callback); static bool UnregisterPlugin(SymbolVendorCreateInstance create_callback);
static SymbolVendorCreateInstance static SymbolVendorCreateInstance
GetSymbolVendorCreateCallbackAtIndex(uint32_t idx); GetSymbolVendorCreateCallbackAtIndex(uint32_t idx);
static SymbolVendorCreateInstance static SymbolVendorCreateInstance
GetSymbolVendorCreateCallbackForPluginName(const ConstString &name); GetSymbolVendorCreateCallbackForPluginName(ConstString name);
//------------------------------------------------------------------ //------------------------------------------------------------------
// UnwindAssembly // UnwindAssembly
//------------------------------------------------------------------ //------------------------------------------------------------------
static bool RegisterPlugin(const ConstString &name, const char *description, static bool RegisterPlugin(ConstString name, const char *description,
UnwindAssemblyCreateInstance create_callback); UnwindAssemblyCreateInstance create_callback);
static bool UnregisterPlugin(UnwindAssemblyCreateInstance create_callback); static bool UnregisterPlugin(UnwindAssemblyCreateInstance create_callback);
static UnwindAssemblyCreateInstance static UnwindAssemblyCreateInstance
GetUnwindAssemblyCreateCallbackAtIndex(uint32_t idx); GetUnwindAssemblyCreateCallbackAtIndex(uint32_t idx);
static UnwindAssemblyCreateInstance static UnwindAssemblyCreateInstance
GetUnwindAssemblyCreateCallbackForPluginName(const ConstString &name); GetUnwindAssemblyCreateCallbackForPluginName(ConstString name);
//------------------------------------------------------------------ //------------------------------------------------------------------
// MemoryHistory // MemoryHistory
//------------------------------------------------------------------ //------------------------------------------------------------------
static bool RegisterPlugin(const ConstString &name, const char *description, static bool RegisterPlugin(ConstString name, const char *description,
MemoryHistoryCreateInstance create_callback); MemoryHistoryCreateInstance create_callback);
static bool UnregisterPlugin(MemoryHistoryCreateInstance create_callback); static bool UnregisterPlugin(MemoryHistoryCreateInstance create_callback);
static MemoryHistoryCreateInstance static MemoryHistoryCreateInstance
GetMemoryHistoryCreateCallbackAtIndex(uint32_t idx); GetMemoryHistoryCreateCallbackAtIndex(uint32_t idx);
static MemoryHistoryCreateInstance static MemoryHistoryCreateInstance
GetMemoryHistoryCreateCallbackForPluginName(const ConstString &name); GetMemoryHistoryCreateCallbackForPluginName(ConstString name);
//------------------------------------------------------------------ //------------------------------------------------------------------
// InstrumentationRuntime // InstrumentationRuntime
//------------------------------------------------------------------ //------------------------------------------------------------------
static bool static bool
RegisterPlugin(const ConstString &name, const char *description, RegisterPlugin(ConstString name, const char *description,
InstrumentationRuntimeCreateInstance create_callback, InstrumentationRuntimeCreateInstance create_callback,
InstrumentationRuntimeGetType get_type_callback); InstrumentationRuntimeGetType get_type_callback);
static bool static bool
UnregisterPlugin(InstrumentationRuntimeCreateInstance create_callback); UnregisterPlugin(InstrumentationRuntimeCreateInstance create_callback);
static InstrumentationRuntimeGetType static InstrumentationRuntimeGetType
GetInstrumentationRuntimeGetTypeCallbackAtIndex(uint32_t idx); GetInstrumentationRuntimeGetTypeCallbackAtIndex(uint32_t idx);
static InstrumentationRuntimeCreateInstance static InstrumentationRuntimeCreateInstance
GetInstrumentationRuntimeCreateCallbackAtIndex(uint32_t idx); GetInstrumentationRuntimeCreateCallbackAtIndex(uint32_t idx);
static InstrumentationRuntimeCreateInstance static InstrumentationRuntimeCreateInstance
GetInstrumentationRuntimeCreateCallbackForPluginName(const ConstString &name); GetInstrumentationRuntimeCreateCallbackForPluginName(ConstString name);
//------------------------------------------------------------------ //------------------------------------------------------------------
// TypeSystem // TypeSystem
//------------------------------------------------------------------ //------------------------------------------------------------------
static bool RegisterPlugin( static bool RegisterPlugin(
const ConstString &name, const char *description, ConstString name, const char *description,
TypeSystemCreateInstance create_callback, TypeSystemCreateInstance create_callback,
TypeSystemEnumerateSupportedLanguages enumerate_languages_callback); TypeSystemEnumerateSupportedLanguages enumerate_languages_callback);
static bool UnregisterPlugin(TypeSystemCreateInstance create_callback); static bool UnregisterPlugin(TypeSystemCreateInstance create_callback);
static TypeSystemCreateInstance static TypeSystemCreateInstance
GetTypeSystemCreateCallbackAtIndex(uint32_t idx); GetTypeSystemCreateCallbackAtIndex(uint32_t idx);
static TypeSystemCreateInstance static TypeSystemCreateInstance
GetTypeSystemCreateCallbackForPluginName(const ConstString &name); GetTypeSystemCreateCallbackForPluginName(ConstString name);
static TypeSystemEnumerateSupportedLanguages static TypeSystemEnumerateSupportedLanguages
GetTypeSystemEnumerateSupportedLanguagesCallbackAtIndex(uint32_t idx); GetTypeSystemEnumerateSupportedLanguagesCallbackAtIndex(uint32_t idx);
static TypeSystemEnumerateSupportedLanguages static TypeSystemEnumerateSupportedLanguages
GetTypeSystemEnumerateSupportedLanguagesCallbackForPluginName( GetTypeSystemEnumerateSupportedLanguagesCallbackForPluginName(
const ConstString &name); ConstString name);
//------------------------------------------------------------------ //------------------------------------------------------------------
// REPL // REPL
//------------------------------------------------------------------ //------------------------------------------------------------------
static bool static bool
RegisterPlugin(const ConstString &name, const char *description, RegisterPlugin(ConstString name, const char *description,
REPLCreateInstance create_callback, REPLCreateInstance create_callback,
REPLEnumerateSupportedLanguages enumerate_languages_callback); REPLEnumerateSupportedLanguages enumerate_languages_callback);
static bool UnregisterPlugin(REPLCreateInstance create_callback); static bool UnregisterPlugin(REPLCreateInstance create_callback);
static REPLCreateInstance GetREPLCreateCallbackAtIndex(uint32_t idx); static REPLCreateInstance GetREPLCreateCallbackAtIndex(uint32_t idx);
static REPLCreateInstance static REPLCreateInstance
GetREPLCreateCallbackForPluginName(const ConstString &name); GetREPLCreateCallbackForPluginName(ConstString name);
static REPLEnumerateSupportedLanguages static REPLEnumerateSupportedLanguages
GetREPLEnumerateSupportedLanguagesCallbackAtIndex(uint32_t idx); GetREPLEnumerateSupportedLanguagesCallbackAtIndex(uint32_t idx);
static REPLEnumerateSupportedLanguages static REPLEnumerateSupportedLanguages
GetREPLSystemEnumerateSupportedLanguagesCallbackForPluginName( GetREPLSystemEnumerateSupportedLanguagesCallbackForPluginName(
const ConstString &name); ConstString name);
//------------------------------------------------------------------ //------------------------------------------------------------------
// Some plug-ins might register a DebuggerInitializeCallback callback when // Some plug-ins might register a DebuggerInitializeCallback callback when
// registering the plug-in. After a new Debugger instance is created, this // registering the plug-in. After a new Debugger instance is created, this
// DebuggerInitialize function will get called. This allows plug-ins to // DebuggerInitialize function will get called. This allows plug-ins to
// install Properties and do any other initialization that requires a // install Properties and do any other initialization that requires a
// debugger instance. // debugger instance.
//------------------------------------------------------------------ //------------------------------------------------------------------
static void DebuggerInitialize(Debugger &debugger); static void DebuggerInitialize(Debugger &debugger);
static lldb::OptionValuePropertiesSP static lldb::OptionValuePropertiesSP
GetSettingForDynamicLoaderPlugin(Debugger &debugger, GetSettingForDynamicLoaderPlugin(Debugger &debugger,
const ConstString &setting_name); ConstString setting_name);
static bool CreateSettingForDynamicLoaderPlugin( static bool CreateSettingForDynamicLoaderPlugin(
Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp, Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
const ConstString &description, bool is_global_property); ConstString description, bool is_global_property);
static lldb::OptionValuePropertiesSP static lldb::OptionValuePropertiesSP
GetSettingForPlatformPlugin(Debugger &debugger, GetSettingForPlatformPlugin(Debugger &debugger,
const ConstString &setting_name); ConstString setting_name);
static bool CreateSettingForPlatformPlugin( static bool CreateSettingForPlatformPlugin(
Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp, Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
const ConstString &description, bool is_global_property); ConstString description, bool is_global_property);
static lldb::OptionValuePropertiesSP static lldb::OptionValuePropertiesSP
GetSettingForProcessPlugin(Debugger &debugger, GetSettingForProcessPlugin(Debugger &debugger,
const ConstString &setting_name); ConstString setting_name);
static bool CreateSettingForProcessPlugin( static bool CreateSettingForProcessPlugin(
Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp, Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
const ConstString &description, bool is_global_property); ConstString description, bool is_global_property);
static lldb::OptionValuePropertiesSP static lldb::OptionValuePropertiesSP
GetSettingForSymbolFilePlugin(Debugger &debugger, GetSettingForSymbolFilePlugin(Debugger &debugger,
const ConstString &setting_name); ConstString setting_name);
static bool CreateSettingForSymbolFilePlugin( static bool CreateSettingForSymbolFilePlugin(
Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp, Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
const ConstString &description, bool is_global_property); ConstString description, bool is_global_property);
static lldb::OptionValuePropertiesSP static lldb::OptionValuePropertiesSP
GetSettingForJITLoaderPlugin(Debugger &debugger, GetSettingForJITLoaderPlugin(Debugger &debugger,
const ConstString &setting_name); ConstString setting_name);
static bool CreateSettingForJITLoaderPlugin( static bool CreateSettingForJITLoaderPlugin(
Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp, Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
const ConstString &description, bool is_global_property); ConstString description, bool is_global_property);
static lldb::OptionValuePropertiesSP static lldb::OptionValuePropertiesSP
GetSettingForOperatingSystemPlugin(Debugger &debugger, GetSettingForOperatingSystemPlugin(Debugger &debugger,
const ConstString &setting_name); ConstString setting_name);
static bool CreateSettingForOperatingSystemPlugin( static bool CreateSettingForOperatingSystemPlugin(
Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp, Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
const ConstString &description, bool is_global_property); ConstString description, bool is_global_property);
static lldb::OptionValuePropertiesSP static lldb::OptionValuePropertiesSP
GetSettingForStructuredDataPlugin(Debugger &debugger, GetSettingForStructuredDataPlugin(Debugger &debugger,
const ConstString &setting_name); ConstString setting_name);
static bool CreateSettingForStructuredDataPlugin( static bool CreateSettingForStructuredDataPlugin(
Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp, Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
const ConstString &description, bool is_global_property); ConstString description, bool is_global_property);
}; };
} // namespace lldb_private } // namespace lldb_private
#endif // liblldb_PluginManager_h_ #endif // liblldb_PluginManager_h_
Context not available.

lldb/include/lldb/Core/RichManglingContext.h

Show All 16 Lines
m_ipd_buf = static_cast<char *>(std::malloc(m_ipd_buf_size)); m_ipd_buf = static_cast<char *>(std::malloc(m_ipd_buf_size));
m_ipd_buf[0] = '\0'; m_ipd_buf[0] = '\0';
} }
~RichManglingContext() { std::free(m_ipd_buf); } ~RichManglingContext() { std::free(m_ipd_buf); }
/// Use the ItaniumPartialDemangler to obtain rich mangling information from /// Use the ItaniumPartialDemangler to obtain rich mangling information from
/// the given mangled name. /// the given mangled name.
bool FromItaniumName(const ConstString &mangled); bool FromItaniumName(ConstString mangled);
/// Use the legacy language parser implementation to obtain rich mangling /// Use the legacy language parser implementation to obtain rich mangling
/// information from the given demangled name. /// information from the given demangled name.
bool FromCxxMethodName(const ConstString &demangled); bool FromCxxMethodName(ConstString demangled);
/// If this symbol describes a constructor or destructor. /// If this symbol describes a constructor or destructor.
bool IsCtorOrDtor() const; bool IsCtorOrDtor() const;
/// If this symbol describes a function. /// If this symbol describes a function.
bool IsFunction() const; bool IsFunction() const;
/// Get the base name of a function. This doesn't include trailing template /// Get the base name of a function. This doesn't include trailing template
Show All 16 Lines

lldb/include/lldb/Core/Section.h

Show All 16 Lines
size_t AddUniqueSection(const lldb::SectionSP &section_sp); size_t AddUniqueSection(const lldb::SectionSP &section_sp);
size_t FindSectionIndex(const Section *sect); size_t FindSectionIndex(const Section *sect);
bool ContainsSection(lldb::user_id_t sect_id) const; bool ContainsSection(lldb::user_id_t sect_id) const;
void Dump(Stream *s, Target *target, bool show_header, uint32_t depth) const; void Dump(Stream *s, Target *target, bool show_header, uint32_t depth) const;
lldb::SectionSP FindSectionByName(const ConstString &section_dstr) const; lldb::SectionSP FindSectionByName(ConstString section_dstr) const;
lldb::SectionSP FindSectionByID(lldb::user_id_t sect_id) const; lldb::SectionSP FindSectionByID(lldb::user_id_t sect_id) const;
lldb::SectionSP FindSectionByType(lldb::SectionType sect_type, lldb::SectionSP FindSectionByType(lldb::SectionType sect_type,
bool check_children, bool check_children,
size_t start_idx = 0) const; size_t start_idx = 0) const;
lldb::SectionSP lldb::SectionSP
Show All 25 Lines
class Section : public std::enable_shared_from_this<Section>, class Section : public std::enable_shared_from_this<Section>,
public ModuleChild, public ModuleChild,
public UserID, public UserID,
public Flags { public Flags {
public: public:
// Create a root section (one that has no parent) // Create a root section (one that has no parent)
Section(const lldb::ModuleSP &module_sp, ObjectFile *obj_file, Section(const lldb::ModuleSP &module_sp, ObjectFile *obj_file,
lldb::user_id_t sect_id, const ConstString &name, lldb::user_id_t sect_id, ConstString name,
lldb::SectionType sect_type, lldb::addr_t file_vm_addr, lldb::SectionType sect_type, lldb::addr_t file_vm_addr,
lldb::addr_t vm_size, lldb::offset_t file_offset, lldb::addr_t vm_size, lldb::offset_t file_offset,
lldb::offset_t file_size, uint32_t log2align, uint32_t flags, lldb::offset_t file_size, uint32_t log2align, uint32_t flags,
uint32_t target_byte_size = 1); uint32_t target_byte_size = 1);
// Create a section that is a child of parent_section_sp // Create a section that is a child of parent_section_sp
Section(const lldb::SectionSP &parent_section_sp, // NULL for top level Section(const lldb::SectionSP &parent_section_sp, // NULL for top level
// sections, non-NULL for // sections, non-NULL for
// child sections // child sections
const lldb::ModuleSP &module_sp, ObjectFile *obj_file, const lldb::ModuleSP &module_sp, ObjectFile *obj_file,
lldb::user_id_t sect_id, const ConstString &name, lldb::user_id_t sect_id, ConstString name,
lldb::SectionType sect_type, lldb::addr_t file_vm_addr, lldb::SectionType sect_type, lldb::addr_t file_vm_addr,
lldb::addr_t vm_size, lldb::offset_t file_offset, lldb::addr_t vm_size, lldb::offset_t file_offset,
lldb::offset_t file_size, uint32_t log2align, uint32_t flags, lldb::offset_t file_size, uint32_t log2align, uint32_t flags,
uint32_t target_byte_size = 1); uint32_t target_byte_size = 1);
~Section(); ~Section();
static int Compare(const Section &a, const Section &b); static int Compare(const Section &a, const Section &b);
Show All 32 Lines
void SetIsFake(bool fake) { m_fake = fake; } void SetIsFake(bool fake) { m_fake = fake; }
bool IsEncrypted() const { return m_encrypted; } bool IsEncrypted() const { return m_encrypted; }
void SetIsEncrypted(bool b) { m_encrypted = b; } void SetIsEncrypted(bool b) { m_encrypted = b; }
bool IsDescendant(const Section *section); bool IsDescendant(const Section *section);
const ConstString &GetName() const { return m_name; } ConstString GetName() const { return m_name; }
bool Slide(lldb::addr_t slide_amount, bool slide_children); bool Slide(lldb::addr_t slide_amount, bool slide_children);
lldb::SectionType GetType() const { return m_type; } lldb::SectionType GetType() const { return m_type; }
const char *GetTypeAsCString() const; const char *GetTypeAsCString() const;
lldb::SectionSP GetParent() const { return m_parent_wp.lock(); } lldb::SectionSP GetParent() const { return m_parent_wp.lock(); }
Show All 16 Lines

lldb/include/lldb/Core/UserSettingsController.h

Show All 16 Lines
virtual void DumpAllDescriptions(CommandInterpreter &interpreter, virtual void DumpAllDescriptions(CommandInterpreter &interpreter,
Stream &strm) const; Stream &strm) const;
size_t Apropos(llvm::StringRef keyword, size_t Apropos(llvm::StringRef keyword,
std::vector<const Property *> &matching_properties) const; std::vector<const Property *> &matching_properties) const;
lldb::OptionValuePropertiesSP GetSubProperty(const ExecutionContext *exe_ctx, lldb::OptionValuePropertiesSP GetSubProperty(const ExecutionContext *exe_ctx,
const ConstString &name); ConstString name);
// We sometimes need to introduce a setting to enable experimental features, // We sometimes need to introduce a setting to enable experimental features,
// but then we don't want the setting for these to cause errors when the // but then we don't want the setting for these to cause errors when the
// setting goes away. Add a sub-topic of the settings using this // setting goes away. Add a sub-topic of the settings using this
// experimental name, and two things will happen. One is that settings that // experimental name, and two things will happen. One is that settings that
// don't find the name will not be treated as errors. Also, if you decide to // don't find the name will not be treated as errors. Also, if you decide to
// keep the settings just move them into the containing properties, and we // keep the settings just move them into the containing properties, and we
// will auto-forward the experimental settings to the real one. // will auto-forward the experimental settings to the real one.
Show All 11 Lines

lldb/include/lldb/Core/ValueObject.h

Show All 16 Lines
virtual bool GetDeclaration(Declaration &decl); virtual bool GetDeclaration(Declaration &decl);
//------------------------------------------------------------------ //------------------------------------------------------------------
// The functions below should NOT be modified by subclasses // The functions below should NOT be modified by subclasses
//------------------------------------------------------------------ //------------------------------------------------------------------
const Status &GetError(); const Status &GetError();
const ConstString &GetName() const; ConstString GetName() const;
virtual lldb::ValueObjectSP GetChildAtIndex(size_t idx, bool can_create); virtual lldb::ValueObjectSP GetChildAtIndex(size_t idx, bool can_create);
// this will always create the children if necessary // this will always create the children if necessary
lldb::ValueObjectSP GetChildAtIndexPath(llvm::ArrayRef<size_t> idxs, lldb::ValueObjectSP GetChildAtIndexPath(llvm::ArrayRef<size_t> idxs,
size_t *index_of_error = nullptr); size_t *index_of_error = nullptr);
lldb::ValueObjectSP lldb::ValueObjectSP
GetChildAtIndexPath(llvm::ArrayRef<std::pair<size_t, bool>> idxs, GetChildAtIndexPath(llvm::ArrayRef<std::pair<size_t, bool>> idxs,
size_t *index_of_error = nullptr); size_t *index_of_error = nullptr);
// this will always create the children if necessary // this will always create the children if necessary
lldb::ValueObjectSP GetChildAtNamePath(llvm::ArrayRef<ConstString> names, lldb::ValueObjectSP GetChildAtNamePath(llvm::ArrayRef<ConstString> names,
ConstString *name_of_error = nullptr); ConstString *name_of_error = nullptr);
lldb::ValueObjectSP lldb::ValueObjectSP
GetChildAtNamePath(llvm::ArrayRef<std::pair<ConstString, bool>> names, GetChildAtNamePath(llvm::ArrayRef<std::pair<ConstString, bool>> names,
ConstString *name_of_error = nullptr); ConstString *name_of_error = nullptr);
virtual lldb::ValueObjectSP GetChildMemberWithName(const ConstString &name, virtual lldb::ValueObjectSP GetChildMemberWithName(ConstString name,
bool can_create); bool can_create);
virtual size_t GetIndexOfChildWithName(const ConstString &name); virtual size_t GetIndexOfChildWithName(ConstString name);
size_t GetNumChildren(uint32_t max = UINT32_MAX); size_t GetNumChildren(uint32_t max = UINT32_MAX);
const Value &GetValue() const; const Value &GetValue() const;
Value &GetValue(); Value &GetValue();
virtual bool ResolveValue(Scalar &scalar); virtual bool ResolveValue(Scalar &scalar);
Show All 32 Lines
bool UpdateFormatsIfNeeded(); bool UpdateFormatsIfNeeded();
lldb::ValueObjectSP GetSP() { return m_manager->GetSharedPointer(this); } lldb::ValueObjectSP GetSP() { return m_manager->GetSharedPointer(this); }
// Change the name of the current ValueObject. Should *not* be used from a // Change the name of the current ValueObject. Should *not* be used from a
// synthetic child provider as it would change the name of the non synthetic // synthetic child provider as it would change the name of the non synthetic
// child as well. // child as well.
void SetName(const ConstString &name); void SetName(ConstString name);
virtual lldb::addr_t GetAddressOf(bool scalar_is_load_address = true, virtual lldb::addr_t GetAddressOf(bool scalar_is_load_address = true,
AddressType *address_type = nullptr); AddressType *address_type = nullptr);
lldb::addr_t GetPointerValue(AddressType *address_type = nullptr); lldb::addr_t GetPointerValue(AddressType *address_type = nullptr);
lldb::ValueObjectSP GetSyntheticChild(const ConstString &key) const; lldb::ValueObjectSP GetSyntheticChild(ConstString key) const;
lldb::ValueObjectSP GetSyntheticArrayMember(size_t index, bool can_create); lldb::ValueObjectSP GetSyntheticArrayMember(size_t index, bool can_create);
lldb::ValueObjectSP GetSyntheticBitFieldChild(uint32_t from, uint32_t to, lldb::ValueObjectSP GetSyntheticBitFieldChild(uint32_t from, uint32_t to,
bool can_create); bool can_create);
lldb::ValueObjectSP GetSyntheticExpressionPathChild(const char *expression, lldb::ValueObjectSP GetSyntheticExpressionPathChild(const char *expression,
bool can_create); bool can_create);
Show All 20 Lines
virtual bool HasSyntheticValue(); virtual bool HasSyntheticValue();
virtual bool IsSynthetic() { return false; } virtual bool IsSynthetic() { return false; }
lldb::ValueObjectSP lldb::ValueObjectSP
GetQualifiedRepresentationIfAvailable(lldb::DynamicValueType dynValue, GetQualifiedRepresentationIfAvailable(lldb::DynamicValueType dynValue,
bool synthValue); bool synthValue);
virtual lldb::ValueObjectSP CreateConstantValue(const ConstString &name); virtual lldb::ValueObjectSP CreateConstantValue(ConstString name);
virtual lldb::ValueObjectSP Dereference(Status &error); virtual lldb::ValueObjectSP Dereference(Status &error);
// Creates a copy of the ValueObject with a new name and setting the current // Creates a copy of the ValueObject with a new name and setting the current
// ValueObject as its parent. It should be used when we want to change the // ValueObject as its parent. It should be used when we want to change the
// name of a ValueObject without modifying the actual ValueObject itself // name of a ValueObject without modifying the actual ValueObject itself
// (e.g. sythetic child provider). // (e.g. sythetic child provider).
virtual lldb::ValueObjectSP Clone(const ConstString &new_name); virtual lldb::ValueObjectSP Clone(ConstString new_name);
virtual lldb::ValueObjectSP AddressOf(Status &error); virtual lldb::ValueObjectSP AddressOf(Status &error);
virtual lldb::addr_t GetLiveAddress() { return LLDB_INVALID_ADDRESS; } virtual lldb::addr_t GetLiveAddress() { return LLDB_INVALID_ADDRESS; }
virtual void SetLiveAddress(lldb::addr_t addr = LLDB_INVALID_ADDRESS, virtual void SetLiveAddress(lldb::addr_t addr = LLDB_INVALID_ADDRESS,
AddressType address_type = eAddressTypeLoad) {} AddressType address_type = eAddressTypeLoad) {}
Show All 32 Lines
void SetValueDidChange(bool value_changed); void SetValueDidChange(bool value_changed);
void SetValueIsValid(bool valid); void SetValueIsValid(bool valid);
void ClearUserVisibleData( void ClearUserVisibleData(
uint32_t items = ValueObject::eClearUserVisibleDataItemsAllStrings); uint32_t items = ValueObject::eClearUserVisibleDataItemsAllStrings);
void AddSyntheticChild(const ConstString &key, ValueObject *valobj); void AddSyntheticChild(ConstString key, ValueObject *valobj);
DataExtractor &GetDataExtractor(); DataExtractor &GetDataExtractor();
void ClearDynamicTypeInformation(); void ClearDynamicTypeInformation();
//------------------------------------------------------------------ //------------------------------------------------------------------
// Subclasses must implement the functions below. // Subclasses must implement the functions below.
//------------------------------------------------------------------ //------------------------------------------------------------------
Show All 16 Lines

lldb/include/lldb/Core/ValueObjectCast.h

Show All 16 Lines
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
// A ValueObject that represents a given value represented as a different type. // A ValueObject that represents a given value represented as a different type.
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
class ValueObjectCast : public ValueObject { class ValueObjectCast : public ValueObject {
public: public:
~ValueObjectCast() override; ~ValueObjectCast() override;
static lldb::ValueObjectSP Create(ValueObject &parent, static lldb::ValueObjectSP Create(ValueObject &parent,
const ConstString &name, ConstString name,
const CompilerType &cast_type); const CompilerType &cast_type);
uint64_t GetByteSize() override; uint64_t GetByteSize() override;
size_t CalculateNumChildren(uint32_t max) override; size_t CalculateNumChildren(uint32_t max) override;
lldb::ValueType GetValueType() const override; lldb::ValueType GetValueType() const override;
bool IsInScope() override; bool IsInScope() override;
ValueObject *GetParent() override { ValueObject *GetParent() override {
return ((m_parent != nullptr) ? m_parent->GetParent() : nullptr); return ((m_parent != nullptr) ? m_parent->GetParent() : nullptr);
} }
const ValueObject *GetParent() const override { const ValueObject *GetParent() const override {
return ((m_parent != nullptr) ? m_parent->GetParent() : nullptr); return ((m_parent != nullptr) ? m_parent->GetParent() : nullptr);
} }
protected: protected:
ValueObjectCast(ValueObject &parent, const ConstString &name, ValueObjectCast(ValueObject &parent, ConstString name,
const CompilerType &cast_type); const CompilerType &cast_type);
bool UpdateValue() override; bool UpdateValue() override;
CompilerType GetCompilerTypeImpl() override; CompilerType GetCompilerTypeImpl() override;
CompilerType m_cast_type; CompilerType m_cast_type;
private: private:
DISALLOW_COPY_AND_ASSIGN(ValueObjectCast); DISALLOW_COPY_AND_ASSIGN(ValueObjectCast);
}; };
} // namespace lldb_private } // namespace lldb_private
#endif // liblldb_ValueObjectCast_h_ #endif // liblldb_ValueObjectCast_h_
Context not available.

lldb/include/lldb/Core/ValueObjectChild.h

Show All 16 Lines
// ReadValueFromMemory (ValueObject* parent, lldb::addr_t address); // ReadValueFromMemory (ValueObject* parent, lldb::addr_t address);
protected: protected:
friend class ValueObject; friend class ValueObject;
friend class ValueObjectConstResult; friend class ValueObjectConstResult;
friend class ValueObjectConstResultImpl; friend class ValueObjectConstResultImpl;
ValueObjectChild(ValueObject &parent, const CompilerType &compiler_type, ValueObjectChild(ValueObject &parent, const CompilerType &compiler_type,
const ConstString &name, uint64_t byte_size, ConstString name, uint64_t byte_size,
int32_t byte_offset, uint32_t bitfield_bit_size, int32_t byte_offset, uint32_t bitfield_bit_size,
uint32_t bitfield_bit_offset, bool is_base_class, uint32_t bitfield_bit_offset, bool is_base_class,
bool is_deref_of_parent, bool is_deref_of_parent,
AddressType child_ptr_or_ref_addr_type, AddressType child_ptr_or_ref_addr_type,
uint64_t language_flags); uint64_t language_flags);
DISALLOW_COPY_AND_ASSIGN(ValueObjectChild); DISALLOW_COPY_AND_ASSIGN(ValueObjectChild);
}; };
} // namespace lldb_private } // namespace lldb_private
#endif // liblldb_ValueObjectChild_h_ #endif // liblldb_ValueObjectChild_h_
Context not available.

lldb/include/lldb/Core/ValueObjectConstResult.h

Show All 16 Lines
~ValueObjectConstResult() override; ~ValueObjectConstResult() override;
static lldb::ValueObjectSP static lldb::ValueObjectSP
Create(ExecutionContextScope *exe_scope, lldb::ByteOrder byte_order, Create(ExecutionContextScope *exe_scope, lldb::ByteOrder byte_order,
uint32_t addr_byte_size, lldb::addr_t address = LLDB_INVALID_ADDRESS); uint32_t addr_byte_size, lldb::addr_t address = LLDB_INVALID_ADDRESS);
static lldb::ValueObjectSP static lldb::ValueObjectSP
Create(ExecutionContextScope *exe_scope, const CompilerType &compiler_type, Create(ExecutionContextScope *exe_scope, const CompilerType &compiler_type,
const ConstString &name, const DataExtractor &data, ConstString name, const DataExtractor &data,
lldb::addr_t address = LLDB_INVALID_ADDRESS); lldb::addr_t address = LLDB_INVALID_ADDRESS);
static lldb::ValueObjectSP static lldb::ValueObjectSP
Create(ExecutionContextScope *exe_scope, const CompilerType &compiler_type, Create(ExecutionContextScope *exe_scope, const CompilerType &compiler_type,
const ConstString &name, const lldb::DataBufferSP &result_data_sp, ConstString name, const lldb::DataBufferSP &result_data_sp,
lldb::ByteOrder byte_order, uint32_t addr_size, lldb::ByteOrder byte_order, uint32_t addr_size,
lldb::addr_t address = LLDB_INVALID_ADDRESS); lldb::addr_t address = LLDB_INVALID_ADDRESS);
static lldb::ValueObjectSP static lldb::ValueObjectSP
Create(ExecutionContextScope *exe_scope, const CompilerType &compiler_type, Create(ExecutionContextScope *exe_scope, const CompilerType &compiler_type,
const ConstString &name, lldb::addr_t address, ConstString name, lldb::addr_t address,
AddressType address_type, uint32_t addr_byte_size); AddressType address_type, uint32_t addr_byte_size);
static lldb::ValueObjectSP Create(ExecutionContextScope *exe_scope, static lldb::ValueObjectSP Create(ExecutionContextScope *exe_scope,
Value &value, const ConstString &name, Value &value, ConstString name,
Module *module = nullptr); Module *module = nullptr);
// When an expression fails to evaluate, we return an error // When an expression fails to evaluate, we return an error
static lldb::ValueObjectSP Create(ExecutionContextScope *exe_scope, static lldb::ValueObjectSP Create(ExecutionContextScope *exe_scope,
const Status &error); const Status &error);
uint64_t GetByteSize() override; uint64_t GetByteSize() override;
Show All 32 Lines
friend class ValueObjectConstResultImpl; friend class ValueObjectConstResultImpl;
ValueObjectConstResult(ExecutionContextScope *exe_scope, ValueObjectConstResult(ExecutionContextScope *exe_scope,
lldb::ByteOrder byte_order, uint32_t addr_byte_size, lldb::ByteOrder byte_order, uint32_t addr_byte_size,
lldb::addr_t address); lldb::addr_t address);
ValueObjectConstResult(ExecutionContextScope *exe_scope, ValueObjectConstResult(ExecutionContextScope *exe_scope,
const CompilerType &compiler_type, const CompilerType &compiler_type,
const ConstString &name, const DataExtractor &data, ConstString name, const DataExtractor &data,
lldb::addr_t address); lldb::addr_t address);
ValueObjectConstResult(ExecutionContextScope *exe_scope, ValueObjectConstResult(ExecutionContextScope *exe_scope,
const CompilerType &compiler_type, const CompilerType &compiler_type,
const ConstString &name, ConstString name,
const lldb::DataBufferSP &result_data_sp, const lldb::DataBufferSP &result_data_sp,
lldb::ByteOrder byte_order, uint32_t addr_size, lldb::ByteOrder byte_order, uint32_t addr_size,
lldb::addr_t address); lldb::addr_t address);
ValueObjectConstResult(ExecutionContextScope *exe_scope, ValueObjectConstResult(ExecutionContextScope *exe_scope,
const CompilerType &compiler_type, const CompilerType &compiler_type,
const ConstString &name, lldb::addr_t address, ConstString name, lldb::addr_t address,
AddressType address_type, uint32_t addr_byte_size); AddressType address_type, uint32_t addr_byte_size);
ValueObjectConstResult(ExecutionContextScope *exe_scope, const Value &value, ValueObjectConstResult(ExecutionContextScope *exe_scope, const Value &value,
const ConstString &name, Module *module = nullptr); ConstString name, Module *module = nullptr);
ValueObjectConstResult(ExecutionContextScope *exe_scope, const Status &error); ValueObjectConstResult(ExecutionContextScope *exe_scope, const Status &error);
DISALLOW_COPY_AND_ASSIGN(ValueObjectConstResult); DISALLOW_COPY_AND_ASSIGN(ValueObjectConstResult);
}; };
} // namespace lldb_private } // namespace lldb_private
#endif // liblldb_ValueObjectConstResult_h_ #endif // liblldb_ValueObjectConstResult_h_
Context not available.

lldb/include/lldb/Core/ValueObjectConstResultCast.h

Show All 16 Lines
namespace lldb_private { namespace lldb_private {
class ValueObject; class ValueObject;
} }
namespace lldb_private { namespace lldb_private {
class ValueObjectConstResultCast : public ValueObjectCast { class ValueObjectConstResultCast : public ValueObjectCast {
public: public:
ValueObjectConstResultCast(ValueObject &parent, const ConstString &name, ValueObjectConstResultCast(ValueObject &parent, ConstString name,
const CompilerType &cast_type, const CompilerType &cast_type,
lldb::addr_t live_address = LLDB_INVALID_ADDRESS); lldb::addr_t live_address = LLDB_INVALID_ADDRESS);
~ValueObjectConstResultCast() override; ~ValueObjectConstResultCast() override;
lldb::ValueObjectSP Dereference(Status &error) override; lldb::ValueObjectSP Dereference(Status &error) override;
ValueObject *CreateChildAtIndex(size_t idx, bool synthetic_array_member, ValueObject *CreateChildAtIndex(size_t idx, bool synthetic_array_member,
Show All 16 Lines

lldb/include/lldb/Core/ValueObjectConstResultChild.h

Show All 16 Lines
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// A child of a ValueObjectConstResult. // A child of a ValueObjectConstResult.
//---------------------------------------------------------------------- //----------------------------------------------------------------------
class ValueObjectConstResultChild : public ValueObjectChild { class ValueObjectConstResultChild : public ValueObjectChild {
public: public:
ValueObjectConstResultChild(ValueObject &parent, ValueObjectConstResultChild(ValueObject &parent,
const CompilerType &compiler_type, const CompilerType &compiler_type,
const ConstString &name, uint32_t byte_size, ConstString name, uint32_t byte_size,
int32_t byte_offset, uint32_t bitfield_bit_size, int32_t byte_offset, uint32_t bitfield_bit_size,
uint32_t bitfield_bit_offset, bool is_base_class, uint32_t bitfield_bit_offset, bool is_base_class,
bool is_deref_of_parent, bool is_deref_of_parent,
lldb::addr_t live_address, lldb::addr_t live_address,
uint64_t language_flags); uint64_t language_flags);
~ValueObjectConstResultChild() override; ~ValueObjectConstResultChild() override;
Show All 16 Lines

lldb/include/lldb/Core/ValueObjectRegister.h

Show All 16 Lines
ConstString GetQualifiedTypeName() override; ConstString GetQualifiedTypeName() override;
size_t CalculateNumChildren(uint32_t max) override; size_t CalculateNumChildren(uint32_t max) override;
ValueObject *CreateChildAtIndex(size_t idx, bool synthetic_array_member, ValueObject *CreateChildAtIndex(size_t idx, bool synthetic_array_member,
int32_t synthetic_index) override; int32_t synthetic_index) override;
lldb::ValueObjectSP GetChildMemberWithName(const ConstString &name, lldb::ValueObjectSP GetChildMemberWithName(ConstString name,
bool can_create) override; bool can_create) override;
size_t GetIndexOfChildWithName(const ConstString &name) override; size_t GetIndexOfChildWithName(ConstString name) override;
protected: protected:
bool UpdateValue() override; bool UpdateValue() override;
CompilerType GetCompilerTypeImpl() override; CompilerType GetCompilerTypeImpl() override;
lldb::RegisterContextSP m_reg_ctx_sp; lldb::RegisterContextSP m_reg_ctx_sp;
const RegisterSet *m_reg_set; const RegisterSet *m_reg_set;
Show All 16 Lines

lldb/include/lldb/Core/ValueObjectSyntheticFilter.h

Show All 16 Lines
bool MightHaveChildren() override; bool MightHaveChildren() override;
size_t CalculateNumChildren(uint32_t max) override; size_t CalculateNumChildren(uint32_t max) override;
lldb::ValueType GetValueType() const override; lldb::ValueType GetValueType() const override;
lldb::ValueObjectSP GetChildAtIndex(size_t idx, bool can_create) override; lldb::ValueObjectSP GetChildAtIndex(size_t idx, bool can_create) override;
lldb::ValueObjectSP GetChildMemberWithName(const ConstString &name, lldb::ValueObjectSP GetChildMemberWithName(ConstString name,
bool can_create) override; bool can_create) override;
size_t GetIndexOfChildWithName(const ConstString &name) override; size_t GetIndexOfChildWithName(ConstString name) override;
lldb::ValueObjectSP lldb::ValueObjectSP
GetDynamicValue(lldb::DynamicValueType valueType) override; GetDynamicValue(lldb::DynamicValueType valueType) override;
bool IsInScope() override; bool IsInScope() override;
bool HasSyntheticValue() override { return false; } bool HasSyntheticValue() override { return false; }
Show All 16 Lines

lldb/include/lldb/DataFormatters/DataVisualization.h

Show All 16 Lines
AnyMatches(ConstString type_name, AnyMatches(ConstString type_name,
TypeCategoryImpl::FormatCategoryItems items = TypeCategoryImpl::FormatCategoryItems items =
TypeCategoryImpl::ALL_ITEM_TYPES, TypeCategoryImpl::ALL_ITEM_TYPES,
bool only_enabled = true, const char **matching_category = nullptr, bool only_enabled = true, const char **matching_category = nullptr,
TypeCategoryImpl::FormatCategoryItems *matching_type = nullptr); TypeCategoryImpl::FormatCategoryItems *matching_type = nullptr);
class NamedSummaryFormats { class NamedSummaryFormats {
public: public:
static bool GetSummaryFormat(const ConstString &type, static bool GetSummaryFormat(ConstString type,
lldb::TypeSummaryImplSP &entry); lldb::TypeSummaryImplSP &entry);
static void Add(const ConstString &type, static void Add(ConstString type,
const lldb::TypeSummaryImplSP &entry); const lldb::TypeSummaryImplSP &entry);
static bool Delete(const ConstString &type); static bool Delete(ConstString type);
static void Clear(); static void Clear();
static void static void
ForEach(std::function<bool(ConstString, const lldb::TypeSummaryImplSP &)> ForEach(std::function<bool(ConstString, const lldb::TypeSummaryImplSP &)>
callback); callback);
static uint32_t GetCount(); static uint32_t GetCount();
}; };
class Categories { class Categories {
public: public:
static bool GetCategory(const ConstString &category, static bool GetCategory(ConstString category,
lldb::TypeCategoryImplSP &entry, lldb::TypeCategoryImplSP &entry,
bool allow_create = true); bool allow_create = true);
static bool GetCategory(lldb::LanguageType language, static bool GetCategory(lldb::LanguageType language,
lldb::TypeCategoryImplSP &entry); lldb::TypeCategoryImplSP &entry);
static void Add(const ConstString &category); static void Add(ConstString category);
static bool Delete(const ConstString &category); static bool Delete(ConstString category);
static void Clear(); static void Clear();
static void Clear(const ConstString &category); static void Clear(ConstString category);
static void Enable(const ConstString &category, static void Enable(ConstString category,
TypeCategoryMap::Position = TypeCategoryMap::Default); TypeCategoryMap::Position = TypeCategoryMap::Default);
static void Enable(lldb::LanguageType lang_type); static void Enable(lldb::LanguageType lang_type);
static void Disable(const ConstString &category); static void Disable(ConstString category);
static void Disable(lldb::LanguageType lang_type); static void Disable(lldb::LanguageType lang_type);
static void Enable(const lldb::TypeCategoryImplSP &category, static void Enable(const lldb::TypeCategoryImplSP &category,
TypeCategoryMap::Position = TypeCategoryMap::Default); TypeCategoryMap::Position = TypeCategoryMap::Default);
static void Disable(const lldb::TypeCategoryImplSP &category); static void Disable(const lldb::TypeCategoryImplSP &category);
Show All 15 Lines

lldb/include/lldb/DataFormatters/FormatCache.h

Show All 16 Lines
}; };
typedef std::map<ConstString, Entry> CacheMap; typedef std::map<ConstString, Entry> CacheMap;
CacheMap m_map; CacheMap m_map;
std::recursive_mutex m_mutex; std::recursive_mutex m_mutex;
uint64_t m_cache_hits; uint64_t m_cache_hits;
uint64_t m_cache_misses; uint64_t m_cache_misses;
Entry &GetEntry(const ConstString &type); Entry &GetEntry(ConstString type);
public: public:
FormatCache(); FormatCache();
bool GetFormat(const ConstString &type, lldb::TypeFormatImplSP &format_sp); bool GetFormat(ConstString type, lldb::TypeFormatImplSP &format_sp);
bool GetSummary(const ConstString &type, lldb::TypeSummaryImplSP &summary_sp); bool GetSummary(ConstString type, lldb::TypeSummaryImplSP &summary_sp);
bool GetSynthetic(const ConstString &type, bool GetSynthetic(ConstString type,
lldb::SyntheticChildrenSP &synthetic_sp); lldb::SyntheticChildrenSP &synthetic_sp);
bool GetValidator(const ConstString &type, bool GetValidator(ConstString type,
lldb::TypeValidatorImplSP &summary_sp); lldb::TypeValidatorImplSP &summary_sp);
void SetFormat(const ConstString &type, lldb::TypeFormatImplSP &format_sp); void SetFormat(ConstString type, lldb::TypeFormatImplSP &format_sp);
void SetSummary(const ConstString &type, lldb::TypeSummaryImplSP &summary_sp); void SetSummary(ConstString type, lldb::TypeSummaryImplSP &summary_sp);
void SetSynthetic(const ConstString &type, void SetSynthetic(ConstString type,
lldb::SyntheticChildrenSP &synthetic_sp); lldb::SyntheticChildrenSP &synthetic_sp);
void SetValidator(const ConstString &type, void SetValidator(ConstString type,
lldb::TypeValidatorImplSP &synthetic_sp); lldb::TypeValidatorImplSP &synthetic_sp);
void Clear(); void Clear();
uint64_t GetCacheHits() { return m_cache_hits; } uint64_t GetCacheHits() { return m_cache_hits; }
uint64_t GetCacheMisses() { return m_cache_misses; } uint64_t GetCacheMisses() { return m_cache_misses; }
}; };
} // namespace lldb_private } // namespace lldb_private
#endif // lldb_FormatCache_h_ #endif // lldb_FormatCache_h_
Context not available.

lldb/include/lldb/DataFormatters/FormatManager.h

Show All 16 Lines
~FormatManager() override = default; ~FormatManager() override = default;
NamedSummariesMap &GetNamedSummaryContainer() { NamedSummariesMap &GetNamedSummaryContainer() {
return m_named_summaries_map; return m_named_summaries_map;
} }
void void
EnableCategory(const ConstString &category_name, EnableCategory(ConstString category_name,
TypeCategoryMap::Position pos = TypeCategoryMap::Default) { TypeCategoryMap::Position pos = TypeCategoryMap::Default) {
EnableCategory(category_name, pos, EnableCategory(category_name, pos,
std::initializer_list<lldb::LanguageType>()); std::initializer_list<lldb::LanguageType>());
} }
void EnableCategory(const ConstString &category_name, void EnableCategory(ConstString category_name,
TypeCategoryMap::Position pos, lldb::LanguageType lang) { TypeCategoryMap::Position pos, lldb::LanguageType lang) {
std::initializer_list<lldb::LanguageType> langs = {lang}; std::initializer_list<lldb::LanguageType> langs = {lang};
EnableCategory(category_name, pos, langs); EnableCategory(category_name, pos, langs);
} }
void EnableCategory(const ConstString &category_name, void EnableCategory(ConstString category_name,
TypeCategoryMap::Position pos = TypeCategoryMap::Default, TypeCategoryMap::Position pos = TypeCategoryMap::Default,
std::initializer_list<lldb::LanguageType> langs = {}) { std::initializer_list<lldb::LanguageType> langs = {}) {
TypeCategoryMap::ValueSP category_sp; TypeCategoryMap::ValueSP category_sp;
if (m_categories_map.Get(category_name, category_sp) && category_sp) { if (m_categories_map.Get(category_name, category_sp) && category_sp) {
m_categories_map.Enable(category_sp, pos); m_categories_map.Enable(category_sp, pos);
for (const lldb::LanguageType lang : langs) for (const lldb::LanguageType lang : langs)
category_sp->AddLanguage(lang); category_sp->AddLanguage(lang);
} }
} }
void DisableCategory(const ConstString &category_name) { void DisableCategory(ConstString category_name) {
m_categories_map.Disable(category_name); m_categories_map.Disable(category_name);
} }
void void
EnableCategory(const lldb::TypeCategoryImplSP &category, EnableCategory(const lldb::TypeCategoryImplSP &category,
TypeCategoryMap::Position pos = TypeCategoryMap::Default) { TypeCategoryMap::Position pos = TypeCategoryMap::Default) {
m_categories_map.Enable(category, pos); m_categories_map.Enable(category, pos);
} }
void DisableCategory(const lldb::TypeCategoryImplSP &category) { void DisableCategory(const lldb::TypeCategoryImplSP &category) {
m_categories_map.Disable(category); m_categories_map.Disable(category);
} }
void EnableAllCategories(); void EnableAllCategories();
void DisableAllCategories(); void DisableAllCategories();
bool DeleteCategory(const ConstString &category_name) { bool DeleteCategory(ConstString category_name) {
return m_categories_map.Delete(category_name); return m_categories_map.Delete(category_name);
} }
void ClearCategories() { return m_categories_map.Clear(); } void ClearCategories() { return m_categories_map.Clear(); }
uint32_t GetCategoriesCount() { return m_categories_map.GetCount(); } uint32_t GetCategoriesCount() { return m_categories_map.GetCount(); }
lldb::TypeCategoryImplSP GetCategoryAtIndex(size_t index) { lldb::TypeCategoryImplSP GetCategoryAtIndex(size_t index) {
return m_categories_map.GetAtIndex(index); return m_categories_map.GetAtIndex(index);
} }
void ForEachCategory(TypeCategoryMap::ForEachCallback callback); void ForEachCategory(TypeCategoryMap::ForEachCallback callback);
lldb::TypeCategoryImplSP GetCategory(const char *category_name = nullptr, lldb::TypeCategoryImplSP GetCategory(const char *category_name = nullptr,
bool can_create = true) { bool can_create = true) {
if (!category_name) if (!category_name)
return GetCategory(m_default_category_name); return GetCategory(m_default_category_name);
return GetCategory(ConstString(category_name)); return GetCategory(ConstString(category_name));
} }
lldb::TypeCategoryImplSP GetCategory(const ConstString &category_name, lldb::TypeCategoryImplSP GetCategory(ConstString category_name,
bool can_create = true); bool can_create = true);
lldb::TypeFormatImplSP lldb::TypeFormatImplSP
GetFormatForType(lldb::TypeNameSpecifierImplSP type_sp); GetFormatForType(lldb::TypeNameSpecifierImplSP type_sp);
lldb::TypeSummaryImplSP lldb::TypeSummaryImplSP
GetSummaryForType(lldb::TypeNameSpecifierImplSP type_sp); GetSummaryForType(lldb::TypeNameSpecifierImplSP type_sp);
Show All 32 Lines
static const char *GetFormatAsCString(lldb::Format format); static const char *GetFormatAsCString(lldb::Format format);
// if the user tries to add formatters for, say, "struct Foo" those will not // if the user tries to add formatters for, say, "struct Foo" those will not
// match any type because of the way we strip qualifiers from typenames this // match any type because of the way we strip qualifiers from typenames this
// method looks for the case where the user is adding a // method looks for the case where the user is adding a
// "class","struct","enum" or "union" Foo and strips the unnecessary // "class","struct","enum" or "union" Foo and strips the unnecessary
// qualifier // qualifier
static ConstString GetValidTypeName(const ConstString &type); static ConstString GetValidTypeName(ConstString type);
// when DataExtractor dumps a vectorOfT, it uses a predefined format for each // when DataExtractor dumps a vectorOfT, it uses a predefined format for each
// item this method returns it, or eFormatInvalid if vector_format is not a // item this method returns it, or eFormatInvalid if vector_format is not a
// vectorOf // vectorOf
static lldb::Format GetSingleItemFormat(lldb::Format vector_format); static lldb::Format GetSingleItemFormat(lldb::Format vector_format);
// this returns true if the ValueObjectPrinter is *highly encouraged* to // this returns true if the ValueObjectPrinter is *highly encouraged* to
// actually represent this ValueObject in one-liner format If this object has // actually represent this ValueObject in one-liner format If this object has
Show All 16 Lines

lldb/include/lldb/DataFormatters/FormattersContainer.h

Show All 16 Lines
virtual uint32_t GetCurrentRevision() = 0; virtual uint32_t GetCurrentRevision() = 0;
}; };
// if the user tries to add formatters for, say, "struct Foo" those will not // if the user tries to add formatters for, say, "struct Foo" those will not
// match any type because of the way we strip qualifiers from typenames this // match any type because of the way we strip qualifiers from typenames this
// method looks for the case where the user is adding a "class","struct","enum" // method looks for the case where the user is adding a "class","struct","enum"
// or "union" Foo and strips the unnecessary qualifier // or "union" Foo and strips the unnecessary qualifier
static inline ConstString GetValidTypeName_Impl(const ConstString &type) { static inline ConstString GetValidTypeName_Impl(ConstString type) {
if (type.IsEmpty()) if (type.IsEmpty())
return type; return type;
std::string type_cstr(type.AsCString()); std::string type_cstr(type.AsCString());
lldb_utility::StringLexer type_lexer(type_cstr); lldb_utility::StringLexer type_lexer(type_cstr);
type_lexer.AdvanceIf("class "); type_lexer.AdvanceIf("class ");
type_lexer.AdvanceIf("enum "); type_lexer.AdvanceIf("enum ");
Show All 32 Lines
DISALLOW_COPY_AND_ASSIGN(FormattersContainer); DISALLOW_COPY_AND_ASSIGN(FormattersContainer);
void Add_Impl(const MapKeyType &type, const MapValueType &entry, void Add_Impl(const MapKeyType &type, const MapValueType &entry,
lldb::RegularExpressionSP *dummy) { lldb::RegularExpressionSP *dummy) {
m_format_map.Add(type, entry); m_format_map.Add(type, entry);
} }
void Add_Impl(const ConstString &type, const MapValueType &entry, void Add_Impl(ConstString type, const MapValueType &entry,
ConstString *dummy) { ConstString *dummy) {
m_format_map.Add(GetValidTypeName_Impl(type), entry); m_format_map.Add(GetValidTypeName_Impl(type), entry);
} }
bool Delete_Impl(ConstString type, ConstString *dummy) { bool Delete_Impl(ConstString type, ConstString *dummy) {
return m_format_map.Delete(type); return m_format_map.Delete(type);
} }
Show All 16 Lines

lldb/include/lldb/DataFormatters/TypeSynthetic.h

Show All 16 Lines
virtual size_t CalculateNumChildren(uint32_t max) { virtual size_t CalculateNumChildren(uint32_t max) {
auto count = CalculateNumChildren(); auto count = CalculateNumChildren();
return count <= max ? count : max; return count <= max ? count : max;
} }
virtual lldb::ValueObjectSP GetChildAtIndex(size_t idx) = 0; virtual lldb::ValueObjectSP GetChildAtIndex(size_t idx) = 0;
virtual size_t GetIndexOfChildWithName(const ConstString &name) = 0; virtual size_t GetIndexOfChildWithName(ConstString name) = 0;
// this function is assumed to always succeed and it if fails, the front-end // this function is assumed to always succeed and it if fails, the front-end
// should know to deal with it in the correct way (most probably, by refusing // should know to deal with it in the correct way (most probably, by refusing
// to return any children) the return value of Update() should actually be // to return any children) the return value of Update() should actually be
// interpreted as "ValueObjectSyntheticFilter cache is good/bad" if =true, // interpreted as "ValueObjectSyntheticFilter cache is good/bad" if =true,
// ValueObjectSyntheticFilter is allowed to use the children it fetched // ValueObjectSyntheticFilter is allowed to use the children it fetched
// previously and cached if =false, ValueObjectSyntheticFilter must throw // previously and cached if =false, ValueObjectSyntheticFilter must throw
// away its cache, and query again for children // away its cache, and query again for children
Show All 32 Lines
: SyntheticChildrenFrontEnd(backend) {} : SyntheticChildrenFrontEnd(backend) {}
~SyntheticValueProviderFrontEnd() override = default; ~SyntheticValueProviderFrontEnd() override = default;
size_t CalculateNumChildren() override { return 0; } size_t CalculateNumChildren() override { return 0; }
lldb::ValueObjectSP GetChildAtIndex(size_t idx) override { return nullptr; } lldb::ValueObjectSP GetChildAtIndex(size_t idx) override { return nullptr; }
size_t GetIndexOfChildWithName(const ConstString &name) override { size_t GetIndexOfChildWithName(ConstString name) override {
return UINT32_MAX; return UINT32_MAX;
} }
bool Update() override { return false; } bool Update() override { return false; }
bool MightHaveChildren() override { return false; } bool MightHaveChildren() override { return false; }
lldb::ValueObjectSP GetSyntheticValue() override = 0; lldb::ValueObjectSP GetSyntheticValue() override = 0;
Show All 32 Lines
return m_backend.GetSyntheticExpressionPathChild( return m_backend.GetSyntheticExpressionPathChild(
filter->GetExpressionPathAtIndex(idx), true); filter->GetExpressionPathAtIndex(idx), true);
} }
bool Update() override { return false; } bool Update() override { return false; }
bool MightHaveChildren() override { return filter->GetCount() > 0; } bool MightHaveChildren() override { return filter->GetCount() > 0; }
size_t GetIndexOfChildWithName(const ConstString &name) override; size_t GetIndexOfChildWithName(ConstString name) override;
typedef std::shared_ptr<SyntheticChildrenFrontEnd> SharedPointer; typedef std::shared_ptr<SyntheticChildrenFrontEnd> SharedPointer;
private: private:
TypeFilterImpl *filter; TypeFilterImpl *filter;
DISALLOW_COPY_AND_ASSIGN(FrontEnd); DISALLOW_COPY_AND_ASSIGN(FrontEnd);
}; };
Show All 32 Lines
size_t CalculateNumChildren(uint32_t max) override; size_t CalculateNumChildren(uint32_t max) override;
lldb::ValueObjectSP GetChildAtIndex(size_t idx) override; lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
bool Update() override; bool Update() override;
bool MightHaveChildren() override; bool MightHaveChildren() override;
size_t GetIndexOfChildWithName(const ConstString &name) override; size_t GetIndexOfChildWithName(ConstString name) override;
lldb::ValueObjectSP GetSyntheticValue() override; lldb::ValueObjectSP GetSyntheticValue() override;
ConstString GetSyntheticTypeName() override; ConstString GetSyntheticTypeName() override;
typedef std::shared_ptr<SyntheticChildrenFrontEnd> SharedPointer; typedef std::shared_ptr<SyntheticChildrenFrontEnd> SharedPointer;
private: private:
Show All 16 Lines

lldb/include/lldb/DataFormatters/VectorIterator.h

Show All 16 Lines
size_t CalculateNumChildren() override; size_t CalculateNumChildren() override;
lldb::ValueObjectSP GetChildAtIndex(size_t idx) override; lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
bool Update() override; bool Update() override;
bool MightHaveChildren() override; bool MightHaveChildren() override;
size_t GetIndexOfChildWithName(const ConstString &name) override; size_t GetIndexOfChildWithName(ConstString name) override;
private: private:
ExecutionContextRef m_exe_ctx_ref; ExecutionContextRef m_exe_ctx_ref;
ConstString m_item_name; ConstString m_item_name;
lldb::ValueObjectSP m_item_sp; lldb::ValueObjectSP m_item_sp;
}; };
} // namespace formatters } // namespace formatters
} // namespace lldb_private } // namespace lldb_private
#endif // liblldb_CF_h_ #endif // liblldb_CF_h_
Context not available.

lldb/include/lldb/Expression/ExpressionVariable.h

Show All 16 Lines
LLVMCastKind getKind() const { return m_kind; } LLVMCastKind getKind() const { return m_kind; }
ExpressionVariable(LLVMCastKind kind) : m_flags(0), m_kind(kind) {} ExpressionVariable(LLVMCastKind kind) : m_flags(0), m_kind(kind) {}
virtual ~ExpressionVariable(); virtual ~ExpressionVariable();
size_t GetByteSize() { return m_frozen_sp->GetByteSize(); } size_t GetByteSize() { return m_frozen_sp->GetByteSize(); }
const ConstString &GetName() { return m_frozen_sp->GetName(); } ConstString GetName() { return m_frozen_sp->GetName(); }
lldb::ValueObjectSP GetValueObject() { return m_frozen_sp; } lldb::ValueObjectSP GetValueObject() { return m_frozen_sp; }
uint8_t *GetValueBytes(); uint8_t *GetValueBytes();
void ValueUpdated() { m_frozen_sp->ValueUpdated(); } void ValueUpdated() { m_frozen_sp->ValueUpdated(); }
RegisterInfo *GetRegisterInfo() { RegisterInfo *GetRegisterInfo() {
return m_frozen_sp->GetValue().GetRegisterInfo(); return m_frozen_sp->GetValue().GetRegisterInfo();
} }
void SetRegisterInfo(const RegisterInfo *reg_info) { void SetRegisterInfo(const RegisterInfo *reg_info) {
return m_frozen_sp->GetValue().SetContext( return m_frozen_sp->GetValue().SetContext(
Value::eContextTypeRegisterInfo, const_cast<RegisterInfo *>(reg_info)); Value::eContextTypeRegisterInfo, const_cast<RegisterInfo *>(reg_info));
} }
CompilerType GetCompilerType() { return m_frozen_sp->GetCompilerType(); } CompilerType GetCompilerType() { return m_frozen_sp->GetCompilerType(); }
void SetCompilerType(const CompilerType &compiler_type) { void SetCompilerType(const CompilerType &compiler_type) {
m_frozen_sp->GetValue().SetCompilerType(compiler_type); m_frozen_sp->GetValue().SetCompilerType(compiler_type);
} }
void SetName(const ConstString &name) { m_frozen_sp->SetName(name); } void SetName(ConstString name) { m_frozen_sp->SetName(name); }
// this function is used to copy the address-of m_live_sp into m_frozen_sp // this function is used to copy the address-of m_live_sp into m_frozen_sp
// this is necessary because the results of certain cast and pointer- // this is necessary because the results of certain cast and pointer-
// arithmetic operations (such as those described in bugzilla issues 11588 // arithmetic operations (such as those described in bugzilla issues 11588
// and 11618) generate frozen objects that do not have a valid address-of, // and 11618) generate frozen objects that do not have a valid address-of,
// which can be troublesome when using synthetic children providers. // which can be troublesome when using synthetic children providers.
// Transferring the address-of the live object solves these issues and // Transferring the address-of the live object solves these issues and
// provides the expected user-level behavior // provides the expected user-level behavior
Show All 32 Lines
/// ///
/// @param[in] name /// @param[in] name
/// The name of the requested variable. /// The name of the requested variable.
/// ///
/// @return /// @return
/// The variable requested, or nullptr if that variable is not in the /// The variable requested, or nullptr if that variable is not in the
/// list. /// list.
//---------------------------------------------------------------------- //----------------------------------------------------------------------
lldb::ExpressionVariableSP GetVariable(const ConstString &name) { lldb::ExpressionVariableSP GetVariable(ConstString name) {
lldb::ExpressionVariableSP var_sp; lldb::ExpressionVariableSP var_sp;
for (size_t index = 0, size = GetSize(); index < size; ++index) { for (size_t index = 0, size = GetSize(); index < size; ++index) {
var_sp = GetVariableAtIndex(index); var_sp = GetVariableAtIndex(index);
if (var_sp->GetName() == name) if (var_sp->GetName() == name)
return var_sp; return var_sp;
} }
var_sp.reset(); var_sp.reset();
return var_sp; return var_sp;
Show All 32 Lines
virtual ~PersistentExpressionState(); virtual ~PersistentExpressionState();
virtual lldb::ExpressionVariableSP virtual lldb::ExpressionVariableSP
CreatePersistentVariable(const lldb::ValueObjectSP &valobj_sp) = 0; CreatePersistentVariable(const lldb::ValueObjectSP &valobj_sp) = 0;
virtual lldb::ExpressionVariableSP virtual lldb::ExpressionVariableSP
CreatePersistentVariable(ExecutionContextScope *exe_scope, CreatePersistentVariable(ExecutionContextScope *exe_scope,
const ConstString &name, const CompilerType &type, ConstString name, const CompilerType &type,
lldb::ByteOrder byte_order, lldb::ByteOrder byte_order,
uint32_t addr_byte_size) = 0; uint32_t addr_byte_size) = 0;
/// Return a new persistent variable name with the specified prefix. /// Return a new persistent variable name with the specified prefix.
ConstString GetNextPersistentVariableName(Target &target, ConstString GetNextPersistentVariableName(Target &target,
llvm::StringRef prefix); llvm::StringRef prefix);
virtual llvm::StringRef virtual llvm::StringRef
GetPersistentVariablePrefix(bool is_error = false) const = 0; GetPersistentVariablePrefix(bool is_error = false) const = 0;
virtual void virtual void
RemovePersistentVariable(lldb::ExpressionVariableSP variable) = 0; RemovePersistentVariable(lldb::ExpressionVariableSP variable) = 0;
virtual lldb::addr_t LookupSymbol(const ConstString &name); virtual lldb::addr_t LookupSymbol(ConstString name);
void RegisterExecutionUnit(lldb::IRExecutionUnitSP &execution_unit_sp); void RegisterExecutionUnit(lldb::IRExecutionUnitSP &execution_unit_sp);
private: private:
LLVMCastKind m_kind; LLVMCastKind m_kind;
typedef std::set<lldb::IRExecutionUnitSP> ExecutionUnitSet; typedef std::set<lldb::IRExecutionUnitSP> ExecutionUnitSet;
ExecutionUnitSet ExecutionUnitSet
Show All 10 Lines

lldb/include/lldb/Expression/IRExecutionUnit.h

Show All 16 Lines
void PopulateSectionList(lldb_private::ObjectFile *obj_file, void PopulateSectionList(lldb_private::ObjectFile *obj_file,
lldb_private::SectionList &section_list) override; lldb_private::SectionList &section_list) override;
ArchSpec GetArchitecture() override; ArchSpec GetArchitecture() override;
lldb::ModuleSP GetJITModule(); lldb::ModuleSP GetJITModule();
lldb::addr_t FindSymbol(const ConstString &name); lldb::addr_t FindSymbol(ConstString name);
void GetStaticInitializers(std::vector<lldb::addr_t> &static_initializers); void GetStaticInitializers(std::vector<lldb::addr_t> &static_initializers);
//---------------------------------------------------------------------- //----------------------------------------------------------------------
/// @class JittedFunction IRExecutionUnit.h /// @class JittedFunction IRExecutionUnit.h
/// "lldb/Expression/IRExecutionUnit.h" /// "lldb/Expression/IRExecutionUnit.h"
/// Encapsulates a single function that has been generated by the JIT. /// Encapsulates a single function that has been generated by the JIT.
/// ///
Show All 32 Lines
//------------------------------------------------------------------ //------------------------------------------------------------------
bool WriteData(lldb::ProcessSP &process_sp); bool WriteData(lldb::ProcessSP &process_sp);
Status DisassembleFunction(Stream &stream, lldb::ProcessSP &process_sp); Status DisassembleFunction(Stream &stream, lldb::ProcessSP &process_sp);
struct SearchSpec; struct SearchSpec;
void CollectCandidateCNames(std::vector<SearchSpec> &C_specs, void CollectCandidateCNames(std::vector<SearchSpec> &C_specs,
const ConstString &name); ConstString name);
void CollectCandidateCPlusPlusNames(std::vector<SearchSpec> &CPP_specs, void CollectCandidateCPlusPlusNames(std::vector<SearchSpec> &CPP_specs,
const std::vector<SearchSpec> &C_specs, const std::vector<SearchSpec> &C_specs,
const SymbolContext &sc); const SymbolContext &sc);
void CollectFallbackNames(std::vector<SearchSpec> &fallback_specs, void CollectFallbackNames(std::vector<SearchSpec> &fallback_specs,
const std::vector<SearchSpec> &C_specs); const std::vector<SearchSpec> &C_specs);
lldb::addr_t FindInSymbols(const std::vector<SearchSpec> &specs, lldb::addr_t FindInSymbols(const std::vector<SearchSpec> &specs,
const lldb_private::SymbolContext &sc); const lldb_private::SymbolContext &sc);
lldb::addr_t FindInRuntimes(const std::vector<SearchSpec> &specs, lldb::addr_t FindInRuntimes(const std::vector<SearchSpec> &specs,
const lldb_private::SymbolContext &sc); const lldb_private::SymbolContext &sc);
lldb::addr_t FindInUserDefinedSymbols(const std::vector<SearchSpec> &specs, lldb::addr_t FindInUserDefinedSymbols(const std::vector<SearchSpec> &specs,
const lldb_private::SymbolContext &sc); const lldb_private::SymbolContext &sc);
void ReportSymbolLookupError(const ConstString &name); void ReportSymbolLookupError(ConstString name);
class MemoryManager : public llvm::SectionMemoryManager { class MemoryManager : public llvm::SectionMemoryManager {
public: public:
MemoryManager(IRExecutionUnit &parent); MemoryManager(IRExecutionUnit &parent);
~MemoryManager() override; ~MemoryManager() override;
//------------------------------------------------------------------ //------------------------------------------------------------------
Show All 16 Lines

lldb/include/lldb/Interpreter/OptionGroupPlatform.h

Show All 16 Lines
void SetPlatformName(const char *platform_name) { void SetPlatformName(const char *platform_name) {
if (platform_name && platform_name[0]) if (platform_name && platform_name[0])
m_platform_name.assign(platform_name); m_platform_name.assign(platform_name);
else else
m_platform_name.clear(); m_platform_name.clear();
} }
const ConstString &GetSDKRootDirectory() const { return m_sdk_sysroot; } ConstString GetSDKRootDirectory() const { return m_sdk_sysroot; }
void SetSDKRootDirectory(const ConstString &sdk_root_directory) { void SetSDKRootDirectory(ConstString sdk_root_directory) {
m_sdk_sysroot = sdk_root_directory; m_sdk_sysroot = sdk_root_directory;
} }
const ConstString &GetSDKBuild() const { return m_sdk_build; } ConstString GetSDKBuild() const { return m_sdk_build; }
void SetSDKBuild(const ConstString &sdk_build) { m_sdk_build = sdk_build; } void SetSDKBuild(ConstString sdk_build) { m_sdk_build = sdk_build; }
bool PlatformMatches(const lldb::PlatformSP &platform_sp) const; bool PlatformMatches(const lldb::PlatformSP &platform_sp) const;
protected: protected:
std::string m_platform_name; std::string m_platform_name;
ConstString m_sdk_sysroot; ConstString m_sdk_sysroot;
ConstString m_sdk_build; ConstString m_sdk_build;
llvm::VersionTuple m_os_version; llvm::VersionTuple m_os_version;
bool m_include_platform_option; bool m_include_platform_option;
}; };
} // namespace lldb_private } // namespace lldb_private
#endif // liblldb_OptionGroupPlatform_h_ #endif // liblldb_OptionGroupPlatform_h_
Context not available.

lldb/include/lldb/Interpreter/OptionValueDictionary.h

Show All 16 Lines
} }
//--------------------------------------------------------------------- //---------------------------------------------------------------------
// Subclass specific functions // Subclass specific functions
//--------------------------------------------------------------------- //---------------------------------------------------------------------
size_t GetNumValues() const { return m_values.size(); } size_t GetNumValues() const { return m_values.size(); }
lldb::OptionValueSP GetValueForKey(const ConstString &key) const; lldb::OptionValueSP GetValueForKey(ConstString key) const;
lldb::OptionValueSP GetSubValue(const ExecutionContext *exe_ctx, lldb::OptionValueSP GetSubValue(const ExecutionContext *exe_ctx,
llvm::StringRef name, bool will_modify, llvm::StringRef name, bool will_modify,
Status &error) const override; Status &error) const override;
Status SetSubValue(const ExecutionContext *exe_ctx, VarSetOperationType op, Status SetSubValue(const ExecutionContext *exe_ctx, VarSetOperationType op,
llvm::StringRef name, llvm::StringRef value) override; llvm::StringRef name, llvm::StringRef value) override;
bool SetValueForKey(const ConstString &key, bool SetValueForKey(ConstString key,
const lldb::OptionValueSP &value_sp, const lldb::OptionValueSP &value_sp,
bool can_replace = true); bool can_replace = true);
bool DeleteValueForKey(const ConstString &key); bool DeleteValueForKey(ConstString key);
size_t GetArgs(Args &args) const; size_t GetArgs(Args &args) const;
Status SetArgs(const Args &args, VarSetOperationType op); Status SetArgs(const Args &args, VarSetOperationType op);
protected: protected:
typedef std::map<ConstString, lldb::OptionValueSP> collection; typedef std::map<ConstString, lldb::OptionValueSP> collection;
uint32_t m_type_mask; uint32_t m_type_mask;
collection m_values; collection m_values;
bool m_raw_value_dump; bool m_raw_value_dump;
}; };
} // namespace lldb_private } // namespace lldb_private
#endif // liblldb_OptionValueDictionary_h_ #endif // liblldb_OptionValueDictionary_h_
Context not available.

lldb/include/lldb/Interpreter/OptionValueProperties.h

Show All 16 Lines
class OptionValueProperties class OptionValueProperties
: public OptionValue, : public OptionValue,
public std::enable_shared_from_this<OptionValueProperties> { public std::enable_shared_from_this<OptionValueProperties> {
public: public:
OptionValueProperties() OptionValueProperties()
: OptionValue(), m_name(), m_properties(), m_name_to_index() {} : OptionValue(), m_name(), m_properties(), m_name_to_index() {}
OptionValueProperties(const ConstString &name); OptionValueProperties(ConstString name);
OptionValueProperties(const OptionValueProperties &global_properties); OptionValueProperties(const OptionValueProperties &global_properties);
~OptionValueProperties() override = default; ~OptionValueProperties() override = default;
Type GetType() const override { return eTypeProperties; } Type GetType() const override { return eTypeProperties; }
bool Clear() override; bool Clear() override;
Show All 30 Lines
virtual size_t GetNumProperties() const; virtual size_t GetNumProperties() const;
//--------------------------------------------------------------------- //---------------------------------------------------------------------
// Get the index of a property given its exact name in this property // Get the index of a property given its exact name in this property
// collection, "name" can't be a path to a property path that refers to a // collection, "name" can't be a path to a property path that refers to a
// property within a property // property within a property
//--------------------------------------------------------------------- //---------------------------------------------------------------------
virtual uint32_t GetPropertyIndex(const ConstString &name) const; virtual uint32_t GetPropertyIndex(ConstString name) const;
//--------------------------------------------------------------------- //---------------------------------------------------------------------
// Get a property by exact name exists in this property collection, name can // Get a property by exact name exists in this property collection, name can
// not be a path to a property path that refers to a property within a // not be a path to a property path that refers to a property within a
// property // property
//--------------------------------------------------------------------- //---------------------------------------------------------------------
virtual const Property *GetProperty(const ExecutionContext *exe_ctx, virtual const Property *GetProperty(const ExecutionContext *exe_ctx,
bool will_modify, bool will_modify,
const ConstString &name) const; ConstString name) const;
virtual const Property *GetPropertyAtIndex(const ExecutionContext *exe_ctx, virtual const Property *GetPropertyAtIndex(const ExecutionContext *exe_ctx,
bool will_modify, bool will_modify,
uint32_t idx) const; uint32_t idx) const;
//--------------------------------------------------------------------- //---------------------------------------------------------------------
// Property can be be a property path like // Property can be be a property path like
// "target.process.extra-startup-command" // "target.process.extra-startup-command"
//--------------------------------------------------------------------- //---------------------------------------------------------------------
virtual const Property *GetPropertyAtPath(const ExecutionContext *exe_ctx, virtual const Property *GetPropertyAtPath(const ExecutionContext *exe_ctx,
bool will_modify, bool will_modify,
llvm::StringRef property_path) const; llvm::StringRef property_path) const;
virtual lldb::OptionValueSP virtual lldb::OptionValueSP
GetPropertyValueAtIndex(const ExecutionContext *exe_ctx, bool will_modify, GetPropertyValueAtIndex(const ExecutionContext *exe_ctx, bool will_modify,
uint32_t idx) const; uint32_t idx) const;
virtual lldb::OptionValueSP GetValueForKey(const ExecutionContext *exe_ctx, virtual lldb::OptionValueSP GetValueForKey(const ExecutionContext *exe_ctx,
const ConstString &key, ConstString key,
bool value_will_be_modified) const; bool value_will_be_modified) const;
lldb::OptionValueSP GetSubValue(const ExecutionContext *exe_ctx, lldb::OptionValueSP GetSubValue(const ExecutionContext *exe_ctx,
llvm::StringRef name, llvm::StringRef name,
bool value_will_be_modified, bool value_will_be_modified,
Status &error) const override; Status &error) const override;
Status SetSubValue(const ExecutionContext *exe_ctx, VarSetOperationType op, Status SetSubValue(const ExecutionContext *exe_ctx, VarSetOperationType op,
Show All 32 Lines
uint32_t idx, const FileSpec &file_spec); uint32_t idx, const FileSpec &file_spec);
OptionValuePathMappings *GetPropertyAtIndexAsOptionValuePathMappings( OptionValuePathMappings *GetPropertyAtIndexAsOptionValuePathMappings(
const ExecutionContext *exe_ctx, bool will_modify, uint32_t idx) const; const ExecutionContext *exe_ctx, bool will_modify, uint32_t idx) const;
OptionValueFileSpecList *GetPropertyAtIndexAsOptionValueFileSpecList( OptionValueFileSpecList *GetPropertyAtIndexAsOptionValueFileSpecList(
const ExecutionContext *exe_ctx, bool will_modify, uint32_t idx) const; const ExecutionContext *exe_ctx, bool will_modify, uint32_t idx) const;
void AppendProperty(const ConstString &name, const ConstString &desc, void AppendProperty(ConstString name, ConstString desc,
bool is_global, const lldb::OptionValueSP &value_sp); bool is_global, const lldb::OptionValueSP &value_sp);
lldb::OptionValuePropertiesSP GetSubProperty(const ExecutionContext *exe_ctx, lldb::OptionValuePropertiesSP GetSubProperty(const ExecutionContext *exe_ctx,
const ConstString &name); ConstString name);
void SetValueChangedCallback(uint32_t property_idx, void SetValueChangedCallback(uint32_t property_idx,
OptionValueChangedCallback callback, OptionValueChangedCallback callback,
void *baton); void *baton);
protected: protected:
Property *ProtectedGetPropertyAtIndex(uint32_t idx) { Property *ProtectedGetPropertyAtIndex(uint32_t idx) {
return ((idx < m_properties.size()) ? &m_properties[idx] : nullptr); return ((idx < m_properties.size()) ? &m_properties[idx] : nullptr);
Show All 16 Lines

lldb/include/lldb/Interpreter/Property.h

Show All 16 Lines
}; };
using PropertyDefinitions = llvm::ArrayRef<PropertyDefinition>; using PropertyDefinitions = llvm::ArrayRef<PropertyDefinition>;
class Property { class Property {
public: public:
Property(const PropertyDefinition &definition); Property(const PropertyDefinition &definition);
Property(const ConstString &name, const ConstString &desc, bool is_global, Property(ConstString name, ConstString desc, bool is_global,
const lldb::OptionValueSP &value_sp); const lldb::OptionValueSP &value_sp);
llvm::StringRef GetName() const { return m_name.GetStringRef(); } llvm::StringRef GetName() const { return m_name.GetStringRef(); }
llvm::StringRef GetDescription() const { llvm::StringRef GetDescription() const {
return m_description.GetStringRef(); return m_description.GetStringRef();
} }
const lldb::OptionValueSP &GetValue() const { return m_value_sp; } const lldb::OptionValueSP &GetValue() const { return m_value_sp; }
Show All 16 Lines

lldb/include/lldb/Symbol/ClangASTContext.h

Show All 16 Lines
clang::ASTContext *ast, lldb::Encoding encoding, uint32_t bit_size); clang::ASTContext *ast, lldb::Encoding encoding, uint32_t bit_size);
CompilerType GetBasicType(lldb::BasicType type); CompilerType GetBasicType(lldb::BasicType type);
static CompilerType GetBasicType(clang::ASTContext *ast, static CompilerType GetBasicType(clang::ASTContext *ast,
lldb::BasicType type); lldb::BasicType type);
static CompilerType GetBasicType(clang::ASTContext *ast, static CompilerType GetBasicType(clang::ASTContext *ast,
const ConstString &name); ConstString name);
static lldb::BasicType GetBasicTypeEnumeration(const ConstString &name); static lldb::BasicType GetBasicTypeEnumeration(ConstString name);
CompilerType GetBuiltinTypeForDWARFEncodingAndBitSize(const char *type_name, CompilerType GetBuiltinTypeForDWARFEncodingAndBitSize(const char *type_name,
uint32_t dw_ate, uint32_t dw_ate,
uint32_t bit_size); uint32_t bit_size);
CompilerType GetCStringType(bool is_const); CompilerType GetCStringType(bool is_const);
static CompilerType GetUnknownAnyType(clang::ASTContext *ast); static CompilerType GetUnknownAnyType(clang::ASTContext *ast);
Show All 24 Lines
static CompilerType GetTypeForDecl(clang::NamedDecl *decl); static CompilerType GetTypeForDecl(clang::NamedDecl *decl);
static CompilerType GetTypeForDecl(clang::TagDecl *decl); static CompilerType GetTypeForDecl(clang::TagDecl *decl);
static CompilerType GetTypeForDecl(clang::ObjCInterfaceDecl *objc_decl); static CompilerType GetTypeForDecl(clang::ObjCInterfaceDecl *objc_decl);
template <typename RecordDeclType> template <typename RecordDeclType>
CompilerType CompilerType
GetTypeForIdentifier(const ConstString &type_name, GetTypeForIdentifier(ConstString type_name,
clang::DeclContext *decl_context = nullptr) { clang::DeclContext *decl_context = nullptr) {
CompilerType compiler_type; CompilerType compiler_type;
if (type_name.GetLength()) { if (type_name.GetLength()) {
clang::ASTContext *ast = getASTContext(); clang::ASTContext *ast = getASTContext();
if (ast) { if (ast) {
if (!decl_context) if (!decl_context)
decl_context = ast->getTranslationUnitDecl(); decl_context = ast->getTranslationUnitDecl();
Show All 15 Lines
} }
} }
} }
return compiler_type; return compiler_type;
} }
CompilerType CreateStructForIdentifier( CompilerType CreateStructForIdentifier(
const ConstString &type_name, ConstString type_name,
const std::initializer_list<std::pair<const char *, CompilerType>> const std::initializer_list<std::pair<const char *, CompilerType>>
&type_fields, &type_fields,
bool packed = false); bool packed = false);
CompilerType GetOrCreateStructForIdentifier( CompilerType GetOrCreateStructForIdentifier(
const ConstString &type_name, ConstString type_name,
const std::initializer_list<std::pair<const char *, CompilerType>> const std::initializer_list<std::pair<const char *, CompilerType>>
&type_fields, &type_fields,
bool packed = false); bool packed = false);
static bool IsOperator(const char *name, static bool IsOperator(const char *name,
clang::OverloadedOperatorKind &op_kind); clang::OverloadedOperatorKind &op_kind);
//------------------------------------------------------------------ //------------------------------------------------------------------
Show All 32 Lines
lldb::Format GetFormat(lldb::opaque_compiler_type_t type) override; lldb::Format GetFormat(lldb::opaque_compiler_type_t type) override;
size_t GetTypeBitAlign(lldb::opaque_compiler_type_t type) override; size_t GetTypeBitAlign(lldb::opaque_compiler_type_t type) override;
uint32_t GetNumChildren(lldb::opaque_compiler_type_t type, uint32_t GetNumChildren(lldb::opaque_compiler_type_t type,
bool omit_empty_base_classes, bool omit_empty_base_classes,
const ExecutionContext *exe_ctx) override; const ExecutionContext *exe_ctx) override;
CompilerType GetBuiltinTypeByName(const ConstString &name) override; CompilerType GetBuiltinTypeByName(ConstString name) override;
lldb::BasicType lldb::BasicType
GetBasicTypeEnumeration(lldb::opaque_compiler_type_t type) override; GetBasicTypeEnumeration(lldb::opaque_compiler_type_t type) override;
static lldb::BasicType static lldb::BasicType
GetBasicTypeEnumeration(lldb::opaque_compiler_type_t type, GetBasicTypeEnumeration(lldb::opaque_compiler_type_t type,
const ConstString &name); ConstString name);
void ForEachEnumerator( void ForEachEnumerator(
lldb::opaque_compiler_type_t type, lldb::opaque_compiler_type_t type,
std::function<bool(const CompilerType &integer_type, std::function<bool(const CompilerType &integer_type,
const ConstString &name, ConstString name,
const llvm::APSInt &value)> const &callback) override; const llvm::APSInt &value)> const &callback) override;
uint32_t GetNumFields(lldb::opaque_compiler_type_t type) override; uint32_t GetNumFields(lldb::opaque_compiler_type_t type) override;
CompilerType GetFieldAtIndex(lldb::opaque_compiler_type_t type, size_t idx, CompilerType GetFieldAtIndex(lldb::opaque_compiler_type_t type, size_t idx,
std::string &name, uint64_t *bit_offset_ptr, std::string &name, uint64_t *bit_offset_ptr,
uint32_t *bitfield_bit_size_ptr, uint32_t *bitfield_bit_size_ptr,
bool *is_bitfield_ptr) override; bool *is_bitfield_ptr) override;
Show All 16 Lines

lldb/include/lldb/Symbol/ClangASTImporter.h

Show All 16 Lines
// Completers for maps // Completers for maps
// //
class MapCompleter { class MapCompleter {
public: public:
virtual ~MapCompleter(); virtual ~MapCompleter();
virtual void CompleteNamespaceMap(NamespaceMapSP &namespace_map, virtual void CompleteNamespaceMap(NamespaceMapSP &namespace_map,
const ConstString &name, ConstString name,
NamespaceMapSP &parent_map) const = 0; NamespaceMapSP &parent_map) const = 0;
}; };
void InstallMapCompleter(clang::ASTContext *dst_ctx, void InstallMapCompleter(clang::ASTContext *dst_ctx,
MapCompleter &completer) { MapCompleter &completer) {
ASTContextMetadataSP context_md; ASTContextMetadataSP context_md;
ContextMetadataMap::iterator context_md_iter = m_metadata_map.find(dst_ctx); ContextMetadataMap::iterator context_md_iter = m_metadata_map.find(dst_ctx);
Show All 16 Lines

lldb/include/lldb/Symbol/CompilerType.h

Show All 16 Lines
size_t GetTypeBitAlign() const; size_t GetTypeBitAlign() const;
uint32_t GetNumChildren(bool omit_empty_base_classes, uint32_t GetNumChildren(bool omit_empty_base_classes,
const ExecutionContext *exe_ctx) const; const ExecutionContext *exe_ctx) const;
lldb::BasicType GetBasicTypeEnumeration() const; lldb::BasicType GetBasicTypeEnumeration() const;
static lldb::BasicType GetBasicTypeEnumeration(const ConstString &name); static lldb::BasicType GetBasicTypeEnumeration(ConstString name);
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// If this type is an enumeration, iterate through all of its enumerators // If this type is an enumeration, iterate through all of its enumerators
// using a callback. If the callback returns true, keep iterating, else abort // using a callback. If the callback returns true, keep iterating, else abort
// the iteration. // the iteration.
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void ForEachEnumerator( void ForEachEnumerator(
std::function<bool(const CompilerType &integer_type, std::function<bool(const CompilerType &integer_type,
const ConstString &name, ConstString name,
const llvm::APSInt &value)> const &callback) const; const llvm::APSInt &value)> const &callback) const;
uint32_t GetNumFields() const; uint32_t GetNumFields() const;
CompilerType GetFieldAtIndex(size_t idx, std::string &name, CompilerType GetFieldAtIndex(size_t idx, std::string &name,
uint64_t *bit_offset_ptr, uint64_t *bit_offset_ptr,
uint32_t *bitfield_bit_size_ptr, uint32_t *bitfield_bit_size_ptr,
bool *is_bitfield_ptr) const; bool *is_bitfield_ptr) const;
Show All 16 Lines

lldb/include/lldb/Symbol/DeclVendor.h

Show All 16 Lines
/// @param[in] max_matches /// @param[in] max_matches
/// The maximum number of Decls to return. UINT32_MAX means "as /// The maximum number of Decls to return. UINT32_MAX means "as
/// many as possible." /// many as possible."
/// ///
/// @return /// @return
/// The number of Decls added to decls; will not exceed /// The number of Decls added to decls; will not exceed
/// max_matches. /// max_matches.
//------------------------------------------------------------------ //------------------------------------------------------------------
virtual uint32_t FindDecls(const ConstString &name, bool append, virtual uint32_t FindDecls(ConstString name, bool append,
uint32_t max_matches, uint32_t max_matches,
std::vector<clang::NamedDecl *> &decls) = 0; std::vector<clang::NamedDecl *> &decls) = 0;
//------------------------------------------------------------------ //------------------------------------------------------------------
/// Interface for ExternalASTMerger. Returns an ImporterSource /// Interface for ExternalASTMerger. Returns an ImporterSource
/// allowing type completion. /// allowing type completion.
/// ///
/// @return /// @return
Show All 14 Lines

lldb/include/lldb/Symbol/Function.h

Show All 16 Lines
/// @param[in] name /// @param[in] name
/// A name for the method name for this function. This value /// A name for the method name for this function. This value
/// should not be the mangled named, but the simple method name. /// should not be the mangled named, but the simple method name.
/// ///
/// @param[in] decl_ptr /// @param[in] decl_ptr
/// Optional declaration information that describes where the /// Optional declaration information that describes where the
/// function was declared. This can be NULL. /// function was declared. This can be NULL.
//------------------------------------------------------------------ //------------------------------------------------------------------
FunctionInfo(const ConstString &name, const Declaration *decl_ptr); FunctionInfo(ConstString name, const Declaration *decl_ptr);
//------------------------------------------------------------------ //------------------------------------------------------------------
/// Destructor. /// Destructor.
/// ///
/// The destructor is virtual since classes inherit from this class. /// The destructor is virtual since classes inherit from this class.
//------------------------------------------------------------------ //------------------------------------------------------------------
virtual ~FunctionInfo(); virtual ~FunctionInfo();
Show All 32 Lines
/// @param[in] decl_ptr /// @param[in] decl_ptr
/// Optional declaration information that describes where the /// Optional declaration information that describes where the
/// function was declared. This can be NULL. /// function was declared. This can be NULL.
/// ///
/// @param[in] call_decl_ptr /// @param[in] call_decl_ptr
/// Optional calling location declaration information that /// Optional calling location declaration information that
/// describes from where this inlined function was called. /// describes from where this inlined function was called.
//------------------------------------------------------------------ //------------------------------------------------------------------
InlineFunctionInfo(const ConstString &name, const Mangled &mangled, InlineFunctionInfo(ConstString name, const Mangled &mangled,
const Declaration *decl_ptr, const Declaration *decl_ptr,
const Declaration *call_decl_ptr); const Declaration *call_decl_ptr);
//------------------------------------------------------------------ //------------------------------------------------------------------
/// Destructor. /// Destructor.
//------------------------------------------------------------------ //------------------------------------------------------------------
~InlineFunctionInfo() override; ~InlineFunctionInfo() override;
Show All 16 Lines

lldb/include/lldb/Symbol/Symbol.h

Show All 16 Lines
bool contains_linker_annotations, uint32_t flags); bool contains_linker_annotations, uint32_t flags);
Symbol(const Symbol &rhs); Symbol(const Symbol &rhs);
const Symbol &operator=(const Symbol &rhs); const Symbol &operator=(const Symbol &rhs);
void Clear(); void Clear();
bool Compare(const ConstString &name, lldb::SymbolType type) const; bool Compare(ConstString name, lldb::SymbolType type) const;
void Dump(Stream *s, Target *target, uint32_t index) const; void Dump(Stream *s, Target *target, uint32_t index) const;
bool ValueIsAddress() const; bool ValueIsAddress() const;
//------------------------------------------------------------------ //------------------------------------------------------------------
// The GetAddressRef() accessor functions should only be called if you // The GetAddressRef() accessor functions should only be called if you
// previously call ValueIsAddress() otherwise you might get an reference to // previously call ValueIsAddress() otherwise you might get an reference to
Show All 32 Lines
Mangled &GetMangled() { return m_mangled; } Mangled &GetMangled() { return m_mangled; }
const Mangled &GetMangled() const { return m_mangled; } const Mangled &GetMangled() const { return m_mangled; }
ConstString GetReExportedSymbolName() const; ConstString GetReExportedSymbolName() const;
FileSpec GetReExportedSymbolSharedLibrary() const; FileSpec GetReExportedSymbolSharedLibrary() const;
void SetReExportedSymbolName(const ConstString &name); void SetReExportedSymbolName(ConstString name);
bool SetReExportedSymbolSharedLibrary(const FileSpec &fspec); bool SetReExportedSymbolSharedLibrary(const FileSpec &fspec);
Symbol *ResolveReExportedSymbol(Target &target) const; Symbol *ResolveReExportedSymbol(Target &target) const;
uint32_t GetSiblingIndex() const; uint32_t GetSiblingIndex() const;
lldb::SymbolType GetType() const { return (lldb::SymbolType)m_type; } lldb::SymbolType GetType() const { return (lldb::SymbolType)m_type; }
Show All 16 Lines

lldb/include/lldb/Symbol/SymbolContext.h

Show All 16 Lines
/// @param[out] error /// @param[out] error
/// An error that will be populated with a message if there was an /// An error that will be populated with a message if there was an
/// ambiguous result. The error will not be populated if no result /// ambiguous result. The error will not be populated if no result
/// was found. /// was found.
/// ///
/// @return /// @return
/// The symbol that was found, or \b nullptr if none was found. /// The symbol that was found, or \b nullptr if none was found.
//------------------------------------------------------------------ //------------------------------------------------------------------
const Symbol *FindBestGlobalDataSymbol(const ConstString &name, Status &error); const Symbol *FindBestGlobalDataSymbol(ConstString name, Status &error);
void GetDescription(Stream *s, lldb::DescriptionLevel level, void GetDescription(Stream *s, lldb::DescriptionLevel level,
Target *target) const; Target *target) const;
uint32_t GetResolvedMask() const; uint32_t GetResolvedMask() const;
lldb::LanguageType GetLanguage() const; lldb::LanguageType GetLanguage() const;
Show All 16 Lines

lldb/include/lldb/Symbol/SymbolFile.h

Show All 16 Lines
SymbolContext &sc) = 0; SymbolContext &sc) = 0;
virtual uint32_t ResolveSymbolContext(const FileSpec &file_spec, virtual uint32_t ResolveSymbolContext(const FileSpec &file_spec,
uint32_t line, bool check_inlines, uint32_t line, bool check_inlines,
lldb::SymbolContextItem resolve_scope, lldb::SymbolContextItem resolve_scope,
SymbolContextList &sc_list); SymbolContextList &sc_list);
virtual void DumpClangAST(Stream &s) {} virtual void DumpClangAST(Stream &s) {}
virtual uint32_t virtual uint32_t
FindGlobalVariables(const ConstString &name, FindGlobalVariables(ConstString name,
const CompilerDeclContext *parent_decl_ctx, const CompilerDeclContext *parent_decl_ctx,
uint32_t max_matches, VariableList &variables); uint32_t max_matches, VariableList &variables);
virtual uint32_t FindGlobalVariables(const RegularExpression &regex, virtual uint32_t FindGlobalVariables(const RegularExpression &regex,
uint32_t max_matches, uint32_t max_matches,
VariableList &variables); VariableList &variables);
virtual uint32_t FindFunctions(const ConstString &name, virtual uint32_t FindFunctions(ConstString name,
const CompilerDeclContext *parent_decl_ctx, const CompilerDeclContext *parent_decl_ctx,
lldb::FunctionNameType name_type_mask, lldb::FunctionNameType name_type_mask,
bool include_inlines, bool append, bool include_inlines, bool append,
SymbolContextList &sc_list); SymbolContextList &sc_list);
virtual uint32_t FindFunctions(const RegularExpression &regex, virtual uint32_t FindFunctions(const RegularExpression &regex,
bool include_inlines, bool append, bool include_inlines, bool append,
SymbolContextList &sc_list); SymbolContextList &sc_list);
virtual uint32_t virtual uint32_t
FindTypes(const ConstString &name, const CompilerDeclContext *parent_decl_ctx, FindTypes(ConstString name, const CompilerDeclContext *parent_decl_ctx,
bool append, uint32_t max_matches, bool append, uint32_t max_matches,
llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files, llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
TypeMap &types); TypeMap &types);
virtual size_t FindTypes(const std::vector<CompilerContext> &context, virtual size_t FindTypes(const std::vector<CompilerContext> &context,
bool append, TypeMap &types); bool append, TypeMap &types);
virtual void virtual void
GetMangledNamesForFunction(const std::string &scope_qualified_name, GetMangledNamesForFunction(const std::string &scope_qualified_name,
std::vector<ConstString> &mangled_names); std::vector<ConstString> &mangled_names);
// virtual uint32_t FindTypes (const SymbolContext& sc, const // virtual uint32_t FindTypes (const SymbolContext& sc, const
// RegularExpression& regex, bool append, uint32_t max_matches, TypeList& // RegularExpression& regex, bool append, uint32_t max_matches, TypeList&
// types) = 0; // types) = 0;
virtual TypeList *GetTypeList(); virtual TypeList *GetTypeList();
virtual size_t GetTypes(lldb_private::SymbolContextScope *sc_scope, virtual size_t GetTypes(lldb_private::SymbolContextScope *sc_scope,
lldb::TypeClass type_mask, lldb::TypeClass type_mask,
lldb_private::TypeList &type_list) = 0; lldb_private::TypeList &type_list) = 0;
virtual void PreloadSymbols(); virtual void PreloadSymbols();
virtual lldb_private::TypeSystem * virtual lldb_private::TypeSystem *
GetTypeSystemForLanguage(lldb::LanguageType language); GetTypeSystemForLanguage(lldb::LanguageType language);
virtual CompilerDeclContext virtual CompilerDeclContext
FindNamespace(const ConstString &name, FindNamespace(ConstString name,
const CompilerDeclContext *parent_decl_ctx) { const CompilerDeclContext *parent_decl_ctx) {
return CompilerDeclContext(); return CompilerDeclContext();
} }
ObjectFile *GetObjectFile() { return m_obj_file; } ObjectFile *GetObjectFile() { return m_obj_file; }
const ObjectFile *GetObjectFile() const { return m_obj_file; } const ObjectFile *GetObjectFile() const { return m_obj_file; }
virtual std::vector<CallEdge> ParseCallEdgesInFunction(UserID func_id) { virtual std::vector<CallEdge> ParseCallEdgesInFunction(UserID func_id) {
Show All 16 Lines

lldb/include/lldb/Symbol/SymbolVendor.h

Show All 16 Lines
lldb::SymbolContextItem resolve_scope, lldb::SymbolContextItem resolve_scope,
SymbolContext &sc); SymbolContext &sc);
virtual uint32_t ResolveSymbolContext(const FileSpec &file_spec, virtual uint32_t ResolveSymbolContext(const FileSpec &file_spec,
uint32_t line, bool check_inlines, uint32_t line, bool check_inlines,
lldb::SymbolContextItem resolve_scope, lldb::SymbolContextItem resolve_scope,
SymbolContextList &sc_list); SymbolContextList &sc_list);
virtual size_t FindGlobalVariables(const ConstString &name, virtual size_t FindGlobalVariables(ConstString name,
const CompilerDeclContext *parent_decl_ctx, const CompilerDeclContext *parent_decl_ctx,
size_t max_matches, size_t max_matches,
VariableList &variables); VariableList &variables);
virtual size_t FindGlobalVariables(const RegularExpression &regex, virtual size_t FindGlobalVariables(const RegularExpression &regex,
size_t max_matches, size_t max_matches,
VariableList &variables); VariableList &variables);
virtual size_t FindFunctions(const ConstString &name, virtual size_t FindFunctions(ConstString name,
const CompilerDeclContext *parent_decl_ctx, const CompilerDeclContext *parent_decl_ctx,
lldb::FunctionNameType name_type_mask, lldb::FunctionNameType name_type_mask,
bool include_inlines, bool append, bool include_inlines, bool append,
SymbolContextList &sc_list); SymbolContextList &sc_list);
virtual size_t FindFunctions(const RegularExpression &regex, virtual size_t FindFunctions(const RegularExpression &regex,
bool include_inlines, bool append, bool include_inlines, bool append,
SymbolContextList &sc_list); SymbolContextList &sc_list);
virtual size_t virtual size_t
FindTypes(const ConstString &name, const CompilerDeclContext *parent_decl_ctx, FindTypes(ConstString name, const CompilerDeclContext *parent_decl_ctx,
bool append, size_t max_matches, bool append, size_t max_matches,
llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files, llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
TypeMap &types); TypeMap &types);
virtual size_t FindTypes(const std::vector<CompilerContext> &context, virtual size_t FindTypes(const std::vector<CompilerContext> &context,
bool append, TypeMap &types); bool append, TypeMap &types);
virtual CompilerDeclContext virtual CompilerDeclContext
FindNamespace(const ConstString &name, FindNamespace(ConstString name,
const CompilerDeclContext *parent_decl_ctx); const CompilerDeclContext *parent_decl_ctx);
virtual size_t GetNumCompileUnits(); virtual size_t GetNumCompileUnits();
virtual bool SetCompileUnitAtIndex(size_t cu_idx, virtual bool SetCompileUnitAtIndex(size_t cu_idx,
const lldb::CompUnitSP &cu_sp); const lldb::CompUnitSP &cu_sp);
virtual lldb::CompUnitSP GetCompileUnitAtIndex(size_t idx); virtual lldb::CompUnitSP GetCompileUnitAtIndex(size_t idx);
Show All 16 Lines

lldb/include/lldb/Symbol/Symtab.h

Show All 16 Lines
std::vector<uint32_t> &indexes, uint32_t start_idx = 0, std::vector<uint32_t> &indexes, uint32_t start_idx = 0,
uint32_t end_index = UINT32_MAX) const; uint32_t end_index = UINT32_MAX) const;
uint32_t AppendSymbolIndexesWithType(lldb::SymbolType symbol_type, uint32_t AppendSymbolIndexesWithType(lldb::SymbolType symbol_type,
Debug symbol_debug_type, Debug symbol_debug_type,
Visibility symbol_visibility, Visibility symbol_visibility,
std::vector<uint32_t> &matches, std::vector<uint32_t> &matches,
uint32_t start_idx = 0, uint32_t start_idx = 0,
uint32_t end_index = UINT32_MAX) const; uint32_t end_index = UINT32_MAX) const;
uint32_t AppendSymbolIndexesWithName(const ConstString &symbol_name, uint32_t AppendSymbolIndexesWithName(ConstString symbol_name,
std::vector<uint32_t> &matches); std::vector<uint32_t> &matches);
uint32_t AppendSymbolIndexesWithName(const ConstString &symbol_name, uint32_t AppendSymbolIndexesWithName(ConstString symbol_name,
Debug symbol_debug_type, Debug symbol_debug_type,
Visibility symbol_visibility, Visibility symbol_visibility,
std::vector<uint32_t> &matches); std::vector<uint32_t> &matches);
uint32_t AppendSymbolIndexesWithNameAndType(const ConstString &symbol_name, uint32_t AppendSymbolIndexesWithNameAndType(ConstString symbol_name,
lldb::SymbolType symbol_type, lldb::SymbolType symbol_type,
std::vector<uint32_t> &matches); std::vector<uint32_t> &matches);
uint32_t AppendSymbolIndexesWithNameAndType(const ConstString &symbol_name, uint32_t AppendSymbolIndexesWithNameAndType(ConstString symbol_name,
lldb::SymbolType symbol_type, lldb::SymbolType symbol_type,
Debug symbol_debug_type, Debug symbol_debug_type,
Visibility symbol_visibility, Visibility symbol_visibility,
std::vector<uint32_t> &matches); std::vector<uint32_t> &matches);
uint32_t uint32_t
AppendSymbolIndexesMatchingRegExAndType(const RegularExpression &regex, AppendSymbolIndexesMatchingRegExAndType(const RegularExpression &regex,
lldb::SymbolType symbol_type, lldb::SymbolType symbol_type,
std::vector<uint32_t> &indexes); std::vector<uint32_t> &indexes);
uint32_t AppendSymbolIndexesMatchingRegExAndType( uint32_t AppendSymbolIndexesMatchingRegExAndType(
const RegularExpression &regex, lldb::SymbolType symbol_type, const RegularExpression &regex, lldb::SymbolType symbol_type,
Debug symbol_debug_type, Visibility symbol_visibility, Debug symbol_debug_type, Visibility symbol_visibility,
std::vector<uint32_t> &indexes); std::vector<uint32_t> &indexes);
size_t FindAllSymbolsWithNameAndType(const ConstString &name, size_t FindAllSymbolsWithNameAndType(ConstString name,
lldb::SymbolType symbol_type, lldb::SymbolType symbol_type,
std::vector<uint32_t> &symbol_indexes); std::vector<uint32_t> &symbol_indexes);
size_t FindAllSymbolsWithNameAndType(const ConstString &name, size_t FindAllSymbolsWithNameAndType(ConstString name,
lldb::SymbolType symbol_type, lldb::SymbolType symbol_type,
Debug symbol_debug_type, Debug symbol_debug_type,
Visibility symbol_visibility, Visibility symbol_visibility,
std::vector<uint32_t> &symbol_indexes); std::vector<uint32_t> &symbol_indexes);
size_t FindAllSymbolsMatchingRexExAndType( size_t FindAllSymbolsMatchingRexExAndType(
const RegularExpression &regex, lldb::SymbolType symbol_type, const RegularExpression &regex, lldb::SymbolType symbol_type,
Debug symbol_debug_type, Visibility symbol_visibility, Debug symbol_debug_type, Visibility symbol_visibility,
std::vector<uint32_t> &symbol_indexes); std::vector<uint32_t> &symbol_indexes);
Symbol *FindFirstSymbolWithNameAndType(const ConstString &name, Symbol *FindFirstSymbolWithNameAndType(ConstString name,
lldb::SymbolType symbol_type, lldb::SymbolType symbol_type,
Debug symbol_debug_type, Debug symbol_debug_type,
Visibility symbol_visibility); Visibility symbol_visibility);
Symbol *FindSymbolAtFileAddress(lldb::addr_t file_addr); Symbol *FindSymbolAtFileAddress(lldb::addr_t file_addr);
Symbol *FindSymbolContainingFileAddress(lldb::addr_t file_addr); Symbol *FindSymbolContainingFileAddress(lldb::addr_t file_addr);
void ForEachSymbolContainingFileAddress( void ForEachSymbolContainingFileAddress(
lldb::addr_t file_addr, std::function<bool(Symbol *)> const &callback); lldb::addr_t file_addr, std::function<bool(Symbol *)> const &callback);
size_t FindFunctionSymbols(const ConstString &name, uint32_t name_type_mask, size_t FindFunctionSymbols(ConstString name, uint32_t name_type_mask,
SymbolContextList &sc_list); SymbolContextList &sc_list);
void CalculateSymbolSizes(); void CalculateSymbolSizes();
void SortSymbolIndexesByValue(std::vector<uint32_t> &indexes, void SortSymbolIndexesByValue(std::vector<uint32_t> &indexes,
bool remove_duplicates) const; bool remove_duplicates) const;
static void DumpSymbolHeader(Stream *s); static void DumpSymbolHeader(Stream *s);
Show All 16 Lines

lldb/include/lldb/Symbol/Type.h

Show All 16 Lines
#include <set> #include <set>
namespace lldb_private { namespace lldb_private {
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// CompilerContext allows an array of these items to be passed to perform // CompilerContext allows an array of these items to be passed to perform
// detailed lookups in SymbolVendor and SymbolFile functions. // detailed lookups in SymbolVendor and SymbolFile functions.
//---------------------------------------------------------------------- //----------------------------------------------------------------------
struct CompilerContext { struct CompilerContext {
CompilerContext(CompilerContextKind t, const ConstString &n) CompilerContext(CompilerContextKind t, ConstString n)
: type(t), name(n) {} : type(t), name(n) {}
bool operator==(const CompilerContext &rhs) const { bool operator==(const CompilerContext &rhs) const {
return type == rhs.type && name == rhs.name; return type == rhs.type && name == rhs.name;
} }
void Dump() const; void Dump() const;
Show All 32 Lines
// eResolveStateUnresolved when used in a 2-bit bitfield. // eResolveStateUnresolved when used in a 2-bit bitfield.
typedef enum ResolveStateTag : unsigned { typedef enum ResolveStateTag : unsigned {
eResolveStateUnresolved = 0, eResolveStateUnresolved = 0,
eResolveStateForward = 1, eResolveStateForward = 1,
eResolveStateLayout = 2, eResolveStateLayout = 2,
eResolveStateFull = 3 eResolveStateFull = 3
} ResolveState; } ResolveState;
Type(lldb::user_id_t uid, SymbolFile *symbol_file, const ConstString &name, Type(lldb::user_id_t uid, SymbolFile *symbol_file, ConstString name,
llvm::Optional<uint64_t> byte_size, SymbolContextScope *context, llvm::Optional<uint64_t> byte_size, SymbolContextScope *context,
lldb::user_id_t encoding_uid, EncodingDataType encoding_uid_type, lldb::user_id_t encoding_uid, EncodingDataType encoding_uid_type,
const Declaration &decl, const CompilerType &compiler_qual_type, const Declaration &decl, const CompilerType &compiler_qual_type,
ResolveState compiler_type_resolve_state); ResolveState compiler_type_resolve_state);
// This makes an invalid type. Used for functions that return a Type when // This makes an invalid type. Used for functions that return a Type when
// they get an error. // they get an error.
Type(); Type();
Show All 14 Lines
void GetDescription(Stream *s, lldb::DescriptionLevel level, bool show_name); void GetDescription(Stream *s, lldb::DescriptionLevel level, bool show_name);
SymbolFile *GetSymbolFile() { return m_symbol_file; } SymbolFile *GetSymbolFile() { return m_symbol_file; }
const SymbolFile *GetSymbolFile() const { return m_symbol_file; } const SymbolFile *GetSymbolFile() const { return m_symbol_file; }
TypeList *GetTypeList(); TypeList *GetTypeList();
const ConstString &GetName(); ConstString GetName();
llvm::Optional<uint64_t> GetByteSize(); llvm::Optional<uint64_t> GetByteSize();
uint32_t GetNumChildren(bool omit_empty_base_classes); uint32_t GetNumChildren(bool omit_empty_base_classes);
bool IsAggregateType(); bool IsAggregateType();
bool IsValidType() { return m_encoding_uid_type != eEncodingInvalid; } bool IsValidType() { return m_encoding_uid_type != eEncodingInvalid; }
bool IsTypedef() { return m_encoding_uid_type == eEncodingIsTypedefUID; } bool IsTypedef() { return m_encoding_uid_type == eEncodingIsTypedefUID; }
lldb::TypeSP GetTypedefType(); lldb::TypeSP GetTypedefType();
const ConstString &GetName() const { return m_name; } ConstString GetName() const { return m_name; }
ConstString GetQualifiedName(); ConstString GetQualifiedName();
void DumpValue(ExecutionContext *exe_ctx, Stream *s, void DumpValue(ExecutionContext *exe_ctx, Stream *s,
const DataExtractor &data, uint32_t data_offset, const DataExtractor &data, uint32_t data_offset,
bool show_type, bool show_summary, bool verbose, bool show_type, bool show_summary, bool verbose,
lldb::Format format = lldb::eFormatDefault); lldb::Format format = lldb::eFormatDefault);
Show All 32 Lines
public: public:
TypeMemberImpl() TypeMemberImpl()
: m_type_impl_sp(), m_bit_offset(0), m_name(), m_bitfield_bit_size(0), : m_type_impl_sp(), m_bit_offset(0), m_name(), m_bitfield_bit_size(0),
m_is_bitfield(false) m_is_bitfield(false)
{} {}
TypeMemberImpl(const lldb::TypeImplSP &type_impl_sp, uint64_t bit_offset, TypeMemberImpl(const lldb::TypeImplSP &type_impl_sp, uint64_t bit_offset,
const ConstString &name, uint32_t bitfield_bit_size = 0, ConstString name, uint32_t bitfield_bit_size = 0,
bool is_bitfield = false) bool is_bitfield = false)
: m_type_impl_sp(type_impl_sp), m_bit_offset(bit_offset), m_name(name), : m_type_impl_sp(type_impl_sp), m_bit_offset(bit_offset), m_name(name),
m_bitfield_bit_size(bitfield_bit_size), m_is_bitfield(is_bitfield) {} m_bitfield_bit_size(bitfield_bit_size), m_is_bitfield(is_bitfield) {}
TypeMemberImpl(const lldb::TypeImplSP &type_impl_sp, uint64_t bit_offset) TypeMemberImpl(const lldb::TypeImplSP &type_impl_sp, uint64_t bit_offset)
: m_type_impl_sp(type_impl_sp), m_bit_offset(bit_offset), m_name(), : m_type_impl_sp(type_impl_sp), m_bit_offset(bit_offset), m_name(),
m_bitfield_bit_size(0), m_is_bitfield(false) { m_bitfield_bit_size(0), m_is_bitfield(false) {
if (m_type_impl_sp) if (m_type_impl_sp)
m_name = m_type_impl_sp->GetName(); m_name = m_type_impl_sp->GetName();
} }
const lldb::TypeImplSP &GetTypeImpl() { return m_type_impl_sp; } const lldb::TypeImplSP &GetTypeImpl() { return m_type_impl_sp; }
const ConstString &GetName() const { return m_name; } ConstString GetName() const { return m_name; }
uint64_t GetBitOffset() const { return m_bit_offset; } uint64_t GetBitOffset() const { return m_bit_offset; }
uint32_t GetBitfieldBitSize() const { return m_bitfield_bit_size; } uint32_t GetBitfieldBitSize() const { return m_bitfield_bit_size; }
void SetBitfieldBitSize(uint32_t bitfield_bit_size) { void SetBitfieldBitSize(uint32_t bitfield_bit_size) {
m_bitfield_bit_size = bitfield_bit_size; m_bitfield_bit_size = bitfield_bit_size;
} }
Show All 32 Lines
bool operator!=(const TypeAndOrName &other) const; bool operator!=(const TypeAndOrName &other) const;
ConstString GetName() const; ConstString GetName() const;
lldb::TypeSP GetTypeSP() const { return m_type_pair.GetTypeSP(); } lldb::TypeSP GetTypeSP() const { return m_type_pair.GetTypeSP(); }
CompilerType GetCompilerType() const { return m_type_pair.GetCompilerType(); } CompilerType GetCompilerType() const { return m_type_pair.GetCompilerType(); }
void SetName(const ConstString &type_name); void SetName(ConstString type_name);
void SetName(const char *type_name_cstr); void SetName(const char *type_name_cstr);
void SetTypeSP(lldb::TypeSP type_sp); void SetTypeSP(lldb::TypeSP type_sp);
void SetCompilerType(CompilerType compiler_type); void SetCompilerType(CompilerType compiler_type);
bool IsEmpty() const; bool IsEmpty() const;
Show All 32 Lines
}; };
class TypeEnumMemberImpl { class TypeEnumMemberImpl {
public: public:
TypeEnumMemberImpl() TypeEnumMemberImpl()
: m_integer_type_sp(), m_name("<invalid>"), m_value(), m_valid(false) {} : m_integer_type_sp(), m_name("<invalid>"), m_value(), m_valid(false) {}
TypeEnumMemberImpl(const lldb::TypeImplSP &integer_type_sp, TypeEnumMemberImpl(const lldb::TypeImplSP &integer_type_sp,
const ConstString &name, const llvm::APSInt &value); ConstString name, const llvm::APSInt &value);
TypeEnumMemberImpl(const TypeEnumMemberImpl &rhs) TypeEnumMemberImpl(const TypeEnumMemberImpl &rhs)
: m_integer_type_sp(rhs.m_integer_type_sp), m_name(rhs.m_name), : m_integer_type_sp(rhs.m_integer_type_sp), m_name(rhs.m_name),
m_value(rhs.m_value), m_valid(rhs.m_valid) {} m_value(rhs.m_value), m_valid(rhs.m_valid) {}
TypeEnumMemberImpl &operator=(const TypeEnumMemberImpl &rhs); TypeEnumMemberImpl &operator=(const TypeEnumMemberImpl &rhs);
bool IsValid() { return m_valid; } bool IsValid() { return m_valid; }
const ConstString &GetName() const { return m_name; } ConstString GetName() const { return m_name; }
const lldb::TypeImplSP &GetIntegerType() const { return m_integer_type_sp; } const lldb::TypeImplSP &GetIntegerType() const { return m_integer_type_sp; }
uint64_t GetValueAsUnsigned() const { return m_value.getZExtValue(); } uint64_t GetValueAsUnsigned() const { return m_value.getZExtValue(); }
int64_t GetValueAsSigned() const { return m_value.getSExtValue(); } int64_t GetValueAsSigned() const { return m_value.getSExtValue(); }
protected: protected:
Show All 16 Lines

lldb/include/lldb/Symbol/TypeList.h

Show All 16 Lines
void Clear(); void Clear();
void Dump(Stream *s, bool show_context); void Dump(Stream *s, bool show_context);
// lldb::TypeSP // lldb::TypeSP
// FindType(lldb::user_id_t uid); // FindType(lldb::user_id_t uid);
TypeList FindTypes(const ConstString &name); TypeList FindTypes(ConstString name);
void Insert(const lldb::TypeSP &type); void Insert(const lldb::TypeSP &type);
uint32_t GetSize() const; uint32_t GetSize() const;
lldb::TypeSP GetTypeAtIndex(uint32_t idx); lldb::TypeSP GetTypeAtIndex(uint32_t idx);
typedef std::vector<lldb::TypeSP> collection; typedef std::vector<lldb::TypeSP> collection;
Show All 16 Lines

lldb/include/lldb/Symbol/TypeMap.h

Show All 16 Lines
TypeMap(); TypeMap();
virtual ~TypeMap(); virtual ~TypeMap();
void Clear(); void Clear();
void Dump(Stream *s, bool show_context); void Dump(Stream *s, bool show_context);
TypeMap FindTypes(const ConstString &name); TypeMap FindTypes(ConstString name);
void Insert(const lldb::TypeSP &type); void Insert(const lldb::TypeSP &type);
bool Empty() const; bool Empty() const;
bool InsertUnique(const lldb::TypeSP &type); bool InsertUnique(const lldb::TypeSP &type);
uint32_t GetSize() const; uint32_t GetSize() const;
Show All 16 Lines

lldb/include/lldb/Symbol/TypeSystem.h

Show All 16 Lines
uint64_t &count) = 0; uint64_t &count) = 0;
virtual lldb::Format GetFormat(lldb::opaque_compiler_type_t type) = 0; virtual lldb::Format GetFormat(lldb::opaque_compiler_type_t type) = 0;
virtual uint32_t GetNumChildren(lldb::opaque_compiler_type_t type, virtual uint32_t GetNumChildren(lldb::opaque_compiler_type_t type,
bool omit_empty_base_classes, bool omit_empty_base_classes,
const ExecutionContext *exe_ctx) = 0; const ExecutionContext *exe_ctx) = 0;
virtual CompilerType GetBuiltinTypeByName(const ConstString &name); virtual CompilerType GetBuiltinTypeByName(ConstString name);
virtual lldb::BasicType virtual lldb::BasicType
GetBasicTypeEnumeration(lldb::opaque_compiler_type_t type) = 0; GetBasicTypeEnumeration(lldb::opaque_compiler_type_t type) = 0;
virtual void ForEachEnumerator( virtual void ForEachEnumerator(
lldb::opaque_compiler_type_t type, lldb::opaque_compiler_type_t type,
std::function<bool(const CompilerType &integer_type, std::function<bool(const CompilerType &integer_type,
const ConstString &name, ConstString name,
const llvm::APSInt &value)> const &callback) {} const llvm::APSInt &value)> const &callback) {}
virtual uint32_t GetNumFields(lldb::opaque_compiler_type_t type) = 0; virtual uint32_t GetNumFields(lldb::opaque_compiler_type_t type) = 0;
virtual CompilerType GetFieldAtIndex(lldb::opaque_compiler_type_t type, virtual CompilerType GetFieldAtIndex(lldb::opaque_compiler_type_t type,
size_t idx, std::string &name, size_t idx, std::string &name,
uint64_t *bit_offset_ptr, uint64_t *bit_offset_ptr,
uint32_t *bitfield_bit_size_ptr, uint32_t *bitfield_bit_size_ptr,
Show All 16 Lines

lldb/include/lldb/Symbol/Variable.h

Show All 16 Lines
SymbolContextScope *GetSymbolContextScope() const { return m_owner_scope; } SymbolContextScope *GetSymbolContextScope() const { return m_owner_scope; }
// Since a variable can have a basename "i" and also a mangled named // Since a variable can have a basename "i" and also a mangled named
// "_ZN12_GLOBAL__N_11iE" and a demangled mangled name "(anonymous // "_ZN12_GLOBAL__N_11iE" and a demangled mangled name "(anonymous
// namespace)::i", this function will allow a generic match function that can // namespace)::i", this function will allow a generic match function that can
// be called by commands and expression parsers to make sure we match // be called by commands and expression parsers to make sure we match
// anything we come across. // anything we come across.
bool NameMatches(const ConstString &name) const; bool NameMatches(ConstString name) const;
bool NameMatches(const RegularExpression &regex) const; bool NameMatches(const RegularExpression &regex) const;
Type *GetType(); Type *GetType();
lldb::LanguageType GetLanguage() const; lldb::LanguageType GetLanguage() const;
lldb::ValueType GetScope() const { return m_scope; } lldb::ValueType GetScope() const { return m_scope; }
Show All 16 Lines

lldb/include/lldb/Symbol/VariableList.h

Show All 16 Lines
void Clear(); void Clear();
void Dump(Stream *s, bool show_context) const; void Dump(Stream *s, bool show_context) const;
lldb::VariableSP GetVariableAtIndex(size_t idx) const; lldb::VariableSP GetVariableAtIndex(size_t idx) const;
lldb::VariableSP RemoveVariableAtIndex(size_t idx); lldb::VariableSP RemoveVariableAtIndex(size_t idx);
lldb::VariableSP FindVariable(const ConstString &name, lldb::VariableSP FindVariable(ConstString name,
bool include_static_members = true); bool include_static_members = true);
lldb::VariableSP FindVariable(const ConstString &name, lldb::VariableSP FindVariable(ConstString name,
lldb::ValueType value_type, lldb::ValueType value_type,
bool include_static_members = true); bool include_static_members = true);
uint32_t FindVariableIndex(const lldb::VariableSP &var_sp); uint32_t FindVariableIndex(const lldb::VariableSP &var_sp);
size_t AppendVariablesIfUnique(VariableList &var_list); size_t AppendVariablesIfUnique(VariableList &var_list);
// Returns the actual number of unique variables that were added to the list. // Returns the actual number of unique variables that were added to the list.
Show All 16 Lines

lldb/include/lldb/Target/ABI.h

Show All 16 Lines
// Some targets might use bits in a code address to indicate a mode switch. // Some targets might use bits in a code address to indicate a mode switch.
// ARM uses bit zero to signify a code address is thumb, so any ARM ABI // ARM uses bit zero to signify a code address is thumb, so any ARM ABI
// plug-ins would strip those bits. // plug-ins would strip those bits.
return pc; return pc;
} }
virtual const RegisterInfo *GetRegisterInfoArray(uint32_t &count) = 0; virtual const RegisterInfo *GetRegisterInfoArray(uint32_t &count) = 0;
bool GetRegisterInfoByName(const ConstString &name, RegisterInfo &info); bool GetRegisterInfoByName(ConstString name, RegisterInfo &info);
bool GetRegisterInfoByKind(lldb::RegisterKind reg_kind, uint32_t reg_num, bool GetRegisterInfoByKind(lldb::RegisterKind reg_kind, uint32_t reg_num,
RegisterInfo &info); RegisterInfo &info);
virtual bool GetPointerReturnRegister(const char *&name) { return false; } virtual bool GetPointerReturnRegister(const char *&name) { return false; }
static lldb::ABISP FindPlugin(lldb::ProcessSP process_sp, const ArchSpec &arch); static lldb::ABISP FindPlugin(lldb::ProcessSP process_sp, const ArchSpec &arch);
Show All 16 Lines

lldb/include/lldb/Target/MemoryRegionInfo.h

Show All 16 Lines
OptionalBool GetReadable() const { return m_read; } OptionalBool GetReadable() const { return m_read; }
OptionalBool GetWritable() const { return m_write; } OptionalBool GetWritable() const { return m_write; }
OptionalBool GetExecutable() const { return m_execute; } OptionalBool GetExecutable() const { return m_execute; }
OptionalBool GetMapped() const { return m_mapped; } OptionalBool GetMapped() const { return m_mapped; }
const ConstString &GetName() const { return m_name; } ConstString GetName() const { return m_name; }
void SetReadable(OptionalBool val) { m_read = val; } void SetReadable(OptionalBool val) { m_read = val; }
void SetWritable(OptionalBool val) { m_write = val; } void SetWritable(OptionalBool val) { m_write = val; }
void SetExecutable(OptionalBool val) { m_execute = val; } void SetExecutable(OptionalBool val) { m_execute = val; }
void SetMapped(OptionalBool val) { m_mapped = val; } void SetMapped(OptionalBool val) { m_mapped = val; }
Show All 16 Lines

lldb/include/lldb/Target/ObjCLanguageRuntime.h

Show All 16 Lines
virtual EncodingToTypeSP GetEncodingToType(); virtual EncodingToTypeSP GetEncodingToType();
virtual ClassDescriptorSP GetClassDescriptor(ValueObject &in_value); virtual ClassDescriptorSP GetClassDescriptor(ValueObject &in_value);
ClassDescriptorSP GetNonKVOClassDescriptor(ValueObject &in_value); ClassDescriptorSP GetNonKVOClassDescriptor(ValueObject &in_value);
virtual ClassDescriptorSP virtual ClassDescriptorSP
GetClassDescriptorFromClassName(const ConstString &class_name); GetClassDescriptorFromClassName(ConstString class_name);
virtual ClassDescriptorSP GetClassDescriptorFromISA(ObjCISA isa); virtual ClassDescriptorSP GetClassDescriptorFromISA(ObjCISA isa);
ClassDescriptorSP GetNonKVOClassDescriptor(ObjCISA isa); ClassDescriptorSP GetNonKVOClassDescriptor(ObjCISA isa);
lldb::LanguageType GetLanguageType() const override { lldb::LanguageType GetLanguageType() const override {
return lldb::eLanguageTypeObjC; return lldb::eLanguageTypeObjC;
} }
Show All 32 Lines
virtual void UpdateISAToDescriptorMapIfNeeded() = 0; virtual void UpdateISAToDescriptorMapIfNeeded() = 0;
void UpdateISAToDescriptorMap() { void UpdateISAToDescriptorMap() {
if (m_process && m_process->GetStopID() != m_isa_to_descriptor_stop_id) { if (m_process && m_process->GetStopID() != m_isa_to_descriptor_stop_id) {
UpdateISAToDescriptorMapIfNeeded(); UpdateISAToDescriptorMapIfNeeded();
} }
} }
virtual ObjCISA GetISA(const ConstString &name); virtual ObjCISA GetISA(ConstString name);
virtual ConstString GetActualTypeName(ObjCISA isa); virtual ConstString GetActualTypeName(ObjCISA isa);
virtual ObjCISA GetParentClass(ObjCISA isa); virtual ObjCISA GetParentClass(ObjCISA isa);
virtual DeclVendor *GetDeclVendor() { return nullptr; } virtual DeclVendor *GetDeclVendor() { return nullptr; }
// Finds the byte offset of the child_type ivar in parent_type. If it can't // Finds the byte offset of the child_type ivar in parent_type. If it can't
// find the offset, returns LLDB_INVALID_IVAR_OFFSET. // find the offset, returns LLDB_INVALID_IVAR_OFFSET.
virtual size_t GetByteOffsetForIvar(CompilerType &parent_qual_type, virtual size_t GetByteOffsetForIvar(CompilerType &parent_qual_type,
const char *ivar_name); const char *ivar_name);
// Given the name of an Objective-C runtime symbol (e.g., ivar offset // Given the name of an Objective-C runtime symbol (e.g., ivar offset
// symbol), try to determine from the runtime what the value of that symbol // symbol), try to determine from the runtime what the value of that symbol
// would be. Useful when the underlying binary is stripped. // would be. Useful when the underlying binary is stripped.
virtual lldb::addr_t LookupRuntimeSymbol(const ConstString &name) { virtual lldb::addr_t LookupRuntimeSymbol(ConstString name) {
return LLDB_INVALID_ADDRESS; return LLDB_INVALID_ADDRESS;
} }
bool HasNewLiteralsAndIndexing() { bool HasNewLiteralsAndIndexing() {
if (m_has_new_literals_and_indexing == eLazyBoolCalculate) { if (m_has_new_literals_and_indexing == eLazyBoolCalculate) {
if (CalculateHasNewLiteralsAndIndexing()) if (CalculateHasNewLiteralsAndIndexing())
m_has_new_literals_and_indexing = eLazyBoolYes; m_has_new_literals_and_indexing = eLazyBoolYes;
else else
Show All 32 Lines
protected: protected:
uint32_t m_isa_to_descriptor_stop_id; uint32_t m_isa_to_descriptor_stop_id;
typedef std::map<ConstString, lldb::TypeWP> CompleteClassMap; typedef std::map<ConstString, lldb::TypeWP> CompleteClassMap;
CompleteClassMap m_complete_class_cache; CompleteClassMap m_complete_class_cache;
struct ConstStringSetHelpers { struct ConstStringSetHelpers {
size_t operator()(const ConstString &arg) const // for hashing size_t operator()(ConstString arg) const // for hashing
{ {
return (size_t)arg.GetCString(); return (size_t)arg.GetCString();
} }
bool operator()(const ConstString &arg1, bool operator()(ConstString arg1,
const ConstString &arg2) const // for equality ConstString arg2) const // for equality
{ {
return arg1.operator==(arg2); return arg1.operator==(arg2);
} }
}; };
typedef std::unordered_set<ConstString, ConstStringSetHelpers, typedef std::unordered_set<ConstString, ConstStringSetHelpers,
ConstStringSetHelpers> ConstStringSetHelpers>
CompleteClassSet; CompleteClassSet;
CompleteClassSet m_negative_complete_class_cache; CompleteClassSet m_negative_complete_class_cache;
ISAToDescriptorIterator GetDescriptorIterator(const ConstString &name); ISAToDescriptorIterator GetDescriptorIterator(ConstString name);
friend class ::CommandObjectObjC_ClassTable_Dump; friend class ::CommandObjectObjC_ClassTable_Dump;
std::pair<ISAToDescriptorIterator, ISAToDescriptorIterator> std::pair<ISAToDescriptorIterator, ISAToDescriptorIterator>
GetDescriptorIteratorPair(bool update_if_needed = true); GetDescriptorIteratorPair(bool update_if_needed = true);
void ReadObjCLibraryIfNeeded(const ModuleList &module_list); void ReadObjCLibraryIfNeeded(const ModuleList &module_list);
DISALLOW_COPY_AND_ASSIGN(ObjCLanguageRuntime); DISALLOW_COPY_AND_ASSIGN(ObjCLanguageRuntime);
}; };
} // namespace lldb_private } // namespace lldb_private
#endif // liblldb_ObjCLanguageRuntime_h_ #endif // liblldb_ObjCLanguageRuntime_h_
Context not available.

lldb/include/lldb/Target/PathMappingList.h

Show All 16 Lines
PathMappingList(ChangedCallback callback, void *callback_baton); PathMappingList(ChangedCallback callback, void *callback_baton);
PathMappingList(const PathMappingList &rhs); PathMappingList(const PathMappingList &rhs);
~PathMappingList(); ~PathMappingList();
const PathMappingList &operator=(const PathMappingList &rhs); const PathMappingList &operator=(const PathMappingList &rhs);
void Append(const ConstString &path, const ConstString &replacement, void Append(ConstString path, ConstString replacement,
bool notify); bool notify);
void Append(const PathMappingList &rhs, bool notify); void Append(const PathMappingList &rhs, bool notify);
void Clear(bool notify); void Clear(bool notify);
// By default, dump all pairs. // By default, dump all pairs.
void Dump(Stream *s, int pair_index = -1); void Dump(Stream *s, int pair_index = -1);
bool IsEmpty() const { return m_pairs.empty(); } bool IsEmpty() const { return m_pairs.empty(); }
size_t GetSize() const { return m_pairs.size(); } size_t GetSize() const { return m_pairs.size(); }
bool GetPathsAtIndex(uint32_t idx, ConstString &path, bool GetPathsAtIndex(uint32_t idx, ConstString &path,
ConstString &new_path) const; ConstString &new_path) const;
void Insert(const ConstString &path, const ConstString &replacement, void Insert(ConstString path, ConstString replacement,
uint32_t insert_idx, bool notify); uint32_t insert_idx, bool notify);
bool Remove(size_t index, bool notify); bool Remove(size_t index, bool notify);
bool Remove(const ConstString &path, bool notify); bool Remove(ConstString path, bool notify);
bool Replace(const ConstString &path, const ConstString &replacement, bool Replace(ConstString path, ConstString replacement,
bool notify); bool notify);
bool Replace(const ConstString &path, const ConstString &replacement, bool Replace(ConstString path, ConstString replacement,
uint32_t index, bool notify); uint32_t index, bool notify);
bool RemapPath(const ConstString &path, ConstString &new_path) const; bool RemapPath(ConstString path, ConstString &new_path) const;
//------------------------------------------------------------------ //------------------------------------------------------------------
/// Remaps a source file given \a path into \a new_path. /// Remaps a source file given \a path into \a new_path.
/// ///
/// Remaps \a path if any source remappings match. This function /// Remaps \a path if any source remappings match. This function
/// does NOT stat the file system so it can be used in tight loops /// does NOT stat the file system so it can be used in tight loops
/// where debug info is being parsed. /// where debug info is being parsed.
/// ///
Show All 29 Lines
/// ///
/// @return /// @return
/// /b true if \a orig_spec was successfully located and /// /b true if \a orig_spec was successfully located and
/// \a new_spec is filled in with an existing file spec, /// \a new_spec is filled in with an existing file spec,
/// \b false otherwise. /// \b false otherwise.
//------------------------------------------------------------------ //------------------------------------------------------------------
bool FindFile(const FileSpec &orig_spec, FileSpec &new_spec) const; bool FindFile(const FileSpec &orig_spec, FileSpec &new_spec) const;
uint32_t FindIndexForPath(const ConstString &path) const; uint32_t FindIndexForPath(ConstString path) const;
uint32_t GetModificationID() const { return m_mod_id; } uint32_t GetModificationID() const { return m_mod_id; }
protected: protected:
typedef std::pair<ConstString, ConstString> pair; typedef std::pair<ConstString, ConstString> pair;
typedef std::vector<pair> collection; typedef std::vector<pair> collection;
typedef collection::iterator iterator; typedef collection::iterator iterator;
typedef collection::const_iterator const_iterator; typedef collection::const_iterator const_iterator;
iterator FindIteratorForPath(const ConstString &path); iterator FindIteratorForPath(ConstString path);
const_iterator FindIteratorForPath(const ConstString &path) const; const_iterator FindIteratorForPath(ConstString path) const;
collection m_pairs; collection m_pairs;
ChangedCallback m_callback; ChangedCallback m_callback;
void *m_callback_baton; void *m_callback_baton;
uint32_t m_mod_id; // Incremented anytime anything is added or removed. uint32_t m_mod_id; // Incremented anytime anything is added or removed.
}; };
} // namespace lldb_private } // namespace lldb_private
#endif // liblldb_PathMappingList_h_ #endif // liblldb_PathMappingList_h_
Context not available.

lldb/include/lldb/Target/Platform.h

Show All 16 Lines
static lldb::PlatformSP static lldb::PlatformSP
GetPlatformForArchitecture(const ArchSpec &arch, ArchSpec *platform_arch_ptr); GetPlatformForArchitecture(const ArchSpec &arch, ArchSpec *platform_arch_ptr);
static const char *GetHostPlatformName(); static const char *GetHostPlatformName();
static void SetHostPlatform(const lldb::PlatformSP &platform_sp); static void SetHostPlatform(const lldb::PlatformSP &platform_sp);
// Find an existing platform plug-in by name // Find an existing platform plug-in by name
static lldb::PlatformSP Find(const ConstString &name); static lldb::PlatformSP Find(ConstString name);
static lldb::PlatformSP Create(const ConstString &name, Status &error); static lldb::PlatformSP Create(ConstString name, Status &error);
static lldb::PlatformSP Create(const ArchSpec &arch, static lldb::PlatformSP Create(const ArchSpec &arch,
ArchSpec *platform_arch_ptr, Status &error); ArchSpec *platform_arch_ptr, Status &error);
//------------------------------------------------------------------------ //------------------------------------------------------------------------
/// Augments the triple either with information from platform or the host /// Augments the triple either with information from platform or the host
/// system (if platform is null). /// system (if platform is null).
//------------------------------------------------------------------------ //------------------------------------------------------------------------
Show All 10 Lines
/// The process for which to try and locate a platform /// The process for which to try and locate a platform
/// plug-in instance. /// plug-in instance.
/// ///
/// @param[in] plugin_name /// @param[in] plugin_name
/// An optional name of a specific platform plug-in that /// An optional name of a specific platform plug-in that
/// should be used. If nullptr, pick the best plug-in. /// should be used. If nullptr, pick the best plug-in.
//------------------------------------------------------------------ //------------------------------------------------------------------
// static lldb::PlatformSP // static lldb::PlatformSP
// FindPlugin (Process *process, const ConstString &plugin_name); // FindPlugin (Process *process, ConstString plugin_name);
//------------------------------------------------------------------ //------------------------------------------------------------------
/// Set the target's executable based off of the existing architecture /// Set the target's executable based off of the existing architecture
/// information in \a target given a path to an executable \a exe_file. /// information in \a target given a path to an executable \a exe_file.
/// ///
/// Each platform knows the architectures that it supports and can select /// Each platform knows the architectures that it supports and can select
/// the correct architecture slice within \a exe_file by inspecting the /// the correct architecture slice within \a exe_file by inspecting the
/// architecture in \a target. If the target had an architecture specified, /// architecture in \a target. If the target had an architecture specified,
Show All 32 Lines
ArchSpec GetAugmentedArchSpec(llvm::StringRef triple); ArchSpec GetAugmentedArchSpec(llvm::StringRef triple);
// Used for column widths // Used for column widths
size_t GetMaxUserIDNameLength() const { return m_max_uid_name_len; } size_t GetMaxUserIDNameLength() const { return m_max_uid_name_len; }
// Used for column widths // Used for column widths
size_t GetMaxGroupIDNameLength() const { return m_max_gid_name_len; } size_t GetMaxGroupIDNameLength() const { return m_max_gid_name_len; }
const ConstString &GetSDKRootDirectory() const { return m_sdk_sysroot; } ConstString GetSDKRootDirectory() const { return m_sdk_sysroot; }
void SetSDKRootDirectory(const ConstString &dir) { m_sdk_sysroot = dir; } void SetSDKRootDirectory(ConstString dir) { m_sdk_sysroot = dir; }
const ConstString &GetSDKBuild() const { return m_sdk_build; } ConstString GetSDKBuild() const { return m_sdk_build; }
void SetSDKBuild(const ConstString &sdk_build) { m_sdk_build = sdk_build; } void SetSDKBuild(ConstString sdk_build) { m_sdk_build = sdk_build; }
// Override this to return true if your platform supports Clang modules. You // Override this to return true if your platform supports Clang modules. You
// may also need to override AddClangModuleCompilationOptions to pass the // may also need to override AddClangModuleCompilationOptions to pass the
// right Clang flags for your platform. // right Clang flags for your platform.
virtual bool SupportsModules() { return false; } virtual bool SupportsModules() { return false; }
// Appends the platform-specific options required to find the modules for the // Appends the platform-specific options required to find the modules for the
// current platform. // current platform.
Show All 16 Lines

lldb/include/lldb/Target/Process.h

Show All 16 Lines
friend class Process; friend class Process;
public: public:
ProcessEventData(); ProcessEventData();
ProcessEventData(const lldb::ProcessSP &process, lldb::StateType state); ProcessEventData(const lldb::ProcessSP &process, lldb::StateType state);
~ProcessEventData() override; ~ProcessEventData() override;
static const ConstString &GetFlavorString(); static ConstString GetFlavorString();
const ConstString &GetFlavor() const override; ConstString GetFlavor() const override;
lldb::ProcessSP GetProcessSP() const { return m_process_wp.lock(); } lldb::ProcessSP GetProcessSP() const { return m_process_wp.lock(); }
lldb::StateType GetState() const { return m_state; } lldb::StateType GetState() const { return m_state; }
bool GetRestarted() const { return m_restarted; } bool GetRestarted() const { return m_restarted; }
size_t GetNumRestartedReasons() { return m_restarted_reasons.size(); } size_t GetNumRestartedReasons() { return m_restarted_reasons.size(); }
Show All 32 Lines
/// an array or some other object. If the feature needs to be /// an array or some other object. If the feature needs to be
/// set up properly before it can be enabled, then the config should /// set up properly before it can be enabled, then the config should
/// also take an enable/disable flag. /// also take an enable/disable flag.
/// ///
/// @return /// @return
/// Returns the result of attempting to configure the feature. /// Returns the result of attempting to configure the feature.
//------------------------------------------------------------------ //------------------------------------------------------------------
virtual Status virtual Status
ConfigureStructuredData(const ConstString &type_name, ConfigureStructuredData(ConstString type_name,
const StructuredData::ObjectSP &config_sp); const StructuredData::ObjectSP &config_sp);
//------------------------------------------------------------------ //------------------------------------------------------------------
/// Broadcasts the given structured data object from the given plugin. /// Broadcasts the given structured data object from the given plugin.
/// ///
/// StructuredDataPlugin instances can use this to optionally broadcast any /// StructuredDataPlugin instances can use this to optionally broadcast any
/// of their data if they want to make it available for clients. The data /// of their data if they want to make it available for clients. The data
/// will come in on the structured data event bit /// will come in on the structured data event bit
Show All 17 Lines
/// debugged process monitor claims that the feature is supported. This is /// debugged process monitor claims that the feature is supported. This is
/// one way to tell whether a feature is available. /// one way to tell whether a feature is available.
/// ///
/// @return /// @return
/// The plugin if one is available for the specified feature; /// The plugin if one is available for the specified feature;
/// otherwise, returns an empty shared pointer. /// otherwise, returns an empty shared pointer.
//------------------------------------------------------------------ //------------------------------------------------------------------
lldb::StructuredDataPluginSP lldb::StructuredDataPluginSP
GetStructuredDataPlugin(const ConstString &type_name) const; GetStructuredDataPlugin(ConstString type_name) const;
//------------------------------------------------------------------ //------------------------------------------------------------------
/// Starts tracing with the configuration provided in options. To enable /// Starts tracing with the configuration provided in options. To enable
/// tracing on the complete process the thread_id in the options should be /// tracing on the complete process the thread_id in the options should be
/// set to LLDB_INVALID_THREAD_ID. The API returns a user_id which is needed /// set to LLDB_INVALID_THREAD_ID. The API returns a user_id which is needed
/// by other API's that manipulate the trace instance. The handling of /// by other API's that manipulate the trace instance. The handling of
/// erroneous or unsupported configuration is left to the trace technology /// erroneous or unsupported configuration is left to the trace technology
/// implementations in the server, as they could be returned as an error, or /// implementations in the server, as they could be returned as an error, or
Show All 32 Lines
/// When non-null and pointing to a dictionary, the 'type' /// When non-null and pointing to a dictionary, the 'type'
/// key's string value is used to look up the plugin that /// key's string value is used to look up the plugin that
/// was registered for that structured data type. It then /// was registered for that structured data type. It then
/// calls the following method on the StructuredDataPlugin /// calls the following method on the StructuredDataPlugin
/// instance: /// instance:
/// ///
/// virtual void /// virtual void
/// HandleArrivalOfStructuredData(Process &process, /// HandleArrivalOfStructuredData(Process &process,
/// const ConstString &type_name, /// ConstString type_name,
/// const StructuredData::ObjectSP /// const StructuredData::ObjectSP
/// &object_sp) /// &object_sp)
/// ///
/// @return /// @return
/// True if the structured data was routed to a plugin; otherwise, /// True if the structured data was routed to a plugin; otherwise,
/// false. /// false.
//------------------------------------------------------------------ //------------------------------------------------------------------
bool RouteAsyncStructuredData(const StructuredData::ObjectSP object_sp); bool RouteAsyncStructuredData(const StructuredData::ObjectSP object_sp);
Show All 16 Lines

lldb/include/lldb/Target/StackFrameRecognizer.h

Show All 16 Lines
/// @class StackFrameRecognizerManager /// @class StackFrameRecognizerManager
/// ///
/// Static class that provides a registry of known stack frame recognizers. /// Static class that provides a registry of known stack frame recognizers.
/// Has static methods to add, enumerate, remove, query and invoke recognizers. /// Has static methods to add, enumerate, remove, query and invoke recognizers.
class StackFrameRecognizerManager { class StackFrameRecognizerManager {
public: public:
static void AddRecognizer(lldb::StackFrameRecognizerSP recognizer, static void AddRecognizer(lldb::StackFrameRecognizerSP recognizer,
const ConstString &module, ConstString module,
const ConstString &symbol, ConstString symbol,
bool first_instruction_only = true); bool first_instruction_only = true);
static void AddRecognizer(lldb::StackFrameRecognizerSP recognizer, static void AddRecognizer(lldb::StackFrameRecognizerSP recognizer,
lldb::RegularExpressionSP module, lldb::RegularExpressionSP module,
lldb::RegularExpressionSP symbol, lldb::RegularExpressionSP symbol,
bool first_instruction_only = true); bool first_instruction_only = true);
static void ForEach( static void ForEach(
Show All 16 Lines

lldb/include/lldb/Target/StructuredDataPlugin.h

Show All 16 Lines
/// ///
/// @param[in] type_name /// @param[in] type_name
/// The name of the feature tag supported by a process. /// The name of the feature tag supported by a process.
/// e.g. "darwin-log". /// e.g. "darwin-log".
/// ///
/// @return /// @return
/// true if the plugin supports the feature; otherwise, false. /// true if the plugin supports the feature; otherwise, false.
// ------------------------------------------------------------------------- // -------------------------------------------------------------------------
virtual bool SupportsStructuredDataType(const ConstString &type_name) = 0; virtual bool SupportsStructuredDataType(ConstString type_name) = 0;
// ------------------------------------------------------------------------- // -------------------------------------------------------------------------
/// Handle the arrival of asynchronous structured data from the process. /// Handle the arrival of asynchronous structured data from the process.
/// ///
/// When asynchronous structured data arrives from the process monitor, /// When asynchronous structured data arrives from the process monitor,
/// it is immediately delivered to the plugin mapped for that feature /// it is immediately delivered to the plugin mapped for that feature
/// if one exists. The structured data that arrives from a process /// if one exists. The structured data that arrives from a process
/// monitor must be a dictionary, and it must have a string field named /// monitor must be a dictionary, and it must have a string field named
Show All 13 Lines
/// ///
/// @param[in] object_sp /// @param[in] object_sp
/// A shared pointer to the structured data that arrived. This must /// A shared pointer to the structured data that arrived. This must
/// be a dictionary. The only key required is the aforementioned /// be a dictionary. The only key required is the aforementioned
/// key named "type" that must be a string value containing the /// key named "type" that must be a string value containing the
/// structured data type name. /// structured data type name.
// ------------------------------------------------------------------------- // -------------------------------------------------------------------------
virtual void virtual void
HandleArrivalOfStructuredData(Process &process, const ConstString &type_name, HandleArrivalOfStructuredData(Process &process, ConstString type_name,
const StructuredData::ObjectSP &object_sp) = 0; const StructuredData::ObjectSP &object_sp) = 0;
// ------------------------------------------------------------------------- // -------------------------------------------------------------------------
/// Get a human-readable description of the contents of the data. /// Get a human-readable description of the contents of the data.
/// ///
/// In command-line LLDB, this method will be called by the Debugger /// In command-line LLDB, this method will be called by the Debugger
/// instance for each structured data event generated, and the output /// instance for each structured data event generated, and the output
/// will be printed to the LLDB console. If nothing is added to the stream, /// will be printed to the LLDB console. If nothing is added to the stream,
Show All 19 Lines
/// This is a convenience method for plugins that can enable or disable /// This is a convenience method for plugins that can enable or disable
/// their functionality. It allows retrieval of this state without /// their functionality. It allows retrieval of this state without
/// requiring a cast. /// requiring a cast.
/// ///
/// @param[in] type_name /// @param[in] type_name
/// The name of the feature tag for the asynchronous structured data. /// The name of the feature tag for the asynchronous structured data.
/// This is needed for plugins that support more than one feature. /// This is needed for plugins that support more than one feature.
// ------------------------------------------------------------------------- // -------------------------------------------------------------------------
virtual bool GetEnabled(const ConstString &type_name) const; virtual bool GetEnabled(ConstString type_name) const;
// ------------------------------------------------------------------------- // -------------------------------------------------------------------------
/// Allow the plugin to do work related to modules that loaded in the /// Allow the plugin to do work related to modules that loaded in the
/// the corresponding process. /// the corresponding process.
/// ///
/// This method defaults to doing nothing. Plugins can override it /// This method defaults to doing nothing. Plugins can override it
/// if they have any behavior they want to enable/modify based on loaded /// if they have any behavior they want to enable/modify based on loaded
/// modules. /// modules.
Show All 16 Lines

lldb/include/lldb/Target/Target.h

Show All 16 Lines
public: public:
TargetEventData(const lldb::TargetSP &target_sp); TargetEventData(const lldb::TargetSP &target_sp);
TargetEventData(const lldb::TargetSP &target_sp, TargetEventData(const lldb::TargetSP &target_sp,
const ModuleList &module_list); const ModuleList &module_list);
~TargetEventData() override; ~TargetEventData() override;
static const ConstString &GetFlavorString(); static ConstString GetFlavorString();
const ConstString &GetFlavor() const override { ConstString GetFlavor() const override {
return TargetEventData::GetFlavorString(); return TargetEventData::GetFlavorString();
} }
void Dump(Stream *s) const override; void Dump(Stream *s) const override;
static const TargetEventData *GetEventDataFromEvent(const Event *event_ptr); static const TargetEventData *GetEventDataFromEvent(const Event *event_ptr);
static lldb::TargetSP GetTargetFromEvent(const Event *event_ptr); static lldb::TargetSP GetTargetFromEvent(const Event *event_ptr);
Show All 32 Lines
// Manages breakpoint names: // Manages breakpoint names:
void AddNameToBreakpoint(BreakpointID &id, const char *name, Status &error); void AddNameToBreakpoint(BreakpointID &id, const char *name, Status &error);
void AddNameToBreakpoint(lldb::BreakpointSP &bp_sp, const char *name, void AddNameToBreakpoint(lldb::BreakpointSP &bp_sp, const char *name,
Status &error); Status &error);
void RemoveNameFromBreakpoint(lldb::BreakpointSP &bp_sp, void RemoveNameFromBreakpoint(lldb::BreakpointSP &bp_sp,
const ConstString &name); ConstString name);
BreakpointName *FindBreakpointName(const ConstString &name, bool can_create, BreakpointName *FindBreakpointName(ConstString name, bool can_create,
Status &error); Status &error);
void DeleteBreakpointName(const ConstString &name); void DeleteBreakpointName(ConstString name);
void ConfigureBreakpointName(BreakpointName &bp_name, void ConfigureBreakpointName(BreakpointName &bp_name,
const BreakpointOptions &options, const BreakpointOptions &options,
const BreakpointName::Permissions &permissions); const BreakpointName::Permissions &permissions);
void ApplyNameToBreakpoints(BreakpointName &bp_name); void ApplyNameToBreakpoints(BreakpointName &bp_name);
// This takes ownership of the name obj passed in. // This takes ownership of the name obj passed in.
void AddBreakpointName(BreakpointName *bp_name); void AddBreakpointName(BreakpointName *bp_name);
Show All 32 Lines
// th execution context. // th execution context.
lldb::ExpressionResults EvaluateExpression( lldb::ExpressionResults EvaluateExpression(
llvm::StringRef expression, ExecutionContextScope *exe_scope, llvm::StringRef expression, ExecutionContextScope *exe_scope,
lldb::ValueObjectSP &result_valobj_sp, lldb::ValueObjectSP &result_valobj_sp,
const EvaluateExpressionOptions &options = EvaluateExpressionOptions(), const EvaluateExpressionOptions &options = EvaluateExpressionOptions(),
std::string *fixed_expression = nullptr, std::string *fixed_expression = nullptr,
ValueObject *ctx_obj = nullptr); ValueObject *ctx_obj = nullptr);
lldb::ExpressionVariableSP GetPersistentVariable(const ConstString &name); lldb::ExpressionVariableSP GetPersistentVariable(ConstString name);
/// Return the next available number for numbered persistent variables. /// Return the next available number for numbered persistent variables.
unsigned GetNextPersistentVariableIndex() { unsigned GetNextPersistentVariableIndex() {
return m_next_persistent_variable_index++; return m_next_persistent_variable_index++;
} }
lldb::addr_t GetPersistentSymbol(const ConstString &name); lldb::addr_t GetPersistentSymbol(ConstString name);
//------------------------------------------------------------------ //------------------------------------------------------------------
// Target Stop Hooks // Target Stop Hooks
//------------------------------------------------------------------ //------------------------------------------------------------------
class StopHook : public UserID { class StopHook : public UserID {
public: public:
StopHook(const StopHook &rhs); StopHook(const StopHook &rhs);
Show All 16 Lines

lldb/include/lldb/Target/Thread.h

Show All 16 Lines
ThreadEventData(const lldb::ThreadSP thread_sp); ThreadEventData(const lldb::ThreadSP thread_sp);
ThreadEventData(const lldb::ThreadSP thread_sp, const StackID &stack_id); ThreadEventData(const lldb::ThreadSP thread_sp, const StackID &stack_id);
ThreadEventData(); ThreadEventData();
~ThreadEventData() override; ~ThreadEventData() override;
static const ConstString &GetFlavorString(); static ConstString GetFlavorString();
const ConstString &GetFlavor() const override { ConstString GetFlavor() const override {
return ThreadEventData::GetFlavorString(); return ThreadEventData::GetFlavorString();
} }
void Dump(Stream *s) const override; void Dump(Stream *s) const override;
static const ThreadEventData *GetEventDataFromEvent(const Event *event_ptr); static const ThreadEventData *GetEventDataFromEvent(const Event *event_ptr);
static lldb::ThreadSP GetThreadFromEvent(const Event *event_ptr); static lldb::ThreadSP GetThreadFromEvent(const Event *event_ptr);
Show All 16 Lines

lldb/include/lldb/Utility/ArchSpec.h

Show All 16 Lines
//------------------------------------------------------------------ //------------------------------------------------------------------
/// Returns the distribution id of the architecture. /// Returns the distribution id of the architecture.
/// ///
/// This will be something like "ubuntu", "fedora", etc. on Linux. /// This will be something like "ubuntu", "fedora", etc. on Linux.
/// ///
/// @return A ConstString ref containing the distribution id, /// @return A ConstString ref containing the distribution id,
/// potentially empty. /// potentially empty.
//------------------------------------------------------------------ //------------------------------------------------------------------
const ConstString &GetDistributionId() const; ConstString GetDistributionId() const;
//------------------------------------------------------------------ //------------------------------------------------------------------
/// Set the distribution id of the architecture. /// Set the distribution id of the architecture.
/// ///
/// This will be something like "ubuntu", "fedora", etc. on Linux. This /// This will be something like "ubuntu", "fedora", etc. on Linux. This
/// should be the same value returned by HostInfo::GetDistributionId (). /// should be the same value returned by HostInfo::GetDistributionId ().
///------------------------------------------------------------------ ///------------------------------------------------------------------
void SetDistributionId(const char *distribution_id); void SetDistributionId(const char *distribution_id);
Show All 16 Lines

lldb/include/lldb/Utility/Broadcaster.h

Show All 16 Lines
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// lldb::BroadcastEventSpec // lldb::BroadcastEventSpec
// //
// This class is used to specify a kind of event to register for. The Debugger // This class is used to specify a kind of event to register for. The Debugger
// maintains a list of BroadcastEventSpec's and when it is made // maintains a list of BroadcastEventSpec's and when it is made
//---------------------------------------------------------------------- //----------------------------------------------------------------------
class BroadcastEventSpec { class BroadcastEventSpec {
public: public:
BroadcastEventSpec(const ConstString &broadcaster_class, uint32_t event_bits) BroadcastEventSpec(ConstString broadcaster_class, uint32_t event_bits)
: m_broadcaster_class(broadcaster_class), m_event_bits(event_bits) {} : m_broadcaster_class(broadcaster_class), m_event_bits(event_bits) {}
BroadcastEventSpec(const BroadcastEventSpec &rhs); BroadcastEventSpec(const BroadcastEventSpec &rhs);
~BroadcastEventSpec() = default; ~BroadcastEventSpec() = default;
const ConstString &GetBroadcasterClass() const { return m_broadcaster_class; } ConstString GetBroadcasterClass() const { return m_broadcaster_class; }
uint32_t GetEventBits() const { return m_event_bits; } uint32_t GetEventBits() const { return m_event_bits; }
// Tell whether this BroadcastEventSpec is contained in in_spec. That is: (a) // Tell whether this BroadcastEventSpec is contained in in_spec. That is: (a)
// the two spec's share the same broadcaster class (b) the event bits of this // the two spec's share the same broadcaster class (b) the event bits of this
// spec are wholly contained in those of in_spec. // spec are wholly contained in those of in_spec.
bool IsContainedIn(BroadcastEventSpec in_spec) const { bool IsContainedIn(BroadcastEventSpec in_spec) const {
if (m_broadcaster_class != in_spec.GetBroadcasterClass()) if (m_broadcaster_class != in_spec.GetBroadcasterClass())
Show All 32 Lines
listener_collection m_listeners; listener_collection m_listeners;
mutable std::recursive_mutex m_manager_mutex; mutable std::recursive_mutex m_manager_mutex;
// A couple of comparator classes for find_if: // A couple of comparator classes for find_if:
class BroadcasterClassMatches { class BroadcasterClassMatches {
public: public:
BroadcasterClassMatches(const ConstString &broadcaster_class) BroadcasterClassMatches(ConstString broadcaster_class)
: m_broadcaster_class(broadcaster_class) {} : m_broadcaster_class(broadcaster_class) {}
~BroadcasterClassMatches() = default; ~BroadcasterClassMatches() = default;
bool operator()(const event_listener_key input) const { bool operator()(const event_listener_key input) const {
return (input.first.GetBroadcasterClass() == m_broadcaster_class); return (input.first.GetBroadcasterClass() == m_broadcaster_class);
} }
Show All 32 Lines
} }
//------------------------------------------------------------------ //------------------------------------------------------------------
/// Get the NULL terminated C string name of this Broadcaster object. /// Get the NULL terminated C string name of this Broadcaster object.
/// ///
/// @return /// @return
/// The NULL terminated C string name of this Broadcaster. /// The NULL terminated C string name of this Broadcaster.
//------------------------------------------------------------------ //------------------------------------------------------------------
const ConstString &GetBroadcasterName() { return m_broadcaster_name; } ConstString GetBroadcasterName() { return m_broadcaster_name; }
//------------------------------------------------------------------ //------------------------------------------------------------------
/// Get the event name(s) for one or more event bits. /// Get the event name(s) for one or more event bits.
/// ///
/// @param[in] event_mask /// @param[in] event_mask
/// A bit mask that indicates which events to get names for. /// A bit mask that indicates which events to get names for.
/// ///
/// @return /// @return
Show All 16 Lines

lldb/include/lldb/Utility/ConstString.h

Show All 16 Lines
/// Assigns the string in this object with the value from \a rhs. /// Assigns the string in this object with the value from \a rhs.
/// ///
/// @param[in] rhs /// @param[in] rhs
/// Another string object to copy into this object. /// Another string object to copy into this object.
/// ///
/// @return /// @return
/// A const reference to this object. /// A const reference to this object.
//------------------------------------------------------------------ //------------------------------------------------------------------
const ConstString &operator=(const ConstString &rhs) { ConstString operator=(ConstString rhs) {
m_string = rhs.m_string; m_string = rhs.m_string;
return *this; return *this;
} }
//------------------------------------------------------------------ //------------------------------------------------------------------
/// Equal to operator /// Equal to operator
/// ///
/// Returns true if this string is equal to the string in \a rhs. This /// Returns true if this string is equal to the string in \a rhs. This
/// operation is very fast as it results in a pointer comparison since all /// operation is very fast as it results in a pointer comparison since all
/// strings are in a uniqued in a global string pool. /// strings are in a uniqued in a global string pool.
/// ///
/// @param[in] rhs /// @param[in] rhs
/// Another string object to compare this object to. /// Another string object to compare this object to.
/// ///
/// @return /// @return
/// @li \b true if this object is equal to \a rhs. /// @li \b true if this object is equal to \a rhs.
/// @li \b false if this object is not equal to \a rhs. /// @li \b false if this object is not equal to \a rhs.
//------------------------------------------------------------------ //------------------------------------------------------------------
bool operator==(const ConstString &rhs) const { bool operator==(ConstString rhs) const {
// We can do a pointer compare to compare these strings since they must // We can do a pointer compare to compare these strings since they must
// come from the same pool in order to be equal. // come from the same pool in order to be equal.
return m_string == rhs.m_string; return m_string == rhs.m_string;
} }
//------------------------------------------------------------------ //------------------------------------------------------------------
/// Not equal to operator /// Not equal to operator
/// ///
/// Returns true if this string is not equal to the string in \a rhs. This /// Returns true if this string is not equal to the string in \a rhs. This
/// operation is very fast as it results in a pointer comparison since all /// operation is very fast as it results in a pointer comparison since all
/// strings are in a uniqued in a global string pool. /// strings are in a uniqued in a global string pool.
/// ///
/// @param[in] rhs /// @param[in] rhs
/// Another string object to compare this object to. /// Another string object to compare this object to.
/// ///
/// @return /// @return
/// @li \b true if this object is not equal to \a rhs. /// @li \b true if this object is not equal to \a rhs.
/// @li \b false if this object is equal to \a rhs. /// @li \b false if this object is equal to \a rhs.
//------------------------------------------------------------------ //------------------------------------------------------------------
bool operator!=(const ConstString &rhs) const { bool operator!=(ConstString rhs) const {
return m_string != rhs.m_string; return m_string != rhs.m_string;
} }
bool operator<(const ConstString &rhs) const; bool operator<(ConstString rhs) const;
//------------------------------------------------------------------ //------------------------------------------------------------------
/// Get the string value as a C string. /// Get the string value as a C string.
/// ///
/// Get the value of the contained string as a NULL terminated C string /// Get the value of the contained string as a NULL terminated C string
/// value. /// value.
/// ///
/// If \a value_if_empty is nullptr, then nullptr will be returned. /// If \a value_if_empty is nullptr, then nullptr will be returned.
Show All 32 Lines
/// @param[in] case_sensitive /// @param[in] case_sensitive
/// Case sensitivity. If true, case sensitive equality /// Case sensitivity. If true, case sensitive equality
/// will be tested, otherwise character case will be ignored /// will be tested, otherwise character case will be ignored
/// ///
/// @return /// @return
/// @li \b true if this object is equal to \a rhs. /// @li \b true if this object is equal to \a rhs.
/// @li \b false if this object is not equal to \a rhs. /// @li \b false if this object is not equal to \a rhs.
//------------------------------------------------------------------ //------------------------------------------------------------------
static bool Equals(const ConstString &lhs, const ConstString &rhs, static bool Equals(ConstString lhs, ConstString rhs,
const bool case_sensitive = true); const bool case_sensitive = true);
//------------------------------------------------------------------ //------------------------------------------------------------------
/// Compare two string objects. /// Compare two string objects.
/// ///
/// Compares the C string values contained in \a lhs and \a rhs and returns /// Compares the C string values contained in \a lhs and \a rhs and returns
/// an integer result. /// an integer result.
/// ///
Show All 12 Lines
/// Case sensitivity of compare. If true, case sensitive compare /// Case sensitivity of compare. If true, case sensitive compare
/// will be performed, otherwise character case will be ignored /// will be performed, otherwise character case will be ignored
/// ///
/// @return /// @return
/// @li -1 if lhs < rhs /// @li -1 if lhs < rhs
/// @li 0 if lhs == rhs /// @li 0 if lhs == rhs
/// @li 1 if lhs > rhs /// @li 1 if lhs > rhs
//------------------------------------------------------------------ //------------------------------------------------------------------
static int Compare(const ConstString &lhs, const ConstString &rhs, static int Compare(ConstString lhs, ConstString rhs,
const bool case_sensitive = true); const bool case_sensitive = true);
//------------------------------------------------------------------ //------------------------------------------------------------------
/// Dump the object description to a stream. /// Dump the object description to a stream.
/// ///
/// Dump the string value to the stream \a s. If the contained string is /// Dump the string value to the stream \a s. If the contained string is
/// empty, print \a value_if_empty to the stream instead. If \a /// empty, print \a value_if_empty to the stream instead. If \a
/// value_if_empty is nullptr, then nothing will be dumped to the stream. /// value_if_empty is nullptr, then nothing will be dumped to the stream.
Show All 32 Lines
/// @param[in] demangled /// @param[in] demangled
/// The demangled string to correlate with the \a mangled name. /// The demangled string to correlate with the \a mangled name.
/// ///
/// @param[in] mangled /// @param[in] mangled
/// The already uniqued mangled ConstString to correlate the /// The already uniqued mangled ConstString to correlate the
/// soon to be uniqued version of \a demangled. /// soon to be uniqued version of \a demangled.
//------------------------------------------------------------------ //------------------------------------------------------------------
void SetStringWithMangledCounterpart(llvm::StringRef demangled, void SetStringWithMangledCounterpart(llvm::StringRef demangled,
const ConstString &mangled); ConstString mangled);
//------------------------------------------------------------------ //------------------------------------------------------------------
/// Retrieve the mangled or demangled counterpart for a mangled or demangled /// Retrieve the mangled or demangled counterpart for a mangled or demangled
/// ConstString. /// ConstString.
/// ///
/// Object files and debug symbols often use mangled string to represent the /// Object files and debug symbols often use mangled string to represent the
/// linkage name for a symbol, function or global. The string pool can /// linkage name for a symbol, function or global. The string pool can
/// efficiently store these values and their counterparts so when we run /// efficiently store these values and their counterparts so when we run
Show All 32 Lines
// Member variables // Member variables
//------------------------------------------------------------------ //------------------------------------------------------------------
const char *m_string; const char *m_string;
}; };
//------------------------------------------------------------------ //------------------------------------------------------------------
/// Stream the string value \a str to the stream \a s /// Stream the string value \a str to the stream \a s
//------------------------------------------------------------------ //------------------------------------------------------------------
Stream &operator<<(Stream &s, const ConstString &str); Stream &operator<<(Stream &s, ConstString str);
} // namespace lldb_private } // namespace lldb_private
namespace llvm { namespace llvm {
template <> struct format_provider<lldb_private::ConstString> { template <> struct format_provider<lldb_private::ConstString> {
static void format(const lldb_private::ConstString &CS, llvm::raw_ostream &OS, static void format(const lldb_private::ConstString &CS, llvm::raw_ostream &OS,
llvm::StringRef Options); llvm::StringRef Options);
}; };
} }
#endif // liblldb_ConstString_h_ #endif // liblldb_ConstString_h_
Context not available.

lldb/include/lldb/Utility/Event.h

Show All 16 Lines
class EventData { class EventData {
friend class Event; friend class Event;
public: public:
EventData(); EventData();
virtual ~EventData(); virtual ~EventData();
virtual const ConstString &GetFlavor() const = 0; virtual ConstString GetFlavor() const = 0;
virtual void Dump(Stream *s) const; virtual void Dump(Stream *s) const;
private: private:
virtual void DoOnRemoval(Event *event_ptr) {} virtual void DoOnRemoval(Event *event_ptr) {}
DISALLOW_COPY_AND_ASSIGN(EventData); DISALLOW_COPY_AND_ASSIGN(EventData);
}; };
Show All 14 Lines
EventDataBytes(const void *src, size_t src_len); EventDataBytes(const void *src, size_t src_len);
~EventDataBytes() override; ~EventDataBytes() override;
//------------------------------------------------------------------ //------------------------------------------------------------------
// Member functions // Member functions
//------------------------------------------------------------------ //------------------------------------------------------------------
const ConstString &GetFlavor() const override; ConstString GetFlavor() const override;
void Dump(Stream *s) const override; void Dump(Stream *s) const override;
const void *GetBytes() const; const void *GetBytes() const;
size_t GetByteSize() const; size_t GetByteSize() const;
void SetBytes(const void *src, size_t src_len); void SetBytes(const void *src, size_t src_len);
void SwapBytes(std::string &new_bytes); void SwapBytes(std::string &new_bytes);
void SetBytesFromCString(const char *cstr); void SetBytesFromCString(const char *cstr);
//------------------------------------------------------------------ //------------------------------------------------------------------
// Static functions // Static functions
//------------------------------------------------------------------ //------------------------------------------------------------------
static const EventDataBytes *GetEventDataFromEvent(const Event *event_ptr); static const EventDataBytes *GetEventDataFromEvent(const Event *event_ptr);
static const void *GetBytesFromEvent(const Event *event_ptr); static const void *GetBytesFromEvent(const Event *event_ptr);
static size_t GetByteSizeFromEvent(const Event *event_ptr); static size_t GetByteSizeFromEvent(const Event *event_ptr);
static const ConstString &GetFlavorString(); static ConstString GetFlavorString();
private: private:
std::string m_bytes; std::string m_bytes;
DISALLOW_COPY_AND_ASSIGN(EventDataBytes); DISALLOW_COPY_AND_ASSIGN(EventDataBytes);
}; };
class EventDataReceipt : public EventData { class EventDataReceipt : public EventData {
public: public:
EventDataReceipt() : EventData(), m_predicate(false) {} EventDataReceipt() : EventData(), m_predicate(false) {}
~EventDataReceipt() override {} ~EventDataReceipt() override {}
static const ConstString &GetFlavorString() { static ConstString GetFlavorString() {
static ConstString g_flavor("Process::ProcessEventData"); static ConstString g_flavor("Process::ProcessEventData");
return g_flavor; return g_flavor;
} }
const ConstString &GetFlavor() const override { return GetFlavorString(); } ConstString GetFlavor() const override { return GetFlavorString(); }
bool WaitForEventReceived(const Timeout<std::micro> &timeout = llvm::None) { bool WaitForEventReceived(const Timeout<std::micro> &timeout = llvm::None) {
return m_predicate.WaitForValueEqualTo(true, timeout); return m_predicate.WaitForValueEqualTo(true, timeout);
} }
private: private:
Predicate<bool> m_predicate; Predicate<bool> m_predicate;
Show All 18 Lines
const StructuredData::ObjectSP &object_sp, const StructuredData::ObjectSP &object_sp,
const lldb::StructuredDataPluginSP &plugin_sp); const lldb::StructuredDataPluginSP &plugin_sp);
~EventDataStructuredData() override; ~EventDataStructuredData() override;
//------------------------------------------------------------------ //------------------------------------------------------------------
// Member functions // Member functions
//------------------------------------------------------------------ //------------------------------------------------------------------
const ConstString &GetFlavor() const override; ConstString GetFlavor() const override;
void Dump(Stream *s) const override; void Dump(Stream *s) const override;
const lldb::ProcessSP &GetProcess() const; const lldb::ProcessSP &GetProcess() const;
const StructuredData::ObjectSP &GetObject() const; const StructuredData::ObjectSP &GetObject() const;
const lldb::StructuredDataPluginSP &GetStructuredDataPlugin() const; const lldb::StructuredDataPluginSP &GetStructuredDataPlugin() const;
Show All 12 Lines
static lldb::ProcessSP GetProcessFromEvent(const Event *event_ptr); static lldb::ProcessSP GetProcessFromEvent(const Event *event_ptr);
static StructuredData::ObjectSP GetObjectFromEvent(const Event *event_ptr); static StructuredData::ObjectSP GetObjectFromEvent(const Event *event_ptr);
static lldb::StructuredDataPluginSP static lldb::StructuredDataPluginSP
GetPluginFromEvent(const Event *event_ptr); GetPluginFromEvent(const Event *event_ptr);
static const ConstString &GetFlavorString(); static ConstString GetFlavorString();
private: private:
lldb::ProcessSP m_process_sp; lldb::ProcessSP m_process_sp;
StructuredData::ObjectSP m_object_sp; StructuredData::ObjectSP m_object_sp;
lldb::StructuredDataPluginSP m_plugin_sp; lldb::StructuredDataPluginSP m_plugin_sp;
DISALLOW_COPY_AND_ASSIGN(EventDataStructuredData); DISALLOW_COPY_AND_ASSIGN(EventDataStructuredData);
}; };
Show All 16 Lines

lldb/include/lldb/Utility/FileSpec.h

Show All 16 Lines
ConstString &GetDirectory(); ConstString &GetDirectory();
//------------------------------------------------------------------ //------------------------------------------------------------------
/// Directory string const get accessor. /// Directory string const get accessor.
/// ///
/// @return /// @return
/// A const reference to the directory string object. /// A const reference to the directory string object.
//------------------------------------------------------------------ //------------------------------------------------------------------
const ConstString &GetDirectory() const; ConstString GetDirectory() const;
//------------------------------------------------------------------ //------------------------------------------------------------------
/// Filename string get accessor. /// Filename string get accessor.
/// ///
/// @return /// @return
/// A reference to the filename string object. /// A reference to the filename string object.
//------------------------------------------------------------------ //------------------------------------------------------------------
ConstString &GetFilename(); ConstString &GetFilename();
//------------------------------------------------------------------ //------------------------------------------------------------------
/// Filename string const get accessor. /// Filename string const get accessor.
/// ///
/// @return /// @return
/// A const reference to the filename string object. /// A const reference to the filename string object.
//------------------------------------------------------------------ //------------------------------------------------------------------
const ConstString &GetFilename() const; ConstString GetFilename() const;
//------------------------------------------------------------------ //------------------------------------------------------------------
/// Returns true if the filespec represents an implementation source file /// Returns true if the filespec represents an implementation source file
/// (files with a ".c", ".cpp", ".m", ".mm" (many more) extension). /// (files with a ".c", ".cpp", ".m", ".mm" (many more) extension).
/// ///
/// @return /// @return
/// \b true if the filespec represents an implementation source /// \b true if the filespec represents an implementation source
/// file, \b false otherwise. /// file, \b false otherwise.
Show All 16 Lines

lldb/include/lldb/Utility/Log.h

Show All 16 Lines
uint32_t log_options, llvm::StringRef channel, uint32_t log_options, llvm::StringRef channel,
llvm::ArrayRef<const char *> categories, llvm::ArrayRef<const char *> categories,
llvm::raw_ostream &error_stream); llvm::raw_ostream &error_stream);
static bool DisableLogChannel(llvm::StringRef channel, static bool DisableLogChannel(llvm::StringRef channel,
llvm::ArrayRef<const char *> categories, llvm::ArrayRef<const char *> categories,
llvm::raw_ostream &error_stream); llvm::raw_ostream &error_stream);
static bool ListChannelCategories(llvm::StringRef channel, llvm::raw_ostream &stream); static bool ListChannelCategories(llvm::StringRef channel,
llvm::raw_ostream &stream);
static void DisableAllLogChannels(); static void DisableAllLogChannels();
static void ListAllLogChannels(llvm::raw_ostream &stream); static void ListAllLogChannels(llvm::raw_ostream &stream);
//------------------------------------------------------------------ //------------------------------------------------------------------
// Member functions // Member functions
// //
Show All 16 Lines

lldb/source/API/SBType.cpp

Show All 16 Lines
GetEnumMembers); GetEnumMembers);
SBTypeEnumMemberList sb_enum_member_list; SBTypeEnumMemberList sb_enum_member_list;
if (IsValid()) { if (IsValid()) {
CompilerType this_type(m_opaque_sp->GetCompilerType(true)); CompilerType this_type(m_opaque_sp->GetCompilerType(true));
if (this_type.IsValid()) { if (this_type.IsValid()) {
this_type.ForEachEnumerator([&sb_enum_member_list]( this_type.ForEachEnumerator([&sb_enum_member_list](
const CompilerType &integer_type, const CompilerType &integer_type,
const ConstString &name, ConstString name,
const llvm::APSInt &value) -> bool { const llvm::APSInt &value) -> bool {
SBTypeEnumMember enum_member( SBTypeEnumMember enum_member(
lldb::TypeEnumMemberImplSP(new TypeEnumMemberImpl( lldb::TypeEnumMemberImplSP(new TypeEnumMemberImpl(
lldb::TypeImplSP(new TypeImpl(integer_type)), name, value))); lldb::TypeImplSP(new TypeImpl(integer_type)), name, value)));
sb_enum_member_list.Append(enum_member); sb_enum_member_list.Append(enum_member);
return true; // Keep iterating return true; // Keep iterating
}); });
} }
Show All 16 Lines

lldb/source/Breakpoint/Breakpoint.cpp

Show All 16 Lines
#include "lldb/Utility/StreamString.h" #include "lldb/Utility/StreamString.h"
#include <memory> #include <memory>
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
using namespace llvm; using namespace llvm;
const ConstString &Breakpoint::GetEventIdentifier() { ConstString Breakpoint::GetEventIdentifier() {
static ConstString g_identifier("event-identifier.breakpoint.changed"); static ConstString g_identifier("event-identifier.breakpoint.changed");
return g_identifier; return g_identifier;
} }
const char *Breakpoint::g_option_names[static_cast<uint32_t>( const char *Breakpoint::g_option_names[static_cast<uint32_t>(
Breakpoint::OptionNames::LastOptionName)]{"Names", "Hardware"}; Breakpoint::OptionNames::LastOptionName)]{"Names", "Hardware"};
//---------------------------------------------------------------------- //----------------------------------------------------------------------
Show All 32 Lines
} }
} }
void Breakpoint::GetResolverDescription(Stream *s) { void Breakpoint::GetResolverDescription(Stream *s) {
if (m_resolver_sp) if (m_resolver_sp)
m_resolver_sp->GetDescription(s); m_resolver_sp->GetDescription(s);
} }
bool Breakpoint::GetMatchingFileLine(const ConstString &filename, bool Breakpoint::GetMatchingFileLine(ConstString filename,
uint32_t line_number, uint32_t line_number,
BreakpointLocationCollection &loc_coll) { BreakpointLocationCollection &loc_coll) {
// TODO: To be correct, this method needs to fill the breakpoint location // TODO: To be correct, this method needs to fill the breakpoint location
// collection // collection
// with the location IDs which match the filename and line_number. // with the location IDs which match the filename and line_number.
// //
if (m_resolver_sp) { if (m_resolver_sp) {
Show All 32 Lines
Breakpoint::BreakpointEventData::BreakpointEventData( Breakpoint::BreakpointEventData::BreakpointEventData(
BreakpointEventType sub_type, const BreakpointSP &new_breakpoint_sp) BreakpointEventType sub_type, const BreakpointSP &new_breakpoint_sp)
: EventData(), m_breakpoint_event(sub_type), : EventData(), m_breakpoint_event(sub_type),
m_new_breakpoint_sp(new_breakpoint_sp) {} m_new_breakpoint_sp(new_breakpoint_sp) {}
Breakpoint::BreakpointEventData::~BreakpointEventData() = default; Breakpoint::BreakpointEventData::~BreakpointEventData() = default;
const ConstString &Breakpoint::BreakpointEventData::GetFlavorString() { ConstString Breakpoint::BreakpointEventData::GetFlavorString() {
static ConstString g_flavor("Breakpoint::BreakpointEventData"); static ConstString g_flavor("Breakpoint::BreakpointEventData");
return g_flavor; return g_flavor;
} }
const ConstString &Breakpoint::BreakpointEventData::GetFlavor() const { ConstString Breakpoint::BreakpointEventData::GetFlavor() const {
return BreakpointEventData::GetFlavorString(); return BreakpointEventData::GetFlavorString();
} }
BreakpointSP &Breakpoint::BreakpointEventData::GetBreakpoint() { BreakpointSP &Breakpoint::BreakpointEventData::GetBreakpoint() {
return m_new_breakpoint_sp; return m_new_breakpoint_sp;
} }
BreakpointEventType BreakpointEventType
Show All 16 Lines

lldb/source/Breakpoint/BreakpointName.cpp

Show All 16 Lines
const Flags::ValueType BreakpointName::Permissions::permissions_mask const Flags::ValueType BreakpointName::Permissions::permissions_mask
[BreakpointName::Permissions::PermissionKinds::allPerms + 1] = { [BreakpointName::Permissions::PermissionKinds::allPerms + 1] = {
(1u << 0), (1u << 0),
(1u << 1), (1u << 1),
(1u << 2), (1u << 2),
(0x5u) (0x5u)
}; };
BreakpointName::BreakpointName(const ConstString &name, const Breakpoint &bkpt, BreakpointName::BreakpointName(ConstString name, const Breakpoint &bkpt,
const char *help) : const char *help) :
m_name(name), m_options(bkpt.GetOptions()) m_name(name), m_options(bkpt.GetOptions())
{ {
SetHelp(help); SetHelp(help);
} }
bool BreakpointName::Permissions::GetDescription(Stream *s, bool BreakpointName::Permissions::GetDescription(Stream *s,
lldb::DescriptionLevel level) { lldb::DescriptionLevel level) {
Show All 16 Lines

lldb/source/Breakpoint/BreakpointResolverName.cpp

Show All 16 Lines
GetKey(OptionNames::LanguageName), GetKey(OptionNames::LanguageName),
Language::GetNameForLanguageType(m_language)); Language::GetNameForLanguageType(m_language));
options_dict_sp->AddBooleanItem(GetKey(OptionNames::SkipPrologue), options_dict_sp->AddBooleanItem(GetKey(OptionNames::SkipPrologue),
m_skip_prologue); m_skip_prologue);
return WrapOptionsDict(options_dict_sp); return WrapOptionsDict(options_dict_sp);
} }
void BreakpointResolverName::AddNameLookup(const ConstString &name, void BreakpointResolverName::AddNameLookup(ConstString name,
FunctionNameType name_type_mask) { FunctionNameType name_type_mask) {
ObjCLanguage::MethodName objc_method(name.GetCString(), false); ObjCLanguage::MethodName objc_method(name.GetCString(), false);
if (objc_method.IsValid(false)) { if (objc_method.IsValid(false)) {
std::vector<ConstString> objc_names; std::vector<ConstString> objc_names;
objc_method.GetFullNames(objc_names, true); objc_method.GetFullNames(objc_names, true);
for (ConstString objc_name : objc_names) { for (ConstString objc_name : objc_names) {
Module::LookupInfo lookup; Module::LookupInfo lookup;
lookup.SetName(name); lookup.SetName(name);
Show All 16 Lines

lldb/source/Breakpoint/Watchpoint.cpp

Show All 16 Lines
Watchpoint::WatchpointEventData::WatchpointEventData( Watchpoint::WatchpointEventData::WatchpointEventData(
WatchpointEventType sub_type, const WatchpointSP &new_watchpoint_sp) WatchpointEventType sub_type, const WatchpointSP &new_watchpoint_sp)
: EventData(), m_watchpoint_event(sub_type), : EventData(), m_watchpoint_event(sub_type),
m_new_watchpoint_sp(new_watchpoint_sp) {} m_new_watchpoint_sp(new_watchpoint_sp) {}
Watchpoint::WatchpointEventData::~WatchpointEventData() = default; Watchpoint::WatchpointEventData::~WatchpointEventData() = default;
const ConstString &Watchpoint::WatchpointEventData::GetFlavorString() { ConstString Watchpoint::WatchpointEventData::GetFlavorString() {
static ConstString g_flavor("Watchpoint::WatchpointEventData"); static ConstString g_flavor("Watchpoint::WatchpointEventData");
return g_flavor; return g_flavor;
} }
const ConstString &Watchpoint::WatchpointEventData::GetFlavor() const { ConstString Watchpoint::WatchpointEventData::GetFlavor() const {
return WatchpointEventData::GetFlavorString(); return WatchpointEventData::GetFlavorString();
} }
WatchpointSP &Watchpoint::WatchpointEventData::GetWatchpoint() { WatchpointSP &Watchpoint::WatchpointEventData::GetWatchpoint() {
return m_new_watchpoint_sp; return m_new_watchpoint_sp;
} }
WatchpointEventType WatchpointEventType
Show All 16 Lines

lldb/source/Commands/CommandObjectSource.cpp

Show All 16 Lines
if (start_line > 0 && line_entry.line < start_line) if (start_line > 0 && line_entry.line < start_line)
continue; continue;
if (end_line > 0 && line_entry.line > end_line) if (end_line > 0 && line_entry.line > end_line)
continue; continue;
if (num_lines > 0 && num_matches > num_lines) if (num_lines > 0 && num_matches > num_lines)
continue; continue;
// Print a new header if the module changed. // Print a new header if the module changed.
const ConstString &module_file_name = ConstString module_file_name =
module->GetFileSpec().GetFilename(); module->GetFileSpec().GetFilename();
assert(module_file_name); assert(module_file_name);
if (module_file_name != last_module_file_name) { if (module_file_name != last_module_file_name) {
if (num_matches > 0) if (num_matches > 0)
strm << "\n\n"; strm << "\n\n";
strm << "Lines found in module `" << module_file_name << "\n"; strm << "Lines found in module `" << module_file_name << "\n";
} }
// Dump the line entry. // Dump the line entry.
Show All 29 Lines
size_t file_idx = cu_file_list.FindFileIndex(0, file_spec, has_path); size_t file_idx = cu_file_list.FindFileIndex(0, file_spec, has_path);
if (file_idx != UINT32_MAX) { if (file_idx != UINT32_MAX) {
// Update the file to how it appears in the CU. // Update the file to how it appears in the CU.
const FileSpec &cu_file_spec = const FileSpec &cu_file_spec =
cu_file_list.GetFileSpecAtIndex(file_idx); cu_file_list.GetFileSpecAtIndex(file_idx);
// Dump all matching lines at or above start_line for the file in the // Dump all matching lines at or above start_line for the file in the
// CU. // CU.
const ConstString &file_spec_name = file_spec.GetFilename(); ConstString file_spec_name = file_spec.GetFilename();
const ConstString &module_file_name = ConstString module_file_name =
module->GetFileSpec().GetFilename(); module->GetFileSpec().GetFilename();
bool cu_header_printed = false; bool cu_header_printed = false;
uint32_t line = start_line; uint32_t line = start_line;
while (true) { while (true) {
LineEntry line_entry; LineEntry line_entry;
// Find the lowest index of a line entry with a line equal to or // Find the lowest index of a line entry with a line equal to or
// higher than 'line'. // higher than 'line'.
Show All 32 Lines
return m_reverse_name.c_str(); return m_reverse_name.c_str();
} }
protected: protected:
struct SourceInfo { struct SourceInfo {
ConstString function; ConstString function;
LineEntry line_entry; LineEntry line_entry;
SourceInfo(const ConstString &name, const LineEntry &line_entry) SourceInfo(ConstString name, const LineEntry &line_entry)
: function(name), line_entry(line_entry) {} : function(name), line_entry(line_entry) {}
SourceInfo() : function(), line_entry() {} SourceInfo() : function(), line_entry() {}
bool IsValid() const { return (bool)function && line_entry.IsValid(); } bool IsValid() const { return (bool)function && line_entry.IsValid(); }
bool operator==(const SourceInfo &rhs) const { bool operator==(const SourceInfo &rhs) const {
return function == rhs.function && return function == rhs.function &&
Show All 32 Lines
// From Jim: The FindMatchingFunctions / FindMatchingFunctionSymbols // From Jim: The FindMatchingFunctions / FindMatchingFunctionSymbols
// functions "take a possibly empty vector of strings which are names of // functions "take a possibly empty vector of strings which are names of
// modules, and run the two search functions on the subset of the full module // modules, and run the two search functions on the subset of the full module
// list that matches the strings in the input vector". If we wanted to put // list that matches the strings in the input vector". If we wanted to put
// these somewhere, there should probably be a module-filter-list that can be // these somewhere, there should probably be a module-filter-list that can be
// passed to the various ModuleList::Find* calls, which would either be a // passed to the various ModuleList::Find* calls, which would either be a
// vector of string names or a ModuleSpecList. // vector of string names or a ModuleSpecList.
size_t FindMatchingFunctions(Target *target, const ConstString &name, size_t FindMatchingFunctions(Target *target, ConstString name,
SymbolContextList &sc_list) { SymbolContextList &sc_list) {
// Displaying the source for a symbol: // Displaying the source for a symbol:
bool include_inlines = true; bool include_inlines = true;
bool append = true; bool append = true;
bool include_symbols = false; bool include_symbols = false;
size_t num_matches = 0; size_t num_matches = 0;
if (m_options.num_lines == 0) if (m_options.num_lines == 0)
Show All 16 Lines
} else { } else {
num_matches = target->GetImages().FindFunctions( num_matches = target->GetImages().FindFunctions(
name, eFunctionNameTypeAuto, include_symbols, include_inlines, append, name, eFunctionNameTypeAuto, include_symbols, include_inlines, append,
sc_list); sc_list);
} }
return num_matches; return num_matches;
} }
size_t FindMatchingFunctionSymbols(Target *target, const ConstString &name, size_t FindMatchingFunctionSymbols(Target *target, ConstString name,
SymbolContextList &sc_list) { SymbolContextList &sc_list) {
size_t num_matches = 0; size_t num_matches = 0;
const size_t num_modules = m_options.modules.size(); const size_t num_modules = m_options.modules.size();
if (num_modules > 0) { if (num_modules > 0) {
ModuleList matching_modules; ModuleList matching_modules;
for (size_t i = 0; i < num_modules; ++i) { for (size_t i = 0; i < num_modules; ++i) {
FileSpec module_file_spec(m_options.modules[i]); FileSpec module_file_spec(m_options.modules[i]);
if (module_file_spec) { if (module_file_spec) {
Show All 16 Lines

lldb/source/Commands/CommandObjectType.cpp

Show All 16 Lines
public: public:
TypeSummaryImpl::Flags m_flags; TypeSummaryImpl::Flags m_flags;
StringList m_target_types; StringList m_target_types;
bool m_regex; bool m_regex;
ConstString m_name; ConstString m_name;
std::string m_category; std::string m_category;
ScriptAddOptions(const TypeSummaryImpl::Flags &flags, bool regx, ScriptAddOptions(const TypeSummaryImpl::Flags &flags, bool regx,
const ConstString &name, std::string catg) ConstString name, std::string catg)
: m_flags(flags), m_regex(regx), m_name(name), m_category(catg) {} : m_flags(flags), m_regex(regx), m_name(name), m_category(catg) {}
typedef std::shared_ptr<ScriptAddOptions> SharedPointer; typedef std::shared_ptr<ScriptAddOptions> SharedPointer;
}; };
class SynthAddOptions { class SynthAddOptions {
public: public:
bool m_skip_pointers; bool m_skip_pointers;
Show All 16 Lines

lldb/source/Core/Debugger.cpp

Show All 16 Lines
g_debugger_list_ptr->erase(pos); g_debugger_list_ptr->erase(pos);
return; return;
} }
} }
} }
} }
DebuggerSP DebuggerSP
Debugger::FindDebuggerWithInstanceName(const ConstString &instance_name) { Debugger::FindDebuggerWithInstanceName(ConstString instance_name) {
DebuggerSP debugger_sp; DebuggerSP debugger_sp;
if (g_debugger_list_ptr && g_debugger_list_mutex_ptr) { if (g_debugger_list_ptr && g_debugger_list_mutex_ptr) {
std::lock_guard<std::recursive_mutex> guard(*g_debugger_list_mutex_ptr); std::lock_guard<std::recursive_mutex> guard(*g_debugger_list_mutex_ptr);
DebuggerList::iterator pos, end = g_debugger_list_ptr->end(); DebuggerList::iterator pos, end = g_debugger_list_ptr->end();
for (pos = g_debugger_list_ptr->begin(); pos != end; ++pos) { for (pos = g_debugger_list_ptr->begin(); pos != end; ++pos) {
if ((*pos)->m_instance_name == instance_name) { if ((*pos)->m_instance_name == instance_name) {
debugger_sp = *pos; debugger_sp = *pos;
break; break;
Show All 16 Lines

lldb/source/Core/Disassembler.cpp

Show All 16 Lines
} }
} }
return success_count; return success_count;
} }
bool Disassembler::Disassemble(Debugger &debugger, const ArchSpec &arch, bool Disassembler::Disassemble(Debugger &debugger, const ArchSpec &arch,
const char *plugin_name, const char *flavor, const char *plugin_name, const char *flavor,
const ExecutionContext &exe_ctx, const ExecutionContext &exe_ctx,
const ConstString &name, Module *module, ConstString name, Module *module,
uint32_t num_instructions, uint32_t num_instructions,
bool mixed_source_and_assembly, bool mixed_source_and_assembly,
uint32_t num_mixed_context_lines, uint32_t num_mixed_context_lines,
uint32_t options, Stream &strm) { uint32_t options, Stream &strm) {
SymbolContextList sc_list; SymbolContextList sc_list;
if (name) { if (name) {
const bool include_symbols = true; const bool include_symbols = true;
const bool include_inlines = true; const bool include_inlines = true;
Show All 16 Lines

lldb/source/Core/Mangled.cpp

Show All 16 Lines
} }
return Mangled::eManglingSchemeNone; return Mangled::eManglingSchemeNone;
} }
static inline bool cstring_is_mangled(const char *s) { static inline bool cstring_is_mangled(const char *s) {
return cstring_mangling_scheme(s) != Mangled::eManglingSchemeNone; return cstring_mangling_scheme(s) != Mangled::eManglingSchemeNone;
} }
static const ConstString & static ConstString
get_demangled_name_without_arguments(ConstString mangled, get_demangled_name_without_arguments(ConstString mangled,
ConstString demangled) { ConstString demangled) {
// This pair is <mangled name, demangled name without function arguments> // This pair is <mangled name, demangled name without function arguments>
static std::pair<ConstString, ConstString> static std::pair<ConstString, ConstString>
g_most_recent_mangled_to_name_sans_args; g_most_recent_mangled_to_name_sans_args;
// Need to have the mangled & demangled names we're currently examining as // Need to have the mangled & demangled names we're currently examining as
// statics so we can return a const ref to them at the end of the func if we // statics so we can return a const ref to them at the end of the func if we
Show All 32 Lines
// Default constructor // Default constructor
//---------------------------------------------------------------------- //----------------------------------------------------------------------
Mangled::Mangled() : m_mangled(), m_demangled() {} Mangled::Mangled() : m_mangled(), m_demangled() {}
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// Constructor with an optional string and a boolean indicating if it is the // Constructor with an optional string and a boolean indicating if it is the
// mangled version. // mangled version.
//---------------------------------------------------------------------- //----------------------------------------------------------------------
Mangled::Mangled(const ConstString &s, bool mangled) Mangled::Mangled(ConstString s, bool mangled)
: m_mangled(), m_demangled() { : m_mangled(), m_demangled() {
if (s) if (s)
SetValue(s, mangled); SetValue(s, mangled);
} }
Mangled::Mangled(llvm::StringRef name, bool is_mangled) { Mangled::Mangled(llvm::StringRef name, bool is_mangled) {
if (!name.empty()) if (!name.empty())
SetValue(ConstString(name), is_mangled); SetValue(ConstString(name), is_mangled);
} }
Mangled::Mangled(const ConstString &s) : m_mangled(), m_demangled() { Mangled::Mangled(ConstString s) : m_mangled(), m_demangled() {
if (s) if (s)
SetValue(s); SetValue(s);
} }
Mangled::Mangled(llvm::StringRef name) { Mangled::Mangled(llvm::StringRef name) {
if (!name.empty()) if (!name.empty())
SetValue(ConstString(name)); SetValue(ConstString(name));
} }
Show All 32 Lines
a.GetName(lldb::eLanguageTypeUnknown, ePreferMangled), a.GetName(lldb::eLanguageTypeUnknown, ePreferMangled),
b.GetName(lldb::eLanguageTypeUnknown, ePreferMangled)); b.GetName(lldb::eLanguageTypeUnknown, ePreferMangled));
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// Set the string value in this objects. If "mangled" is true, then the mangled // Set the string value in this objects. If "mangled" is true, then the mangled
// named is set with the new value in "s", else the demangled name is set. // named is set with the new value in "s", else the demangled name is set.
//---------------------------------------------------------------------- //----------------------------------------------------------------------
void Mangled::SetValue(const ConstString &s, bool mangled) { void Mangled::SetValue(ConstString s, bool mangled) {
if (s) { if (s) {
if (mangled) { if (mangled) {
m_demangled.Clear(); m_demangled.Clear();
m_mangled = s; m_mangled = s;
} else { } else {
m_demangled = s; m_demangled = s;
m_mangled.Clear(); m_mangled.Clear();
} }
} else { } else {
m_demangled.Clear(); m_demangled.Clear();
m_mangled.Clear(); m_mangled.Clear();
} }
} }
void Mangled::SetValue(const ConstString &name) { void Mangled::SetValue(ConstString name) {
if (name) { if (name) {
if (cstring_is_mangled(name.GetCString())) { if (cstring_is_mangled(name.GetCString())) {
m_demangled.Clear(); m_demangled.Clear();
m_mangled = name; m_mangled = name;
} else { } else {
m_demangled = name; m_demangled = name;
m_mangled.Clear(); m_mangled.Clear();
} }
Show All 32 Lines
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// Generate the demangled name on demand using this accessor. Code in this // Generate the demangled name on demand using this accessor. Code in this
// class will need to use this accessor if it wishes to decode the demangled // class will need to use this accessor if it wishes to decode the demangled
// name. The result is cached and will be kept until a new string value is // name. The result is cached and will be kept until a new string value is
// supplied to this object, or until the end of the object's lifetime. // supplied to this object, or until the end of the object's lifetime.
//---------------------------------------------------------------------- //----------------------------------------------------------------------
const ConstString & ConstString
Mangled::GetDemangledName(lldb::LanguageType language) const { Mangled::GetDemangledName(lldb::LanguageType language) const {
// Check to make sure we have a valid mangled name and that we haven't // Check to make sure we have a valid mangled name and that we haven't
// already decoded our mangled name. // already decoded our mangled name.
if (m_mangled && m_demangled.IsNull()) { if (m_mangled && m_demangled.IsNull()) {
// We need to generate and cache the demangled name. // We need to generate and cache the demangled name.
static Timer::Category func_cat(LLVM_PRETTY_FUNCTION); static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
Timer scoped_timer(func_cat, "Mangled::GetDemangledName (m_mangled = %s)", Timer scoped_timer(func_cat, "Mangled::GetDemangledName (m_mangled = %s)",
m_mangled.GetCString()); m_mangled.GetCString());
Show All 32 Lines
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// Dump OBJ to the supplied stream S. // Dump OBJ to the supplied stream S.
//---------------------------------------------------------------------- //----------------------------------------------------------------------
Stream &operator<<(Stream &s, const Mangled &obj) { Stream &operator<<(Stream &s, const Mangled &obj) {
if (obj.GetMangledName()) if (obj.GetMangledName())
s << "mangled = '" << obj.GetMangledName() << "'"; s << "mangled = '" << obj.GetMangledName() << "'";
const ConstString &demangled = ConstString demangled =
obj.GetDemangledName(lldb::eLanguageTypeUnknown); obj.GetDemangledName(lldb::eLanguageTypeUnknown);
if (demangled) if (demangled)
s << ", demangled = '" << demangled << '\''; s << ", demangled = '" << demangled << '\'';
else else
s << ", demangled = <error>"; s << ", demangled = <error>";
return s; return s;
} }
Context not available.

lldb/source/Core/Module.cpp

Show All 16 Lines
SymbolVendor *symbols = GetSymbolVendor(); SymbolVendor *symbols = GetSymbolVendor();
if (symbols) if (symbols)
symbols->ResolveSymbolContext(file_spec, line, check_inlines, resolve_scope, symbols->ResolveSymbolContext(file_spec, line, check_inlines, resolve_scope,
sc_list); sc_list);
return sc_list.GetSize() - initial_count; return sc_list.GetSize() - initial_count;
} }
size_t Module::FindGlobalVariables(const ConstString &name, size_t Module::FindGlobalVariables(ConstString name,
const CompilerDeclContext *parent_decl_ctx, const CompilerDeclContext *parent_decl_ctx,
size_t max_matches, size_t max_matches,
VariableList &variables) { VariableList &variables) {
SymbolVendor *symbols = GetSymbolVendor(); SymbolVendor *symbols = GetSymbolVendor();
if (symbols) if (symbols)
return symbols->FindGlobalVariables(name, parent_decl_ctx, max_matches, return symbols->FindGlobalVariables(name, parent_decl_ctx, max_matches,
variables); variables);
return 0; return 0;
Show All 23 Lines
if (sc.comp_unit) { if (sc.comp_unit) {
if (FileSpec::Equal(*sc.comp_unit, path, compare_directory)) if (FileSpec::Equal(*sc.comp_unit, path, compare_directory))
sc_list.Append(sc); sc_list.Append(sc);
} }
} }
return sc_list.GetSize() - start_size; return sc_list.GetSize() - start_size;
} }
Module::LookupInfo::LookupInfo(const ConstString &name, Module::LookupInfo::LookupInfo(ConstString name,
FunctionNameType name_type_mask, FunctionNameType name_type_mask,
LanguageType language) LanguageType language)
: m_name(name), m_lookup_name(), m_language(language), : m_name(name), m_lookup_name(), m_language(language),
m_name_type_mask(eFunctionNameTypeNone), m_name_type_mask(eFunctionNameTypeNone),
m_match_name_after_lookup(false) { m_match_name_after_lookup(false) {
const char *name_cstr = name.GetCString(); const char *name_cstr = name.GetCString();
llvm::StringRef basename; llvm::StringRef basename;
llvm::StringRef context; llvm::StringRef context;
Show All 32 Lines
} }
} }
} }
++i; ++i;
} }
} }
} }
size_t Module::FindFunctions(const ConstString &name, size_t Module::FindFunctions(ConstString name,
const CompilerDeclContext *parent_decl_ctx, const CompilerDeclContext *parent_decl_ctx,
FunctionNameType name_type_mask, FunctionNameType name_type_mask,
bool include_symbols, bool include_inlines, bool include_symbols, bool include_inlines,
bool append, SymbolContextList &sc_list) { bool append, SymbolContextList &sc_list) {
if (!append) if (!append)
sc_list.Clear(); sc_list.Clear();
const size_t old_size = sc_list.GetSize(); const size_t old_size = sc_list.GetSize();
Show All 32 Lines
if (f && f == function) if (f && f == function)
output_local.push_back(addr); output_local.push_back(addr);
else else
output_extern.push_back(addr); output_extern.push_back(addr);
} }
} }
size_t Module::FindTypes_Impl( size_t Module::FindTypes_Impl(
const ConstString &name, const CompilerDeclContext *parent_decl_ctx, ConstString name, const CompilerDeclContext *parent_decl_ctx,
bool append, size_t max_matches, bool append, size_t max_matches,
llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files, llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
TypeMap &types) { TypeMap &types) {
static Timer::Category func_cat(LLVM_PRETTY_FUNCTION); static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION); Timer scoped_timer(func_cat, LLVM_PRETTY_FUNCTION);
SymbolVendor *symbols = GetSymbolVendor(); SymbolVendor *symbols = GetSymbolVendor();
if (symbols) if (symbols)
return symbols->FindTypes(name, parent_decl_ctx, append, max_matches, return symbols->FindTypes(name, parent_decl_ctx, append, max_matches,
searched_symbol_files, types); searched_symbol_files, types);
return 0; return 0;
} }
size_t Module::FindTypesInNamespace(const ConstString &type_name, size_t Module::FindTypesInNamespace(ConstString type_name,
const CompilerDeclContext *parent_decl_ctx, const CompilerDeclContext *parent_decl_ctx,
size_t max_matches, TypeList &type_list) { size_t max_matches, TypeList &type_list) {
const bool append = true; const bool append = true;
TypeMap types_map; TypeMap types_map;
llvm::DenseSet<lldb_private::SymbolFile *> searched_symbol_files; llvm::DenseSet<lldb_private::SymbolFile *> searched_symbol_files;
size_t num_types = size_t num_types =
FindTypes_Impl(type_name, parent_decl_ctx, append, max_matches, FindTypes_Impl(type_name, parent_decl_ctx, append, max_matches,
searched_symbol_files, types_map); searched_symbol_files, types_map);
if (num_types > 0) { if (num_types > 0) {
SymbolContext sc; SymbolContext sc;
sc.module_sp = shared_from_this(); sc.module_sp = shared_from_this();
sc.SortTypeList(types_map, type_list); sc.SortTypeList(types_map, type_list);
} }
return num_types; return num_types;
} }
lldb::TypeSP Module::FindFirstType(const SymbolContext &sc, lldb::TypeSP Module::FindFirstType(const SymbolContext &sc,
const ConstString &name, bool exact_match) { ConstString name, bool exact_match) {
TypeList type_list; TypeList type_list;
llvm::DenseSet<lldb_private::SymbolFile *> searched_symbol_files; llvm::DenseSet<lldb_private::SymbolFile *> searched_symbol_files;
const size_t num_matches = const size_t num_matches =
FindTypes(name, exact_match, 1, searched_symbol_files, type_list); FindTypes(name, exact_match, 1, searched_symbol_files, type_list);
if (num_matches) if (num_matches)
return type_list.GetTypeAtIndex(0); return type_list.GetTypeAtIndex(0);
return TypeSP(); return TypeSP();
} }
size_t Module::FindTypes( size_t Module::FindTypes(
const ConstString &name, bool exact_match, size_t max_matches, ConstString name, bool exact_match, size_t max_matches,
llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files, llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
TypeList &types) { TypeList &types) {
size_t num_matches = 0; size_t num_matches = 0;
const char *type_name_cstr = name.GetCString(); const char *type_name_cstr = name.GetCString();
llvm::StringRef type_scope; llvm::StringRef type_scope;
llvm::StringRef type_basename; llvm::StringRef type_basename;
const bool append = true; const bool append = true;
TypeClass type_class = eTypeClassAny; TypeClass type_class = eTypeClassAny;
Show All 32 Lines
m_did_load_symbol_vendor = true; m_did_load_symbol_vendor = true;
} }
} }
} }
return m_symfile_up.get(); return m_symfile_up.get();
} }
void Module::SetFileSpecAndObjectName(const FileSpec &file, void Module::SetFileSpecAndObjectName(const FileSpec &file,
const ConstString &object_name) { ConstString object_name) {
// Container objects whose paths do not specify a file directly can call this // Container objects whose paths do not specify a file directly can call this
// function to correct the file and object names. // function to correct the file and object names.
m_file = file; m_file = file;
m_mod_time = FileSystem::Instance().GetModificationTime(file); m_mod_time = FileSystem::Instance().GetModificationTime(file);
m_object_name = object_name; m_object_name = object_name;
} }
const ArchSpec &Module::GetArchitecture() const { return m_arch; } const ArchSpec &Module::GetArchitecture() const { return m_arch; }
Show All 32 Lines
TypeList *Module::GetTypeList() { TypeList *Module::GetTypeList() {
SymbolVendor *symbols = GetSymbolVendor(); SymbolVendor *symbols = GetSymbolVendor();
if (symbols) if (symbols)
return &symbols->GetTypeList(); return &symbols->GetTypeList();
return nullptr; return nullptr;
} }
const ConstString &Module::GetObjectName() const { return m_object_name; } ConstString Module::GetObjectName() const { return m_object_name; }
ObjectFile *Module::GetObjectFile() { ObjectFile *Module::GetObjectFile() {
if (!m_did_load_objfile.load()) { if (!m_did_load_objfile.load()) {
std::lock_guard<std::recursive_mutex> guard(m_mutex); std::lock_guard<std::recursive_mutex> guard(m_mutex);
if (!m_did_load_objfile.load()) { if (!m_did_load_objfile.load()) {
static Timer::Category func_cat(LLVM_PRETTY_FUNCTION); static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
Timer scoped_timer(func_cat, "Module::GetObjectFile () module = %s", Timer scoped_timer(func_cat, "Module::GetObjectFile () module = %s",
GetFileSpec().GetFilename().AsCString("")); GetFileSpec().GetFilename().AsCString(""));
Show All 32 Lines
} }
SectionList *Module::GetUnifiedSectionList() { SectionList *Module::GetUnifiedSectionList() {
if (!m_sections_up) if (!m_sections_up)
m_sections_up = llvm::make_unique<SectionList>(); m_sections_up = llvm::make_unique<SectionList>();
return m_sections_up.get(); return m_sections_up.get();
} }
const Symbol *Module::FindFirstSymbolWithNameAndType(const ConstString &name, const Symbol *Module::FindFirstSymbolWithNameAndType(ConstString name,
SymbolType symbol_type) { SymbolType symbol_type) {
static Timer::Category func_cat(LLVM_PRETTY_FUNCTION); static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
Timer scoped_timer( Timer scoped_timer(
func_cat, "Module::FindFirstSymbolWithNameAndType (name = %s, type = %i)", func_cat, "Module::FindFirstSymbolWithNameAndType (name = %s, type = %i)",
name.AsCString(), symbol_type); name.AsCString(), symbol_type);
SymbolVendor *sym_vendor = GetSymbolVendor(); SymbolVendor *sym_vendor = GetSymbolVendor();
if (sym_vendor) { if (sym_vendor) {
Symtab *symtab = sym_vendor->GetSymtab(); Symtab *symtab = sym_vendor->GetSymtab();
Show All 16 Lines
for (size_t i = 0; i < num_indices; i++) { for (size_t i = 0; i < num_indices; i++) {
sc.symbol = symtab->SymbolAtIndex(symbol_indexes[i]); sc.symbol = symtab->SymbolAtIndex(symbol_indexes[i]);
if (sc.symbol) if (sc.symbol)
sc_list.Append(sc); sc_list.Append(sc);
} }
} }
} }
size_t Module::FindFunctionSymbols(const ConstString &name, size_t Module::FindFunctionSymbols(ConstString name,
uint32_t name_type_mask, uint32_t name_type_mask,
SymbolContextList &sc_list) { SymbolContextList &sc_list) {
static Timer::Category func_cat(LLVM_PRETTY_FUNCTION); static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
Timer scoped_timer(func_cat, Timer scoped_timer(func_cat,
"Module::FindSymbolsFunctions (name = %s, mask = 0x%8.8x)", "Module::FindSymbolsFunctions (name = %s, mask = 0x%8.8x)",
name.AsCString(), name_type_mask); name.AsCString(), name_type_mask);
SymbolVendor *sym_vendor = GetSymbolVendor(); SymbolVendor *sym_vendor = GetSymbolVendor();
if (sym_vendor) { if (sym_vendor) {
Symtab *symtab = sym_vendor->GetSymtab(); Symtab *symtab = sym_vendor->GetSymtab();
if (symtab) if (symtab)
return symtab->FindFunctionSymbols(name, name_type_mask, sc_list); return symtab->FindFunctionSymbols(name, name_type_mask, sc_list);
} }
return 0; return 0;
} }
size_t Module::FindSymbolsWithNameAndType(const ConstString &name, size_t Module::FindSymbolsWithNameAndType(ConstString name,
SymbolType symbol_type, SymbolType symbol_type,
SymbolContextList &sc_list) { SymbolContextList &sc_list) {
// No need to protect this call using m_mutex all other method calls are // No need to protect this call using m_mutex all other method calls are
// already thread safe. // already thread safe.
static Timer::Category func_cat(LLVM_PRETTY_FUNCTION); static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
Timer scoped_timer( Timer scoped_timer(
func_cat, "Module::FindSymbolsWithNameAndType (name = %s, type = %i)", func_cat, "Module::FindSymbolsWithNameAndType (name = %s, type = %i)",
Show All 32 Lines
} }
const ArchSpec &arch = module_ref.GetArchitecture(); const ArchSpec &arch = module_ref.GetArchitecture();
if (arch.IsValid()) { if (arch.IsValid()) {
if (!m_arch.IsCompatibleMatch(arch)) if (!m_arch.IsCompatibleMatch(arch))
return false; return false;
} }
const ConstString &object_name = module_ref.GetObjectName(); ConstString object_name = module_ref.GetObjectName();
if (object_name) { if (object_name) {
if (object_name != GetObjectName()) if (object_name != GetObjectName())
return false; return false;
} }
return true; return true;
} }
bool Module::FindSourceFile(const FileSpec &orig_spec, bool Module::FindSourceFile(const FileSpec &orig_spec,
Show All 16 Lines

lldb/source/Core/ModuleList.cpp

Show All 16 Lines
ModuleSP ModuleList::GetModuleAtIndexUnlocked(size_t idx) const { ModuleSP ModuleList::GetModuleAtIndexUnlocked(size_t idx) const {
ModuleSP module_sp; ModuleSP module_sp;
if (idx < m_modules.size()) if (idx < m_modules.size())
module_sp = m_modules[idx]; module_sp = m_modules[idx];
return module_sp; return module_sp;
} }
size_t ModuleList::FindFunctions(const ConstString &name, size_t ModuleList::FindFunctions(ConstString name,
FunctionNameType name_type_mask, FunctionNameType name_type_mask,
bool include_symbols, bool include_inlines, bool include_symbols, bool include_inlines,
bool append, bool append,
SymbolContextList &sc_list) const { SymbolContextList &sc_list) const {
if (!append) if (!append)
sc_list.Clear(); sc_list.Clear();
const size_t old_size = sc_list.GetSize(); const size_t old_size = sc_list.GetSize();
Show All 19 Lines
for (pos = m_modules.begin(); pos != end; ++pos) { for (pos = m_modules.begin(); pos != end; ++pos) {
(*pos)->FindFunctions(name, nullptr, name_type_mask, include_symbols, (*pos)->FindFunctions(name, nullptr, name_type_mask, include_symbols,
include_inlines, true, sc_list); include_inlines, true, sc_list);
} }
} }
return sc_list.GetSize() - old_size; return sc_list.GetSize() - old_size;
} }
size_t ModuleList::FindFunctionSymbols(const ConstString &name, size_t ModuleList::FindFunctionSymbols(ConstString name,
lldb::FunctionNameType name_type_mask, lldb::FunctionNameType name_type_mask,
SymbolContextList &sc_list) { SymbolContextList &sc_list) {
const size_t old_size = sc_list.GetSize(); const size_t old_size = sc_list.GetSize();
if (name_type_mask & eFunctionNameTypeAuto) { if (name_type_mask & eFunctionNameTypeAuto) {
Module::LookupInfo lookup_info(name, name_type_mask, eLanguageTypeUnknown); Module::LookupInfo lookup_info(name, name_type_mask, eLanguageTypeUnknown);
std::lock_guard<std::recursive_mutex> guard(m_modules_mutex); std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
Show All 32 Lines
collection::const_iterator pos, end = m_modules.end(); collection::const_iterator pos, end = m_modules.end();
for (pos = m_modules.begin(); pos != end; ++pos) { for (pos = m_modules.begin(); pos != end; ++pos) {
(*pos)->FindCompileUnits(path, true, sc_list); (*pos)->FindCompileUnits(path, true, sc_list);
} }
return sc_list.GetSize(); return sc_list.GetSize();
} }
size_t ModuleList::FindGlobalVariables(const ConstString &name, size_t ModuleList::FindGlobalVariables(ConstString name,
size_t max_matches, size_t max_matches,
VariableList &variable_list) const { VariableList &variable_list) const {
size_t initial_size = variable_list.GetSize(); size_t initial_size = variable_list.GetSize();
std::lock_guard<std::recursive_mutex> guard(m_modules_mutex); std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
collection::const_iterator pos, end = m_modules.end(); collection::const_iterator pos, end = m_modules.end();
for (pos = m_modules.begin(); pos != end; ++pos) { for (pos = m_modules.begin(); pos != end; ++pos) {
(*pos)->FindGlobalVariables(name, nullptr, max_matches, variable_list); (*pos)->FindGlobalVariables(name, nullptr, max_matches, variable_list);
} }
return variable_list.GetSize() - initial_size; return variable_list.GetSize() - initial_size;
} }
size_t ModuleList::FindGlobalVariables(const RegularExpression &regex, size_t ModuleList::FindGlobalVariables(const RegularExpression &regex,
size_t max_matches, size_t max_matches,
VariableList &variable_list) const { VariableList &variable_list) const {
size_t initial_size = variable_list.GetSize(); size_t initial_size = variable_list.GetSize();
std::lock_guard<std::recursive_mutex> guard(m_modules_mutex); std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
collection::const_iterator pos, end = m_modules.end(); collection::const_iterator pos, end = m_modules.end();
for (pos = m_modules.begin(); pos != end; ++pos) { for (pos = m_modules.begin(); pos != end; ++pos) {
(*pos)->FindGlobalVariables(regex, max_matches, variable_list); (*pos)->FindGlobalVariables(regex, max_matches, variable_list);
} }
return variable_list.GetSize() - initial_size; return variable_list.GetSize() - initial_size;
} }
size_t ModuleList::FindSymbolsWithNameAndType(const ConstString &name, size_t ModuleList::FindSymbolsWithNameAndType(ConstString name,
SymbolType symbol_type, SymbolType symbol_type,
SymbolContextList &sc_list, SymbolContextList &sc_list,
bool append) const { bool append) const {
std::lock_guard<std::recursive_mutex> guard(m_modules_mutex); std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
if (!append) if (!append)
sc_list.Clear(); sc_list.Clear();
size_t initial_size = sc_list.GetSize(); size_t initial_size = sc_list.GetSize();
Show All 32 Lines
break; break;
} }
} }
} }
return module_sp; return module_sp;
} }
size_t size_t
ModuleList::FindTypes(Module *search_first, const ConstString &name, ModuleList::FindTypes(Module *search_first, ConstString name,
bool name_is_fully_qualified, size_t max_matches, bool name_is_fully_qualified, size_t max_matches,
llvm::DenseSet<SymbolFile *> &searched_symbol_files, llvm::DenseSet<SymbolFile *> &searched_symbol_files,
TypeList &types) const { TypeList &types) const {
std::lock_guard<std::recursive_mutex> guard(m_modules_mutex); std::lock_guard<std::recursive_mutex> guard(m_modules_mutex);
size_t total_matches = 0; size_t total_matches = 0;
collection::const_iterator pos, end = m_modules.end(); collection::const_iterator pos, end = m_modules.end();
if (search_first) { if (search_first) {
Show All 16 Lines

lldb/source/Core/PluginManager.cpp

Show All 16 Lines
return g_instances_mutex; return g_instances_mutex;
} }
static ABIInstances &GetABIInstances() { static ABIInstances &GetABIInstances() {
static ABIInstances g_instances; static ABIInstances g_instances;
return g_instances; return g_instances;
} }
bool PluginManager::RegisterPlugin(const ConstString &name, bool PluginManager::RegisterPlugin(ConstString name,
const char *description, const char *description,
ABICreateInstance create_callback) { ABICreateInstance create_callback) {
if (create_callback) { if (create_callback) {
ABIInstance instance; ABIInstance instance;
assert((bool)name); assert((bool)name);
instance.name = name; instance.name = name;
if (description && description[0]) if (description && description[0])
instance.description = description; instance.description = description;
Show All 25 Lines
std::lock_guard<std::recursive_mutex> guard(GetABIInstancesMutex()); std::lock_guard<std::recursive_mutex> guard(GetABIInstancesMutex());
ABIInstances &instances = GetABIInstances(); ABIInstances &instances = GetABIInstances();
if (idx < instances.size()) if (idx < instances.size())
return instances[idx].create_callback; return instances[idx].create_callback;
return nullptr; return nullptr;
} }
ABICreateInstance ABICreateInstance
PluginManager::GetABICreateCallbackForPluginName(const ConstString &name) { PluginManager::GetABICreateCallbackForPluginName(ConstString name) {
if (name) { if (name) {
std::lock_guard<std::recursive_mutex> guard(GetABIInstancesMutex()); std::lock_guard<std::recursive_mutex> guard(GetABIInstancesMutex());
ABIInstances &instances = GetABIInstances(); ABIInstances &instances = GetABIInstances();
ABIInstances::iterator pos, end = instances.end(); ABIInstances::iterator pos, end = instances.end();
for (pos = instances.begin(); pos != end; ++pos) { for (pos = instances.begin(); pos != end; ++pos) {
if (name == pos->name) if (name == pos->name)
return pos->create_callback; return pos->create_callback;
Show All 17 Lines
return g_architecture_mutex; return g_architecture_mutex;
} }
static ArchitectureInstances &GetArchitectureInstances() { static ArchitectureInstances &GetArchitectureInstances() {
static ArchitectureInstances g_instances; static ArchitectureInstances g_instances;
return g_instances; return g_instances;
} }
void PluginManager::RegisterPlugin(const ConstString &name, void PluginManager::RegisterPlugin(ConstString name,
llvm::StringRef description, llvm::StringRef description,
ArchitectureCreateInstance create_callback) { ArchitectureCreateInstance create_callback) {
std::lock_guard<std::mutex> guard(GetArchitectureMutex()); std::lock_guard<std::mutex> guard(GetArchitectureMutex());
GetArchitectureInstances().push_back({name, description, create_callback}); GetArchitectureInstances().push_back({name, description, create_callback});
} }
void PluginManager::UnregisterPlugin( void PluginManager::UnregisterPlugin(
ArchitectureCreateInstance create_callback) { ArchitectureCreateInstance create_callback) {
Show All 32 Lines
return g_instances_mutex; return g_instances_mutex;
} }
static DisassemblerInstances &GetDisassemblerInstances() { static DisassemblerInstances &GetDisassemblerInstances() {
static DisassemblerInstances g_instances; static DisassemblerInstances g_instances;
return g_instances; return g_instances;
} }
bool PluginManager::RegisterPlugin(const ConstString &name, bool PluginManager::RegisterPlugin(ConstString name,
const char *description, const char *description,
DisassemblerCreateInstance create_callback) { DisassemblerCreateInstance create_callback) {
if (create_callback) { if (create_callback) {
DisassemblerInstance instance; DisassemblerInstance instance;
assert((bool)name); assert((bool)name);
instance.name = name; instance.name = name;
if (description && description[0]) if (description && description[0])
instance.description = description; instance.description = description;
Show All 28 Lines
DisassemblerInstances &instances = GetDisassemblerInstances(); DisassemblerInstances &instances = GetDisassemblerInstances();
if (idx < instances.size()) if (idx < instances.size())
return instances[idx].create_callback; return instances[idx].create_callback;
return nullptr; return nullptr;
} }
DisassemblerCreateInstance DisassemblerCreateInstance
PluginManager::GetDisassemblerCreateCallbackForPluginName( PluginManager::GetDisassemblerCreateCallbackForPluginName(
const ConstString &name) { ConstString name) {
if (name) { if (name) {
std::lock_guard<std::recursive_mutex> guard(GetDisassemblerMutex()); std::lock_guard<std::recursive_mutex> guard(GetDisassemblerMutex());
DisassemblerInstances &instances = GetDisassemblerInstances(); DisassemblerInstances &instances = GetDisassemblerInstances();
DisassemblerInstances::iterator pos, end = instances.end(); DisassemblerInstances::iterator pos, end = instances.end();
for (pos = instances.begin(); pos != end; ++pos) { for (pos = instances.begin(); pos != end; ++pos) {
if (name == pos->name) if (name == pos->name)
return pos->create_callback; return pos->create_callback;
Show All 23 Lines
} }
static DynamicLoaderInstances &GetDynamicLoaderInstances() { static DynamicLoaderInstances &GetDynamicLoaderInstances() {
static DynamicLoaderInstances g_instances; static DynamicLoaderInstances g_instances;
return g_instances; return g_instances;
} }
bool PluginManager::RegisterPlugin( bool PluginManager::RegisterPlugin(
const ConstString &name, const char *description, ConstString name, const char *description,
DynamicLoaderCreateInstance create_callback, DynamicLoaderCreateInstance create_callback,
DebuggerInitializeCallback debugger_init_callback) { DebuggerInitializeCallback debugger_init_callback) {
if (create_callback) { if (create_callback) {
DynamicLoaderInstance instance; DynamicLoaderInstance instance;
assert((bool)name); assert((bool)name);
instance.name = name; instance.name = name;
if (description && description[0]) if (description && description[0])
instance.description = description; instance.description = description;
Show All 28 Lines
DynamicLoaderInstances &instances = GetDynamicLoaderInstances(); DynamicLoaderInstances &instances = GetDynamicLoaderInstances();
if (idx < instances.size()) if (idx < instances.size())
return instances[idx].create_callback; return instances[idx].create_callback;
return nullptr; return nullptr;
} }
DynamicLoaderCreateInstance DynamicLoaderCreateInstance
PluginManager::GetDynamicLoaderCreateCallbackForPluginName( PluginManager::GetDynamicLoaderCreateCallbackForPluginName(
const ConstString &name) { ConstString name) {
if (name) { if (name) {
std::lock_guard<std::recursive_mutex> guard(GetDynamicLoaderMutex()); std::lock_guard<std::recursive_mutex> guard(GetDynamicLoaderMutex());
DynamicLoaderInstances &instances = GetDynamicLoaderInstances(); DynamicLoaderInstances &instances = GetDynamicLoaderInstances();
DynamicLoaderInstances::iterator pos, end = instances.end(); DynamicLoaderInstances::iterator pos, end = instances.end();
for (pos = instances.begin(); pos != end; ++pos) { for (pos = instances.begin(); pos != end; ++pos) {
if (name == pos->name) if (name == pos->name)
return pos->create_callback; return pos->create_callback;
Show All 23 Lines
} }
static JITLoaderInstances &GetJITLoaderInstances() { static JITLoaderInstances &GetJITLoaderInstances() {
static JITLoaderInstances g_instances; static JITLoaderInstances g_instances;
return g_instances; return g_instances;
} }
bool PluginManager::RegisterPlugin( bool PluginManager::RegisterPlugin(
const ConstString &name, const char *description, ConstString name, const char *description,
JITLoaderCreateInstance create_callback, JITLoaderCreateInstance create_callback,
DebuggerInitializeCallback debugger_init_callback) { DebuggerInitializeCallback debugger_init_callback) {
if (create_callback) { if (create_callback) {
JITLoaderInstance instance; JITLoaderInstance instance;
assert((bool)name); assert((bool)name);
instance.name = name; instance.name = name;
if (description && description[0]) if (description && description[0])
instance.description = description; instance.description = description;
Show All 26 Lines
std::lock_guard<std::recursive_mutex> guard(GetJITLoaderMutex()); std::lock_guard<std::recursive_mutex> guard(GetJITLoaderMutex());
JITLoaderInstances &instances = GetJITLoaderInstances(); JITLoaderInstances &instances = GetJITLoaderInstances();
if (idx < instances.size()) if (idx < instances.size())
return instances[idx].create_callback; return instances[idx].create_callback;
return nullptr; return nullptr;
} }
JITLoaderCreateInstance PluginManager::GetJITLoaderCreateCallbackForPluginName( JITLoaderCreateInstance PluginManager::GetJITLoaderCreateCallbackForPluginName(
const ConstString &name) { ConstString name) {
if (name) { if (name) {
std::lock_guard<std::recursive_mutex> guard(GetJITLoaderMutex()); std::lock_guard<std::recursive_mutex> guard(GetJITLoaderMutex());
JITLoaderInstances &instances = GetJITLoaderInstances(); JITLoaderInstances &instances = GetJITLoaderInstances();
JITLoaderInstances::iterator pos, end = instances.end(); JITLoaderInstances::iterator pos, end = instances.end();
for (pos = instances.begin(); pos != end; ++pos) { for (pos = instances.begin(); pos != end; ++pos) {
if (name == pos->name) if (name == pos->name)
return pos->create_callback; return pos->create_callback;
Show All 21 Lines
} }
static EmulateInstructionInstances &GetEmulateInstructionInstances() { static EmulateInstructionInstances &GetEmulateInstructionInstances() {
static EmulateInstructionInstances g_instances; static EmulateInstructionInstances g_instances;
return g_instances; return g_instances;
} }
bool PluginManager::RegisterPlugin( bool PluginManager::RegisterPlugin(
const ConstString &name, const char *description, ConstString name, const char *description,
EmulateInstructionCreateInstance create_callback) { EmulateInstructionCreateInstance create_callback) {
if (create_callback) { if (create_callback) {
EmulateInstructionInstance instance; EmulateInstructionInstance instance;
assert((bool)name); assert((bool)name);
instance.name = name; instance.name = name;
if (description && description[0]) if (description && description[0])
instance.description = description; instance.description = description;
instance.create_callback = create_callback; instance.create_callback = create_callback;
Show All 26 Lines
EmulateInstructionInstances &instances = GetEmulateInstructionInstances(); EmulateInstructionInstances &instances = GetEmulateInstructionInstances();
if (idx < instances.size()) if (idx < instances.size())
return instances[idx].create_callback; return instances[idx].create_callback;
return nullptr; return nullptr;
} }
EmulateInstructionCreateInstance EmulateInstructionCreateInstance
PluginManager::GetEmulateInstructionCreateCallbackForPluginName( PluginManager::GetEmulateInstructionCreateCallbackForPluginName(
const ConstString &name) { ConstString name) {
if (name) { if (name) {
std::lock_guard<std::recursive_mutex> guard(GetEmulateInstructionMutex()); std::lock_guard<std::recursive_mutex> guard(GetEmulateInstructionMutex());
EmulateInstructionInstances &instances = GetEmulateInstructionInstances(); EmulateInstructionInstances &instances = GetEmulateInstructionInstances();
EmulateInstructionInstances::iterator pos, end = instances.end(); EmulateInstructionInstances::iterator pos, end = instances.end();
for (pos = instances.begin(); pos != end; ++pos) { for (pos = instances.begin(); pos != end; ++pos) {
if (name == pos->name) if (name == pos->name)
return pos->create_callback; return pos->create_callback;
Show All 23 Lines
} }
static OperatingSystemInstances &GetOperatingSystemInstances() { static OperatingSystemInstances &GetOperatingSystemInstances() {
static OperatingSystemInstances g_instances; static OperatingSystemInstances g_instances;
return g_instances; return g_instances;
} }
bool PluginManager::RegisterPlugin( bool PluginManager::RegisterPlugin(
const ConstString &name, const char *description, ConstString name, const char *description,
OperatingSystemCreateInstance create_callback, OperatingSystemCreateInstance create_callback,
DebuggerInitializeCallback debugger_init_callback) { DebuggerInitializeCallback debugger_init_callback) {
if (create_callback) { if (create_callback) {
OperatingSystemInstance instance; OperatingSystemInstance instance;
assert((bool)name); assert((bool)name);
instance.name = name; instance.name = name;
if (description && description[0]) if (description && description[0])
instance.description = description; instance.description = description;
Show All 28 Lines
OperatingSystemInstances &instances = GetOperatingSystemInstances(); OperatingSystemInstances &instances = GetOperatingSystemInstances();
if (idx < instances.size()) if (idx < instances.size())
return instances[idx].create_callback; return instances[idx].create_callback;
return nullptr; return nullptr;
} }
OperatingSystemCreateInstance OperatingSystemCreateInstance
PluginManager::GetOperatingSystemCreateCallbackForPluginName( PluginManager::GetOperatingSystemCreateCallbackForPluginName(
const ConstString &name) { ConstString name) {
if (name) { if (name) {
std::lock_guard<std::recursive_mutex> guard(GetOperatingSystemMutex()); std::lock_guard<std::recursive_mutex> guard(GetOperatingSystemMutex());
OperatingSystemInstances &instances = GetOperatingSystemInstances(); OperatingSystemInstances &instances = GetOperatingSystemInstances();
OperatingSystemInstances::iterator pos, end = instances.end(); OperatingSystemInstances::iterator pos, end = instances.end();
for (pos = instances.begin(); pos != end; ++pos) { for (pos = instances.begin(); pos != end; ++pos) {
if (name == pos->name) if (name == pos->name)
return pos->create_callback; return pos->create_callback;
Show All 19 Lines
return g_instances_mutex; return g_instances_mutex;
} }
static LanguageInstances &GetLanguageInstances() { static LanguageInstances &GetLanguageInstances() {
static LanguageInstances g_instances; static LanguageInstances g_instances;
return g_instances; return g_instances;
} }
bool PluginManager::RegisterPlugin(const ConstString &name, bool PluginManager::RegisterPlugin(ConstString name,
const char *description, const char *description,
LanguageCreateInstance create_callback) { LanguageCreateInstance create_callback) {
if (create_callback) { if (create_callback) {
LanguageInstance instance; LanguageInstance instance;
assert((bool)name); assert((bool)name);
instance.name = name; instance.name = name;
if (description && description[0]) if (description && description[0])
instance.description = description; instance.description = description;
Show All 25 Lines
std::lock_guard<std::recursive_mutex> guard(GetLanguageMutex()); std::lock_guard<std::recursive_mutex> guard(GetLanguageMutex());
LanguageInstances &instances = GetLanguageInstances(); LanguageInstances &instances = GetLanguageInstances();
if (idx < instances.size()) if (idx < instances.size())
return instances[idx].create_callback; return instances[idx].create_callback;
return nullptr; return nullptr;
} }
LanguageCreateInstance LanguageCreateInstance
PluginManager::GetLanguageCreateCallbackForPluginName(const ConstString &name) { PluginManager::GetLanguageCreateCallbackForPluginName(ConstString name) {
if (name) { if (name) {
std::lock_guard<std::recursive_mutex> guard(GetLanguageMutex()); std::lock_guard<std::recursive_mutex> guard(GetLanguageMutex());
LanguageInstances &instances = GetLanguageInstances(); LanguageInstances &instances = GetLanguageInstances();
LanguageInstances::iterator pos, end = instances.end(); LanguageInstances::iterator pos, end = instances.end();
for (pos = instances.begin(); pos != end; ++pos) { for (pos = instances.begin(); pos != end; ++pos) {
if (name == pos->name) if (name == pos->name)
return pos->create_callback; return pos->create_callback;
Show All 21 Lines
} }
static LanguageRuntimeInstances &GetLanguageRuntimeInstances() { static LanguageRuntimeInstances &GetLanguageRuntimeInstances() {
static LanguageRuntimeInstances g_instances; static LanguageRuntimeInstances g_instances;
return g_instances; return g_instances;
} }
bool PluginManager::RegisterPlugin( bool PluginManager::RegisterPlugin(
const ConstString &name, const char *description, ConstString name, const char *description,
LanguageRuntimeCreateInstance create_callback, LanguageRuntimeCreateInstance create_callback,
LanguageRuntimeGetCommandObject command_callback) { LanguageRuntimeGetCommandObject command_callback) {
if (create_callback) { if (create_callback) {
LanguageRuntimeInstance instance; LanguageRuntimeInstance instance;
assert((bool)name); assert((bool)name);
instance.name = name; instance.name = name;
if (description && description[0]) if (description && description[0])
instance.description = description; instance.description = description;
Show All 32 Lines
LanguageRuntimeInstances &instances = GetLanguageRuntimeInstances(); LanguageRuntimeInstances &instances = GetLanguageRuntimeInstances();
if (idx < instances.size()) if (idx < instances.size())
return instances[idx].command_callback; return instances[idx].command_callback;
return nullptr; return nullptr;
} }
LanguageRuntimeCreateInstance LanguageRuntimeCreateInstance
PluginManager::GetLanguageRuntimeCreateCallbackForPluginName( PluginManager::GetLanguageRuntimeCreateCallbackForPluginName(
const ConstString &name) { ConstString name) {
if (name) { if (name) {
std::lock_guard<std::recursive_mutex> guard(GetLanguageRuntimeMutex()); std::lock_guard<std::recursive_mutex> guard(GetLanguageRuntimeMutex());
LanguageRuntimeInstances &instances = GetLanguageRuntimeInstances(); LanguageRuntimeInstances &instances = GetLanguageRuntimeInstances();
LanguageRuntimeInstances::iterator pos, end = instances.end(); LanguageRuntimeInstances::iterator pos, end = instances.end();
for (pos = instances.begin(); pos != end; ++pos) { for (pos = instances.begin(); pos != end; ++pos) {
if (name == pos->name) if (name == pos->name)
return pos->create_callback; return pos->create_callback;
Show All 20 Lines
} }
static SystemRuntimeInstances &GetSystemRuntimeInstances() { static SystemRuntimeInstances &GetSystemRuntimeInstances() {
static SystemRuntimeInstances g_instances; static SystemRuntimeInstances g_instances;
return g_instances; return g_instances;
} }
bool PluginManager::RegisterPlugin( bool PluginManager::RegisterPlugin(
const ConstString &name, const char *description, ConstString name, const char *description,
SystemRuntimeCreateInstance create_callback) { SystemRuntimeCreateInstance create_callback) {
if (create_callback) { if (create_callback) {
SystemRuntimeInstance instance; SystemRuntimeInstance instance;
assert((bool)name); assert((bool)name);
instance.name = name; instance.name = name;
if (description && description[0]) if (description && description[0])
instance.description = description; instance.description = description;
instance.create_callback = create_callback; instance.create_callback = create_callback;
Show All 26 Lines
SystemRuntimeInstances &instances = GetSystemRuntimeInstances(); SystemRuntimeInstances &instances = GetSystemRuntimeInstances();
if (idx < instances.size()) if (idx < instances.size())
return instances[idx].create_callback; return instances[idx].create_callback;
return nullptr; return nullptr;
} }
SystemRuntimeCreateInstance SystemRuntimeCreateInstance
PluginManager::GetSystemRuntimeCreateCallbackForPluginName( PluginManager::GetSystemRuntimeCreateCallbackForPluginName(
const ConstString &name) { ConstString name) {
if (name) { if (name) {
std::lock_guard<std::recursive_mutex> guard(GetSystemRuntimeMutex()); std::lock_guard<std::recursive_mutex> guard(GetSystemRuntimeMutex());
SystemRuntimeInstances &instances = GetSystemRuntimeInstances(); SystemRuntimeInstances &instances = GetSystemRuntimeInstances();
SystemRuntimeInstances::iterator pos, end = instances.end(); SystemRuntimeInstances::iterator pos, end = instances.end();
for (pos = instances.begin(); pos != end; ++pos) { for (pos = instances.begin(); pos != end; ++pos) {
if (name == pos->name) if (name == pos->name)
return pos->create_callback; return pos->create_callback;
Show All 26 Lines
} }
static ObjectFileInstances &GetObjectFileInstances() { static ObjectFileInstances &GetObjectFileInstances() {
static ObjectFileInstances g_instances; static ObjectFileInstances g_instances;
return g_instances; return g_instances;
} }
bool PluginManager::RegisterPlugin( bool PluginManager::RegisterPlugin(
const ConstString &name, const char *description, ConstString name, const char *description,
ObjectFileCreateInstance create_callback, ObjectFileCreateInstance create_callback,
ObjectFileCreateMemoryInstance create_memory_callback, ObjectFileCreateMemoryInstance create_memory_callback,
ObjectFileGetModuleSpecifications get_module_specifications, ObjectFileGetModuleSpecifications get_module_specifications,
ObjectFileSaveCore save_core) { ObjectFileSaveCore save_core) {
if (create_callback) { if (create_callback) {
ObjectFileInstance instance; ObjectFileInstance instance;
assert((bool)name); assert((bool)name);
instance.name = name; instance.name = name;
Show All 32 Lines
ObjectFileInstances &instances = GetObjectFileInstances(); ObjectFileInstances &instances = GetObjectFileInstances();
if (idx < instances.size()) if (idx < instances.size())
return instances[idx].get_module_specifications; return instances[idx].get_module_specifications;
return nullptr; return nullptr;
} }
ObjectFileCreateInstance ObjectFileCreateInstance
PluginManager::GetObjectFileCreateCallbackForPluginName( PluginManager::GetObjectFileCreateCallbackForPluginName(
const ConstString &name) { ConstString name) {
if (name) { if (name) {
std::lock_guard<std::recursive_mutex> guard(GetObjectFileMutex()); std::lock_guard<std::recursive_mutex> guard(GetObjectFileMutex());
ObjectFileInstances &instances = GetObjectFileInstances(); ObjectFileInstances &instances = GetObjectFileInstances();
ObjectFileInstances::iterator pos, end = instances.end(); ObjectFileInstances::iterator pos, end = instances.end();
for (pos = instances.begin(); pos != end; ++pos) { for (pos = instances.begin(); pos != end; ++pos) {
if (name == pos->name) if (name == pos->name)
return pos->create_callback; return pos->create_callback;
} }
} }
return nullptr; return nullptr;
} }
ObjectFileCreateMemoryInstance ObjectFileCreateMemoryInstance
PluginManager::GetObjectFileCreateMemoryCallbackForPluginName( PluginManager::GetObjectFileCreateMemoryCallbackForPluginName(
const ConstString &name) { ConstString name) {
if (name) { if (name) {
std::lock_guard<std::recursive_mutex> guard(GetObjectFileMutex()); std::lock_guard<std::recursive_mutex> guard(GetObjectFileMutex());
ObjectFileInstances &instances = GetObjectFileInstances(); ObjectFileInstances &instances = GetObjectFileInstances();
ObjectFileInstances::iterator pos, end = instances.end(); ObjectFileInstances::iterator pos, end = instances.end();
for (pos = instances.begin(); pos != end; ++pos) { for (pos = instances.begin(); pos != end; ++pos) {
if (name == pos->name) if (name == pos->name)
return pos->create_memory_callback; return pos->create_memory_callback;
Show All 32 Lines
} }
static ObjectContainerInstances &GetObjectContainerInstances() { static ObjectContainerInstances &GetObjectContainerInstances() {
static ObjectContainerInstances g_instances; static ObjectContainerInstances g_instances;
return g_instances; return g_instances;
} }
bool PluginManager::RegisterPlugin( bool PluginManager::RegisterPlugin(
const ConstString &name, const char *description, ConstString name, const char *description,
ObjectContainerCreateInstance create_callback, ObjectContainerCreateInstance create_callback,
ObjectFileGetModuleSpecifications get_module_specifications) { ObjectFileGetModuleSpecifications get_module_specifications) {
if (create_callback) { if (create_callback) {
ObjectContainerInstance instance; ObjectContainerInstance instance;
assert((bool)name); assert((bool)name);
instance.name = name; instance.name = name;
if (description && description[0]) if (description && description[0])
instance.description = description; instance.description = description;
Show All 28 Lines
ObjectContainerInstances &instances = GetObjectContainerInstances(); ObjectContainerInstances &instances = GetObjectContainerInstances();
if (idx < instances.size()) if (idx < instances.size())
return instances[idx].create_callback; return instances[idx].create_callback;
return nullptr; return nullptr;
} }
ObjectContainerCreateInstance ObjectContainerCreateInstance
PluginManager::GetObjectContainerCreateCallbackForPluginName( PluginManager::GetObjectContainerCreateCallbackForPluginName(
const ConstString &name) { ConstString name) {
if (name) { if (name) {
std::lock_guard<std::recursive_mutex> guard(GetObjectContainerMutex()); std::lock_guard<std::recursive_mutex> guard(GetObjectContainerMutex());
ObjectContainerInstances &instances = GetObjectContainerInstances(); ObjectContainerInstances &instances = GetObjectContainerInstances();
ObjectContainerInstances::iterator pos, end = instances.end(); ObjectContainerInstances::iterator pos, end = instances.end();
for (pos = instances.begin(); pos != end; ++pos) { for (pos = instances.begin(); pos != end; ++pos) {
if (name == pos->name) if (name == pos->name)
return pos->create_callback; return pos->create_callback;
Show All 32 Lines
} }
static PlatformInstances &GetPlatformInstances() { static PlatformInstances &GetPlatformInstances() {
static PlatformInstances g_platform_instances; static PlatformInstances g_platform_instances;
return g_platform_instances; return g_platform_instances;
} }
bool PluginManager::RegisterPlugin( bool PluginManager::RegisterPlugin(
const ConstString &name, const char *description, ConstString name, const char *description,
PlatformCreateInstance create_callback, PlatformCreateInstance create_callback,
DebuggerInitializeCallback debugger_init_callback) { DebuggerInitializeCallback debugger_init_callback) {
if (create_callback) { if (create_callback) {
std::lock_guard<std::recursive_mutex> guard(GetPlatformInstancesMutex()); std::lock_guard<std::recursive_mutex> guard(GetPlatformInstancesMutex());
PlatformInstance instance; PlatformInstance instance;
assert((bool)name); assert((bool)name);
instance.name = name; instance.name = name;
Show All 32 Lines
std::lock_guard<std::recursive_mutex> guard(GetPlatformInstancesMutex()); std::lock_guard<std::recursive_mutex> guard(GetPlatformInstancesMutex());
PlatformInstances &instances = GetPlatformInstances(); PlatformInstances &instances = GetPlatformInstances();
if (idx < instances.size()) if (idx < instances.size())
return instances[idx].create_callback; return instances[idx].create_callback;
return nullptr; return nullptr;
} }
PlatformCreateInstance PlatformCreateInstance
PluginManager::GetPlatformCreateCallbackForPluginName(const ConstString &name) { PluginManager::GetPlatformCreateCallbackForPluginName(ConstString name) {
if (name) { if (name) {
std::lock_guard<std::recursive_mutex> guard(GetPlatformInstancesMutex()); std::lock_guard<std::recursive_mutex> guard(GetPlatformInstancesMutex());
PlatformInstances &instances = GetPlatformInstances(); PlatformInstances &instances = GetPlatformInstances();
PlatformInstances::iterator pos, end = instances.end(); PlatformInstances::iterator pos, end = instances.end();
for (pos = instances.begin(); pos != end; ++pos) { for (pos = instances.begin(); pos != end; ++pos) {
if (name == pos->name) if (name == pos->name)
return pos->create_callback; return pos->create_callback;
Show All 32 Lines
} }
static ProcessInstances &GetProcessInstances() { static ProcessInstances &GetProcessInstances() {
static ProcessInstances g_instances; static ProcessInstances g_instances;
return g_instances; return g_instances;
} }
bool PluginManager::RegisterPlugin( bool PluginManager::RegisterPlugin(
const ConstString &name, const char *description, ConstString name, const char *description,
ProcessCreateInstance create_callback, ProcessCreateInstance create_callback,
DebuggerInitializeCallback debugger_init_callback) { DebuggerInitializeCallback debugger_init_callback) {
if (create_callback) { if (create_callback) {
ProcessInstance instance; ProcessInstance instance;
assert((bool)name); assert((bool)name);
instance.name = name; instance.name = name;
if (description && description[0]) if (description && description[0])
instance.description = description; instance.description = description;
Show All 32 Lines
std::lock_guard<std::recursive_mutex> guard(GetProcessMutex()); std::lock_guard<std::recursive_mutex> guard(GetProcessMutex());
ProcessInstances &instances = GetProcessInstances(); ProcessInstances &instances = GetProcessInstances();
if (idx < instances.size()) if (idx < instances.size())
return instances[idx].create_callback; return instances[idx].create_callback;
return nullptr; return nullptr;
} }
ProcessCreateInstance ProcessCreateInstance
PluginManager::GetProcessCreateCallbackForPluginName(const ConstString &name) { PluginManager::GetProcessCreateCallbackForPluginName(ConstString name) {
if (name) { if (name) {
std::lock_guard<std::recursive_mutex> guard(GetProcessMutex()); std::lock_guard<std::recursive_mutex> guard(GetProcessMutex());
ProcessInstances &instances = GetProcessInstances(); ProcessInstances &instances = GetProcessInstances();
ProcessInstances::iterator pos, end = instances.end(); ProcessInstances::iterator pos, end = instances.end();
for (pos = instances.begin(); pos != end; ++pos) { for (pos = instances.begin(); pos != end; ++pos) {
if (name == pos->name) if (name == pos->name)
return pos->create_callback; return pos->create_callback;
Show All 23 Lines
} }
static ScriptInterpreterInstances &GetScriptInterpreterInstances() { static ScriptInterpreterInstances &GetScriptInterpreterInstances() {
static ScriptInterpreterInstances g_instances; static ScriptInterpreterInstances g_instances;
return g_instances; return g_instances;
} }
bool PluginManager::RegisterPlugin( bool PluginManager::RegisterPlugin(
const ConstString &name, const char *description, ConstString name, const char *description,
lldb::ScriptLanguage script_language, lldb::ScriptLanguage script_language,
ScriptInterpreterCreateInstance create_callback) { ScriptInterpreterCreateInstance create_callback) {
if (!create_callback) if (!create_callback)
return false; return false;
ScriptInterpreterInstance instance; ScriptInterpreterInstance instance;
assert((bool)name); assert((bool)name);
instance.name = name; instance.name = name;
if (description && description[0]) if (description && description[0])
Show All 32 Lines
} }
static StructuredDataPluginInstances &GetStructuredDataPluginInstances() { static StructuredDataPluginInstances &GetStructuredDataPluginInstances() {
static StructuredDataPluginInstances g_instances; static StructuredDataPluginInstances g_instances;
return g_instances; return g_instances;
} }
bool PluginManager::RegisterPlugin( bool PluginManager::RegisterPlugin(
const ConstString &name, const char *description, ConstString name, const char *description,
StructuredDataPluginCreateInstance create_callback, StructuredDataPluginCreateInstance create_callback,
DebuggerInitializeCallback debugger_init_callback, DebuggerInitializeCallback debugger_init_callback,
StructuredDataFilterLaunchInfo filter_callback) { StructuredDataFilterLaunchInfo filter_callback) {
if (create_callback) { if (create_callback) {
StructuredDataPluginInstance instance; StructuredDataPluginInstance instance;
assert((bool)name); assert((bool)name);
instance.name = name; instance.name = name;
if (description && description[0]) if (description && description[0])
Show All 31 Lines
StructuredDataPluginInstances &instances = GetStructuredDataPluginInstances(); StructuredDataPluginInstances &instances = GetStructuredDataPluginInstances();
if (idx < instances.size()) if (idx < instances.size())
return instances[idx].create_callback; return instances[idx].create_callback;
return nullptr; return nullptr;
} }
StructuredDataPluginCreateInstance StructuredDataPluginCreateInstance
PluginManager::GetStructuredDataPluginCreateCallbackForPluginName( PluginManager::GetStructuredDataPluginCreateCallbackForPluginName(
const ConstString &name) { ConstString name) {
if (name) { if (name) {
std::lock_guard<std::recursive_mutex> guard(GetStructuredDataPluginMutex()); std::lock_guard<std::recursive_mutex> guard(GetStructuredDataPluginMutex());
StructuredDataPluginInstances &instances = StructuredDataPluginInstances &instances =
GetStructuredDataPluginInstances(); GetStructuredDataPluginInstances();
StructuredDataPluginInstances::iterator pos, end = instances.end(); StructuredDataPluginInstances::iterator pos, end = instances.end();
for (pos = instances.begin(); pos != end; ++pos) { for (pos = instances.begin(); pos != end; ++pos) {
if (name == pos->name) if (name == pos->name)
Show All 32 Lines
} }
static SymbolFileInstances &GetSymbolFileInstances() { static SymbolFileInstances &GetSymbolFileInstances() {
static SymbolFileInstances g_instances; static SymbolFileInstances g_instances;
return g_instances; return g_instances;
} }
bool PluginManager::RegisterPlugin( bool PluginManager::RegisterPlugin(
const ConstString &name, const char *description, ConstString name, const char *description,
SymbolFileCreateInstance create_callback, SymbolFileCreateInstance create_callback,
DebuggerInitializeCallback debugger_init_callback) { DebuggerInitializeCallback debugger_init_callback) {
if (create_callback) { if (create_callback) {
SymbolFileInstance instance; SymbolFileInstance instance;
assert((bool)name); assert((bool)name);
instance.name = name; instance.name = name;
if (description && description[0]) if (description && description[0])
instance.description = description; instance.description = description;
Show All 27 Lines
SymbolFileInstances &instances = GetSymbolFileInstances(); SymbolFileInstances &instances = GetSymbolFileInstances();
if (idx < instances.size()) if (idx < instances.size())
return instances[idx].create_callback; return instances[idx].create_callback;
return nullptr; return nullptr;
} }
SymbolFileCreateInstance SymbolFileCreateInstance
PluginManager::GetSymbolFileCreateCallbackForPluginName( PluginManager::GetSymbolFileCreateCallbackForPluginName(
const ConstString &name) { ConstString name) {
if (name) { if (name) {
std::lock_guard<std::recursive_mutex> guard(GetSymbolFileMutex()); std::lock_guard<std::recursive_mutex> guard(GetSymbolFileMutex());
SymbolFileInstances &instances = GetSymbolFileInstances(); SymbolFileInstances &instances = GetSymbolFileInstances();
SymbolFileInstances::iterator pos, end = instances.end(); SymbolFileInstances::iterator pos, end = instances.end();
for (pos = instances.begin(); pos != end; ++pos) { for (pos = instances.begin(); pos != end; ++pos) {
if (name == pos->name) if (name == pos->name)
return pos->create_callback; return pos->create_callback;
Show All 19 Lines
return g_instances_mutex; return g_instances_mutex;
} }
static SymbolVendorInstances &GetSymbolVendorInstances() { static SymbolVendorInstances &GetSymbolVendorInstances() {
static SymbolVendorInstances g_instances; static SymbolVendorInstances g_instances;
return g_instances; return g_instances;
} }
bool PluginManager::RegisterPlugin(const ConstString &name, bool PluginManager::RegisterPlugin(ConstString name,
const char *description, const char *description,
SymbolVendorCreateInstance create_callback) { SymbolVendorCreateInstance create_callback) {
if (create_callback) { if (create_callback) {
SymbolVendorInstance instance; SymbolVendorInstance instance;
assert((bool)name); assert((bool)name);
instance.name = name; instance.name = name;
if (description && description[0]) if (description && description[0])
instance.description = description; instance.description = description;
Show All 27 Lines
SymbolVendorInstances &instances = GetSymbolVendorInstances(); SymbolVendorInstances &instances = GetSymbolVendorInstances();
if (idx < instances.size()) if (idx < instances.size())
return instances[idx].create_callback; return instances[idx].create_callback;
return nullptr; return nullptr;
} }
SymbolVendorCreateInstance SymbolVendorCreateInstance
PluginManager::GetSymbolVendorCreateCallbackForPluginName( PluginManager::GetSymbolVendorCreateCallbackForPluginName(
const ConstString &name) { ConstString name) {
if (name) { if (name) {
std::lock_guard<std::recursive_mutex> guard(GetSymbolVendorMutex()); std::lock_guard<std::recursive_mutex> guard(GetSymbolVendorMutex());
SymbolVendorInstances &instances = GetSymbolVendorInstances(); SymbolVendorInstances &instances = GetSymbolVendorInstances();
SymbolVendorInstances::iterator pos, end = instances.end(); SymbolVendorInstances::iterator pos, end = instances.end();
for (pos = instances.begin(); pos != end; ++pos) { for (pos = instances.begin(); pos != end; ++pos) {
if (name == pos->name) if (name == pos->name)
return pos->create_callback; return pos->create_callback;
Show All 20 Lines
} }
static UnwindAssemblyInstances &GetUnwindAssemblyInstances() { static UnwindAssemblyInstances &GetUnwindAssemblyInstances() {
static UnwindAssemblyInstances g_instances; static UnwindAssemblyInstances g_instances;
return g_instances; return g_instances;
} }
bool PluginManager::RegisterPlugin( bool PluginManager::RegisterPlugin(
const ConstString &name, const char *description, ConstString name, const char *description,
UnwindAssemblyCreateInstance create_callback) { UnwindAssemblyCreateInstance create_callback) {
if (create_callback) { if (create_callback) {
UnwindAssemblyInstance instance; UnwindAssemblyInstance instance;
assert((bool)name); assert((bool)name);
instance.name = name; instance.name = name;
if (description && description[0]) if (description && description[0])
instance.description = description; instance.description = description;
instance.create_callback = create_callback; instance.create_callback = create_callback;
Show All 26 Lines
UnwindAssemblyInstances &instances = GetUnwindAssemblyInstances(); UnwindAssemblyInstances &instances = GetUnwindAssemblyInstances();
if (idx < instances.size()) if (idx < instances.size())
return instances[idx].create_callback; return instances[idx].create_callback;
return nullptr; return nullptr;
} }
UnwindAssemblyCreateInstance UnwindAssemblyCreateInstance
PluginManager::GetUnwindAssemblyCreateCallbackForPluginName( PluginManager::GetUnwindAssemblyCreateCallbackForPluginName(
const ConstString &name) { ConstString name) {
if (name) { if (name) {
std::lock_guard<std::recursive_mutex> guard(GetUnwindAssemblyMutex()); std::lock_guard<std::recursive_mutex> guard(GetUnwindAssemblyMutex());
UnwindAssemblyInstances &instances = GetUnwindAssemblyInstances(); UnwindAssemblyInstances &instances = GetUnwindAssemblyInstances();
UnwindAssemblyInstances::iterator pos, end = instances.end(); UnwindAssemblyInstances::iterator pos, end = instances.end();
for (pos = instances.begin(); pos != end; ++pos) { for (pos = instances.begin(); pos != end; ++pos) {
if (name == pos->name) if (name == pos->name)
return pos->create_callback; return pos->create_callback;
Show All 20 Lines
} }
static MemoryHistoryInstances &GetMemoryHistoryInstances() { static MemoryHistoryInstances &GetMemoryHistoryInstances() {
static MemoryHistoryInstances g_instances; static MemoryHistoryInstances g_instances;
return g_instances; return g_instances;
} }
bool PluginManager::RegisterPlugin( bool PluginManager::RegisterPlugin(
const ConstString &name, const char *description, ConstString name, const char *description,
MemoryHistoryCreateInstance create_callback) { MemoryHistoryCreateInstance create_callback) {
if (create_callback) { if (create_callback) {
MemoryHistoryInstance instance; MemoryHistoryInstance instance;
assert((bool)name); assert((bool)name);
instance.name = name; instance.name = name;
if (description && description[0]) if (description && description[0])
instance.description = description; instance.description = description;
instance.create_callback = create_callback; instance.create_callback = create_callback;
Show All 26 Lines
MemoryHistoryInstances &instances = GetMemoryHistoryInstances(); MemoryHistoryInstances &instances = GetMemoryHistoryInstances();
if (idx < instances.size()) if (idx < instances.size())
return instances[idx].create_callback; return instances[idx].create_callback;
return nullptr; return nullptr;
} }
MemoryHistoryCreateInstance MemoryHistoryCreateInstance
PluginManager::GetMemoryHistoryCreateCallbackForPluginName( PluginManager::GetMemoryHistoryCreateCallbackForPluginName(
const ConstString &name) { ConstString name) {
if (name) { if (name) {
std::lock_guard<std::recursive_mutex> guard(GetMemoryHistoryMutex()); std::lock_guard<std::recursive_mutex> guard(GetMemoryHistoryMutex());
MemoryHistoryInstances &instances = GetMemoryHistoryInstances(); MemoryHistoryInstances &instances = GetMemoryHistoryInstances();
MemoryHistoryInstances::iterator pos, end = instances.end(); MemoryHistoryInstances::iterator pos, end = instances.end();
for (pos = instances.begin(); pos != end; ++pos) { for (pos = instances.begin(); pos != end; ++pos) {
if (name == pos->name) if (name == pos->name)
return pos->create_callback; return pos->create_callback;
Show All 23 Lines
} }
static InstrumentationRuntimeInstances &GetInstrumentationRuntimeInstances() { static InstrumentationRuntimeInstances &GetInstrumentationRuntimeInstances() {
static InstrumentationRuntimeInstances g_instances; static InstrumentationRuntimeInstances g_instances;
return g_instances; return g_instances;
} }
bool PluginManager::RegisterPlugin( bool PluginManager::RegisterPlugin(
const ConstString &name, const char *description, ConstString name, const char *description,
InstrumentationRuntimeCreateInstance create_callback, InstrumentationRuntimeCreateInstance create_callback,
InstrumentationRuntimeGetType get_type_callback) { InstrumentationRuntimeGetType get_type_callback) {
if (create_callback) { if (create_callback) {
InstrumentationRuntimeInstance instance; InstrumentationRuntimeInstance instance;
assert((bool)name); assert((bool)name);
instance.name = name; instance.name = name;
if (description && description[0]) if (description && description[0])
instance.description = description; instance.description = description;
Show All 32 Lines
GetInstrumentationRuntimeInstances(); GetInstrumentationRuntimeInstances();
if (idx < instances.size()) if (idx < instances.size())
return instances[idx].create_callback; return instances[idx].create_callback;
return nullptr; return nullptr;
} }
InstrumentationRuntimeCreateInstance InstrumentationRuntimeCreateInstance
PluginManager::GetInstrumentationRuntimeCreateCallbackForPluginName( PluginManager::GetInstrumentationRuntimeCreateCallbackForPluginName(
const ConstString &name) { ConstString name) {
if (name) { if (name) {
std::lock_guard<std::recursive_mutex> guard( std::lock_guard<std::recursive_mutex> guard(
GetInstrumentationRuntimeMutex()); GetInstrumentationRuntimeMutex());
InstrumentationRuntimeInstances &instances = InstrumentationRuntimeInstances &instances =
GetInstrumentationRuntimeInstances(); GetInstrumentationRuntimeInstances();
InstrumentationRuntimeInstances::iterator pos, end = instances.end(); InstrumentationRuntimeInstances::iterator pos, end = instances.end();
for (pos = instances.begin(); pos != end; ++pos) { for (pos = instances.begin(); pos != end; ++pos) {
Show All 22 Lines
return g_instances_mutex; return g_instances_mutex;
} }
static TypeSystemInstances &GetTypeSystemInstances() { static TypeSystemInstances &GetTypeSystemInstances() {
static TypeSystemInstances g_instances; static TypeSystemInstances g_instances;
return g_instances; return g_instances;
} }
bool PluginManager::RegisterPlugin(const ConstString &name, bool PluginManager::RegisterPlugin(ConstString name,
const char *description, const char *description,
TypeSystemCreateInstance create_callback, TypeSystemCreateInstance create_callback,
TypeSystemEnumerateSupportedLanguages TypeSystemEnumerateSupportedLanguages
enumerate_supported_languages_callback) { enumerate_supported_languages_callback) {
if (create_callback) { if (create_callback) {
TypeSystemInstance instance; TypeSystemInstance instance;
assert((bool)name); assert((bool)name);
instance.name = name; instance.name = name;
Show All 29 Lines
TypeSystemInstances &instances = GetTypeSystemInstances(); TypeSystemInstances &instances = GetTypeSystemInstances();
if (idx < instances.size()) if (idx < instances.size())
return instances[idx].create_callback; return instances[idx].create_callback;
return nullptr; return nullptr;
} }
TypeSystemCreateInstance TypeSystemCreateInstance
PluginManager::GetTypeSystemCreateCallbackForPluginName( PluginManager::GetTypeSystemCreateCallbackForPluginName(
const ConstString &name) { ConstString name) {
if (name) { if (name) {
std::lock_guard<std::recursive_mutex> guard(GetTypeSystemMutex()); std::lock_guard<std::recursive_mutex> guard(GetTypeSystemMutex());
TypeSystemInstances &instances = GetTypeSystemInstances(); TypeSystemInstances &instances = GetTypeSystemInstances();
TypeSystemInstances::iterator pos, end = instances.end(); TypeSystemInstances::iterator pos, end = instances.end();
for (pos = instances.begin(); pos != end; ++pos) { for (pos = instances.begin(); pos != end; ++pos) {
if (name == pos->name) if (name == pos->name)
return pos->create_callback; return pos->create_callback;
Show All 9 Lines
TypeSystemInstances &instances = GetTypeSystemInstances(); TypeSystemInstances &instances = GetTypeSystemInstances();
if (idx < instances.size()) if (idx < instances.size())
return instances[idx].enumerate_callback; return instances[idx].enumerate_callback;
return nullptr; return nullptr;
} }
TypeSystemEnumerateSupportedLanguages TypeSystemEnumerateSupportedLanguages
PluginManager::GetTypeSystemEnumerateSupportedLanguagesCallbackForPluginName( PluginManager::GetTypeSystemEnumerateSupportedLanguagesCallbackForPluginName(
const ConstString &name) { ConstString name) {
if (name) { if (name) {
std::lock_guard<std::recursive_mutex> guard(GetTypeSystemMutex()); std::lock_guard<std::recursive_mutex> guard(GetTypeSystemMutex());
TypeSystemInstances &instances = GetTypeSystemInstances(); TypeSystemInstances &instances = GetTypeSystemInstances();
TypeSystemInstances::iterator pos, end = instances.end(); TypeSystemInstances::iterator pos, end = instances.end();
for (pos = instances.begin(); pos != end; ++pos) { for (pos = instances.begin(); pos != end; ++pos) {
if (name == pos->name) if (name == pos->name)
return pos->enumerate_callback; return pos->enumerate_callback;
Show All 21 Lines
} }
static REPLInstances &GetREPLInstances() { static REPLInstances &GetREPLInstances() {
static REPLInstances g_instances; static REPLInstances g_instances;
return g_instances; return g_instances;
} }
bool PluginManager::RegisterPlugin( bool PluginManager::RegisterPlugin(
const ConstString &name, const char *description, ConstString name, const char *description,
REPLCreateInstance create_callback, REPLCreateInstance create_callback,
REPLEnumerateSupportedLanguages enumerate_languages_callback) { REPLEnumerateSupportedLanguages enumerate_languages_callback) {
if (create_callback) { if (create_callback) {
REPLInstance instance; REPLInstance instance;
assert((bool)name); assert((bool)name);
instance.name = name; instance.name = name;
if (description && description[0]) if (description && description[0])
instance.description = description; instance.description = description;
Show All 25 Lines
std::lock_guard<std::recursive_mutex> guard(GetREPLMutex()); std::lock_guard<std::recursive_mutex> guard(GetREPLMutex());
REPLInstances &instances = GetREPLInstances(); REPLInstances &instances = GetREPLInstances();
if (idx < instances.size()) if (idx < instances.size())
return instances[idx].create_callback; return instances[idx].create_callback;
return nullptr; return nullptr;
} }
REPLCreateInstance REPLCreateInstance
PluginManager::GetREPLCreateCallbackForPluginName(const ConstString &name) { PluginManager::GetREPLCreateCallbackForPluginName(ConstString name) {
if (name) { if (name) {
std::lock_guard<std::recursive_mutex> guard(GetREPLMutex()); std::lock_guard<std::recursive_mutex> guard(GetREPLMutex());
REPLInstances &instances = GetREPLInstances(); REPLInstances &instances = GetREPLInstances();
REPLInstances::iterator pos, end = instances.end(); REPLInstances::iterator pos, end = instances.end();
for (pos = instances.begin(); pos != end; ++pos) { for (pos = instances.begin(); pos != end; ++pos) {
if (name == pos->name) if (name == pos->name)
return pos->create_callback; return pos->create_callback;
} }
} }
return nullptr; return nullptr;
} }
REPLEnumerateSupportedLanguages REPLEnumerateSupportedLanguages
PluginManager::GetREPLEnumerateSupportedLanguagesCallbackAtIndex(uint32_t idx) { PluginManager::GetREPLEnumerateSupportedLanguagesCallbackAtIndex(uint32_t idx) {
std::lock_guard<std::recursive_mutex> guard(GetREPLMutex()); std::lock_guard<std::recursive_mutex> guard(GetREPLMutex());
REPLInstances &instances = GetREPLInstances(); REPLInstances &instances = GetREPLInstances();
if (idx < instances.size()) if (idx < instances.size())
return instances[idx].enumerate_languages_callback; return instances[idx].enumerate_languages_callback;
return nullptr; return nullptr;
} }
REPLEnumerateSupportedLanguages REPLEnumerateSupportedLanguages
PluginManager::GetREPLSystemEnumerateSupportedLanguagesCallbackForPluginName( PluginManager::GetREPLSystemEnumerateSupportedLanguagesCallbackForPluginName(
const ConstString &name) { ConstString name) {
if (name) { if (name) {
std::lock_guard<std::recursive_mutex> guard(GetREPLMutex()); std::lock_guard<std::recursive_mutex> guard(GetREPLMutex());
REPLInstances &instances = GetREPLInstances(); REPLInstances &instances = GetREPLInstances();
REPLInstances::iterator pos, end = instances.end(); REPLInstances::iterator pos, end = instances.end();
for (pos = instances.begin(); pos != end; ++pos) { for (pos = instances.begin(); pos != end; ++pos) {
if (name == pos->name) if (name == pos->name)
return pos->enumerate_languages_callback; return pos->enumerate_languages_callback;
Show All 32 Lines
} }
} }
} }
// This is the preferred new way to register plugin specific settings. e.g. // This is the preferred new way to register plugin specific settings. e.g.
// This will put a plugin's settings under e.g. // This will put a plugin's settings under e.g.
// "plugin.<plugin_type_name>.<plugin_type_desc>.SETTINGNAME". // "plugin.<plugin_type_name>.<plugin_type_desc>.SETTINGNAME".
static lldb::OptionValuePropertiesSP GetDebuggerPropertyForPlugins( static lldb::OptionValuePropertiesSP GetDebuggerPropertyForPlugins(
Debugger &debugger, const ConstString &plugin_type_name, Debugger &debugger, ConstString plugin_type_name,
const ConstString &plugin_type_desc, bool can_create) { ConstString plugin_type_desc, bool can_create) {
lldb::OptionValuePropertiesSP parent_properties_sp( lldb::OptionValuePropertiesSP parent_properties_sp(
debugger.GetValueProperties()); debugger.GetValueProperties());
if (parent_properties_sp) { if (parent_properties_sp) {
static ConstString g_property_name("plugin"); static ConstString g_property_name("plugin");
OptionValuePropertiesSP plugin_properties_sp = OptionValuePropertiesSP plugin_properties_sp =
parent_properties_sp->GetSubProperty(nullptr, g_property_name); parent_properties_sp->GetSubProperty(nullptr, g_property_name);
if (!plugin_properties_sp && can_create) { if (!plugin_properties_sp && can_create) {
Show All 18 Lines
} }
return lldb::OptionValuePropertiesSP(); return lldb::OptionValuePropertiesSP();
} }
// This is deprecated way to register plugin specific settings. e.g. // This is deprecated way to register plugin specific settings. e.g.
// "<plugin_type_name>.plugin.<plugin_type_desc>.SETTINGNAME" and Platform // "<plugin_type_name>.plugin.<plugin_type_desc>.SETTINGNAME" and Platform
// generic settings would be under "platform.SETTINGNAME". // generic settings would be under "platform.SETTINGNAME".
static lldb::OptionValuePropertiesSP GetDebuggerPropertyForPluginsOldStyle( static lldb::OptionValuePropertiesSP GetDebuggerPropertyForPluginsOldStyle(
Debugger &debugger, const ConstString &plugin_type_name, Debugger &debugger, ConstString plugin_type_name,
const ConstString &plugin_type_desc, bool can_create) { ConstString plugin_type_desc, bool can_create) {
static ConstString g_property_name("plugin"); static ConstString g_property_name("plugin");
lldb::OptionValuePropertiesSP parent_properties_sp( lldb::OptionValuePropertiesSP parent_properties_sp(
debugger.GetValueProperties()); debugger.GetValueProperties());
if (parent_properties_sp) { if (parent_properties_sp) {
OptionValuePropertiesSP plugin_properties_sp = OptionValuePropertiesSP plugin_properties_sp =
parent_properties_sp->GetSubProperty(nullptr, plugin_type_name); parent_properties_sp->GetSubProperty(nullptr, plugin_type_name);
if (!plugin_properties_sp && can_create) { if (!plugin_properties_sp && can_create) {
plugin_properties_sp = plugin_properties_sp =
Show All 16 Lines
} }
} }
return lldb::OptionValuePropertiesSP(); return lldb::OptionValuePropertiesSP();
} }
namespace { namespace {
typedef lldb::OptionValuePropertiesSP typedef lldb::OptionValuePropertiesSP
GetDebuggerPropertyForPluginsPtr(Debugger &, const ConstString &, GetDebuggerPropertyForPluginsPtr(Debugger &, ConstString ,
const ConstString &, bool can_create); ConstString , bool can_create);
lldb::OptionValuePropertiesSP lldb::OptionValuePropertiesSP
GetSettingForPlugin(Debugger &debugger, const ConstString &setting_name, GetSettingForPlugin(Debugger &debugger, ConstString setting_name,
const ConstString &plugin_type_name, ConstString plugin_type_name,
GetDebuggerPropertyForPluginsPtr get_debugger_property = GetDebuggerPropertyForPluginsPtr get_debugger_property =
GetDebuggerPropertyForPlugins) { GetDebuggerPropertyForPlugins) {
lldb::OptionValuePropertiesSP properties_sp; lldb::OptionValuePropertiesSP properties_sp;
lldb::OptionValuePropertiesSP plugin_type_properties_sp(get_debugger_property( lldb::OptionValuePropertiesSP plugin_type_properties_sp(get_debugger_property(
debugger, plugin_type_name, debugger, plugin_type_name,
ConstString(), // not creating to so we don't need the description ConstString(), // not creating to so we don't need the description
false)); false));
if (plugin_type_properties_sp) if (plugin_type_properties_sp)
properties_sp = properties_sp =
plugin_type_properties_sp->GetSubProperty(nullptr, setting_name); plugin_type_properties_sp->GetSubProperty(nullptr, setting_name);
return properties_sp; return properties_sp;
} }
bool CreateSettingForPlugin( bool CreateSettingForPlugin(
Debugger &debugger, const ConstString &plugin_type_name, Debugger &debugger, ConstString plugin_type_name,
const ConstString &plugin_type_desc, ConstString plugin_type_desc,
const lldb::OptionValuePropertiesSP &properties_sp, const lldb::OptionValuePropertiesSP &properties_sp,
const ConstString &description, bool is_global_property, ConstString description, bool is_global_property,
GetDebuggerPropertyForPluginsPtr get_debugger_property = GetDebuggerPropertyForPluginsPtr get_debugger_property =
GetDebuggerPropertyForPlugins) { GetDebuggerPropertyForPlugins) {
if (properties_sp) { if (properties_sp) {
lldb::OptionValuePropertiesSP plugin_type_properties_sp( lldb::OptionValuePropertiesSP plugin_type_properties_sp(
get_debugger_property(debugger, plugin_type_name, plugin_type_desc, get_debugger_property(debugger, plugin_type_name, plugin_type_desc,
true)); true));
if (plugin_type_properties_sp) { if (plugin_type_properties_sp) {
plugin_type_properties_sp->AppendProperty(properties_sp->GetName(), plugin_type_properties_sp->AppendProperty(properties_sp->GetName(),
Show All 10 Lines
const char *kProcessPluginName("process"); const char *kProcessPluginName("process");
const char *kSymbolFilePluginName("symbol-file"); const char *kSymbolFilePluginName("symbol-file");
const char *kJITLoaderPluginName("jit-loader"); const char *kJITLoaderPluginName("jit-loader");
const char *kStructuredDataPluginName("structured-data"); const char *kStructuredDataPluginName("structured-data");
} // anonymous namespace } // anonymous namespace
lldb::OptionValuePropertiesSP PluginManager::GetSettingForDynamicLoaderPlugin( lldb::OptionValuePropertiesSP PluginManager::GetSettingForDynamicLoaderPlugin(
Debugger &debugger, const ConstString &setting_name) { Debugger &debugger, ConstString setting_name) {
return GetSettingForPlugin(debugger, setting_name, return GetSettingForPlugin(debugger, setting_name,
ConstString(kDynamicLoaderPluginName)); ConstString(kDynamicLoaderPluginName));
} }
bool PluginManager::CreateSettingForDynamicLoaderPlugin( bool PluginManager::CreateSettingForDynamicLoaderPlugin(
Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp, Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
const ConstString &description, bool is_global_property) { ConstString description, bool is_global_property) {
return CreateSettingForPlugin( return CreateSettingForPlugin(
debugger, ConstString(kDynamicLoaderPluginName), debugger, ConstString(kDynamicLoaderPluginName),
ConstString("Settings for dynamic loader plug-ins"), properties_sp, ConstString("Settings for dynamic loader plug-ins"), properties_sp,
description, is_global_property); description, is_global_property);
} }
lldb::OptionValuePropertiesSP lldb::OptionValuePropertiesSP
PluginManager::GetSettingForPlatformPlugin(Debugger &debugger, PluginManager::GetSettingForPlatformPlugin(Debugger &debugger,
const ConstString &setting_name) { ConstString setting_name) {
return GetSettingForPlugin(debugger, setting_name, return GetSettingForPlugin(debugger, setting_name,
ConstString(kPlatformPluginName), ConstString(kPlatformPluginName),
GetDebuggerPropertyForPluginsOldStyle); GetDebuggerPropertyForPluginsOldStyle);
} }
bool PluginManager::CreateSettingForPlatformPlugin( bool PluginManager::CreateSettingForPlatformPlugin(
Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp, Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
const ConstString &description, bool is_global_property) { ConstString description, bool is_global_property) {
return CreateSettingForPlugin(debugger, ConstString(kPlatformPluginName), return CreateSettingForPlugin(debugger, ConstString(kPlatformPluginName),
ConstString("Settings for platform plug-ins"), ConstString("Settings for platform plug-ins"),
properties_sp, description, is_global_property, properties_sp, description, is_global_property,
GetDebuggerPropertyForPluginsOldStyle); GetDebuggerPropertyForPluginsOldStyle);
} }
lldb::OptionValuePropertiesSP lldb::OptionValuePropertiesSP
PluginManager::GetSettingForProcessPlugin(Debugger &debugger, PluginManager::GetSettingForProcessPlugin(Debugger &debugger,
const ConstString &setting_name) { ConstString setting_name) {
return GetSettingForPlugin(debugger, setting_name, return GetSettingForPlugin(debugger, setting_name,
ConstString(kProcessPluginName)); ConstString(kProcessPluginName));
} }
bool PluginManager::CreateSettingForProcessPlugin( bool PluginManager::CreateSettingForProcessPlugin(
Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp, Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
const ConstString &description, bool is_global_property) { ConstString description, bool is_global_property) {
return CreateSettingForPlugin(debugger, ConstString(kProcessPluginName), return CreateSettingForPlugin(debugger, ConstString(kProcessPluginName),
ConstString("Settings for process plug-ins"), ConstString("Settings for process plug-ins"),
properties_sp, description, is_global_property); properties_sp, description, is_global_property);
} }
lldb::OptionValuePropertiesSP lldb::OptionValuePropertiesSP
PluginManager::GetSettingForSymbolFilePlugin(Debugger &debugger, PluginManager::GetSettingForSymbolFilePlugin(Debugger &debugger,
const ConstString &setting_name) { ConstString setting_name) {
return GetSettingForPlugin(debugger, setting_name, return GetSettingForPlugin(debugger, setting_name,
ConstString(kSymbolFilePluginName)); ConstString(kSymbolFilePluginName));
} }
bool PluginManager::CreateSettingForSymbolFilePlugin( bool PluginManager::CreateSettingForSymbolFilePlugin(
Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp, Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
const ConstString &description, bool is_global_property) { ConstString description, bool is_global_property) {
return CreateSettingForPlugin( return CreateSettingForPlugin(
debugger, ConstString(kSymbolFilePluginName), debugger, ConstString(kSymbolFilePluginName),
ConstString("Settings for symbol file plug-ins"), properties_sp, ConstString("Settings for symbol file plug-ins"), properties_sp,
description, is_global_property); description, is_global_property);
} }
lldb::OptionValuePropertiesSP lldb::OptionValuePropertiesSP
PluginManager::GetSettingForJITLoaderPlugin(Debugger &debugger, PluginManager::GetSettingForJITLoaderPlugin(Debugger &debugger,
const ConstString &setting_name) { ConstString setting_name) {
return GetSettingForPlugin(debugger, setting_name, return GetSettingForPlugin(debugger, setting_name,
ConstString(kJITLoaderPluginName)); ConstString(kJITLoaderPluginName));
} }
bool PluginManager::CreateSettingForJITLoaderPlugin( bool PluginManager::CreateSettingForJITLoaderPlugin(
Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp, Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
const ConstString &description, bool is_global_property) { ConstString description, bool is_global_property) {
return CreateSettingForPlugin(debugger, ConstString(kJITLoaderPluginName), return CreateSettingForPlugin(debugger, ConstString(kJITLoaderPluginName),
ConstString("Settings for JIT loader plug-ins"), ConstString("Settings for JIT loader plug-ins"),
properties_sp, description, is_global_property); properties_sp, description, is_global_property);
} }
static const char *kOperatingSystemPluginName("os"); static const char *kOperatingSystemPluginName("os");
lldb::OptionValuePropertiesSP PluginManager::GetSettingForOperatingSystemPlugin( lldb::OptionValuePropertiesSP PluginManager::GetSettingForOperatingSystemPlugin(
Debugger &debugger, const ConstString &setting_name) { Debugger &debugger, ConstString setting_name) {
lldb::OptionValuePropertiesSP properties_sp; lldb::OptionValuePropertiesSP properties_sp;
lldb::OptionValuePropertiesSP plugin_type_properties_sp( lldb::OptionValuePropertiesSP plugin_type_properties_sp(
GetDebuggerPropertyForPlugins( GetDebuggerPropertyForPlugins(
debugger, ConstString(kOperatingSystemPluginName), debugger, ConstString(kOperatingSystemPluginName),
ConstString(), // not creating to so we don't need the description ConstString(), // not creating to so we don't need the description
false)); false));
if (plugin_type_properties_sp) if (plugin_type_properties_sp)
properties_sp = properties_sp =
plugin_type_properties_sp->GetSubProperty(nullptr, setting_name); plugin_type_properties_sp->GetSubProperty(nullptr, setting_name);
return properties_sp; return properties_sp;
} }
bool PluginManager::CreateSettingForOperatingSystemPlugin( bool PluginManager::CreateSettingForOperatingSystemPlugin(
Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp, Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
const ConstString &description, bool is_global_property) { ConstString description, bool is_global_property) {
if (properties_sp) { if (properties_sp) {
lldb::OptionValuePropertiesSP plugin_type_properties_sp( lldb::OptionValuePropertiesSP plugin_type_properties_sp(
GetDebuggerPropertyForPlugins( GetDebuggerPropertyForPlugins(
debugger, ConstString(kOperatingSystemPluginName), debugger, ConstString(kOperatingSystemPluginName),
ConstString("Settings for operating system plug-ins"), true)); ConstString("Settings for operating system plug-ins"), true));
if (plugin_type_properties_sp) { if (plugin_type_properties_sp) {
plugin_type_properties_sp->AppendProperty(properties_sp->GetName(), plugin_type_properties_sp->AppendProperty(properties_sp->GetName(),
description, is_global_property, description, is_global_property,
properties_sp); properties_sp);
return true; return true;
} }
} }
return false; return false;
} }
lldb::OptionValuePropertiesSP PluginManager::GetSettingForStructuredDataPlugin( lldb::OptionValuePropertiesSP PluginManager::GetSettingForStructuredDataPlugin(
Debugger &debugger, const ConstString &setting_name) { Debugger &debugger, ConstString setting_name) {
return GetSettingForPlugin(debugger, setting_name, return GetSettingForPlugin(debugger, setting_name,
ConstString(kStructuredDataPluginName)); ConstString(kStructuredDataPluginName));
} }
bool PluginManager::CreateSettingForStructuredDataPlugin( bool PluginManager::CreateSettingForStructuredDataPlugin(
Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp, Debugger &debugger, const lldb::OptionValuePropertiesSP &properties_sp,
const ConstString &description, bool is_global_property) { ConstString description, bool is_global_property) {
return CreateSettingForPlugin( return CreateSettingForPlugin(
debugger, ConstString(kStructuredDataPluginName), debugger, ConstString(kStructuredDataPluginName),
ConstString("Settings for structured data plug-ins"), properties_sp, ConstString("Settings for structured data plug-ins"), properties_sp,
description, is_global_property); description, is_global_property);
} }
Context not available.

lldb/source/Core/RichManglingContext.cpp

Show All 16 Lines
delete get<CPlusPlusLanguage::MethodName>(m_cxx_method_parser); delete get<CPlusPlusLanguage::MethodName>(m_cxx_method_parser);
m_cxx_method_parser.reset(); m_cxx_method_parser.reset();
} }
assert(new_provider != None && "Only reset to a valid provider"); assert(new_provider != None && "Only reset to a valid provider");
m_provider = new_provider; m_provider = new_provider;
} }
bool RichManglingContext::FromItaniumName(const ConstString &mangled) { bool RichManglingContext::FromItaniumName(ConstString mangled) {
bool err = m_ipd.partialDemangle(mangled.GetCString()); bool err = m_ipd.partialDemangle(mangled.GetCString());
if (!err) { if (!err) {
ResetProvider(ItaniumPartialDemangler); ResetProvider(ItaniumPartialDemangler);
} }
if (Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_DEMANGLE)) { if (Log *log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_DEMANGLE)) {
if (!err) { if (!err) {
ParseFullName(); ParseFullName();
LLDB_LOG(log, "demangled itanium: {0} -> \"{1}\"", mangled, m_ipd_buf); LLDB_LOG(log, "demangled itanium: {0} -> \"{1}\"", mangled, m_ipd_buf);
} else { } else {
LLDB_LOG(log, "demangled itanium: {0} -> error: failed to demangle", LLDB_LOG(log, "demangled itanium: {0} -> error: failed to demangle",
mangled); mangled);
} }
} }
return !err; // true == success return !err; // true == success
} }
bool RichManglingContext::FromCxxMethodName(const ConstString &demangled) { bool RichManglingContext::FromCxxMethodName(ConstString demangled) {
ResetProvider(PluginCxxLanguage); ResetProvider(PluginCxxLanguage);
m_cxx_method_parser = new CPlusPlusLanguage::MethodName(demangled); m_cxx_method_parser = new CPlusPlusLanguage::MethodName(demangled);
return true; return true;
} }
bool RichManglingContext::IsCtorOrDtor() const { bool RichManglingContext::IsCtorOrDtor() const {
assert(m_provider != None && "Initialize a provider first"); assert(m_provider != None && "Initialize a provider first");
switch (m_provider) { switch (m_provider) {
Show All 16 Lines

lldb/source/Core/Section.cpp

Show All 16 Lines
return "dwarf-gnu-debugaltlink"; return "dwarf-gnu-debugaltlink";
case eSectionTypeOther: case eSectionTypeOther:
return "regular"; return "regular";
} }
return "unknown"; return "unknown";
} }
Section::Section(const ModuleSP &module_sp, ObjectFile *obj_file, Section::Section(const ModuleSP &module_sp, ObjectFile *obj_file,
user_id_t sect_id, const ConstString &name, user_id_t sect_id, ConstString name,
SectionType sect_type, addr_t file_addr, addr_t byte_size, SectionType sect_type, addr_t file_addr, addr_t byte_size,
lldb::offset_t file_offset, lldb::offset_t file_size, lldb::offset_t file_offset, lldb::offset_t file_size,
uint32_t log2align, uint32_t flags, uint32_t log2align, uint32_t flags,
uint32_t target_byte_size /*=1*/) uint32_t target_byte_size /*=1*/)
: ModuleChild(module_sp), UserID(sect_id), Flags(flags), : ModuleChild(module_sp), UserID(sect_id), Flags(flags),
m_obj_file(obj_file), m_type(sect_type), m_parent_wp(), m_name(name), m_obj_file(obj_file), m_type(sect_type), m_parent_wp(), m_name(name),
m_file_addr(file_addr), m_byte_size(byte_size), m_file_addr(file_addr), m_byte_size(byte_size),
m_file_offset(file_offset), m_file_size(file_size), m_file_offset(file_offset), m_file_size(file_size),
m_log2align(log2align), m_children(), m_fake(false), m_encrypted(false), m_log2align(log2align), m_children(), m_fake(false), m_encrypted(false),
m_thread_specific(false), m_readable(false), m_writable(false), m_thread_specific(false), m_readable(false), m_writable(false),
m_executable(false), m_relocated(false), m_target_byte_size(target_byte_size) { m_executable(false), m_relocated(false), m_target_byte_size(target_byte_size) {
// printf ("Section::Section(%p): module=%p, sect_id = 0x%16.16" PRIx64 ", // printf ("Section::Section(%p): module=%p, sect_id = 0x%16.16" PRIx64 ",
// addr=[0x%16.16" PRIx64 " - 0x%16.16" PRIx64 "), file [0x%16.16" PRIx64 " // addr=[0x%16.16" PRIx64 " - 0x%16.16" PRIx64 "), file [0x%16.16" PRIx64 "
// - 0x%16.16" PRIx64 "), flags = 0x%8.8x, name = %s\n", // - 0x%16.16" PRIx64 "), flags = 0x%8.8x, name = %s\n",
// this, module_sp.get(), sect_id, file_addr, file_addr + // this, module_sp.get(), sect_id, file_addr, file_addr +
// byte_size, file_offset, file_offset + file_size, flags, // byte_size, file_offset, file_offset + file_size, flags,
// name.GetCString()); // name.GetCString());
} }
Section::Section(const lldb::SectionSP &parent_section_sp, Section::Section(const lldb::SectionSP &parent_section_sp,
const ModuleSP &module_sp, ObjectFile *obj_file, const ModuleSP &module_sp, ObjectFile *obj_file,
user_id_t sect_id, const ConstString &name, user_id_t sect_id, ConstString name,
SectionType sect_type, addr_t file_addr, addr_t byte_size, SectionType sect_type, addr_t file_addr, addr_t byte_size,
lldb::offset_t file_offset, lldb::offset_t file_size, lldb::offset_t file_offset, lldb::offset_t file_size,
uint32_t log2align, uint32_t flags, uint32_t log2align, uint32_t flags,
uint32_t target_byte_size /*=1*/) uint32_t target_byte_size /*=1*/)
: ModuleChild(module_sp), UserID(sect_id), Flags(flags), : ModuleChild(module_sp), UserID(sect_id), Flags(flags),
m_obj_file(obj_file), m_type(sect_type), m_parent_wp(), m_name(name), m_obj_file(obj_file), m_type(sect_type), m_parent_wp(), m_name(name),
m_file_addr(file_addr), m_byte_size(byte_size), m_file_addr(file_addr), m_byte_size(byte_size),
m_file_offset(file_offset), m_file_size(file_size), m_file_offset(file_offset), m_file_size(file_size),
Show All 32 Lines
SectionSP SectionList::GetSectionAtIndex(size_t idx) const { SectionSP SectionList::GetSectionAtIndex(size_t idx) const {
SectionSP sect_sp; SectionSP sect_sp;
if (idx < m_sections.size()) if (idx < m_sections.size())
sect_sp = m_sections[idx]; sect_sp = m_sections[idx];
return sect_sp; return sect_sp;
} }
SectionSP SectionSP
SectionList::FindSectionByName(const ConstString &section_dstr) const { SectionList::FindSectionByName(ConstString section_dstr) const {
SectionSP sect_sp; SectionSP sect_sp;
// Check if we have a valid section string // Check if we have a valid section string
if (section_dstr && !m_sections.empty()) { if (section_dstr && !m_sections.empty()) {
const_iterator sect_iter; const_iterator sect_iter;
const_iterator end = m_sections.end(); const_iterator end = m_sections.end();
for (sect_iter = m_sections.begin(); for (sect_iter = m_sections.begin();
sect_iter != end && sect_sp.get() == NULL; ++sect_iter) { sect_iter != end && sect_sp.get() == NULL; ++sect_iter) {
Section *child_section = sect_iter->get(); Section *child_section = sect_iter->get();
Show All 16 Lines

lldb/source/Core/UserSettingsController.cpp

Show All 16 Lines
if (properties_sp) { if (properties_sp) {
properties_sp->Apropos(keyword, matching_properties); properties_sp->Apropos(keyword, matching_properties);
} }
return matching_properties.size(); return matching_properties.size();
} }
lldb::OptionValuePropertiesSP lldb::OptionValuePropertiesSP
Properties::GetSubProperty(const ExecutionContext *exe_ctx, Properties::GetSubProperty(const ExecutionContext *exe_ctx,
const ConstString &name) { ConstString name) {
OptionValuePropertiesSP properties_sp(GetValueProperties()); OptionValuePropertiesSP properties_sp(GetValueProperties());
if (properties_sp) if (properties_sp)
return properties_sp->GetSubProperty(exe_ctx, name); return properties_sp->GetSubProperty(exe_ctx, name);
return lldb::OptionValuePropertiesSP(); return lldb::OptionValuePropertiesSP();
} }
const char *Properties::GetExperimentalSettingsName() { return "experimental"; } const char *Properties::GetExperimentalSettingsName() { return "experimental"; }
bool Properties::IsSettingExperimental(llvm::StringRef setting) { bool Properties::IsSettingExperimental(llvm::StringRef setting) {
if (setting.empty()) if (setting.empty())
return false; return false;
llvm::StringRef experimental = GetExperimentalSettingsName(); llvm::StringRef experimental = GetExperimentalSettingsName();
size_t dot_pos = setting.find_first_of('.'); size_t dot_pos = setting.find_first_of('.');
return setting.take_front(dot_pos) == experimental; return setting.take_front(dot_pos) == experimental;
} }
Context not available.

lldb/source/Core/ValueObject.cpp

Show All 16 Lines
return m_data; return m_data;
} }
const Status &ValueObject::GetError() { const Status &ValueObject::GetError() {
UpdateValueIfNeeded(false); UpdateValueIfNeeded(false);
return m_error; return m_error;
} }
const ConstString &ValueObject::GetName() const { return m_name; } ConstString ValueObject::GetName() const { return m_name; }
const char *ValueObject::GetLocationAsCString() { const char *ValueObject::GetLocationAsCString() {
return GetLocationAsCStringImpl(m_value, m_data); return GetLocationAsCStringImpl(m_value, m_data);
} }
const char *ValueObject::GetLocationAsCStringImpl(const Value &value, const char *ValueObject::GetLocationAsCStringImpl(const Value &value,
const DataExtractor &data) { const DataExtractor &data) {
if (UpdateValueIfNeeded(false)) { if (UpdateValueIfNeeded(false)) {
Show All 32 Lines
if (name_of_error) if (name_of_error)
*name_of_error = name.first; *name_of_error = name.first;
return root; return root;
} }
} }
return root; return root;
} }
size_t ValueObject::GetIndexOfChildWithName(const ConstString &name) { size_t ValueObject::GetIndexOfChildWithName(ConstString name) {
bool omit_empty_base_classes = true; bool omit_empty_base_classes = true;
return GetCompilerType().GetIndexOfChildWithName(name.GetCString(), return GetCompilerType().GetIndexOfChildWithName(name.GetCString(),
omit_empty_base_classes); omit_empty_base_classes);
} }
ValueObjectSP ValueObject::GetChildMemberWithName(const ConstString &name, ValueObjectSP ValueObject::GetChildMemberWithName(ConstString name,
bool can_create) { bool can_create) {
// when getting a child by name, it could be buried inside some base classes // when getting a child by name, it could be buried inside some base classes
// (which really aren't part of the expression path), so we need a vector of // (which really aren't part of the expression path), so we need a vector of
// indexes that can get us down to the correct child // indexes that can get us down to the correct child
ValueObjectSP child_sp; ValueObjectSP child_sp;
// We may need to update our value if we are dynamic // We may need to update our value if we are dynamic
if (IsPossibleDynamicType()) if (IsPossibleDynamicType())
Show All 32 Lines
} }
// Should only be called by ValueObject::GetNumChildren() // Should only be called by ValueObject::GetNumChildren()
void ValueObject::SetNumChildren(size_t num_children) { void ValueObject::SetNumChildren(size_t num_children) {
m_children_count_valid = true; m_children_count_valid = true;
m_children.SetChildrenCount(num_children); m_children.SetChildrenCount(num_children);
} }
void ValueObject::SetName(const ConstString &name) { m_name = name; } void ValueObject::SetName(ConstString name) { m_name = name; }
ValueObject *ValueObject::CreateChildAtIndex(size_t idx, ValueObject *ValueObject::CreateChildAtIndex(size_t idx,
bool synthetic_array_member, bool synthetic_array_member,
int32_t synthetic_index) { int32_t synthetic_index) {
ValueObject *valobj = NULL; ValueObject *valobj = NULL;
bool omit_empty_base_classes = true; bool omit_empty_base_classes = true;
bool ignore_array_bounds = synthetic_array_member; bool ignore_array_bounds = synthetic_array_member;
Show All 32 Lines
ConstString ValueObject::GetQualifiedTypeName() { ConstString ValueObject::GetQualifiedTypeName() {
return GetCompilerType().GetConstQualifiedTypeName(); return GetCompilerType().GetConstQualifiedTypeName();
} }
LanguageType ValueObject::GetObjectRuntimeLanguage() { LanguageType ValueObject::GetObjectRuntimeLanguage() {
return GetCompilerType().GetMinimumLanguage(); return GetCompilerType().GetMinimumLanguage();
} }
void ValueObject::AddSyntheticChild(const ConstString &key, void ValueObject::AddSyntheticChild(ConstString key,
ValueObject *valobj) { ValueObject *valobj) {
m_synthetic_children[key] = valobj; m_synthetic_children[key] = valobj;
} }
ValueObjectSP ValueObject::GetSyntheticChild(const ConstString &key) const { ValueObjectSP ValueObject::GetSyntheticChild(ConstString key) const {
ValueObjectSP synthetic_child_sp; ValueObjectSP synthetic_child_sp;
std::map<ConstString, ValueObject *>::const_iterator pos = std::map<ConstString, ValueObject *>::const_iterator pos =
m_synthetic_children.find(key); m_synthetic_children.find(key);
if (pos != m_synthetic_children.end()) if (pos != m_synthetic_children.end())
synthetic_child_sp = pos->second->GetSP(); synthetic_child_sp = pos->second->GetSP();
return synthetic_child_sp; return synthetic_child_sp;
} }
Show All 32 Lines
void ValueObject::Dump(Stream &s) { Dump(s, DumpValueObjectOptions(*this)); } void ValueObject::Dump(Stream &s) { Dump(s, DumpValueObjectOptions(*this)); }
void ValueObject::Dump(Stream &s, const DumpValueObjectOptions &options) { void ValueObject::Dump(Stream &s, const DumpValueObjectOptions &options) {
ValueObjectPrinter printer(this, &s, options); ValueObjectPrinter printer(this, &s, options);
printer.PrintValueObject(); printer.PrintValueObject();
} }
ValueObjectSP ValueObject::CreateConstantValue(const ConstString &name) { ValueObjectSP ValueObject::CreateConstantValue(ConstString name) {
ValueObjectSP valobj_sp; ValueObjectSP valobj_sp;
if (UpdateValueIfNeeded(false) && m_error.Success()) { if (UpdateValueIfNeeded(false) && m_error.Success()) {
ExecutionContext exe_ctx(GetExecutionContextRef()); ExecutionContext exe_ctx(GetExecutionContextRef());
DataExtractor data; DataExtractor data;
data.SetByteOrder(m_data.GetByteOrder()); data.SetByteOrder(m_data.GetByteOrder());
data.SetAddressByteSize(m_data.GetAddressByteSize()); data.SetAddressByteSize(m_data.GetAddressByteSize());
Show All 32 Lines
return m_addr_of_valobj_sp; return m_addr_of_valobj_sp;
} }
ValueObjectSP ValueObject::Cast(const CompilerType &compiler_type) { ValueObjectSP ValueObject::Cast(const CompilerType &compiler_type) {
return ValueObjectCast::Create(*this, GetName(), compiler_type); return ValueObjectCast::Create(*this, GetName(), compiler_type);
} }
lldb::ValueObjectSP ValueObject::Clone(const ConstString &new_name) { lldb::ValueObjectSP ValueObject::Clone(ConstString new_name) {
return ValueObjectCast::Create(*this, new_name, GetCompilerType()); return ValueObjectCast::Create(*this, new_name, GetCompilerType());
} }
ValueObjectSP ValueObject::CastPointerType(const char *name, ValueObjectSP ValueObject::CastPointerType(const char *name,
CompilerType &compiler_type) { CompilerType &compiler_type) {
ValueObjectSP valobj_sp; ValueObjectSP valobj_sp;
AddressType address_type; AddressType address_type;
addr_t ptr_value = GetPointerValue(&address_type); addr_t ptr_value = GetPointerValue(&address_type);
Show All 16 Lines

lldb/source/Core/ValueObjectCast.cpp

Show All 16 Lines
namespace lldb_private { namespace lldb_private {
class ConstString; class ConstString;
} }
using namespace lldb_private; using namespace lldb_private;
lldb::ValueObjectSP ValueObjectCast::Create(ValueObject &parent, lldb::ValueObjectSP ValueObjectCast::Create(ValueObject &parent,
const ConstString &name, ConstString name,
const CompilerType &cast_type) { const CompilerType &cast_type) {
ValueObjectCast *cast_valobj_ptr = ValueObjectCast *cast_valobj_ptr =
new ValueObjectCast(parent, name, cast_type); new ValueObjectCast(parent, name, cast_type);
return cast_valobj_ptr->GetSP(); return cast_valobj_ptr->GetSP();
} }
ValueObjectCast::ValueObjectCast(ValueObject &parent, const ConstString &name, ValueObjectCast::ValueObjectCast(ValueObject &parent, ConstString name,
const CompilerType &cast_type) const CompilerType &cast_type)
: ValueObject(parent), m_cast_type(cast_type) { : ValueObject(parent), m_cast_type(cast_type) {
SetName(name); SetName(name);
// m_value.SetContext (Value::eContextTypeClangType, // m_value.SetContext (Value::eContextTypeClangType,
// cast_type.GetOpaqueQualType()); // cast_type.GetOpaqueQualType());
m_value.SetCompilerType(cast_type); m_value.SetCompilerType(cast_type);
} }
Show All 16 Lines

lldb/source/Core/ValueObjectChild.cpp

Show All 16 Lines
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
using namespace lldb_private; using namespace lldb_private;
ValueObjectChild::ValueObjectChild( ValueObjectChild::ValueObjectChild(
ValueObject &parent, const CompilerType &compiler_type, ValueObject &parent, const CompilerType &compiler_type,
const ConstString &name, uint64_t byte_size, int32_t byte_offset, ConstString name, uint64_t byte_size, int32_t byte_offset,
uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset, uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset,
bool is_base_class, bool is_deref_of_parent, bool is_base_class, bool is_deref_of_parent,
AddressType child_ptr_or_ref_addr_type, uint64_t language_flags) AddressType child_ptr_or_ref_addr_type, uint64_t language_flags)
: ValueObject(parent), m_compiler_type(compiler_type), : ValueObject(parent), m_compiler_type(compiler_type),
m_byte_size(byte_size), m_byte_offset(byte_offset), m_byte_size(byte_size), m_byte_offset(byte_offset),
m_bitfield_bit_size(bitfield_bit_size), m_bitfield_bit_size(bitfield_bit_size),
m_bitfield_bit_offset(bitfield_bit_offset), m_bitfield_bit_offset(bitfield_bit_offset),
m_is_base_class(is_base_class), m_is_deref_of_parent(is_deref_of_parent), m_is_base_class(is_base_class), m_is_deref_of_parent(is_deref_of_parent),
Show All 16 Lines

lldb/source/Core/ValueObjectConstResult.cpp

Show All 16 Lines
SetValueIsValid(true); SetValueIsValid(true);
m_data.SetByteOrder(byte_order); m_data.SetByteOrder(byte_order);
m_data.SetAddressByteSize(addr_byte_size); m_data.SetAddressByteSize(addr_byte_size);
SetAddressTypeOfChildren(eAddressTypeLoad); SetAddressTypeOfChildren(eAddressTypeLoad);
} }
ValueObjectSP ValueObjectConstResult::Create(ExecutionContextScope *exe_scope, ValueObjectSP ValueObjectConstResult::Create(ExecutionContextScope *exe_scope,
const CompilerType &compiler_type, const CompilerType &compiler_type,
const ConstString &name, ConstString name,
const DataExtractor &data, const DataExtractor &data,
lldb::addr_t address) { lldb::addr_t address) {
return (new ValueObjectConstResult(exe_scope, compiler_type, name, data, return (new ValueObjectConstResult(exe_scope, compiler_type, name, data,
address)) address))
->GetSP(); ->GetSP();
} }
ValueObjectConstResult::ValueObjectConstResult( ValueObjectConstResult::ValueObjectConstResult(
ExecutionContextScope *exe_scope, const CompilerType &compiler_type, ExecutionContextScope *exe_scope, const CompilerType &compiler_type,
const ConstString &name, const DataExtractor &data, lldb::addr_t address) ConstString name, const DataExtractor &data, lldb::addr_t address)
: ValueObject(exe_scope), m_type_name(), m_byte_size(0), : ValueObject(exe_scope), m_type_name(), m_byte_size(0),
m_impl(this, address) { m_impl(this, address) {
m_data = data; m_data = data;
if (!m_data.GetSharedDataBuffer()) { if (!m_data.GetSharedDataBuffer()) {
DataBufferSP shared_data_buffer( DataBufferSP shared_data_buffer(
new DataBufferHeap(data.GetDataStart(), data.GetByteSize())); new DataBufferHeap(data.GetDataStart(), data.GetByteSize()));
m_data.SetData(shared_data_buffer); m_data.SetData(shared_data_buffer);
} }
m_value.GetScalar() = (uintptr_t)m_data.GetDataStart(); m_value.GetScalar() = (uintptr_t)m_data.GetDataStart();
m_value.SetValueType(Value::eValueTypeHostAddress); m_value.SetValueType(Value::eValueTypeHostAddress);
m_value.SetCompilerType(compiler_type); m_value.SetCompilerType(compiler_type);
m_name = name; m_name = name;
SetIsConstant(); SetIsConstant();
SetValueIsValid(true); SetValueIsValid(true);
SetAddressTypeOfChildren(eAddressTypeLoad); SetAddressTypeOfChildren(eAddressTypeLoad);
} }
ValueObjectSP ValueObjectConstResult::Create(ExecutionContextScope *exe_scope, ValueObjectSP ValueObjectConstResult::Create(ExecutionContextScope *exe_scope,
const CompilerType &compiler_type, const CompilerType &compiler_type,
const ConstString &name, ConstString name,
const lldb::DataBufferSP &data_sp, const lldb::DataBufferSP &data_sp,
lldb::ByteOrder data_byte_order, lldb::ByteOrder data_byte_order,
uint32_t data_addr_size, uint32_t data_addr_size,
lldb::addr_t address) { lldb::addr_t address) {
return (new ValueObjectConstResult(exe_scope, compiler_type, name, data_sp, return (new ValueObjectConstResult(exe_scope, compiler_type, name, data_sp,
data_byte_order, data_addr_size, address)) data_byte_order, data_addr_size, address))
->GetSP(); ->GetSP();
} }
ValueObjectSP ValueObjectConstResult::Create(ExecutionContextScope *exe_scope, ValueObjectSP ValueObjectConstResult::Create(ExecutionContextScope *exe_scope,
Value &value, Value &value,
const ConstString &name, ConstString name,
Module *module) { Module *module) {
return (new ValueObjectConstResult(exe_scope, value, name, module))->GetSP(); return (new ValueObjectConstResult(exe_scope, value, name, module))->GetSP();
} }
ValueObjectConstResult::ValueObjectConstResult( ValueObjectConstResult::ValueObjectConstResult(
ExecutionContextScope *exe_scope, const CompilerType &compiler_type, ExecutionContextScope *exe_scope, const CompilerType &compiler_type,
const ConstString &name, const lldb::DataBufferSP &data_sp, ConstString name, const lldb::DataBufferSP &data_sp,
lldb::ByteOrder data_byte_order, uint32_t data_addr_size, lldb::ByteOrder data_byte_order, uint32_t data_addr_size,
lldb::addr_t address) lldb::addr_t address)
: ValueObject(exe_scope), m_type_name(), m_byte_size(0), : ValueObject(exe_scope), m_type_name(), m_byte_size(0),
m_impl(this, address) { m_impl(this, address) {
m_data.SetByteOrder(data_byte_order); m_data.SetByteOrder(data_byte_order);
m_data.SetAddressByteSize(data_addr_size); m_data.SetAddressByteSize(data_addr_size);
m_data.SetData(data_sp); m_data.SetData(data_sp);
m_value.GetScalar() = (uintptr_t)data_sp->GetBytes(); m_value.GetScalar() = (uintptr_t)data_sp->GetBytes();
m_value.SetValueType(Value::eValueTypeHostAddress); m_value.SetValueType(Value::eValueTypeHostAddress);
// m_value.SetContext(Value::eContextTypeClangType, compiler_type); // m_value.SetContext(Value::eContextTypeClangType, compiler_type);
m_value.SetCompilerType(compiler_type); m_value.SetCompilerType(compiler_type);
m_name = name; m_name = name;
SetIsConstant(); SetIsConstant();
SetValueIsValid(true); SetValueIsValid(true);
SetAddressTypeOfChildren(eAddressTypeLoad); SetAddressTypeOfChildren(eAddressTypeLoad);
} }
ValueObjectSP ValueObjectConstResult::Create(ExecutionContextScope *exe_scope, ValueObjectSP ValueObjectConstResult::Create(ExecutionContextScope *exe_scope,
const CompilerType &compiler_type, const CompilerType &compiler_type,
const ConstString &name, ConstString name,
lldb::addr_t address, lldb::addr_t address,
AddressType address_type, AddressType address_type,
uint32_t addr_byte_size) { uint32_t addr_byte_size) {
return (new ValueObjectConstResult(exe_scope, compiler_type, name, address, return (new ValueObjectConstResult(exe_scope, compiler_type, name, address,
address_type, addr_byte_size)) address_type, addr_byte_size))
->GetSP(); ->GetSP();
} }
ValueObjectConstResult::ValueObjectConstResult( ValueObjectConstResult::ValueObjectConstResult(
ExecutionContextScope *exe_scope, const CompilerType &compiler_type, ExecutionContextScope *exe_scope, const CompilerType &compiler_type,
const ConstString &name, lldb::addr_t address, AddressType address_type, ConstString name, lldb::addr_t address, AddressType address_type,
uint32_t addr_byte_size) uint32_t addr_byte_size)
: ValueObject(exe_scope), m_type_name(), m_byte_size(0), : ValueObject(exe_scope), m_type_name(), m_byte_size(0),
m_impl(this, address) { m_impl(this, address) {
m_value.GetScalar() = address; m_value.GetScalar() = address;
m_data.SetAddressByteSize(addr_byte_size); m_data.SetAddressByteSize(addr_byte_size);
m_value.GetScalar().GetData(m_data, addr_byte_size); m_value.GetScalar().GetData(m_data, addr_byte_size);
// m_value.SetValueType(Value::eValueTypeHostAddress); // m_value.SetValueType(Value::eValueTypeHostAddress);
switch (address_type) { switch (address_type) {
Show All 27 Lines
const Status &error) const Status &error)
: ValueObject(exe_scope), m_type_name(), m_byte_size(0), m_impl(this) { : ValueObject(exe_scope), m_type_name(), m_byte_size(0), m_impl(this) {
m_error = error; m_error = error;
SetIsConstant(); SetIsConstant();
} }
ValueObjectConstResult::ValueObjectConstResult(ExecutionContextScope *exe_scope, ValueObjectConstResult::ValueObjectConstResult(ExecutionContextScope *exe_scope,
const Value &value, const Value &value,
const ConstString &name, ConstString name,
Module *module) Module *module)
: ValueObject(exe_scope), m_type_name(), m_byte_size(0), m_impl(this) { : ValueObject(exe_scope), m_type_name(), m_byte_size(0), m_impl(this) {
m_value = value; m_value = value;
m_name = name; m_name = name;
ExecutionContext exe_ctx; ExecutionContext exe_ctx;
exe_scope->CalculateExecutionContext(exe_ctx); exe_scope->CalculateExecutionContext(exe_ctx);
m_error = m_value.GetValueAsData(&exe_ctx, m_data, 0, module); m_error = m_value.GetValueAsData(&exe_ctx, m_data, 0, module);
} }
Show All 16 Lines

lldb/source/Core/ValueObjectConstResultCast.cpp

Show All 15 Lines
} }
namespace lldb_private { namespace lldb_private {
class ValueObject; class ValueObject;
} }
using namespace lldb_private; using namespace lldb_private;
ValueObjectConstResultCast::ValueObjectConstResultCast( ValueObjectConstResultCast::ValueObjectConstResultCast(
ValueObject &parent, const ConstString &name, const CompilerType &cast_type, ValueObject &parent, ConstString name, const CompilerType &cast_type,
lldb::addr_t live_address) lldb::addr_t live_address)
: ValueObjectCast(parent, name, cast_type), m_impl(this, live_address) { : ValueObjectCast(parent, name, cast_type), m_impl(this, live_address) {
m_name = name; m_name = name;
} }
ValueObjectConstResultCast::~ValueObjectConstResultCast() {} ValueObjectConstResultCast::~ValueObjectConstResultCast() {}
lldb::ValueObjectSP ValueObjectConstResultCast::Dereference(Status &error) { lldb::ValueObjectSP ValueObjectConstResultCast::Dereference(Status &error) {
Show All 16 Lines

lldb/source/Core/ValueObjectConstResultChild.cpp

Show All 16 Lines
namespace lldb_private { namespace lldb_private {
class ValueObject; class ValueObject;
} }
using namespace lldb_private; using namespace lldb_private;
ValueObjectConstResultChild::ValueObjectConstResultChild( ValueObjectConstResultChild::ValueObjectConstResultChild(
ValueObject &parent, const CompilerType &compiler_type, ValueObject &parent, const CompilerType &compiler_type,
const ConstString &name, uint32_t byte_size, int32_t byte_offset, ConstString name, uint32_t byte_size, int32_t byte_offset,
uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset, uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset,
bool is_base_class, bool is_deref_of_parent, lldb::addr_t live_address, bool is_base_class, bool is_deref_of_parent, lldb::addr_t live_address,
uint64_t language_flags) uint64_t language_flags)
: ValueObjectChild(parent, compiler_type, name, byte_size, byte_offset, : ValueObjectChild(parent, compiler_type, name, byte_size, byte_offset,
bitfield_bit_size, bitfield_bit_offset, is_base_class, bitfield_bit_size, bitfield_bit_offset, is_base_class,
is_deref_of_parent, eAddressTypeLoad, language_flags), is_deref_of_parent, eAddressTypeLoad, language_flags),
m_impl(this, live_address) { m_impl(this, live_address) {
m_name = name; m_name = name;
Show All 16 Lines

lldb/source/Core/ValueObjectRegister.cpp

Show All 16 Lines
if (idx < num_children) if (idx < num_children)
valobj = new ValueObjectRegister(*this, m_reg_ctx_sp, valobj = new ValueObjectRegister(*this, m_reg_ctx_sp,
m_reg_set->registers[idx]); m_reg_set->registers[idx]);
} }
return valobj; return valobj;
} }
lldb::ValueObjectSP lldb::ValueObjectSP
ValueObjectRegisterSet::GetChildMemberWithName(const ConstString &name, ValueObjectRegisterSet::GetChildMemberWithName(ConstString name,
bool can_create) { bool can_create) {
ValueObject *valobj = NULL; ValueObject *valobj = NULL;
if (m_reg_ctx_sp && m_reg_set) { if (m_reg_ctx_sp && m_reg_set) {
const RegisterInfo *reg_info = const RegisterInfo *reg_info =
m_reg_ctx_sp->GetRegisterInfoByName(name.AsCString()); m_reg_ctx_sp->GetRegisterInfoByName(name.AsCString());
if (reg_info != NULL) if (reg_info != NULL)
valobj = new ValueObjectRegister(*this, m_reg_ctx_sp, valobj = new ValueObjectRegister(*this, m_reg_ctx_sp,
reg_info->kinds[eRegisterKindLLDB]); reg_info->kinds[eRegisterKindLLDB]);
} }
if (valobj) if (valobj)
return valobj->GetSP(); return valobj->GetSP();
else else
return ValueObjectSP(); return ValueObjectSP();
} }
size_t size_t
ValueObjectRegisterSet::GetIndexOfChildWithName(const ConstString &name) { ValueObjectRegisterSet::GetIndexOfChildWithName(ConstString name) {
if (m_reg_ctx_sp && m_reg_set) { if (m_reg_ctx_sp && m_reg_set) {
const RegisterInfo *reg_info = const RegisterInfo *reg_info =
m_reg_ctx_sp->GetRegisterInfoByName(name.AsCString()); m_reg_ctx_sp->GetRegisterInfoByName(name.AsCString());
if (reg_info != NULL) if (reg_info != NULL)
return reg_info->kinds[eRegisterKindLLDB]; return reg_info->kinds[eRegisterKindLLDB];
} }
return UINT32_MAX; return UINT32_MAX;
} }
Show All 16 Lines

lldb/source/Core/ValueObjectSyntheticFilter.cpp

Show All 16 Lines
: SyntheticChildrenFrontEnd(backend) {} : SyntheticChildrenFrontEnd(backend) {}
size_t CalculateNumChildren() override { return m_backend.GetNumChildren(); } size_t CalculateNumChildren() override { return m_backend.GetNumChildren(); }
lldb::ValueObjectSP GetChildAtIndex(size_t idx) override { lldb::ValueObjectSP GetChildAtIndex(size_t idx) override {
return m_backend.GetChildAtIndex(idx, true); return m_backend.GetChildAtIndex(idx, true);
} }
size_t GetIndexOfChildWithName(const ConstString &name) override { size_t GetIndexOfChildWithName(ConstString name) override {
return m_backend.GetIndexOfChildWithName(name); return m_backend.GetIndexOfChildWithName(name);
} }
bool MightHaveChildren() override { return true; } bool MightHaveChildren() override { return true; }
bool Update() override { return false; } bool Update() override { return false; }
}; };
Show All 32 Lines
"index %zu cached as %p", "index %zu cached as %p",
GetName().AsCString(), idx, static_cast<void *>(valobj)); GetName().AsCString(), idx, static_cast<void *>(valobj));
return valobj->GetSP(); return valobj->GetSP();
} }
} }
lldb::ValueObjectSP lldb::ValueObjectSP
ValueObjectSynthetic::GetChildMemberWithName(const ConstString &name, ValueObjectSynthetic::GetChildMemberWithName(ConstString name,
bool can_create) { bool can_create) {
UpdateValueIfNeeded(); UpdateValueIfNeeded();
uint32_t index = GetIndexOfChildWithName(name); uint32_t index = GetIndexOfChildWithName(name);
if (index == UINT32_MAX) if (index == UINT32_MAX)
return lldb::ValueObjectSP(); return lldb::ValueObjectSP();
return GetChildAtIndex(index, can_create); return GetChildAtIndex(index, can_create);
} }
size_t ValueObjectSynthetic::GetIndexOfChildWithName(const ConstString &name) { size_t ValueObjectSynthetic::GetIndexOfChildWithName(ConstString name) {
UpdateValueIfNeeded(); UpdateValueIfNeeded();
uint32_t found_index = UINT32_MAX; uint32_t found_index = UINT32_MAX;
bool did_find = m_name_toindex.GetValueForKey(name.GetCString(), found_index); bool did_find = m_name_toindex.GetValueForKey(name.GetCString(), found_index);
if (!did_find && m_synth_filter_up != nullptr) { if (!did_find && m_synth_filter_up != nullptr) {
uint32_t index = m_synth_filter_up->GetIndexOfChildWithName(name); uint32_t index = m_synth_filter_up->GetIndexOfChildWithName(name);
if (index == UINT32_MAX) if (index == UINT32_MAX)
Show All 16 Lines

lldb/source/DataFormatters/DataVisualization.cpp

Show All 16 Lines
bool DataVisualization::AnyMatches( bool DataVisualization::AnyMatches(
ConstString type_name, TypeCategoryImpl::FormatCategoryItems items, ConstString type_name, TypeCategoryImpl::FormatCategoryItems items,
bool only_enabled, const char **matching_category, bool only_enabled, const char **matching_category,
TypeCategoryImpl::FormatCategoryItems *matching_type) { TypeCategoryImpl::FormatCategoryItems *matching_type) {
return GetFormatManager().AnyMatches(type_name, items, only_enabled, return GetFormatManager().AnyMatches(type_name, items, only_enabled,
matching_category, matching_type); matching_category, matching_type);
} }
bool DataVisualization::Categories::GetCategory(const ConstString &category, bool DataVisualization::Categories::GetCategory(ConstString category,
lldb::TypeCategoryImplSP &entry, lldb::TypeCategoryImplSP &entry,
bool allow_create) { bool allow_create) {
entry = GetFormatManager().GetCategory(category, allow_create); entry = GetFormatManager().GetCategory(category, allow_create);
return (entry.get() != NULL); return (entry.get() != NULL);
} }
bool DataVisualization::Categories::GetCategory( bool DataVisualization::Categories::GetCategory(
lldb::LanguageType language, lldb::TypeCategoryImplSP &entry) { lldb::LanguageType language, lldb::TypeCategoryImplSP &entry) {
if (LanguageCategory *lang_category = if (LanguageCategory *lang_category =
GetFormatManager().GetCategoryForLanguage(language)) GetFormatManager().GetCategoryForLanguage(language))
entry = lang_category->GetCategory(); entry = lang_category->GetCategory();
return (entry.get() != nullptr); return (entry.get() != nullptr);
} }
void DataVisualization::Categories::Add(const ConstString &category) { void DataVisualization::Categories::Add(ConstString category) {
GetFormatManager().GetCategory(category); GetFormatManager().GetCategory(category);
} }
bool DataVisualization::Categories::Delete(const ConstString &category) { bool DataVisualization::Categories::Delete(ConstString category) {
GetFormatManager().DisableCategory(category); GetFormatManager().DisableCategory(category);
return GetFormatManager().DeleteCategory(category); return GetFormatManager().DeleteCategory(category);
} }
void DataVisualization::Categories::Clear() { void DataVisualization::Categories::Clear() {
GetFormatManager().ClearCategories(); GetFormatManager().ClearCategories();
} }
void DataVisualization::Categories::Clear(const ConstString &category) { void DataVisualization::Categories::Clear(ConstString category) {
GetFormatManager().GetCategory(category)->Clear( GetFormatManager().GetCategory(category)->Clear(
eFormatCategoryItemSummary | eFormatCategoryItemRegexSummary); eFormatCategoryItemSummary | eFormatCategoryItemRegexSummary);
} }
void DataVisualization::Categories::Enable(const ConstString &category, void DataVisualization::Categories::Enable(ConstString category,
TypeCategoryMap::Position pos) { TypeCategoryMap::Position pos) {
if (GetFormatManager().GetCategory(category)->IsEnabled()) if (GetFormatManager().GetCategory(category)->IsEnabled())
GetFormatManager().DisableCategory(category); GetFormatManager().DisableCategory(category);
GetFormatManager().EnableCategory( GetFormatManager().EnableCategory(
category, pos, std::initializer_list<lldb::LanguageType>()); category, pos, std::initializer_list<lldb::LanguageType>());
} }
void DataVisualization::Categories::Enable(lldb::LanguageType lang_type) { void DataVisualization::Categories::Enable(lldb::LanguageType lang_type) {
if (LanguageCategory *lang_category = if (LanguageCategory *lang_category =
GetFormatManager().GetCategoryForLanguage(lang_type)) GetFormatManager().GetCategoryForLanguage(lang_type))
lang_category->Enable(); lang_category->Enable();
} }
void DataVisualization::Categories::Disable(const ConstString &category) { void DataVisualization::Categories::Disable(ConstString category) {
if (GetFormatManager().GetCategory(category)->IsEnabled()) if (GetFormatManager().GetCategory(category)->IsEnabled())
GetFormatManager().DisableCategory(category); GetFormatManager().DisableCategory(category);
} }
void DataVisualization::Categories::Disable(lldb::LanguageType lang_type) { void DataVisualization::Categories::Disable(lldb::LanguageType lang_type) {
if (LanguageCategory *lang_category = if (LanguageCategory *lang_category =
GetFormatManager().GetCategoryForLanguage(lang_type)) GetFormatManager().GetCategoryForLanguage(lang_type))
lang_category->Disable(); lang_category->Disable();
Show All 32 Lines
} }
lldb::TypeCategoryImplSP lldb::TypeCategoryImplSP
DataVisualization::Categories::GetCategoryAtIndex(size_t index) { DataVisualization::Categories::GetCategoryAtIndex(size_t index) {
return GetFormatManager().GetCategoryAtIndex(index); return GetFormatManager().GetCategoryAtIndex(index);
} }
bool DataVisualization::NamedSummaryFormats::GetSummaryFormat( bool DataVisualization::NamedSummaryFormats::GetSummaryFormat(
const ConstString &type, lldb::TypeSummaryImplSP &entry) { ConstString type, lldb::TypeSummaryImplSP &entry) {
return GetFormatManager().GetNamedSummaryContainer().Get(type, entry); return GetFormatManager().GetNamedSummaryContainer().Get(type, entry);
} }
void DataVisualization::NamedSummaryFormats::Add( void DataVisualization::NamedSummaryFormats::Add(
const ConstString &type, const lldb::TypeSummaryImplSP &entry) { ConstString type, const lldb::TypeSummaryImplSP &entry) {
GetFormatManager().GetNamedSummaryContainer().Add( GetFormatManager().GetNamedSummaryContainer().Add(
FormatManager::GetValidTypeName(type), entry); FormatManager::GetValidTypeName(type), entry);
} }
bool DataVisualization::NamedSummaryFormats::Delete(const ConstString &type) { bool DataVisualization::NamedSummaryFormats::Delete(ConstString type) {
return GetFormatManager().GetNamedSummaryContainer().Delete(type); return GetFormatManager().GetNamedSummaryContainer().Delete(type);
} }
void DataVisualization::NamedSummaryFormats::Clear() { void DataVisualization::NamedSummaryFormats::Clear() {
GetFormatManager().GetNamedSummaryContainer().Clear(); GetFormatManager().GetNamedSummaryContainer().Clear();
} }
void DataVisualization::NamedSummaryFormats::ForEach( void DataVisualization::NamedSummaryFormats::ForEach(
std::function<bool(ConstString, const lldb::TypeSummaryImplSP &)> std::function<bool(ConstString, const lldb::TypeSummaryImplSP &)>
callback) { callback) {
GetFormatManager().GetNamedSummaryContainer().ForEach(callback); GetFormatManager().GetNamedSummaryContainer().ForEach(callback);
} }
uint32_t DataVisualization::NamedSummaryFormats::GetCount() { uint32_t DataVisualization::NamedSummaryFormats::GetCount() {
return GetFormatManager().GetNamedSummaryContainer().GetCount(); return GetFormatManager().GetNamedSummaryContainer().GetCount();
} }
Context not available.

lldb/source/DataFormatters/FormatCache.cpp

Show All 16 Lines
: m_map(), m_mutex() : m_map(), m_mutex()
#ifdef LLDB_CONFIGURATION_DEBUG #ifdef LLDB_CONFIGURATION_DEBUG
, ,
m_cache_hits(0), m_cache_misses(0) m_cache_hits(0), m_cache_misses(0)
#endif #endif
{ {
} }
FormatCache::Entry &FormatCache::GetEntry(const ConstString &type) { FormatCache::Entry &FormatCache::GetEntry(ConstString type) {
auto i = m_map.find(type), e = m_map.end(); auto i = m_map.find(type), e = m_map.end();
if (i != e) if (i != e)
return i->second; return i->second;
m_map[type] = FormatCache::Entry(); m_map[type] = FormatCache::Entry();
return m_map[type]; return m_map[type];
} }
bool FormatCache::GetFormat(const ConstString &type, bool FormatCache::GetFormat(ConstString type,
lldb::TypeFormatImplSP &format_sp) { lldb::TypeFormatImplSP &format_sp) {
std::lock_guard<std::recursive_mutex> guard(m_mutex); std::lock_guard<std::recursive_mutex> guard(m_mutex);
auto entry = GetEntry(type); auto entry = GetEntry(type);
if (entry.IsFormatCached()) { if (entry.IsFormatCached()) {
#ifdef LLDB_CONFIGURATION_DEBUG #ifdef LLDB_CONFIGURATION_DEBUG
m_cache_hits++; m_cache_hits++;
#endif #endif
format_sp = entry.GetFormat(); format_sp = entry.GetFormat();
return true; return true;
} }
#ifdef LLDB_CONFIGURATION_DEBUG #ifdef LLDB_CONFIGURATION_DEBUG
m_cache_misses++; m_cache_misses++;
#endif #endif
format_sp.reset(); format_sp.reset();
return false; return false;
} }
bool FormatCache::GetSummary(const ConstString &type, bool FormatCache::GetSummary(ConstString type,
lldb::TypeSummaryImplSP &summary_sp) { lldb::TypeSummaryImplSP &summary_sp) {
std::lock_guard<std::recursive_mutex> guard(m_mutex); std::lock_guard<std::recursive_mutex> guard(m_mutex);
auto entry = GetEntry(type); auto entry = GetEntry(type);
if (entry.IsSummaryCached()) { if (entry.IsSummaryCached()) {
#ifdef LLDB_CONFIGURATION_DEBUG #ifdef LLDB_CONFIGURATION_DEBUG
m_cache_hits++; m_cache_hits++;
#endif #endif
summary_sp = entry.GetSummary(); summary_sp = entry.GetSummary();
return true; return true;
} }
#ifdef LLDB_CONFIGURATION_DEBUG #ifdef LLDB_CONFIGURATION_DEBUG
m_cache_misses++; m_cache_misses++;
#endif #endif
summary_sp.reset(); summary_sp.reset();
return false; return false;
} }
bool FormatCache::GetSynthetic(const ConstString &type, bool FormatCache::GetSynthetic(ConstString type,
lldb::SyntheticChildrenSP &synthetic_sp) { lldb::SyntheticChildrenSP &synthetic_sp) {
std::lock_guard<std::recursive_mutex> guard(m_mutex); std::lock_guard<std::recursive_mutex> guard(m_mutex);
auto entry = GetEntry(type); auto entry = GetEntry(type);
if (entry.IsSyntheticCached()) { if (entry.IsSyntheticCached()) {
#ifdef LLDB_CONFIGURATION_DEBUG #ifdef LLDB_CONFIGURATION_DEBUG
m_cache_hits++; m_cache_hits++;
#endif #endif
synthetic_sp = entry.GetSynthetic(); synthetic_sp = entry.GetSynthetic();
return true; return true;
} }
#ifdef LLDB_CONFIGURATION_DEBUG #ifdef LLDB_CONFIGURATION_DEBUG
m_cache_misses++; m_cache_misses++;
#endif #endif
synthetic_sp.reset(); synthetic_sp.reset();
return false; return false;
} }
bool FormatCache::GetValidator(const ConstString &type, bool FormatCache::GetValidator(ConstString type,
lldb::TypeValidatorImplSP &validator_sp) { lldb::TypeValidatorImplSP &validator_sp) {
std::lock_guard<std::recursive_mutex> guard(m_mutex); std::lock_guard<std::recursive_mutex> guard(m_mutex);
auto entry = GetEntry(type); auto entry = GetEntry(type);
if (entry.IsValidatorCached()) { if (entry.IsValidatorCached()) {
#ifdef LLDB_CONFIGURATION_DEBUG #ifdef LLDB_CONFIGURATION_DEBUG
m_cache_hits++; m_cache_hits++;
#endif #endif
validator_sp = entry.GetValidator(); validator_sp = entry.GetValidator();
return true; return true;
} }
#ifdef LLDB_CONFIGURATION_DEBUG #ifdef LLDB_CONFIGURATION_DEBUG
m_cache_misses++; m_cache_misses++;
#endif #endif
validator_sp.reset(); validator_sp.reset();
return false; return false;
} }
void FormatCache::SetFormat(const ConstString &type, void FormatCache::SetFormat(ConstString type,
lldb::TypeFormatImplSP &format_sp) { lldb::TypeFormatImplSP &format_sp) {
std::lock_guard<std::recursive_mutex> guard(m_mutex); std::lock_guard<std::recursive_mutex> guard(m_mutex);
GetEntry(type).SetFormat(format_sp); GetEntry(type).SetFormat(format_sp);
} }
void FormatCache::SetSummary(const ConstString &type, void FormatCache::SetSummary(ConstString type,
lldb::TypeSummaryImplSP &summary_sp) { lldb::TypeSummaryImplSP &summary_sp) {
std::lock_guard<std::recursive_mutex> guard(m_mutex); std::lock_guard<std::recursive_mutex> guard(m_mutex);
GetEntry(type).SetSummary(summary_sp); GetEntry(type).SetSummary(summary_sp);
} }
void FormatCache::SetSynthetic(const ConstString &type, void FormatCache::SetSynthetic(ConstString type,
lldb::SyntheticChildrenSP &synthetic_sp) { lldb::SyntheticChildrenSP &synthetic_sp) {
std::lock_guard<std::recursive_mutex> guard(m_mutex); std::lock_guard<std::recursive_mutex> guard(m_mutex);
GetEntry(type).SetSynthetic(synthetic_sp); GetEntry(type).SetSynthetic(synthetic_sp);
} }
void FormatCache::SetValidator(const ConstString &type, void FormatCache::SetValidator(ConstString type,
lldb::TypeValidatorImplSP &validator_sp) { lldb::TypeValidatorImplSP &validator_sp) {
std::lock_guard<std::recursive_mutex> guard(m_mutex); std::lock_guard<std::recursive_mutex> guard(m_mutex);
GetEntry(type).SetValidator(validator_sp); GetEntry(type).SetValidator(validator_sp);
} }
void FormatCache::Clear() { void FormatCache::Clear() {
std::lock_guard<std::recursive_mutex> guard(m_mutex); std::lock_guard<std::recursive_mutex> guard(m_mutex);
m_map.clear(); m_map.clear();
} }
Context not available.

lldb/source/DataFormatters/FormatManager.cpp

Show All 16 Lines
if (auto category_sp = entry.second->GetCategory()) { if (auto category_sp = entry.second->GetCategory()) {
if (!callback(category_sp)) if (!callback(category_sp))
break; break;
} }
} }
} }
lldb::TypeCategoryImplSP lldb::TypeCategoryImplSP
FormatManager::GetCategory(const ConstString &category_name, bool can_create) { FormatManager::GetCategory(ConstString category_name, bool can_create) {
if (!category_name) if (!category_name)
return GetCategory(m_default_category_name); return GetCategory(m_default_category_name);
lldb::TypeCategoryImplSP category; lldb::TypeCategoryImplSP category;
if (m_categories_map.Get(category_name, category)) if (m_categories_map.Get(category_name, category))
return category; return category;
if (!can_create) if (!can_create)
return lldb::TypeCategoryImplSP(); return lldb::TypeCategoryImplSP();
Show All 32 Lines
// synthetic valued // synthetic valued
// child // child
return false; // then bail out return false; // then bail out
} }
} }
return true; return true;
} }
ConstString FormatManager::GetValidTypeName(const ConstString &type) { ConstString FormatManager::GetValidTypeName(ConstString type) {
return ::GetValidTypeName_Impl(type); return ::GetValidTypeName_Impl(type);
} }
ConstString FormatManager::GetTypeForCache(ValueObject &valobj, ConstString FormatManager::GetTypeForCache(ValueObject &valobj,
lldb::DynamicValueType use_dynamic) { lldb::DynamicValueType use_dynamic) {
ValueObjectSP valobj_sp = valobj.GetQualifiedRepresentationIfAvailable( ValueObjectSP valobj_sp = valobj.GetQualifiedRepresentationIfAvailable(
use_dynamic, valobj.IsSynthetic()); use_dynamic, valobj.IsSynthetic());
if (valobj_sp && valobj_sp->GetCompilerType().IsValid()) { if (valobj_sp && valobj_sp->GetCompilerType().IsValid()) {
Show All 16 Lines

lldb/source/DataFormatters/TypeSynthetic.cpp

Show All 16 Lines
if (!need_add_dot) if (!need_add_dot)
m_expression_paths[i] = path; m_expression_paths[i] = path;
else else
m_expression_paths[i] = std::string(".") + path; m_expression_paths[i] = std::string(".") + path;
return true; return true;
} }
size_t size_t
TypeFilterImpl::FrontEnd::GetIndexOfChildWithName(const ConstString &name) { TypeFilterImpl::FrontEnd::GetIndexOfChildWithName(ConstString name) {
const char *name_cstr = name.GetCString(); const char *name_cstr = name.GetCString();
if (name_cstr) { if (name_cstr) {
for (size_t i = 0; i < filter->GetCount(); i++) { for (size_t i = 0; i < filter->GetCount(); i++) {
const char *expr_cstr = filter->GetExpressionPathAtIndex(i); const char *expr_cstr = filter->GetExpressionPathAtIndex(i);
if (expr_cstr) { if (expr_cstr) {
if (*expr_cstr == '.') if (*expr_cstr == '.')
expr_cstr++; expr_cstr++;
else if (*expr_cstr == '-' && *(expr_cstr + 1) == '>') else if (*expr_cstr == '-' && *(expr_cstr + 1) == '>')
Show All 32 Lines
bool ScriptedSyntheticChildren::FrontEnd::MightHaveChildren() { bool ScriptedSyntheticChildren::FrontEnd::MightHaveChildren() {
if (!m_wrapper_sp || m_interpreter == NULL) if (!m_wrapper_sp || m_interpreter == NULL)
return false; return false;
return m_interpreter->MightHaveChildrenSynthProviderInstance(m_wrapper_sp); return m_interpreter->MightHaveChildrenSynthProviderInstance(m_wrapper_sp);
} }
size_t ScriptedSyntheticChildren::FrontEnd::GetIndexOfChildWithName( size_t ScriptedSyntheticChildren::FrontEnd::GetIndexOfChildWithName(
const ConstString &name) { ConstString name) {
if (!m_wrapper_sp || m_interpreter == NULL) if (!m_wrapper_sp || m_interpreter == NULL)
return UINT32_MAX; return UINT32_MAX;
return m_interpreter->GetIndexOfChildWithName(m_wrapper_sp, return m_interpreter->GetIndexOfChildWithName(m_wrapper_sp,
name.GetCString()); name.GetCString());
} }
lldb::ValueObjectSP ScriptedSyntheticChildren::FrontEnd::GetSyntheticValue() { lldb::ValueObjectSP ScriptedSyntheticChildren::FrontEnd::GetSyntheticValue() {
if (!m_wrapper_sp || m_interpreter == NULL) if (!m_wrapper_sp || m_interpreter == NULL)
Show All 16 Lines

lldb/source/DataFormatters/VectorType.cpp

Show All 16 Lines
: nullptr); : nullptr);
m_num_children = ::CalculateNumChildren(parent_type, m_child_type); m_num_children = ::CalculateNumChildren(parent_type, m_child_type);
m_item_format = GetItemFormatForFormat(m_parent_format, m_child_type); m_item_format = GetItemFormatForFormat(m_parent_format, m_child_type);
return false; return false;
} }
bool MightHaveChildren() override { return true; } bool MightHaveChildren() override { return true; }
size_t GetIndexOfChildWithName(const ConstString &name) override { size_t GetIndexOfChildWithName(ConstString name) override {
const char *item_name = name.GetCString(); const char *item_name = name.GetCString();
uint32_t idx = ExtractIndexFromString(item_name); uint32_t idx = ExtractIndexFromString(item_name);
if (idx < UINT32_MAX && idx >= CalculateNumChildren()) if (idx < UINT32_MAX && idx >= CalculateNumChildren())
return UINT32_MAX; return UINT32_MAX;
return idx; return idx;
} }
private: private:
Show All 16 Lines

lldb/source/Expression/ExpressionVariable.cpp

Show All 16 Lines
return const_cast<uint8_t *>( return const_cast<uint8_t *>(
m_frozen_sp->GetDataExtractor().GetDataStart()); m_frozen_sp->GetDataExtractor().GetDataStart());
} }
return NULL; return NULL;
} }
PersistentExpressionState::~PersistentExpressionState() {} PersistentExpressionState::~PersistentExpressionState() {}
lldb::addr_t PersistentExpressionState::LookupSymbol(const ConstString &name) { lldb::addr_t PersistentExpressionState::LookupSymbol(ConstString name) {
SymbolMap::iterator si = m_symbol_map.find(name.GetCString()); SymbolMap::iterator si = m_symbol_map.find(name.GetCString());
if (si != m_symbol_map.end()) if (si != m_symbol_map.end())
return si->second; return si->second;
else else
return LLDB_INVALID_ADDRESS; return LLDB_INVALID_ADDRESS;
} }
Show All 16 Lines

lldb/source/Expression/IRExecutionUnit.cpp

Show All 16 Lines
if (err && err->Success()) { if (err && err->Success()) {
err->SetErrorToGenericError(); err->SetErrorToGenericError();
err->SetErrorStringWithFormat("Inline assembly error: %s", err->SetErrorStringWithFormat("Inline assembly error: %s",
diagnostic.getMessage().str().c_str()); diagnostic.getMessage().str().c_str());
} }
} }
void IRExecutionUnit::ReportSymbolLookupError(const ConstString &name) { void IRExecutionUnit::ReportSymbolLookupError(ConstString name) {
m_failed_lookups.push_back(name); m_failed_lookups.push_back(name);
} }
void IRExecutionUnit::GetRunnableInfo(Status &error, lldb::addr_t &func_addr, void IRExecutionUnit::GetRunnableInfo(Status &error, lldb::addr_t &func_addr,
lldb::addr_t &func_end) { lldb::addr_t &func_end) {
lldb::ProcessSP process_sp(GetProcessWP().lock()); lldb::ProcessSP process_sp(GetProcessWP().lock());
static std::recursive_mutex s_runnable_info_mutex; static std::recursive_mutex s_runnable_info_mutex;
Show All 32 Lines
if (m_failed_lookups.size()) { if (m_failed_lookups.size()) {
StreamString ss; StreamString ss;
ss.PutCString("Couldn't lookup symbols:\n"); ss.PutCString("Couldn't lookup symbols:\n");
bool emitNewLine = false; bool emitNewLine = false;
for (const ConstString &failed_lookup : m_failed_lookups) { for (ConstString failed_lookup : m_failed_lookups) {
if (emitNewLine) if (emitNewLine)
ss.PutCString("\n"); ss.PutCString("\n");
emitNewLine = true; emitNewLine = true;
ss.PutCString(" "); ss.PutCString(" ");
ss.PutCString(Mangled(failed_lookup) ss.PutCString(Mangled(failed_lookup)
.GetDemangledName(lldb::eLanguageTypeObjC_plus_plus) .GetDemangledName(lldb::eLanguageTypeObjC_plus_plus)
.AsCString()); .AsCString());
} }
Show All 32 Lines
m_parent.CommitOneAllocation(process_sp, err, m_parent.m_records.back()); m_parent.CommitOneAllocation(process_sp, err, m_parent.m_records.back());
} }
return return_value; return return_value;
} }
static ConstString static ConstString
FindBestAlternateMangledName(const ConstString &demangled, FindBestAlternateMangledName(ConstString demangled,
const lldb::LanguageType &lang_type, const lldb::LanguageType &lang_type,
const SymbolContext &sym_ctx) { const SymbolContext &sym_ctx) {
CPlusPlusLanguage::MethodName cpp_name(demangled); CPlusPlusLanguage::MethodName cpp_name(demangled);
std::string scope_qualified_name = cpp_name.GetScopeQualifiedName(); std::string scope_qualified_name = cpp_name.GetScopeQualifiedName();
if (!scope_qualified_name.size()) if (!scope_qualified_name.size())
return ConstString(); return ConstString();
Show All 32 Lines
SearchSpec(ConstString n, SearchSpec(ConstString n,
lldb::FunctionNameType m = lldb::eFunctionNameTypeFull) lldb::FunctionNameType m = lldb::eFunctionNameTypeFull)
: name(n), mask(m) {} : name(n), mask(m) {}
}; };
void IRExecutionUnit::CollectCandidateCNames( void IRExecutionUnit::CollectCandidateCNames(
std::vector<IRExecutionUnit::SearchSpec> &C_specs, std::vector<IRExecutionUnit::SearchSpec> &C_specs,
const ConstString &name) { ConstString name) {
if (m_strip_underscore && name.AsCString()[0] == '_') if (m_strip_underscore && name.AsCString()[0] == '_')
C_specs.insert(C_specs.begin(), ConstString(&name.AsCString()[1])); C_specs.insert(C_specs.begin(), ConstString(&name.AsCString()[1]));
C_specs.push_back(SearchSpec(name)); C_specs.push_back(SearchSpec(name));
} }
void IRExecutionUnit::CollectCandidateCPlusPlusNames( void IRExecutionUnit::CollectCandidateCPlusPlusNames(
std::vector<IRExecutionUnit::SearchSpec> &CPP_specs, std::vector<IRExecutionUnit::SearchSpec> &CPP_specs,
const std::vector<SearchSpec> &C_specs, const SymbolContext &sc) { const std::vector<SearchSpec> &C_specs, const SymbolContext &sc) {
for (const SearchSpec &C_spec : C_specs) { for (const SearchSpec &C_spec : C_specs) {
const ConstString &name = C_spec.name; ConstString name = C_spec.name;
if (CPlusPlusLanguage::IsCPPMangledName(name.GetCString())) { if (CPlusPlusLanguage::IsCPPMangledName(name.GetCString())) {
Mangled mangled(name, true); Mangled mangled(name, true);
ConstString demangled = ConstString demangled =
mangled.GetDemangledName(lldb::eLanguageTypeC_plus_plus); mangled.GetDemangledName(lldb::eLanguageTypeC_plus_plus);
if (demangled) { if (demangled) {
ConstString best_alternate_mangled_name = FindBestAlternateMangledName( ConstString best_alternate_mangled_name = FindBestAlternateMangledName(
Show All 15 Lines
void IRExecutionUnit::CollectFallbackNames( void IRExecutionUnit::CollectFallbackNames(
std::vector<SearchSpec> &fallback_specs, std::vector<SearchSpec> &fallback_specs,
const std::vector<SearchSpec> &C_specs) { const std::vector<SearchSpec> &C_specs) {
// As a last-ditch fallback, try the base name for C++ names. It's terrible, // As a last-ditch fallback, try the base name for C++ names. It's terrible,
// but the DWARF doesn't always encode "extern C" correctly. // but the DWARF doesn't always encode "extern C" correctly.
for (const SearchSpec &C_spec : C_specs) { for (const SearchSpec &C_spec : C_specs) {
const ConstString &name = C_spec.name; ConstString name = C_spec.name;
if (CPlusPlusLanguage::IsCPPMangledName(name.GetCString())) { if (CPlusPlusLanguage::IsCPPMangledName(name.GetCString())) {
Mangled mangled_name(name); Mangled mangled_name(name);
ConstString demangled_name = ConstString demangled_name =
mangled_name.GetDemangledName(lldb::eLanguageTypeC_plus_plus); mangled_name.GetDemangledName(lldb::eLanguageTypeC_plus_plus);
if (!demangled_name.IsEmpty()) { if (!demangled_name.IsEmpty()) {
const char *demangled_cstr = demangled_name.AsCString(); const char *demangled_cstr = demangled_name.AsCString();
const char *lparen_loc = strchr(demangled_cstr, '('); const char *lparen_loc = strchr(demangled_cstr, '(');
Show All 32 Lines
if (symbol_load_addr != LLDB_INVALID_ADDRESS) if (symbol_load_addr != LLDB_INVALID_ADDRESS)
return symbol_load_addr; return symbol_load_addr;
} }
return LLDB_INVALID_ADDRESS; return LLDB_INVALID_ADDRESS;
} }
lldb::addr_t lldb::addr_t
IRExecutionUnit::FindSymbol(const lldb_private::ConstString &name) { IRExecutionUnit::FindSymbol(lldb_private::ConstString name) {
std::vector<SearchSpec> candidate_C_names; std::vector<SearchSpec> candidate_C_names;
std::vector<SearchSpec> candidate_CPlusPlus_names; std::vector<SearchSpec> candidate_CPlusPlus_names;
CollectCandidateCNames(candidate_C_names, name); CollectCandidateCNames(candidate_C_names, name);
lldb::addr_t ret = FindInSymbols(candidate_C_names, m_sym_ctx); lldb::addr_t ret = FindInSymbols(candidate_C_names, m_sym_ctx);
if (ret == LLDB_INVALID_ADDRESS) if (ret == LLDB_INVALID_ADDRESS)
ret = FindInRuntimes(candidate_C_names, m_sym_ctx); ret = FindInRuntimes(candidate_C_names, m_sym_ctx);
Show All 16 Lines

lldb/source/Host/common/FileSystem.cpp

Show All 16 Lines
std::shared_ptr<DataBufferLLVM> std::shared_ptr<DataBufferLLVM>
FileSystem::CreateDataBuffer(const FileSpec &file_spec, uint64_t size, FileSystem::CreateDataBuffer(const FileSpec &file_spec, uint64_t size,
uint64_t offset) { uint64_t offset) {
return CreateDataBuffer(file_spec.GetPath(), size, offset); return CreateDataBuffer(file_spec.GetPath(), size, offset);
} }
bool FileSystem::ResolveExecutableLocation(FileSpec &file_spec) { bool FileSystem::ResolveExecutableLocation(FileSpec &file_spec) {
// If the directory is set there's nothing to do. // If the directory is set there's nothing to do.
const ConstString &directory = file_spec.GetDirectory(); ConstString directory = file_spec.GetDirectory();
if (directory) if (directory)
return false; return false;
// We cannot look for a file if there's no file name. // We cannot look for a file if there's no file name.
const ConstString &filename = file_spec.GetFilename(); ConstString filename = file_spec.GetFilename();
if (!filename) if (!filename)
return false; return false;
// Search for the file on the host. // Search for the file on the host.
const std::string filename_str(filename.GetCString()); const std::string filename_str(filename.GetCString());
llvm::ErrorOr<std::string> error_or_path = llvm::ErrorOr<std::string> error_or_path =
llvm::sys::findProgramByName(filename_str); llvm::sys::findProgramByName(filename_str);
if (!error_or_path) if (!error_or_path)
Show All 16 Lines

lldb/source/Interpreter/OptionValueDictionary.cpp

Show All 16 Lines
else { else {
if (error.AsCString() == nullptr) if (error.AsCString() == nullptr)
error.SetErrorStringWithFormat("invalid value path '%s'", name.str().c_str()); error.SetErrorStringWithFormat("invalid value path '%s'", name.str().c_str());
} }
return error; return error;
} }
lldb::OptionValueSP lldb::OptionValueSP
OptionValueDictionary::GetValueForKey(const ConstString &key) const { OptionValueDictionary::GetValueForKey(ConstString key) const {
lldb::OptionValueSP value_sp; lldb::OptionValueSP value_sp;
collection::const_iterator pos = m_values.find(key); collection::const_iterator pos = m_values.find(key);
if (pos != m_values.end()) if (pos != m_values.end())
value_sp = pos->second; value_sp = pos->second;
return value_sp; return value_sp;
} }
bool OptionValueDictionary::SetValueForKey(const ConstString &key, bool OptionValueDictionary::SetValueForKey(ConstString key,
const lldb::OptionValueSP &value_sp, const lldb::OptionValueSP &value_sp,
bool can_replace) { bool can_replace) {
// Make sure the value_sp object is allowed to contain values of the type // Make sure the value_sp object is allowed to contain values of the type
// passed in... // passed in...
if (value_sp && (m_type_mask & value_sp->GetTypeAsMask())) { if (value_sp && (m_type_mask & value_sp->GetTypeAsMask())) {
if (!can_replace) { if (!can_replace) {
collection::const_iterator pos = m_values.find(key); collection::const_iterator pos = m_values.find(key);
if (pos != m_values.end()) if (pos != m_values.end())
return false; return false;
} }
m_values[key] = value_sp; m_values[key] = value_sp;
return true; return true;
} }
return false; return false;
} }
bool OptionValueDictionary::DeleteValueForKey(const ConstString &key) { bool OptionValueDictionary::DeleteValueForKey(ConstString key) {
collection::iterator pos = m_values.find(key); collection::iterator pos = m_values.find(key);
if (pos != m_values.end()) { if (pos != m_values.end()) {
m_values.erase(pos); m_values.erase(pos);
return true; return true;
} }
return false; return false;
} }
Show All 12 Lines

lldb/source/Interpreter/OptionValueProperties.cpp

Show All 14 Lines
#include "lldb/Interpreter/Property.h" #include "lldb/Interpreter/Property.h"
#include "lldb/Utility/Args.h" #include "lldb/Utility/Args.h"
#include "lldb/Utility/Stream.h" #include "lldb/Utility/Stream.h"
#include "lldb/Utility/StringList.h" #include "lldb/Utility/StringList.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
OptionValueProperties::OptionValueProperties(const ConstString &name) OptionValueProperties::OptionValueProperties(ConstString name)
: OptionValue(), m_name(name), m_properties(), m_name_to_index() {} : OptionValue(), m_name(name), m_properties(), m_name_to_index() {}
OptionValueProperties::OptionValueProperties( OptionValueProperties::OptionValueProperties(
const OptionValueProperties &global_properties) const OptionValueProperties &global_properties)
: OptionValue(global_properties), : OptionValue(global_properties),
std::enable_shared_from_this<OptionValueProperties>(), std::enable_shared_from_this<OptionValueProperties>(),
m_name(global_properties.m_name), m_name(global_properties.m_name),
m_properties(global_properties.m_properties), m_properties(global_properties.m_properties),
Show All 29 Lines
void OptionValueProperties::SetValueChangedCallback( void OptionValueProperties::SetValueChangedCallback(
uint32_t property_idx, OptionValueChangedCallback callback, void *baton) { uint32_t property_idx, OptionValueChangedCallback callback, void *baton) {
Property *property = ProtectedGetPropertyAtIndex(property_idx); Property *property = ProtectedGetPropertyAtIndex(property_idx);
if (property) if (property)
property->SetValueChangedCallback(callback, baton); property->SetValueChangedCallback(callback, baton);
} }
void OptionValueProperties::AppendProperty(const ConstString &name, void OptionValueProperties::AppendProperty(ConstString name,
const ConstString &desc, ConstString desc,
bool is_global, bool is_global,
const OptionValueSP &value_sp) { const OptionValueSP &value_sp) {
Property property(name, desc, is_global, value_sp); Property property(name, desc, is_global, value_sp);
m_name_to_index.Append(name, m_properties.size()); m_name_to_index.Append(name, m_properties.size());
m_properties.push_back(property); m_properties.push_back(property);
value_sp->SetParent(shared_from_this()); value_sp->SetParent(shared_from_this());
m_name_to_index.Sort(); m_name_to_index.Sort();
} }
Show All 14 Lines
// strm << m_name; // strm << m_name;
// dumped_something = true; // dumped_something = true;
// } // }
// return dumped_something; // return dumped_something;
//} //}
// //
lldb::OptionValueSP lldb::OptionValueSP
OptionValueProperties::GetValueForKey(const ExecutionContext *exe_ctx, OptionValueProperties::GetValueForKey(const ExecutionContext *exe_ctx,
const ConstString &key, ConstString key,
bool will_modify) const { bool will_modify) const {
lldb::OptionValueSP value_sp; lldb::OptionValueSP value_sp;
size_t idx = m_name_to_index.Find(key, SIZE_MAX); size_t idx = m_name_to_index.Find(key, SIZE_MAX);
if (idx < m_properties.size()) if (idx < m_properties.size())
value_sp = GetPropertyAtIndex(exe_ctx, will_modify, idx)->GetValue(); value_sp = GetPropertyAtIndex(exe_ctx, will_modify, idx)->GetValue();
return value_sp; return value_sp;
} }
Show All 32 Lines
if (!name_contains_experimental && error.AsCString() == nullptr) { if (!name_contains_experimental && error.AsCString() == nullptr) {
error.SetErrorStringWithFormat("invalid value path '%s'", name.str().c_str()); error.SetErrorStringWithFormat("invalid value path '%s'", name.str().c_str());
} }
} }
return error; return error;
} }
uint32_t uint32_t
OptionValueProperties::GetPropertyIndex(const ConstString &name) const { OptionValueProperties::GetPropertyIndex(ConstString name) const {
return m_name_to_index.Find(name, SIZE_MAX); return m_name_to_index.Find(name, SIZE_MAX);
} }
const Property * const Property *
OptionValueProperties::GetProperty(const ExecutionContext *exe_ctx, OptionValueProperties::GetProperty(const ExecutionContext *exe_ctx,
bool will_modify, bool will_modify,
const ConstString &name) const { ConstString name) const {
return GetPropertyAtIndex( return GetPropertyAtIndex(
exe_ctx, will_modify, exe_ctx, will_modify,
m_name_to_index.Find(name, SIZE_MAX)); m_name_to_index.Find(name, SIZE_MAX));
} }
const Property *OptionValueProperties::GetPropertyAtIndex( const Property *OptionValueProperties::GetPropertyAtIndex(
const ExecutionContext *exe_ctx, bool will_modify, uint32_t idx) const { const ExecutionContext *exe_ctx, bool will_modify, uint32_t idx) const {
return ProtectedGetPropertyAtIndex(idx); return ProtectedGetPropertyAtIndex(idx);
Show All 32 Lines
} }
} }
} }
} }
} }
lldb::OptionValuePropertiesSP lldb::OptionValuePropertiesSP
OptionValueProperties::GetSubProperty(const ExecutionContext *exe_ctx, OptionValueProperties::GetSubProperty(const ExecutionContext *exe_ctx,
const ConstString &name) { ConstString name) {
lldb::OptionValueSP option_value_sp(GetValueForKey(exe_ctx, name, false)); lldb::OptionValueSP option_value_sp(GetValueForKey(exe_ctx, name, false));
if (option_value_sp) { if (option_value_sp) {
OptionValueProperties *ov_properties = option_value_sp->GetAsProperties(); OptionValueProperties *ov_properties = option_value_sp->GetAsProperties();
if (ov_properties) if (ov_properties)
return ov_properties->shared_from_this(); return ov_properties->shared_from_this();
} }
return lldb::OptionValuePropertiesSP(); return lldb::OptionValuePropertiesSP();
} }
Context not available.

lldb/source/Interpreter/Property.cpp

Show All 16 Lines
if (definition.default_uint_value != 0) if (definition.default_uint_value != 0)
string_value->GetOptions().Reset(definition.default_uint_value); string_value->GetOptions().Reset(definition.default_uint_value);
m_value_sp.reset(string_value); m_value_sp.reset(string_value);
} }
break; break;
} }
} }
Property::Property(const ConstString &name, const ConstString &desc, Property::Property(ConstString name, ConstString desc,
bool is_global, const lldb::OptionValueSP &value_sp) bool is_global, const lldb::OptionValueSP &value_sp)
: m_name(name), m_description(desc), m_value_sp(value_sp), : m_name(name), m_description(desc), m_value_sp(value_sp),
m_is_global(is_global) {} m_is_global(is_global) {}
bool Property::DumpQualifiedName(Stream &strm) const { bool Property::DumpQualifiedName(Stream &strm) const {
if (m_name) { if (m_name) {
if (m_value_sp->DumpQualifiedName(strm)) if (m_value_sp->DumpQualifiedName(strm))
strm.PutChar('.'); strm.PutChar('.');
Show All 16 Lines

lldb/source/Plugins/DynamicLoader/Hexagon-DYLD/DynamicLoaderHexagonDYLD.cpp

Show All 16 Lines
assert(exe != nullptr); assert(exe != nullptr);
lldb_private::Symtab *symtab = exe->GetSymtab(); lldb_private::Symtab *symtab = exe->GetSymtab();
assert(symtab != nullptr); assert(symtab != nullptr);
for (size_t i = 0; i < symtab->GetNumSymbols(); i++) { for (size_t i = 0; i < symtab->GetNumSymbols(); i++) {
const Symbol *sym = symtab->SymbolAtIndex(i); const Symbol *sym = symtab->SymbolAtIndex(i);
assert(sym != nullptr); assert(sym != nullptr);
const ConstString &symName = sym->GetName(); ConstString symName = sym->GetName();
if (ConstString::Compare(findName, symName) == 0) { if (ConstString::Compare(findName, symName) == 0) {
Address addr = sym->GetAddress(); Address addr = sym->GetAddress();
return addr.GetLoadAddress(&proc->GetTarget()); return addr.GetLoadAddress(&proc->GetTarget());
} }
} }
return LLDB_INVALID_ADDRESS; return LLDB_INVALID_ADDRESS;
} }
Show All 16 Lines

lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderDarwin.h

Show All 16 Lines
return 0; return 0;
} }
lldb_private::ArchSpec GetArchitecture() const { lldb_private::ArchSpec GetArchitecture() const {
return lldb_private::ArchSpec(lldb_private::eArchTypeMachO, return lldb_private::ArchSpec(lldb_private::eArchTypeMachO,
header.cputype, header.cpusubtype); header.cputype, header.cpusubtype);
} }
const Segment *FindSegment(const lldb_private::ConstString &name) const; const Segment *FindSegment(lldb_private::ConstString name) const;
void PutToLog(lldb_private::Log *log) const; void PutToLog(lldb_private::Log *log) const;
typedef std::vector<ImageInfo> collection; typedef std::vector<ImageInfo> collection;
typedef collection::iterator iterator; typedef collection::iterator iterator;
typedef collection::const_iterator const_iterator; typedef collection::const_iterator const_iterator;
}; };
Show All 16 Lines

lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderDarwin.cpp

Show All 16 Lines
log->Printf("\t\t%16s [0x%16.16" PRIx64 " - 0x%16.16" PRIx64 log->Printf("\t\t%16s [0x%16.16" PRIx64 " - 0x%16.16" PRIx64
") slide = 0x%" PRIx64, ") slide = 0x%" PRIx64,
name.AsCString(""), vmaddr + slide, vmaddr + slide + vmsize, name.AsCString(""), vmaddr + slide, vmaddr + slide + vmsize,
slide); slide);
} }
} }
const DynamicLoaderDarwin::Segment * const DynamicLoaderDarwin::Segment *
DynamicLoaderDarwin::ImageInfo::FindSegment(const ConstString &name) const { DynamicLoaderDarwin::ImageInfo::FindSegment(ConstString name) const {
const size_t num_segments = segments.size(); const size_t num_segments = segments.size();
for (size_t i = 0; i < num_segments; ++i) { for (size_t i = 0; i < num_segments; ++i) {
if (segments[i].name == name) if (segments[i].name == name)
return &segments[i]; return &segments[i];
} }
return NULL; return NULL;
} }
Show All 32 Lines
Symbol *current_symbol = current_context.symbol; Symbol *current_symbol = current_context.symbol;
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP)); Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
TargetSP target_sp(thread.CalculateTarget()); TargetSP target_sp(thread.CalculateTarget());
if (current_symbol != NULL) { if (current_symbol != NULL) {
std::vector<Address> addresses; std::vector<Address> addresses;
if (current_symbol->IsTrampoline()) { if (current_symbol->IsTrampoline()) {
const ConstString &trampoline_name = current_symbol->GetMangled().GetName( ConstString trampoline_name = current_symbol->GetMangled().GetName(
current_symbol->GetLanguage(), Mangled::ePreferMangled); current_symbol->GetLanguage(), Mangled::ePreferMangled);
if (trampoline_name) { if (trampoline_name) {
const ModuleList &images = target_sp->GetImages(); const ModuleList &images = target_sp->GetImages();
SymbolContextList code_symbols; SymbolContextList code_symbols;
images.FindSymbolsWithNameAndType(trampoline_name, eSymbolTypeCode, images.FindSymbolsWithNameAndType(trampoline_name, eSymbolTypeCode,
code_symbols); code_symbols);
Show All 32 Lines
} }
return thread_plan_sp; return thread_plan_sp;
} }
size_t DynamicLoaderDarwin::FindEquivalentSymbols( size_t DynamicLoaderDarwin::FindEquivalentSymbols(
lldb_private::Symbol *original_symbol, lldb_private::ModuleList &images, lldb_private::Symbol *original_symbol, lldb_private::ModuleList &images,
lldb_private::SymbolContextList &equivalent_symbols) { lldb_private::SymbolContextList &equivalent_symbols) {
const ConstString &trampoline_name = original_symbol->GetMangled().GetName( ConstString trampoline_name = original_symbol->GetMangled().GetName(
original_symbol->GetLanguage(), Mangled::ePreferMangled); original_symbol->GetLanguage(), Mangled::ePreferMangled);
if (!trampoline_name) if (!trampoline_name)
return 0; return 0;
size_t initial_size = equivalent_symbols.GetSize(); size_t initial_size = equivalent_symbols.GetSize();
static const char *resolver_name_regex = "(_gc|_non_gc|\\$[A-Za-z0-9\\$]+)$"; static const char *resolver_name_regex = "(_gc|_non_gc|\\$[A-Za-z0-9\\$]+)$";
std::string equivalent_regex_buf("^"); std::string equivalent_regex_buf("^");
Show All 16 Lines

lldb/source/Plugins/ExpressionParser/Clang/ClangASTSource.h

Show All 16 Lines
/// @param[in] name /// @param[in] name
/// The name of the namespace to be found. /// The name of the namespace to be found.
/// ///
/// @param[in] parent_map /// @param[in] parent_map
/// The map for the namespace's parent namespace, if there is /// The map for the namespace's parent namespace, if there is
/// one. /// one.
//------------------------------------------------------------------ //------------------------------------------------------------------
void CompleteNamespaceMap( void CompleteNamespaceMap(
ClangASTImporter::NamespaceMapSP &namespace_map, const ConstString &name, ClangASTImporter::NamespaceMapSP &namespace_map, ConstString name,
ClangASTImporter::NamespaceMapSP &parent_map) const override; ClangASTImporter::NamespaceMapSP &parent_map) const override;
// //
// Helper APIs // Helper APIs
// //
clang::NamespaceDecl * clang::NamespaceDecl *
AddNamespace(NameSearchContext &context, AddNamespace(NameSearchContext &context,
Show All 16 Lines

lldb/source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp

Show All 16 Lines
log->Printf("LRD[%u] Not a CXXRecord, so no bases", current_id); log->Printf("LRD[%u] Not a CXXRecord, so no bases", current_id);
} }
} }
return true; return true;
} }
void ClangASTSource::CompleteNamespaceMap( void ClangASTSource::CompleteNamespaceMap(
ClangASTImporter::NamespaceMapSP &namespace_map, const ConstString &name, ClangASTImporter::NamespaceMapSP &namespace_map, ConstString name,
ClangASTImporter::NamespaceMapSP &parent_map) const { ClangASTImporter::NamespaceMapSP &parent_map) const {
static unsigned int invocation_id = 0; static unsigned int invocation_id = 0;
unsigned int current_id = invocation_id++; unsigned int current_id = invocation_id++;
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
if (log) { if (log) {
if (parent_map && parent_map->size()) if (parent_map && parent_map->size())
Show All 16 Lines

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.h

Show All 16 Lines
/// ///
/// @param[in] type /// @param[in] type
/// The type of the variable, in the Clang parser's context. /// The type of the variable, in the Clang parser's context.
/// ///
/// @return /// @return
/// True on success; false otherwise. /// True on success; false otherwise.
//------------------------------------------------------------------ //------------------------------------------------------------------
bool AddPersistentVariable(const clang::NamedDecl *decl, bool AddPersistentVariable(const clang::NamedDecl *decl,
const ConstString &name, TypeFromParser type, ConstString name, TypeFromParser type,
bool is_result, bool is_lvalue); bool is_result, bool is_lvalue);
//------------------------------------------------------------------ //------------------------------------------------------------------
/// [Used by IRForTarget] Add a variable to the struct that needs to /// [Used by IRForTarget] Add a variable to the struct that needs to
/// be materialized each time the expression runs. /// be materialized each time the expression runs.
/// ///
/// @param[in] decl /// @param[in] decl
/// The Clang declaration for the variable. /// The Clang declaration for the variable.
/// ///
/// @param[in] name /// @param[in] name
/// The name of the variable. /// The name of the variable.
/// ///
/// @param[in] value /// @param[in] value
/// The LLVM IR value for this variable. /// The LLVM IR value for this variable.
/// ///
/// @param[in] size /// @param[in] size
/// The size of the variable in bytes. /// The size of the variable in bytes.
/// ///
/// @param[in] alignment /// @param[in] alignment
/// The required alignment of the variable in bytes. /// The required alignment of the variable in bytes.
/// ///
/// @return /// @return
/// True on success; false otherwise. /// True on success; false otherwise.
//------------------------------------------------------------------ //------------------------------------------------------------------
bool AddValueToStruct(const clang::NamedDecl *decl, const ConstString &name, bool AddValueToStruct(const clang::NamedDecl *decl, ConstString name,
llvm::Value *value, size_t size, llvm::Value *value, size_t size,
lldb::offset_t alignment); lldb::offset_t alignment);
//------------------------------------------------------------------ //------------------------------------------------------------------
/// [Used by IRForTarget] Finalize the struct, laying out the position of /// [Used by IRForTarget] Finalize the struct, laying out the position of
/// each object in it. /// each object in it.
/// ///
/// @return /// @return
Show All 32 Lines
/// ///
/// @param[in] module /// @param[in] module
/// The module to limit the search to. This can be NULL /// The module to limit the search to. This can be NULL
/// ///
/// @return /// @return
/// Valid load address for the symbol /// Valid load address for the symbol
//------------------------------------------------------------------ //------------------------------------------------------------------
lldb::addr_t GetSymbolAddress(Target &target, Process *process, lldb::addr_t GetSymbolAddress(Target &target, Process *process,
const ConstString &name, ConstString name,
lldb::SymbolType symbol_type, lldb::SymbolType symbol_type,
Module *module = NULL); Module *module = NULL);
lldb::addr_t GetSymbolAddress(const ConstString &name, lldb::addr_t GetSymbolAddress(ConstString name,
lldb::SymbolType symbol_type); lldb::SymbolType symbol_type);
//------------------------------------------------------------------ //------------------------------------------------------------------
/// [Used by IRInterpreter] Get basic target information. /// [Used by IRInterpreter] Get basic target information.
/// ///
/// @param[out] byte_order /// @param[out] byte_order
/// The byte order of the target. /// The byte order of the target.
/// ///
Show All 32 Lines
/// The required type for the variable. This function may be called /// The required type for the variable. This function may be called
/// during parsing, in which case we don't know its type; hence the /// during parsing, in which case we don't know its type; hence the
/// default. /// default.
/// ///
/// @return /// @return
/// The LLDB Variable found, or NULL if none was found. /// The LLDB Variable found, or NULL if none was found.
//------------------------------------------------------------------ //------------------------------------------------------------------
lldb::VariableSP FindGlobalVariable(Target &target, lldb::ModuleSP &module, lldb::VariableSP FindGlobalVariable(Target &target, lldb::ModuleSP &module,
const ConstString &name, ConstString name,
CompilerDeclContext *namespace_decl, CompilerDeclContext *namespace_decl,
TypeFromUser *type = NULL); TypeFromUser *type = NULL);
//------------------------------------------------------------------ //------------------------------------------------------------------
/// Get the value of a variable in a given execution context and return the /// Get the value of a variable in a given execution context and return the
/// associated Types if needed. /// associated Types if needed.
/// ///
/// @param[in] var /// @param[in] var
Show All 16 Lines

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

Show All 16 Lines
return TypeFromUser(exported_type.getAsOpaquePtr(), &target); return TypeFromUser(exported_type.getAsOpaquePtr(), &target);
} else { } else {
lldbassert(0 && "No mechanism for deporting a type!"); lldbassert(0 && "No mechanism for deporting a type!");
return TypeFromUser(); return TypeFromUser();
} }
} }
bool ClangExpressionDeclMap::AddPersistentVariable(const NamedDecl *decl, bool ClangExpressionDeclMap::AddPersistentVariable(const NamedDecl *decl,
const ConstString &name, ConstString name,
TypeFromParser parser_type, TypeFromParser parser_type,
bool is_result, bool is_result,
bool is_lvalue) { bool is_lvalue) {
assert(m_parser_vars.get()); assert(m_parser_vars.get());
ClangASTContext *ast = ClangASTContext *ast =
llvm::dyn_cast_or_null<ClangASTContext>(parser_type.GetTypeSystem()); llvm::dyn_cast_or_null<ClangASTContext>(parser_type.GetTypeSystem());
if (ast == nullptr) if (ast == nullptr)
Show All 32 Lines
parser_vars->m_named_decl = decl; parser_vars->m_named_decl = decl;
parser_vars->m_parser_type = parser_type; parser_vars->m_parser_type = parser_type;
return true; return true;
} }
bool ClangExpressionDeclMap::AddValueToStruct(const NamedDecl *decl, bool ClangExpressionDeclMap::AddValueToStruct(const NamedDecl *decl,
const ConstString &name, ConstString name,
llvm::Value *value, size_t size, llvm::Value *value, size_t size,
lldb::offset_t alignment) { lldb::offset_t alignment) {
assert(m_struct_vars.get()); assert(m_struct_vars.get());
assert(m_parser_vars.get()); assert(m_parser_vars.get());
bool is_persistent_variable = false; bool is_persistent_variable = false;
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
Show All 32 Lines
ptr = parser_vars->m_lldb_value.GetScalar().ULongLong(); ptr = parser_vars->m_lldb_value.GetScalar().ULongLong();
return true; return true;
} }
addr_t ClangExpressionDeclMap::GetSymbolAddress(Target &target, addr_t ClangExpressionDeclMap::GetSymbolAddress(Target &target,
Process *process, Process *process,
const ConstString &name, ConstString name,
lldb::SymbolType symbol_type, lldb::SymbolType symbol_type,
lldb_private::Module *module) { lldb_private::Module *module) {
SymbolContextList sc_list; SymbolContextList sc_list;
if (module) if (module)
module->FindSymbolsWithNameAndType(name, symbol_type, sc_list); module->FindSymbolsWithNameAndType(name, symbol_type, sc_list);
else else
target.GetImages().FindSymbolsWithNameAndType(name, symbol_type, sc_list); target.GetImages().FindSymbolsWithNameAndType(name, symbol_type, sc_list);
Show All 32 Lines
if (runtime) { if (runtime) {
symbol_load_addr = runtime->LookupRuntimeSymbol(name); symbol_load_addr = runtime->LookupRuntimeSymbol(name);
} }
} }
return symbol_load_addr; return symbol_load_addr;
} }
addr_t ClangExpressionDeclMap::GetSymbolAddress(const ConstString &name, addr_t ClangExpressionDeclMap::GetSymbolAddress(ConstString name,
lldb::SymbolType symbol_type) { lldb::SymbolType symbol_type) {
assert(m_parser_vars.get()); assert(m_parser_vars.get());
if (!m_parser_vars->m_exe_ctx.GetTargetPtr()) if (!m_parser_vars->m_exe_ctx.GetTargetPtr())
return false; return false;
return GetSymbolAddress(m_parser_vars->m_exe_ctx.GetTargetRef(), return GetSymbolAddress(m_parser_vars->m_exe_ctx.GetTargetRef(),
m_parser_vars->m_exe_ctx.GetProcessPtr(), name, m_parser_vars->m_exe_ctx.GetProcessPtr(), name,
symbol_type); symbol_type);
} }
lldb::VariableSP ClangExpressionDeclMap::FindGlobalVariable( lldb::VariableSP ClangExpressionDeclMap::FindGlobalVariable(
Target &target, ModuleSP &module, const ConstString &name, Target &target, ModuleSP &module, ConstString name,
CompilerDeclContext *namespace_decl, TypeFromUser *type) { CompilerDeclContext *namespace_decl, TypeFromUser *type) {
VariableList vars; VariableList vars;
if (module && namespace_decl) if (module && namespace_decl)
module->FindGlobalVariables(name, namespace_decl, -1, vars); module->FindGlobalVariables(name, namespace_decl, -1, vars);
else else
target.GetImages().FindGlobalVariables(name, -1, vars); target.GetImages().FindGlobalVariables(name, -1, vars);
Show All 16 Lines

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionVariable.h

Show All 16 Lines
/// and provides necessary support methods. Its interface is RTTI-neutral. /// and provides necessary support methods. Its interface is RTTI-neutral.
//---------------------------------------------------------------------- //----------------------------------------------------------------------
class ClangExpressionVariable : public ExpressionVariable { class ClangExpressionVariable : public ExpressionVariable {
public: public:
ClangExpressionVariable(ExecutionContextScope *exe_scope, ClangExpressionVariable(ExecutionContextScope *exe_scope,
lldb::ByteOrder byte_order, uint32_t addr_byte_size); lldb::ByteOrder byte_order, uint32_t addr_byte_size);
ClangExpressionVariable(ExecutionContextScope *exe_scope, Value &value, ClangExpressionVariable(ExecutionContextScope *exe_scope, Value &value,
const ConstString &name, uint16_t flags = EVNone); ConstString name, uint16_t flags = EVNone);
ClangExpressionVariable(const lldb::ValueObjectSP &valobj_sp); ClangExpressionVariable(const lldb::ValueObjectSP &valobj_sp);
ClangExpressionVariable(ExecutionContextScope *exe_scope, ClangExpressionVariable(ExecutionContextScope *exe_scope,
const ConstString &name, ConstString name,
const TypeFromUser &user_type, const TypeFromUser &user_type,
lldb::ByteOrder byte_order, uint32_t addr_byte_size); lldb::ByteOrder byte_order, uint32_t addr_byte_size);
//---------------------------------------------------------------------- //----------------------------------------------------------------------
/// Utility functions for dealing with ExpressionVariableLists in Clang- /// Utility functions for dealing with ExpressionVariableLists in Clang-
/// specific ways /// specific ways
//---------------------------------------------------------------------- //----------------------------------------------------------------------
Show All 16 Lines

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionVariable.cpp

Show All 16 Lines
: ExpressionVariable(LLVMCastKind::eKindClang), m_parser_vars(), : ExpressionVariable(LLVMCastKind::eKindClang), m_parser_vars(),
m_jit_vars() { m_jit_vars() {
m_flags = EVNone; m_flags = EVNone;
m_frozen_sp = m_frozen_sp =
ValueObjectConstResult::Create(exe_scope, byte_order, addr_byte_size); ValueObjectConstResult::Create(exe_scope, byte_order, addr_byte_size);
} }
ClangExpressionVariable::ClangExpressionVariable( ClangExpressionVariable::ClangExpressionVariable(
ExecutionContextScope *exe_scope, Value &value, const ConstString &name, ExecutionContextScope *exe_scope, Value &value, ConstString name,
uint16_t flags) uint16_t flags)
: ExpressionVariable(LLVMCastKind::eKindClang), m_parser_vars(), : ExpressionVariable(LLVMCastKind::eKindClang), m_parser_vars(),
m_jit_vars() { m_jit_vars() {
m_flags = flags; m_flags = flags;
m_frozen_sp = ValueObjectConstResult::Create(exe_scope, value, name); m_frozen_sp = ValueObjectConstResult::Create(exe_scope, value, name);
} }
ClangExpressionVariable::ClangExpressionVariable( ClangExpressionVariable::ClangExpressionVariable(
const lldb::ValueObjectSP &valobj_sp) const lldb::ValueObjectSP &valobj_sp)
: ExpressionVariable(LLVMCastKind::eKindClang), m_parser_vars(), : ExpressionVariable(LLVMCastKind::eKindClang), m_parser_vars(),
m_jit_vars() { m_jit_vars() {
m_flags = EVNone; m_flags = EVNone;
m_frozen_sp = valobj_sp; m_frozen_sp = valobj_sp;
} }
ClangExpressionVariable::ClangExpressionVariable( ClangExpressionVariable::ClangExpressionVariable(
ExecutionContextScope *exe_scope, const ConstString &name, ExecutionContextScope *exe_scope, ConstString name,
const TypeFromUser &user_type, lldb::ByteOrder byte_order, const TypeFromUser &user_type, lldb::ByteOrder byte_order,
uint32_t addr_byte_size) uint32_t addr_byte_size)
: ExpressionVariable(LLVMCastKind::eKindClang), m_parser_vars(), : ExpressionVariable(LLVMCastKind::eKindClang), m_parser_vars(),
m_jit_vars() { m_jit_vars() {
m_flags = EVNone; m_flags = EVNone;
m_frozen_sp = m_frozen_sp =
ValueObjectConstResult::Create(exe_scope, byte_order, addr_byte_size); ValueObjectConstResult::Create(exe_scope, byte_order, addr_byte_size);
SetName(name); SetName(name);
SetCompilerType(user_type); SetCompilerType(user_type);
} }
TypeFromUser ClangExpressionVariable::GetTypeFromUser() { TypeFromUser ClangExpressionVariable::GetTypeFromUser() {
TypeFromUser tfu(m_frozen_sp->GetCompilerType()); TypeFromUser tfu(m_frozen_sp->GetCompilerType());
return tfu; return tfu;
} }
Context not available.

lldb/source/Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.cpp

Show All 16 Lines
~ClangModulesDeclVendorImpl() override = default; ~ClangModulesDeclVendorImpl() override = default;
bool AddModule(const SourceModule &module, ModuleVector *exported_modules, bool AddModule(const SourceModule &module, ModuleVector *exported_modules,
Stream &error_stream) override; Stream &error_stream) override;
bool AddModulesForCompileUnit(CompileUnit &cu, ModuleVector &exported_modules, bool AddModulesForCompileUnit(CompileUnit &cu, ModuleVector &exported_modules,
Stream &error_stream) override; Stream &error_stream) override;
uint32_t FindDecls(const ConstString &name, bool append, uint32_t max_matches, uint32_t FindDecls(ConstString name, bool append, uint32_t max_matches,
std::vector<clang::NamedDecl *> &decls) override; std::vector<clang::NamedDecl *> &decls) override;
void ForEachMacro(const ModuleVector &modules, void ForEachMacro(const ModuleVector &modules,
std::function<bool(const std::string &)> handler) override; std::function<bool(const std::string &)> handler) override;
clang::ExternalASTMerger::ImporterSource GetImporterSource() override; clang::ExternalASTMerger::ImporterSource GetImporterSource() override;
private: private:
void void
Show All 32 Lines
return false; return false;
} }
return true; return true;
} }
// ClangImporter::lookupValue // ClangImporter::lookupValue
uint32_t uint32_t
ClangModulesDeclVendorImpl::FindDecls(const ConstString &name, bool append, ClangModulesDeclVendorImpl::FindDecls(ConstString name, bool append,
uint32_t max_matches, uint32_t max_matches,
std::vector<clang::NamedDecl *> &decls) { std::vector<clang::NamedDecl *> &decls) {
if (!m_enabled) { if (!m_enabled) {
return 0; return 0;
} }
if (!append) if (!append)
decls.clear(); decls.clear();
Show All 16 Lines

lldb/source/Plugins/ExpressionParser/Clang/ClangPersistentVariables.h

Show All 16 Lines
static bool classof(const PersistentExpressionState *pv) { static bool classof(const PersistentExpressionState *pv) {
return pv->getKind() == PersistentExpressionState::eKindClang; return pv->getKind() == PersistentExpressionState::eKindClang;
} }
lldb::ExpressionVariableSP lldb::ExpressionVariableSP
CreatePersistentVariable(const lldb::ValueObjectSP &valobj_sp) override; CreatePersistentVariable(const lldb::ValueObjectSP &valobj_sp) override;
lldb::ExpressionVariableSP CreatePersistentVariable( lldb::ExpressionVariableSP CreatePersistentVariable(
ExecutionContextScope *exe_scope, const ConstString &name, ExecutionContextScope *exe_scope, ConstString name,
const CompilerType &compiler_type, lldb::ByteOrder byte_order, const CompilerType &compiler_type, lldb::ByteOrder byte_order,
uint32_t addr_byte_size) override; uint32_t addr_byte_size) override;
void RemovePersistentVariable(lldb::ExpressionVariableSP variable) override; void RemovePersistentVariable(lldb::ExpressionVariableSP variable) override;
llvm::StringRef llvm::StringRef
GetPersistentVariablePrefix(bool is_error) const override { GetPersistentVariablePrefix(bool is_error) const override {
return "$"; return "$";
} }
void RegisterPersistentDecl(const ConstString &name, clang::NamedDecl *decl); void RegisterPersistentDecl(ConstString name, clang::NamedDecl *decl);
clang::NamedDecl *GetPersistentDecl(const ConstString &name); clang::NamedDecl *GetPersistentDecl(ConstString name);
void AddHandLoadedClangModule(ClangModulesDeclVendor::ModuleID module) { void AddHandLoadedClangModule(ClangModulesDeclVendor::ModuleID module) {
m_hand_loaded_clang_modules.push_back(module); m_hand_loaded_clang_modules.push_back(module);
} }
const ClangModulesDeclVendor::ModuleVector &GetHandLoadedClangModules() { const ClangModulesDeclVendor::ModuleVector &GetHandLoadedClangModules() {
return m_hand_loaded_clang_modules; return m_hand_loaded_clang_modules;
} }
Show All 16 Lines

lldb/source/Plugins/ExpressionParser/Clang/ClangPersistentVariables.cpp

Show All 16 Lines
m_next_persistent_variable_id(0) {} m_next_persistent_variable_id(0) {}
ExpressionVariableSP ClangPersistentVariables::CreatePersistentVariable( ExpressionVariableSP ClangPersistentVariables::CreatePersistentVariable(
const lldb::ValueObjectSP &valobj_sp) { const lldb::ValueObjectSP &valobj_sp) {
return AddNewlyConstructedVariable(new ClangExpressionVariable(valobj_sp)); return AddNewlyConstructedVariable(new ClangExpressionVariable(valobj_sp));
} }
ExpressionVariableSP ClangPersistentVariables::CreatePersistentVariable( ExpressionVariableSP ClangPersistentVariables::CreatePersistentVariable(
ExecutionContextScope *exe_scope, const ConstString &name, ExecutionContextScope *exe_scope, ConstString name,
const CompilerType &compiler_type, lldb::ByteOrder byte_order, const CompilerType &compiler_type, lldb::ByteOrder byte_order,
uint32_t addr_byte_size) { uint32_t addr_byte_size) {
return AddNewlyConstructedVariable(new ClangExpressionVariable( return AddNewlyConstructedVariable(new ClangExpressionVariable(
exe_scope, name, compiler_type, byte_order, addr_byte_size)); exe_scope, name, compiler_type, byte_order, addr_byte_size));
} }
void ClangPersistentVariables::RemovePersistentVariable( void ClangPersistentVariables::RemovePersistentVariable(
lldb::ExpressionVariableSP variable) { lldb::ExpressionVariableSP variable) {
RemoveVariable(variable); RemoveVariable(variable);
const char *name = variable->GetName().AsCString(); const char *name = variable->GetName().AsCString();
if (*name != '$') if (*name != '$')
return; return;
name++; name++;
if (strtoul(name, NULL, 0) == m_next_persistent_variable_id - 1) if (strtoul(name, NULL, 0) == m_next_persistent_variable_id - 1)
m_next_persistent_variable_id--; m_next_persistent_variable_id--;
} }
void ClangPersistentVariables::RegisterPersistentDecl(const ConstString &name, void ClangPersistentVariables::RegisterPersistentDecl(ConstString name,
clang::NamedDecl *decl) { clang::NamedDecl *decl) {
m_persistent_decls.insert( m_persistent_decls.insert(
std::pair<const char *, clang::NamedDecl *>(name.GetCString(), decl)); std::pair<const char *, clang::NamedDecl *>(name.GetCString(), decl));
if (clang::EnumDecl *enum_decl = llvm::dyn_cast<clang::EnumDecl>(decl)) { if (clang::EnumDecl *enum_decl = llvm::dyn_cast<clang::EnumDecl>(decl)) {
for (clang::EnumConstantDecl *enumerator_decl : enum_decl->enumerators()) { for (clang::EnumConstantDecl *enumerator_decl : enum_decl->enumerators()) {
m_persistent_decls.insert(std::pair<const char *, clang::NamedDecl *>( m_persistent_decls.insert(std::pair<const char *, clang::NamedDecl *>(
ConstString(enumerator_decl->getNameAsString()).GetCString(), ConstString(enumerator_decl->getNameAsString()).GetCString(),
enumerator_decl)); enumerator_decl));
} }
} }
} }
clang::NamedDecl * clang::NamedDecl *
ClangPersistentVariables::GetPersistentDecl(const ConstString &name) { ClangPersistentVariables::GetPersistentDecl(ConstString name) {
PersistentDeclMap::const_iterator i = PersistentDeclMap::const_iterator i =
m_persistent_decls.find(name.GetCString()); m_persistent_decls.find(name.GetCString());
if (i == m_persistent_decls.end()) if (i == m_persistent_decls.end())
return NULL; return NULL;
else else
return i->second; return i->second;
} }
Context not available.

lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.h

Show All 16 Lines
/// ///
/// @param[in] name /// @param[in] name
/// The name of the result variable. /// The name of the result variable.
/// ///
/// @param[in] type /// @param[in] type
/// The Clang type of the result variable. /// The Clang type of the result variable.
//------------------------------------------------------------------ //------------------------------------------------------------------
void MaybeSetConstantResult(llvm::Constant *initializer, void MaybeSetConstantResult(llvm::Constant *initializer,
const lldb_private::ConstString &name, lldb_private::ConstString name,
lldb_private::TypeFromParser type); lldb_private::TypeFromParser type);
//------------------------------------------------------------------ //------------------------------------------------------------------
/// If the IR represents a cast of a variable, set m_const_result to the /// If the IR represents a cast of a variable, set m_const_result to the
/// result of the cast. The result variable will be reset to /// result of the cast. The result variable will be reset to
/// NULL latger if the expression has side effects. /// NULL latger if the expression has side effects.
/// ///
/// @param[in] type /// @param[in] type
Show All 16 Lines

lldb/source/Plugins/JITLoader/GDB/JITLoaderGDB.h

Show All 16 Lines
void DidAttach() override; void DidAttach() override;
void DidLaunch() override; void DidLaunch() override;
void ModulesDidLoad(lldb_private::ModuleList &module_list) override; void ModulesDidLoad(lldb_private::ModuleList &module_list) override;
private: private:
lldb::addr_t GetSymbolAddress(lldb_private::ModuleList &module_list, lldb::addr_t GetSymbolAddress(lldb_private::ModuleList &module_list,
const lldb_private::ConstString &name, lldb_private::ConstString name,
lldb::SymbolType symbol_type) const; lldb::SymbolType symbol_type) const;
void SetJITBreakpoint(lldb_private::ModuleList &module_list); void SetJITBreakpoint(lldb_private::ModuleList &module_list);
bool DidSetJITBreakpoint() const; bool DidSetJITBreakpoint() const;
bool ReadJITDescriptor(bool all_entries); bool ReadJITDescriptor(bool all_entries);
Show All 16 Lines

lldb/source/Plugins/JITLoader/GDB/JITLoaderGDB.cpp

Show All 16 Lines
PluginManager::UnregisterPlugin(CreateInstance); PluginManager::UnregisterPlugin(CreateInstance);
} }
bool JITLoaderGDB::DidSetJITBreakpoint() const { bool JITLoaderGDB::DidSetJITBreakpoint() const {
return LLDB_BREAK_ID_IS_VALID(m_jit_break_id); return LLDB_BREAK_ID_IS_VALID(m_jit_break_id);
} }
addr_t JITLoaderGDB::GetSymbolAddress(ModuleList &module_list, addr_t JITLoaderGDB::GetSymbolAddress(ModuleList &module_list,
const ConstString &name, ConstString name,
SymbolType symbol_type) const { SymbolType symbol_type) const {
SymbolContextList target_symbols; SymbolContextList target_symbols;
Target &target = m_process->GetTarget(); Target &target = m_process->GetTarget();
if (!module_list.FindSymbolsWithNameAndType(name, symbol_type, if (!module_list.FindSymbolsWithNameAndType(name, symbol_type,
target_symbols)) target_symbols))
return LLDB_INVALID_ADDRESS; return LLDB_INVALID_ADDRESS;
Show All 10 Lines

lldb/source/Plugins/Language/CPlusPlus/BlockPointer.cpp

Show All 16 Lines
// return true if this object is now safe to use forever without ever // return true if this object is now safe to use forever without ever
// updating again; the typical (and tested) answer here is 'false' // updating again; the typical (and tested) answer here is 'false'
bool Update() override { return false; } bool Update() override { return false; }
// maybe return false if the block pointer is, say, null // maybe return false if the block pointer is, say, null
bool MightHaveChildren() override { return true; } bool MightHaveChildren() override { return true; }
size_t GetIndexOfChildWithName(const ConstString &name) override { size_t GetIndexOfChildWithName(ConstString name) override {
if (!m_block_struct_type.IsValid()) if (!m_block_struct_type.IsValid())
return UINT32_MAX; return UINT32_MAX;
const bool omit_empty_base_classes = false; const bool omit_empty_base_classes = false;
return m_block_struct_type.GetIndexOfChildWithName(name.AsCString(), return m_block_struct_type.GetIndexOfChildWithName(name.AsCString(),
omit_empty_base_classes); omit_empty_base_classes);
} }
Show All 16 Lines

lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.h

Show All 16 Lines
public: public:
class MethodName { class MethodName {
public: public:
MethodName() MethodName()
: m_full(), m_basename(), m_context(), m_arguments(), m_qualifiers(), : m_full(), m_basename(), m_context(), m_arguments(), m_qualifiers(),
m_parsed(false), m_parse_error(false) {} m_parsed(false), m_parse_error(false) {}
MethodName(const ConstString &s) MethodName(ConstString s)
: m_full(s), m_basename(), m_context(), m_arguments(), m_qualifiers(), : m_full(s), m_basename(), m_context(), m_arguments(), m_qualifiers(),
m_parsed(false), m_parse_error(false) {} m_parsed(false), m_parse_error(false) {}
void Clear(); void Clear();
bool IsValid() { bool IsValid() {
if (!m_parsed) if (!m_parsed)
Parse(); Parse();
if (m_parse_error) if (m_parse_error)
return false; return false;
return (bool)m_full; return (bool)m_full;
} }
const ConstString &GetFullName() const { return m_full; } ConstString GetFullName() const { return m_full; }
std::string GetScopeQualifiedName(); std::string GetScopeQualifiedName();
llvm::StringRef GetBasename(); llvm::StringRef GetBasename();
llvm::StringRef GetContext(); llvm::StringRef GetContext();
llvm::StringRef GetArguments(); llvm::StringRef GetArguments();
Show All 16 Lines

lldb/source/Plugins/Language/CPlusPlus/LibCxx.h

Show All 16 Lines
size_t CalculateNumChildren() override; size_t CalculateNumChildren() override;
lldb::ValueObjectSP GetChildAtIndex(size_t idx) override; lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
bool Update() override; bool Update() override;
bool MightHaveChildren() override; bool MightHaveChildren() override;
size_t GetIndexOfChildWithName(const ConstString &name) override; size_t GetIndexOfChildWithName(ConstString name) override;
~LibCxxMapIteratorSyntheticFrontEnd() override; ~LibCxxMapIteratorSyntheticFrontEnd() override;
private: private:
ValueObject *m_pair_ptr; ValueObject *m_pair_ptr;
lldb::ValueObjectSP m_pair_sp; lldb::ValueObjectSP m_pair_sp;
}; };
Show All 12 Lines
size_t CalculateNumChildren() override; size_t CalculateNumChildren() override;
lldb::ValueObjectSP GetChildAtIndex(size_t idx) override; lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
bool Update() override; bool Update() override;
bool MightHaveChildren() override; bool MightHaveChildren() override;
size_t GetIndexOfChildWithName(const ConstString &name) override; size_t GetIndexOfChildWithName(ConstString name) override;
~LibcxxSharedPtrSyntheticFrontEnd() override; ~LibcxxSharedPtrSyntheticFrontEnd() override;
private: private:
ValueObject *m_cntrl; ValueObject *m_cntrl;
lldb::ValueObjectSP m_count_sp; lldb::ValueObjectSP m_count_sp;
lldb::ValueObjectSP m_weak_count_sp; lldb::ValueObjectSP m_weak_count_sp;
uint8_t m_ptr_size; uint8_t m_ptr_size;
Show All 16 Lines

lldb/source/Plugins/Language/CPlusPlus/LibCxx.cpp

Show All 16 Lines
} }
bool lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd:: bool lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd::
MightHaveChildren() { MightHaveChildren() {
return true; return true;
} }
size_t lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd:: size_t lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd::
GetIndexOfChildWithName(const ConstString &name) { GetIndexOfChildWithName(ConstString name) {
if (name == ConstString("first")) if (name == ConstString("first"))
return 0; return 0;
if (name == ConstString("second")) if (name == ConstString("second"))
return 1; return 1;
return UINT32_MAX; return UINT32_MAX;
} }
lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd:: lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEnd::
Show All 32 Lines
} }
bool lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd:: bool lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd::
MightHaveChildren() { MightHaveChildren() {
return true; return true;
} }
size_t lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd:: size_t lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEnd::
GetIndexOfChildWithName(const ConstString &name) { GetIndexOfChildWithName(ConstString name) {
if (name == ConstString("__ptr_")) if (name == ConstString("__ptr_"))
return 0; return 0;
if (name == ConstString("count")) if (name == ConstString("count"))
return 1; return 1;
if (name == ConstString("weak_count")) if (name == ConstString("weak_count"))
return 2; return 2;
return UINT32_MAX; return UINT32_MAX;
} }
Show All 16 Lines

lldb/source/Plugins/Language/CPlusPlus/LibCxxAtomic.cpp

Show All 16 Lines
size_t CalculateNumChildren() override; size_t CalculateNumChildren() override;
lldb::ValueObjectSP GetChildAtIndex(size_t idx) override; lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
bool Update() override; bool Update() override;
bool MightHaveChildren() override; bool MightHaveChildren() override;
size_t GetIndexOfChildWithName(const ConstString &name) override; size_t GetIndexOfChildWithName(ConstString name) override;
lldb::ValueObjectSP GetSyntheticValue() override; lldb::ValueObjectSP GetSyntheticValue() override;
private: private:
ValueObject *m_real_child; ValueObject *m_real_child;
}; };
} // namespace formatters } // namespace formatters
} // namespace lldb_private } // namespace lldb_private
Show All 22 Lines
lldb::ValueObjectSP lldb::ValueObjectSP
lldb_private::formatters::LibcxxStdAtomicSyntheticFrontEnd::GetChildAtIndex( lldb_private::formatters::LibcxxStdAtomicSyntheticFrontEnd::GetChildAtIndex(
size_t idx) { size_t idx) {
return m_real_child ? m_real_child->GetChildAtIndex(idx, true) : nullptr; return m_real_child ? m_real_child->GetChildAtIndex(idx, true) : nullptr;
} }
size_t lldb_private::formatters::LibcxxStdAtomicSyntheticFrontEnd:: size_t lldb_private::formatters::LibcxxStdAtomicSyntheticFrontEnd::
GetIndexOfChildWithName(const ConstString &name) { GetIndexOfChildWithName(ConstString name) {
return m_real_child ? m_real_child->GetIndexOfChildWithName(name) return m_real_child ? m_real_child->GetIndexOfChildWithName(name)
: UINT32_MAX; : UINT32_MAX;
} }
lldb::ValueObjectSP lldb_private::formatters::LibcxxStdAtomicSyntheticFrontEnd:: lldb::ValueObjectSP lldb_private::formatters::LibcxxStdAtomicSyntheticFrontEnd::
GetSyntheticValue() { GetSyntheticValue() {
if (m_real_child && m_real_child->CanProvideValue()) if (m_real_child && m_real_child->CanProvideValue())
return m_real_child->GetSP(); return m_real_child->GetSP();
Show All 10 Lines

lldb/source/Plugins/Language/CPlusPlus/LibCxxBitset.cpp

Show All 14 Lines
using namespace lldb_private; using namespace lldb_private;
namespace { namespace {
class BitsetFrontEnd : public SyntheticChildrenFrontEnd { class BitsetFrontEnd : public SyntheticChildrenFrontEnd {
public: public:
BitsetFrontEnd(ValueObject &valobj); BitsetFrontEnd(ValueObject &valobj);
size_t GetIndexOfChildWithName(const ConstString &name) override { size_t GetIndexOfChildWithName(ConstString name) override {
return formatters::ExtractIndexFromString(name.GetCString()); return formatters::ExtractIndexFromString(name.GetCString());
} }
bool MightHaveChildren() override { return true; } bool MightHaveChildren() override { return true; }
bool Update() override; bool Update() override;
size_t CalculateNumChildren() override { return m_elements.size(); } size_t CalculateNumChildren() override { return m_elements.size(); }
ValueObjectSP GetChildAtIndex(size_t idx) override; ValueObjectSP GetChildAtIndex(size_t idx) override;
Show All 16 Lines

lldb/source/Plugins/Language/CPlusPlus/LibCxxInitializerList.cpp

Show All 16 Lines
size_t CalculateNumChildren() override; size_t CalculateNumChildren() override;
lldb::ValueObjectSP GetChildAtIndex(size_t idx) override; lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
bool Update() override; bool Update() override;
bool MightHaveChildren() override; bool MightHaveChildren() override;
size_t GetIndexOfChildWithName(const ConstString &name) override; size_t GetIndexOfChildWithName(ConstString name) override;
private: private:
ValueObject *m_start; ValueObject *m_start;
CompilerType m_element_type; CompilerType m_element_type;
uint32_t m_element_size; uint32_t m_element_size;
size_t m_num_elements; size_t m_num_elements;
}; };
} // namespace formatters } // namespace formatters
Show All 32 Lines
} }
bool lldb_private::formatters::LibcxxInitializerListSyntheticFrontEnd:: bool lldb_private::formatters::LibcxxInitializerListSyntheticFrontEnd::
MightHaveChildren() { MightHaveChildren() {
return true; return true;
} }
size_t lldb_private::formatters::LibcxxInitializerListSyntheticFrontEnd:: size_t lldb_private::formatters::LibcxxInitializerListSyntheticFrontEnd::
GetIndexOfChildWithName(const ConstString &name) { GetIndexOfChildWithName(ConstString name) {
if (!m_start) if (!m_start)
return UINT32_MAX; return UINT32_MAX;
return ExtractIndexFromString(name.GetCString()); return ExtractIndexFromString(name.GetCString());
} }
lldb_private::SyntheticChildrenFrontEnd * lldb_private::SyntheticChildrenFrontEnd *
lldb_private::formatters::LibcxxInitializerListSyntheticFrontEndCreator( lldb_private::formatters::LibcxxInitializerListSyntheticFrontEndCreator(
CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) { CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) {
return (valobj_sp ? new LibcxxInitializerListSyntheticFrontEnd(valobj_sp) return (valobj_sp ? new LibcxxInitializerListSyntheticFrontEnd(valobj_sp)
: nullptr); : nullptr);
} }
Context not available.

lldb/source/Plugins/Language/CPlusPlus/LibCxxList.cpp

Show All 16 Lines
void prev() { m_entry = m_entry.prev(); } void prev() { m_entry = m_entry.prev(); }
private: private:
ListEntry m_entry; ListEntry m_entry;
}; };
class AbstractListFrontEnd : public SyntheticChildrenFrontEnd { class AbstractListFrontEnd : public SyntheticChildrenFrontEnd {
public: public:
size_t GetIndexOfChildWithName(const ConstString &name) override { size_t GetIndexOfChildWithName(ConstString name) override {
return ExtractIndexFromString(name.GetCString()); return ExtractIndexFromString(name.GetCString());
} }
bool MightHaveChildren() override { return true; } bool MightHaveChildren() override { return true; }
bool Update() override; bool Update() override;
protected: protected:
AbstractListFrontEnd(ValueObject &valobj) AbstractListFrontEnd(ValueObject &valobj)
: SyntheticChildrenFrontEnd(valobj) {} : SyntheticChildrenFrontEnd(valobj) {}
Show All 16 Lines

lldb/source/Plugins/Language/CPlusPlus/LibCxxMap.cpp

Show All 16 Lines
size_t CalculateNumChildren() override; size_t CalculateNumChildren() override;
lldb::ValueObjectSP GetChildAtIndex(size_t idx) override; lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
bool Update() override; bool Update() override;
bool MightHaveChildren() override; bool MightHaveChildren() override;
size_t GetIndexOfChildWithName(const ConstString &name) override; size_t GetIndexOfChildWithName(ConstString name) override;
private: private:
bool GetDataType(); bool GetDataType();
void GetValueOffset(const lldb::ValueObjectSP &node); void GetValueOffset(const lldb::ValueObjectSP &node);
ValueObject *m_tree; ValueObject *m_tree;
ValueObject *m_root_node; ValueObject *m_root_node;
Show All 32 Lines
} }
bool lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd:: bool lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::
MightHaveChildren() { MightHaveChildren() {
return true; return true;
} }
size_t lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd:: size_t lldb_private::formatters::LibcxxStdMapSyntheticFrontEnd::
GetIndexOfChildWithName(const ConstString &name) { GetIndexOfChildWithName(ConstString name) {
return ExtractIndexFromString(name.GetCString()); return ExtractIndexFromString(name.GetCString());
} }
SyntheticChildrenFrontEnd * SyntheticChildrenFrontEnd *
lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator( lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator(
CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) { CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) {
return (valobj_sp ? new LibcxxStdMapSyntheticFrontEnd(valobj_sp) : nullptr); return (valobj_sp ? new LibcxxStdMapSyntheticFrontEnd(valobj_sp) : nullptr);
} }
Context not available.

lldb/source/Plugins/Language/CPlusPlus/LibCxxOptional.cpp

Show All 14 Lines
namespace { namespace {
class OptionalFrontEnd : public SyntheticChildrenFrontEnd { class OptionalFrontEnd : public SyntheticChildrenFrontEnd {
public: public:
OptionalFrontEnd(ValueObject &valobj) : SyntheticChildrenFrontEnd(valobj) { OptionalFrontEnd(ValueObject &valobj) : SyntheticChildrenFrontEnd(valobj) {
Update(); Update();
} }
size_t GetIndexOfChildWithName(const ConstString &name) override { size_t GetIndexOfChildWithName(ConstString name) override {
return formatters::ExtractIndexFromString(name.GetCString()); return formatters::ExtractIndexFromString(name.GetCString());
} }
bool MightHaveChildren() override { return true; } bool MightHaveChildren() override { return true; }
bool Update() override; bool Update() override;
size_t CalculateNumChildren() override { return m_size; } size_t CalculateNumChildren() override { return m_size; }
ValueObjectSP GetChildAtIndex(size_t idx) override; ValueObjectSP GetChildAtIndex(size_t idx) override;
Show All 16 Lines

lldb/source/Plugins/Language/CPlusPlus/LibCxxQueue.cpp

Show All 14 Lines
namespace { namespace {
class QueueFrontEnd : public SyntheticChildrenFrontEnd { class QueueFrontEnd : public SyntheticChildrenFrontEnd {
public: public:
QueueFrontEnd(ValueObject &valobj) : SyntheticChildrenFrontEnd(valobj) { QueueFrontEnd(ValueObject &valobj) : SyntheticChildrenFrontEnd(valobj) {
Update(); Update();
} }
size_t GetIndexOfChildWithName(const ConstString &name) override { size_t GetIndexOfChildWithName(ConstString name) override {
return m_container_sp ? m_container_sp->GetIndexOfChildWithName(name) return m_container_sp ? m_container_sp->GetIndexOfChildWithName(name)
: UINT32_MAX; : UINT32_MAX;
} }
bool MightHaveChildren() override { return true; } bool MightHaveChildren() override { return true; }
bool Update() override; bool Update() override;
size_t CalculateNumChildren() override { size_t CalculateNumChildren() override {
Show All 16 Lines

lldb/source/Plugins/Language/CPlusPlus/LibCxxTuple.cpp

Show All 14 Lines
namespace { namespace {
class TupleFrontEnd: public SyntheticChildrenFrontEnd { class TupleFrontEnd: public SyntheticChildrenFrontEnd {
public: public:
TupleFrontEnd(ValueObject &valobj) : SyntheticChildrenFrontEnd(valobj) { TupleFrontEnd(ValueObject &valobj) : SyntheticChildrenFrontEnd(valobj) {
Update(); Update();
} }
size_t GetIndexOfChildWithName(const ConstString &name) override { size_t GetIndexOfChildWithName(ConstString name) override {
return formatters::ExtractIndexFromString(name.GetCString()); return formatters::ExtractIndexFromString(name.GetCString());
} }
bool MightHaveChildren() override { return true; } bool MightHaveChildren() override { return true; }
bool Update() override; bool Update() override;
size_t CalculateNumChildren() override { return m_elements.size(); } size_t CalculateNumChildren() override { return m_elements.size(); }
ValueObjectSP GetChildAtIndex(size_t idx) override; ValueObjectSP GetChildAtIndex(size_t idx) override;
Show All 16 Lines

lldb/source/Plugins/Language/CPlusPlus/LibCxxUnorderedMap.cpp

Show All 16 Lines
size_t CalculateNumChildren() override; size_t CalculateNumChildren() override;
lldb::ValueObjectSP GetChildAtIndex(size_t idx) override; lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
bool Update() override; bool Update() override;
bool MightHaveChildren() override; bool MightHaveChildren() override;
size_t GetIndexOfChildWithName(const ConstString &name) override; size_t GetIndexOfChildWithName(ConstString name) override;
private: private:
CompilerType m_element_type; CompilerType m_element_type;
CompilerType m_node_type; CompilerType m_node_type;
ValueObject *m_tree; ValueObject *m_tree;
size_t m_num_elements; size_t m_num_elements;
ValueObject *m_next_element; ValueObject *m_next_element;
std::vector<std::pair<ValueObject *, uint64_t>> m_elements_cache; std::vector<std::pair<ValueObject *, uint64_t>> m_elements_cache;
Show All 32 Lines
} }
bool lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEnd:: bool lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEnd::
MightHaveChildren() { MightHaveChildren() {
return true; return true;
} }
size_t lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEnd:: size_t lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEnd::
GetIndexOfChildWithName(const ConstString &name) { GetIndexOfChildWithName(ConstString name) {
return ExtractIndexFromString(name.GetCString()); return ExtractIndexFromString(name.GetCString());
} }
SyntheticChildrenFrontEnd * SyntheticChildrenFrontEnd *
lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEndCreator( lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEndCreator(
CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) { CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) {
return (valobj_sp ? new LibcxxStdUnorderedMapSyntheticFrontEnd(valobj_sp) return (valobj_sp ? new LibcxxStdUnorderedMapSyntheticFrontEnd(valobj_sp)
: nullptr); : nullptr);
} }
Context not available.

lldb/source/Plugins/Language/CPlusPlus/LibCxxVariant.cpp

Show All 16 Lines
namespace { namespace {
class VariantFrontEnd : public SyntheticChildrenFrontEnd { class VariantFrontEnd : public SyntheticChildrenFrontEnd {
public: public:
VariantFrontEnd(ValueObject &valobj) : SyntheticChildrenFrontEnd(valobj) { VariantFrontEnd(ValueObject &valobj) : SyntheticChildrenFrontEnd(valobj) {
Update(); Update();
} }
size_t GetIndexOfChildWithName(const ConstString &name) override { size_t GetIndexOfChildWithName(ConstString name) override {
return formatters::ExtractIndexFromString(name.GetCString()); return formatters::ExtractIndexFromString(name.GetCString());
} }
bool MightHaveChildren() override { return true; } bool MightHaveChildren() override { return true; }
bool Update() override; bool Update() override;
size_t CalculateNumChildren() override { return m_size; } size_t CalculateNumChildren() override { return m_size; }
ValueObjectSP GetChildAtIndex(size_t idx) override; ValueObjectSP GetChildAtIndex(size_t idx) override;
Show All 16 Lines

lldb/source/Plugins/Language/CPlusPlus/LibCxxVector.cpp

Show All 16 Lines
size_t CalculateNumChildren() override; size_t CalculateNumChildren() override;
lldb::ValueObjectSP GetChildAtIndex(size_t idx) override; lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
bool Update() override; bool Update() override;
bool MightHaveChildren() override; bool MightHaveChildren() override;
size_t GetIndexOfChildWithName(const ConstString &name) override; size_t GetIndexOfChildWithName(ConstString name) override;
private: private:
ValueObject *m_start; ValueObject *m_start;
ValueObject *m_finish; ValueObject *m_finish;
CompilerType m_element_type; CompilerType m_element_type;
uint32_t m_element_size; uint32_t m_element_size;
}; };
class LibcxxVectorBoolSyntheticFrontEnd : public SyntheticChildrenFrontEnd { class LibcxxVectorBoolSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
public: public:
LibcxxVectorBoolSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp); LibcxxVectorBoolSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
size_t CalculateNumChildren() override; size_t CalculateNumChildren() override;
lldb::ValueObjectSP GetChildAtIndex(size_t idx) override; lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
bool Update() override; bool Update() override;
bool MightHaveChildren() override { return true; } bool MightHaveChildren() override { return true; }
size_t GetIndexOfChildWithName(const ConstString &name) override; size_t GetIndexOfChildWithName(ConstString name) override;
private: private:
CompilerType m_bool_type; CompilerType m_bool_type;
ExecutionContextRef m_exe_ctx_ref; ExecutionContextRef m_exe_ctx_ref;
uint64_t m_count; uint64_t m_count;
lldb::addr_t m_base_data_address; lldb::addr_t m_base_data_address;
std::map<size_t, lldb::ValueObjectSP> m_children; std::map<size_t, lldb::ValueObjectSP> m_children;
}; };
Show All 32 Lines
} }
bool lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd:: bool lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::
MightHaveChildren() { MightHaveChildren() {
return true; return true;
} }
size_t lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd:: size_t lldb_private::formatters::LibcxxStdVectorSyntheticFrontEnd::
GetIndexOfChildWithName(const ConstString &name) { GetIndexOfChildWithName(ConstString name) {
if (!m_start || !m_finish) if (!m_start || !m_finish)
return UINT32_MAX; return UINT32_MAX;
return ExtractIndexFromString(name.GetCString()); return ExtractIndexFromString(name.GetCString());
} }
lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd:: lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::
LibcxxVectorBoolSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp) LibcxxVectorBoolSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
: SyntheticChildrenFrontEnd(*valobj_sp), m_bool_type(), m_exe_ctx_ref(), : SyntheticChildrenFrontEnd(*valobj_sp), m_bool_type(), m_exe_ctx_ref(),
Show All 32 Lines
if (!m_base_data_address) { if (!m_base_data_address) {
m_count = 0; m_count = 0;
return false; return false;
} }
return false; return false;
} }
size_t lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd:: size_t lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::
GetIndexOfChildWithName(const ConstString &name) { GetIndexOfChildWithName(ConstString name) {
if (!m_count || !m_base_data_address) if (!m_count || !m_base_data_address)
return UINT32_MAX; return UINT32_MAX;
const char *item_name = name.GetCString(); const char *item_name = name.GetCString();
uint32_t idx = ExtractIndexFromString(item_name); uint32_t idx = ExtractIndexFromString(item_name);
if (idx < UINT32_MAX && idx >= CalculateNumChildren()) if (idx < UINT32_MAX && idx >= CalculateNumChildren())
return UINT32_MAX; return UINT32_MAX;
return idx; return idx;
} }
Show All 14 Lines

lldb/source/Plugins/Language/CPlusPlus/LibStdcpp.cpp

Show All 16 Lines
size_t CalculateNumChildren() override; size_t CalculateNumChildren() override;
lldb::ValueObjectSP GetChildAtIndex(size_t idx) override; lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
bool Update() override; bool Update() override;
bool MightHaveChildren() override; bool MightHaveChildren() override;
size_t GetIndexOfChildWithName(const ConstString &name) override; size_t GetIndexOfChildWithName(ConstString name) override;
private: private:
ExecutionContextRef m_exe_ctx_ref; ExecutionContextRef m_exe_ctx_ref;
lldb::addr_t m_pair_address; lldb::addr_t m_pair_address;
CompilerType m_pair_type; CompilerType m_pair_type;
lldb::ValueObjectSP m_pair_sp; lldb::ValueObjectSP m_pair_sp;
}; };
class LibStdcppSharedPtrSyntheticFrontEnd : public SyntheticChildrenFrontEnd { class LibStdcppSharedPtrSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
public: public:
explicit LibStdcppSharedPtrSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp); explicit LibStdcppSharedPtrSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
size_t CalculateNumChildren() override; size_t CalculateNumChildren() override;
lldb::ValueObjectSP GetChildAtIndex(size_t idx) override; lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
bool Update() override; bool Update() override;
bool MightHaveChildren() override; bool MightHaveChildren() override;
size_t GetIndexOfChildWithName(const ConstString &name) override; size_t GetIndexOfChildWithName(ConstString name) override;
}; };
} // end of anonymous namespace } // end of anonymous namespace
LibstdcppMapIteratorSyntheticFrontEnd::LibstdcppMapIteratorSyntheticFrontEnd( LibstdcppMapIteratorSyntheticFrontEnd::LibstdcppMapIteratorSyntheticFrontEnd(
lldb::ValueObjectSP valobj_sp) lldb::ValueObjectSP valobj_sp)
: SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(), m_pair_address(0), : SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(), m_pair_address(0),
m_pair_type(), m_pair_sp() { m_pair_type(), m_pair_sp() {
Show All 32 Lines
return m_pair_sp->GetChildAtIndex(idx, true); return m_pair_sp->GetChildAtIndex(idx, true);
} }
return lldb::ValueObjectSP(); return lldb::ValueObjectSP();
} }
bool LibstdcppMapIteratorSyntheticFrontEnd::MightHaveChildren() { return true; } bool LibstdcppMapIteratorSyntheticFrontEnd::MightHaveChildren() { return true; }
size_t LibstdcppMapIteratorSyntheticFrontEnd::GetIndexOfChildWithName( size_t LibstdcppMapIteratorSyntheticFrontEnd::GetIndexOfChildWithName(
const ConstString &name) { ConstString name) {
if (name == ConstString("first")) if (name == ConstString("first"))
return 0; return 0;
if (name == ConstString("second")) if (name == ConstString("second"))
return 1; return 1;
return UINT32_MAX; return UINT32_MAX;
} }
SyntheticChildrenFrontEnd * SyntheticChildrenFrontEnd *
Show All 32 Lines
if (idx == 0) if (idx == 0)
return m_item_sp; return m_item_sp;
return lldb::ValueObjectSP(); return lldb::ValueObjectSP();
} }
bool VectorIteratorSyntheticFrontEnd::MightHaveChildren() { return true; } bool VectorIteratorSyntheticFrontEnd::MightHaveChildren() { return true; }
size_t VectorIteratorSyntheticFrontEnd::GetIndexOfChildWithName( size_t VectorIteratorSyntheticFrontEnd::GetIndexOfChildWithName(
const ConstString &name) { ConstString name) {
if (name == ConstString("item")) if (name == ConstString("item"))
return 0; return 0;
return UINT32_MAX; return UINT32_MAX;
} }
bool lldb_private::formatters::LibStdcppStringSummaryProvider( bool lldb_private::formatters::LibStdcppStringSummaryProvider(
ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) { ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
const bool scalar_is_load_addr = true; const bool scalar_is_load_addr = true;
Show All 32 Lines
return lldb::ValueObjectSP(); return lldb::ValueObjectSP();
} }
bool LibStdcppSharedPtrSyntheticFrontEnd::Update() { return false; } bool LibStdcppSharedPtrSyntheticFrontEnd::Update() { return false; }
bool LibStdcppSharedPtrSyntheticFrontEnd::MightHaveChildren() { return true; } bool LibStdcppSharedPtrSyntheticFrontEnd::MightHaveChildren() { return true; }
size_t LibStdcppSharedPtrSyntheticFrontEnd::GetIndexOfChildWithName( size_t LibStdcppSharedPtrSyntheticFrontEnd::GetIndexOfChildWithName(
const ConstString &name) { ConstString name) {
if (name == ConstString("_M_ptr")) if (name == ConstString("_M_ptr"))
return 0; return 0;
return UINT32_MAX; return UINT32_MAX;
} }
SyntheticChildrenFrontEnd * SyntheticChildrenFrontEnd *
lldb_private::formatters::LibStdcppSharedPtrSyntheticFrontEndCreator( lldb_private::formatters::LibStdcppSharedPtrSyntheticFrontEndCreator(
CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) { CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) {
Show All 16 Lines

lldb/source/Plugins/Language/CPlusPlus/LibStdcppTuple.cpp

Show All 16 Lines
size_t CalculateNumChildren() override; size_t CalculateNumChildren() override;
lldb::ValueObjectSP GetChildAtIndex(size_t idx) override; lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
bool Update() override; bool Update() override;
bool MightHaveChildren() override; bool MightHaveChildren() override;
size_t GetIndexOfChildWithName(const ConstString &name) override; size_t GetIndexOfChildWithName(ConstString name) override;
private: private:
std::vector<ValueObjectSP> m_members; std::vector<ValueObjectSP> m_members;
}; };
} // end of anonymous namespace } // end of anonymous namespace
LibStdcppTupleSyntheticFrontEnd::LibStdcppTupleSyntheticFrontEnd( LibStdcppTupleSyntheticFrontEnd::LibStdcppTupleSyntheticFrontEnd(
Show All 32 Lines
return lldb::ValueObjectSP(); return lldb::ValueObjectSP();
} }
size_t LibStdcppTupleSyntheticFrontEnd::CalculateNumChildren() { size_t LibStdcppTupleSyntheticFrontEnd::CalculateNumChildren() {
return m_members.size(); return m_members.size();
} }
size_t LibStdcppTupleSyntheticFrontEnd::GetIndexOfChildWithName( size_t LibStdcppTupleSyntheticFrontEnd::GetIndexOfChildWithName(
const ConstString &name) { ConstString name) {
return ExtractIndexFromString(name.GetCString()); return ExtractIndexFromString(name.GetCString());
} }
SyntheticChildrenFrontEnd * SyntheticChildrenFrontEnd *
lldb_private::formatters::LibStdcppTupleSyntheticFrontEndCreator( lldb_private::formatters::LibStdcppTupleSyntheticFrontEndCreator(
CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) { CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) {
return (valobj_sp ? new LibStdcppTupleSyntheticFrontEnd(valobj_sp) : nullptr); return (valobj_sp ? new LibStdcppTupleSyntheticFrontEnd(valobj_sp) : nullptr);
} }
Context not available.

lldb/source/Plugins/Language/CPlusPlus/LibStdcppUniquePointer.cpp

Show All 16 Lines
size_t CalculateNumChildren() override; size_t CalculateNumChildren() override;
lldb::ValueObjectSP GetChildAtIndex(size_t idx) override; lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
bool Update() override; bool Update() override;
bool MightHaveChildren() override; bool MightHaveChildren() override;
size_t GetIndexOfChildWithName(const ConstString &name) override; size_t GetIndexOfChildWithName(ConstString name) override;
bool GetSummary(Stream &stream, const TypeSummaryOptions &options); bool GetSummary(Stream &stream, const TypeSummaryOptions &options);
private: private:
ValueObjectSP m_ptr_obj; ValueObjectSP m_ptr_obj;
ValueObjectSP m_obj_obj; ValueObjectSP m_obj_obj;
ValueObjectSP m_del_obj; ValueObjectSP m_del_obj;
Show All 32 Lines
size_t LibStdcppUniquePtrSyntheticFrontEnd::CalculateNumChildren() { size_t LibStdcppUniquePtrSyntheticFrontEnd::CalculateNumChildren() {
if (m_del_obj) if (m_del_obj)
return 2; return 2;
return 1; return 1;
} }
size_t LibStdcppUniquePtrSyntheticFrontEnd::GetIndexOfChildWithName( size_t LibStdcppUniquePtrSyntheticFrontEnd::GetIndexOfChildWithName(
const ConstString &name) { ConstString name) {
if (name == ConstString("ptr") || name == ConstString("pointer")) if (name == ConstString("ptr") || name == ConstString("pointer"))
return 0; return 0;
if (name == ConstString("del") || name == ConstString("deleter")) if (name == ConstString("del") || name == ConstString("deleter"))
return 1; return 1;
if (name == ConstString("obj") || name == ConstString("object") || if (name == ConstString("obj") || name == ConstString("object") ||
name == ConstString("$$dereference$$")) name == ConstString("$$dereference$$"))
return 2; return 2;
return UINT32_MAX; return UINT32_MAX;
Show All 16 Lines

lldb/source/Plugins/Language/ObjC/Cocoa.cpp

Show All 16 Lines
lldb::ValueObjectSP GetChildAtIndex(size_t idx) override { lldb::ValueObjectSP GetChildAtIndex(size_t idx) override {
return lldb::ValueObjectSP(); return lldb::ValueObjectSP();
} }
bool Update() override { return false; } bool Update() override { return false; }
bool MightHaveChildren() override { return false; } bool MightHaveChildren() override { return false; }
size_t GetIndexOfChildWithName(const ConstString &name) override { size_t GetIndexOfChildWithName(ConstString name) override {
return UINT32_MAX; return UINT32_MAX;
} }
}; };
SyntheticChildrenFrontEnd * SyntheticChildrenFrontEnd *
lldb_private::formatters::ObjCClassSyntheticFrontEndCreator( lldb_private::formatters::ObjCClassSyntheticFrontEndCreator(
CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) { CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) {
return new ObjCClassSyntheticChildrenFrontEnd(valobj_sp); return new ObjCClassSyntheticChildrenFrontEnd(valobj_sp);
Show All 16 Lines

lldb/source/Plugins/Language/ObjC/NSArray.cpp

Show All 16 Lines
size_t CalculateNumChildren() override; size_t CalculateNumChildren() override;
lldb::ValueObjectSP GetChildAtIndex(size_t idx) override; lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
bool Update() override = 0; bool Update() override = 0;
bool MightHaveChildren() override; bool MightHaveChildren() override;
size_t GetIndexOfChildWithName(const ConstString &name) override; size_t GetIndexOfChildWithName(ConstString name) override;
protected: protected:
virtual lldb::addr_t GetDataAddress() = 0; virtual lldb::addr_t GetDataAddress() = 0;
virtual uint64_t GetUsedCount() = 0; virtual uint64_t GetUsedCount() = 0;
virtual uint64_t GetOffset() = 0; virtual uint64_t GetOffset() = 0;
Show All 32 Lines
size_t CalculateNumChildren() override; size_t CalculateNumChildren() override;
lldb::ValueObjectSP GetChildAtIndex(size_t idx) override; lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
bool Update() override; bool Update() override;
bool MightHaveChildren() override; bool MightHaveChildren() override;
size_t GetIndexOfChildWithName(const ConstString &name) override; size_t GetIndexOfChildWithName(ConstString name) override;
private: private:
ExecutionContextRef m_exe_ctx_ref; ExecutionContextRef m_exe_ctx_ref;
uint8_t m_ptr_size; uint8_t m_ptr_size;
D32 *m_data_32; D32 *m_data_32;
D64 *m_data_64; D64 *m_data_64;
CompilerType m_id_type; CompilerType m_id_type;
Show All 32 Lines
size_t CalculateNumChildren() override; size_t CalculateNumChildren() override;
lldb::ValueObjectSP GetChildAtIndex(size_t idx) override; lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
bool Update() override; bool Update() override;
bool MightHaveChildren() override; bool MightHaveChildren() override;
size_t GetIndexOfChildWithName(const ConstString &name) override; size_t GetIndexOfChildWithName(ConstString name) override;
}; };
class NSArray1SyntheticFrontEnd : public SyntheticChildrenFrontEnd { class NSArray1SyntheticFrontEnd : public SyntheticChildrenFrontEnd {
public: public:
NSArray1SyntheticFrontEnd(lldb::ValueObjectSP valobj_sp); NSArray1SyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
~NSArray1SyntheticFrontEnd() override = default; ~NSArray1SyntheticFrontEnd() override = default;
size_t CalculateNumChildren() override; size_t CalculateNumChildren() override;
lldb::ValueObjectSP GetChildAtIndex(size_t idx) override; lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
bool Update() override; bool Update() override;
bool MightHaveChildren() override; bool MightHaveChildren() override;
size_t GetIndexOfChildWithName(const ConstString &name) override; size_t GetIndexOfChildWithName(ConstString name) override;
}; };
} // namespace formatters } // namespace formatters
} // namespace lldb_private } // namespace lldb_private
bool lldb_private::formatters::NSArraySummaryProvider( bool lldb_private::formatters::NSArraySummaryProvider(
ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) { ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
static ConstString g_TypeHint("NSArray"); static ConstString g_TypeHint("NSArray");
Show All 32 Lines
bool bool
lldb_private::formatters::NSArrayMSyntheticFrontEndBase::MightHaveChildren() { lldb_private::formatters::NSArrayMSyntheticFrontEndBase::MightHaveChildren() {
return true; return true;
} }
size_t size_t
lldb_private::formatters::NSArrayMSyntheticFrontEndBase::GetIndexOfChildWithName( lldb_private::formatters::NSArrayMSyntheticFrontEndBase::GetIndexOfChildWithName(
const ConstString &name) { ConstString name) {
const char *item_name = name.GetCString(); const char *item_name = name.GetCString();
uint32_t idx = ExtractIndexFromString(item_name); uint32_t idx = ExtractIndexFromString(item_name);
if (idx < UINT32_MAX && idx >= CalculateNumChildren()) if (idx < UINT32_MAX && idx >= CalculateNumChildren())
return UINT32_MAX; return UINT32_MAX;
return idx; return idx;
} }
template <typename D32, typename D64> template <typename D32, typename D64>
Show All 32 Lines
m_data_32 = nullptr; m_data_32 = nullptr;
delete m_data_64; delete m_data_64;
m_data_64 = nullptr; m_data_64 = nullptr;
} }
template <typename D32, typename D64, bool Inline> template <typename D32, typename D64, bool Inline>
size_t size_t
lldb_private::formatters::GenericNSArrayISyntheticFrontEnd<D32, D64, Inline>:: lldb_private::formatters::GenericNSArrayISyntheticFrontEnd<D32, D64, Inline>::
GetIndexOfChildWithName(const ConstString &name) { GetIndexOfChildWithName(ConstString name) {
const char *item_name = name.GetCString(); const char *item_name = name.GetCString();
uint32_t idx = ExtractIndexFromString(item_name); uint32_t idx = ExtractIndexFromString(item_name);
if (idx < UINT32_MAX && idx >= CalculateNumChildren()) if (idx < UINT32_MAX && idx >= CalculateNumChildren())
return UINT32_MAX; return UINT32_MAX;
return idx; return idx;
} }
template <typename D32, typename D64, bool Inline> template <typename D32, typename D64, bool Inline>
Show All 32 Lines
} }
lldb_private::formatters::NSArray0SyntheticFrontEnd::NSArray0SyntheticFrontEnd( lldb_private::formatters::NSArray0SyntheticFrontEnd::NSArray0SyntheticFrontEnd(
lldb::ValueObjectSP valobj_sp) lldb::ValueObjectSP valobj_sp)
: SyntheticChildrenFrontEnd(*valobj_sp) {} : SyntheticChildrenFrontEnd(*valobj_sp) {}
size_t size_t
lldb_private::formatters::NSArray0SyntheticFrontEnd::GetIndexOfChildWithName( lldb_private::formatters::NSArray0SyntheticFrontEnd::GetIndexOfChildWithName(
const ConstString &name) { ConstString name) {
return UINT32_MAX; return UINT32_MAX;
} }
size_t size_t
lldb_private::formatters::NSArray0SyntheticFrontEnd::CalculateNumChildren() { lldb_private::formatters::NSArray0SyntheticFrontEnd::CalculateNumChildren() {
return 0; return 0;
} }
Show All 12 Lines
} }
lldb_private::formatters::NSArray1SyntheticFrontEnd::NSArray1SyntheticFrontEnd( lldb_private::formatters::NSArray1SyntheticFrontEnd::NSArray1SyntheticFrontEnd(
lldb::ValueObjectSP valobj_sp) lldb::ValueObjectSP valobj_sp)
: SyntheticChildrenFrontEnd(*valobj_sp.get()) {} : SyntheticChildrenFrontEnd(*valobj_sp.get()) {}
size_t size_t
lldb_private::formatters::NSArray1SyntheticFrontEnd::GetIndexOfChildWithName( lldb_private::formatters::NSArray1SyntheticFrontEnd::GetIndexOfChildWithName(
const ConstString &name) { ConstString name) {
static const ConstString g_zero("[0]"); static const ConstString g_zero("[0]");
if (name == g_zero) if (name == g_zero)
return 0; return 0;
return UINT32_MAX; return UINT32_MAX;
} }
Show All 16 Lines

lldb/source/Plugins/Language/ObjC/NSDictionary.cpp

Show All 16 Lines
size_t CalculateNumChildren() override; size_t CalculateNumChildren() override;
lldb::ValueObjectSP GetChildAtIndex(size_t idx) override; lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
bool Update() override; bool Update() override;
bool MightHaveChildren() override; bool MightHaveChildren() override;
size_t GetIndexOfChildWithName(const ConstString &name) override; size_t GetIndexOfChildWithName(ConstString name) override;
private: private:
struct DataDescriptor_32 { struct DataDescriptor_32 {
uint32_t _used : 26; uint32_t _used : 26;
uint32_t _szidx : 6; uint32_t _szidx : 6;
}; };
struct DataDescriptor_64 { struct DataDescriptor_64 {
Show All 26 Lines
size_t CalculateNumChildren() override; size_t CalculateNumChildren() override;
lldb::ValueObjectSP GetChildAtIndex(size_t idx) override; lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
bool Update() override; bool Update() override;
bool MightHaveChildren() override; bool MightHaveChildren() override;
size_t GetIndexOfChildWithName(const ConstString &name) override; size_t GetIndexOfChildWithName(ConstString name) override;
private: private:
ValueObjectSP m_pair; ValueObjectSP m_pair;
}; };
template <typename D32, typename D64> template <typename D32, typename D64>
class GenericNSDictionaryMSyntheticFrontEnd : public SyntheticChildrenFrontEnd { class GenericNSDictionaryMSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
public: public:
GenericNSDictionaryMSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp); GenericNSDictionaryMSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp);
~GenericNSDictionaryMSyntheticFrontEnd() override; ~GenericNSDictionaryMSyntheticFrontEnd() override;
size_t CalculateNumChildren() override; size_t CalculateNumChildren() override;
lldb::ValueObjectSP GetChildAtIndex(size_t idx) override; lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
bool Update() override; bool Update() override;
bool MightHaveChildren() override; bool MightHaveChildren() override;
size_t GetIndexOfChildWithName(const ConstString &name) override; size_t GetIndexOfChildWithName(ConstString name) override;
private: private:
struct DictionaryItemDescriptor { struct DictionaryItemDescriptor {
lldb::addr_t key_ptr; lldb::addr_t key_ptr;
lldb::addr_t val_ptr; lldb::addr_t val_ptr;
lldb::ValueObjectSP valobj_sp; lldb::ValueObjectSP valobj_sp;
}; };
Show All 16 Lines
size_t CalculateNumChildren() override; size_t CalculateNumChildren() override;
lldb::ValueObjectSP GetChildAtIndex(size_t idx) override; lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
bool Update() override; bool Update() override;
bool MightHaveChildren() override; bool MightHaveChildren() override;
size_t GetIndexOfChildWithName(const ConstString &name) override; size_t GetIndexOfChildWithName(ConstString name) override;
private: private:
struct DataDescriptor_32 { struct DataDescriptor_32 {
uint32_t _used : 26; uint32_t _used : 26;
uint32_t _kvo : 1; uint32_t _kvo : 1;
uint32_t _size; uint32_t _size;
uint32_t _mutations; uint32_t _mutations;
uint32_t _objs_addr; uint32_t _objs_addr;
Show All 32 Lines
~NSDictionaryISyntheticFrontEnd() { ~NSDictionaryISyntheticFrontEnd() {
delete m_data_32; delete m_data_32;
m_data_32 = nullptr; m_data_32 = nullptr;
delete m_data_64; delete m_data_64;
m_data_64 = nullptr; m_data_64 = nullptr;
} }
size_t lldb_private::formatters::NSDictionaryISyntheticFrontEnd:: size_t lldb_private::formatters::NSDictionaryISyntheticFrontEnd::
GetIndexOfChildWithName(const ConstString &name) { GetIndexOfChildWithName(ConstString name) {
const char *item_name = name.GetCString(); const char *item_name = name.GetCString();
uint32_t idx = ExtractIndexFromString(item_name); uint32_t idx = ExtractIndexFromString(item_name);
if (idx < UINT32_MAX && idx >= CalculateNumChildren()) if (idx < UINT32_MAX && idx >= CalculateNumChildren())
return UINT32_MAX; return UINT32_MAX;
return idx; return idx;
} }
size_t lldb_private::formatters::NSDictionaryISyntheticFrontEnd:: size_t lldb_private::formatters::NSDictionaryISyntheticFrontEnd::
Show All 32 Lines
return dict_item.valobj_sp; return dict_item.valobj_sp;
} }
lldb_private::formatters::NSDictionary1SyntheticFrontEnd:: lldb_private::formatters::NSDictionary1SyntheticFrontEnd::
NSDictionary1SyntheticFrontEnd(lldb::ValueObjectSP valobj_sp) NSDictionary1SyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
: SyntheticChildrenFrontEnd(*valobj_sp.get()), m_pair(nullptr) {} : SyntheticChildrenFrontEnd(*valobj_sp.get()), m_pair(nullptr) {}
size_t lldb_private::formatters::NSDictionary1SyntheticFrontEnd:: size_t lldb_private::formatters::NSDictionary1SyntheticFrontEnd::
GetIndexOfChildWithName(const ConstString &name) { GetIndexOfChildWithName(ConstString name) {
static const ConstString g_zero("[0]"); static const ConstString g_zero("[0]");
return name == g_zero ? 0 : UINT32_MAX; return name == g_zero ? 0 : UINT32_MAX;
} }
size_t lldb_private::formatters::NSDictionary1SyntheticFrontEnd:: size_t lldb_private::formatters::NSDictionary1SyntheticFrontEnd::
CalculateNumChildren() { CalculateNumChildren() {
return 1; return 1;
} }
Show All 32 Lines
delete m_data_32; delete m_data_32;
m_data_32 = nullptr; m_data_32 = nullptr;
delete m_data_64; delete m_data_64;
m_data_64 = nullptr; m_data_64 = nullptr;
} }
template <typename D32, typename D64> template <typename D32, typename D64>
size_t size_t
lldb_private::formatters::GenericNSDictionaryMSyntheticFrontEnd<D32,D64>:: GetIndexOfChildWithName(const ConstString &name) { lldb_private::formatters::GenericNSDictionaryMSyntheticFrontEnd<D32,D64>:: GetIndexOfChildWithName(ConstString name) {
const char *item_name = name.GetCString(); const char *item_name = name.GetCString();
uint32_t idx = ExtractIndexFromString(item_name); uint32_t idx = ExtractIndexFromString(item_name);
if (idx < UINT32_MAX && idx >= CalculateNumChildren()) if (idx < UINT32_MAX && idx >= CalculateNumChildren())
return UINT32_MAX; return UINT32_MAX;
return idx; return idx;
} }
template <typename D32, typename D64> template <typename D32, typename D64>
Show All 32 Lines
delete m_data_32; delete m_data_32;
m_data_32 = nullptr; m_data_32 = nullptr;
delete m_data_64; delete m_data_64;
m_data_64 = nullptr; m_data_64 = nullptr;
} }
size_t size_t
lldb_private::formatters::Foundation1100:: lldb_private::formatters::Foundation1100::
NSDictionaryMSyntheticFrontEnd::GetIndexOfChildWithName(const ConstString &name) { NSDictionaryMSyntheticFrontEnd::GetIndexOfChildWithName(ConstString name) {
const char *item_name = name.GetCString(); const char *item_name = name.GetCString();
uint32_t idx = ExtractIndexFromString(item_name); uint32_t idx = ExtractIndexFromString(item_name);
if (idx < UINT32_MAX && idx >= CalculateNumChildren()) if (idx < UINT32_MAX && idx >= CalculateNumChildren())
return UINT32_MAX; return UINT32_MAX;
return idx; return idx;
} }
size_t size_t
Show All 16 Lines

lldb/source/Plugins/Language/ObjC/NSError.cpp

Show All 16 Lines
m_backend.GetExecutionContextRef(), m_backend.GetExecutionContextRef(),
process_sp->GetTarget().GetScratchClangASTContext()->GetBasicType( process_sp->GetTarget().GetScratchClangASTContext()->GetBasicType(
lldb::eBasicTypeObjCID)); lldb::eBasicTypeObjCID));
return false; return false;
} }
bool MightHaveChildren() override { return true; } bool MightHaveChildren() override { return true; }
size_t GetIndexOfChildWithName(const ConstString &name) override { size_t GetIndexOfChildWithName(ConstString name) override {
static ConstString g___userInfo("_userInfo"); static ConstString g___userInfo("_userInfo");
if (name == g___userInfo) if (name == g___userInfo)
return 0; return 0;
return UINT32_MAX; return UINT32_MAX;
} }
private: private:
// the child here can be "real" (i.e. an actual child of the root) or // the child here can be "real" (i.e. an actual child of the root) or
Show All 16 Lines

lldb/source/Plugins/Language/ObjC/NSException.cpp

Show All 16 Lines
m_reserved_sp.reset(); m_reserved_sp.reset();
return ExtractFields(m_backend, &m_name_sp, &m_reason_sp, &m_userinfo_sp, return ExtractFields(m_backend, &m_name_sp, &m_reason_sp, &m_userinfo_sp,
&m_reserved_sp); &m_reserved_sp);
} }
bool MightHaveChildren() override { return true; } bool MightHaveChildren() override { return true; }
size_t GetIndexOfChildWithName(const ConstString &name) override { size_t GetIndexOfChildWithName(ConstString name) override {
// NSException has 4 members: // NSException has 4 members:
// NSString *name; // NSString *name;
// NSString *reason; // NSString *reason;
// NSDictionary *userInfo; // NSDictionary *userInfo;
// id reserved; // id reserved;
static ConstString g___name("name"); static ConstString g___name("name");
static ConstString g___reason("reason"); static ConstString g___reason("reason");
static ConstString g___userInfo("userInfo"); static ConstString g___userInfo("userInfo");
Show All 16 Lines

lldb/source/Plugins/Language/ObjC/NSIndexPath.cpp

Show All 16 Lines
} }
} }
} }
return false; return false;
} }
bool MightHaveChildren() override { return m_impl.m_mode != Mode::Invalid; } bool MightHaveChildren() override { return m_impl.m_mode != Mode::Invalid; }
size_t GetIndexOfChildWithName(const ConstString &name) override { size_t GetIndexOfChildWithName(ConstString name) override {
const char *item_name = name.GetCString(); const char *item_name = name.GetCString();
uint32_t idx = ExtractIndexFromString(item_name); uint32_t idx = ExtractIndexFromString(item_name);
if (idx < UINT32_MAX && idx >= CalculateNumChildren()) if (idx < UINT32_MAX && idx >= CalculateNumChildren())
return UINT32_MAX; return UINT32_MAX;
return idx; return idx;
} }
lldb::ValueObjectSP GetSyntheticValue() override { return nullptr; } lldb::ValueObjectSP GetSyntheticValue() override { return nullptr; }
Show All 16 Lines

lldb/source/Plugins/Language/ObjC/NSSet.cpp

Show All 16 Lines
size_t CalculateNumChildren() override; size_t CalculateNumChildren() override;
lldb::ValueObjectSP GetChildAtIndex(size_t idx) override; lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
bool Update() override; bool Update() override;
bool MightHaveChildren() override; bool MightHaveChildren() override;
size_t GetIndexOfChildWithName(const ConstString &name) override; size_t GetIndexOfChildWithName(ConstString name) override;
private: private:
struct DataDescriptor_32 { struct DataDescriptor_32 {
uint32_t _used : 26; uint32_t _used : 26;
uint32_t _szidx : 6; uint32_t _szidx : 6;
}; };
struct DataDescriptor_64 { struct DataDescriptor_64 {
Show All 24 Lines
size_t CalculateNumChildren() override; size_t CalculateNumChildren() override;
lldb::ValueObjectSP GetChildAtIndex(size_t idx) override; lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
bool Update() override; bool Update() override;
bool MightHaveChildren() override; bool MightHaveChildren() override;
size_t GetIndexOfChildWithName(const ConstString &name) override; size_t GetIndexOfChildWithName(ConstString name) override;
private: private:
struct SetItemDescriptor { struct SetItemDescriptor {
lldb::addr_t item_ptr; lldb::addr_t item_ptr;
lldb::ValueObjectSP valobj_sp; lldb::ValueObjectSP valobj_sp;
}; };
Show All 32 Lines
size_t CalculateNumChildren() override; size_t CalculateNumChildren() override;
lldb::ValueObjectSP GetChildAtIndex(size_t idx) override; lldb::ValueObjectSP GetChildAtIndex(size_t idx) override;
bool Update() override; bool Update() override;
bool MightHaveChildren() override; bool MightHaveChildren() override;
size_t GetIndexOfChildWithName(const ConstString &name) override; size_t GetIndexOfChildWithName(ConstString name) override;
}; };
} // namespace formatters } // namespace formatters
} // namespace lldb_private } // namespace lldb_private
template <bool cf_style> template <bool cf_style>
bool lldb_private::formatters::NSSetSummaryProvider( bool lldb_private::formatters::NSSetSummaryProvider(
ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) { ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
static ConstString g_TypeHint("NSSet"); static ConstString g_TypeHint("NSSet");
Show All 32 Lines
delete m_data_32; delete m_data_32;
m_data_32 = nullptr; m_data_32 = nullptr;
delete m_data_64; delete m_data_64;
m_data_64 = nullptr; m_data_64 = nullptr;
} }
size_t size_t
lldb_private::formatters::NSSetISyntheticFrontEnd::GetIndexOfChildWithName( lldb_private::formatters::NSSetISyntheticFrontEnd::GetIndexOfChildWithName(
const ConstString &name) { ConstString name) {
const char *item_name = name.GetCString(); const char *item_name = name.GetCString();
uint32_t idx = ExtractIndexFromString(item_name); uint32_t idx = ExtractIndexFromString(item_name);
if (idx < UINT32_MAX && idx >= CalculateNumChildren()) if (idx < UINT32_MAX && idx >= CalculateNumChildren())
return UINT32_MAX; return UINT32_MAX;
return idx; return idx;
} }
size_t size_t
Show All 32 Lines
delete m_data_64; delete m_data_64;
m_data_64 = nullptr; m_data_64 = nullptr;
} }
template <typename D32, typename D64> template <typename D32, typename D64>
size_t size_t
lldb_private::formatters:: lldb_private::formatters::
GenericNSSetMSyntheticFrontEnd<D32, D64>::GetIndexOfChildWithName( GenericNSSetMSyntheticFrontEnd<D32, D64>::GetIndexOfChildWithName(
const ConstString &name) { ConstString name) {
const char *item_name = name.GetCString(); const char *item_name = name.GetCString();
uint32_t idx = ExtractIndexFromString(item_name); uint32_t idx = ExtractIndexFromString(item_name);
if (idx < UINT32_MAX && idx >= CalculateNumChildren()) if (idx < UINT32_MAX && idx >= CalculateNumChildren())
return UINT32_MAX; return UINT32_MAX;
return idx; return idx;
} }
template <typename D32, typename D64> template <typename D32, typename D64>
Show All 16 Lines

lldb/source/Plugins/Language/ObjC/ObjCLanguage.h

Show All 16 Lines
// name is valid. // name is valid.
return (bool)m_full; return (bool)m_full;
} }
bool HasCategory() { return !GetCategory().IsEmpty(); } bool HasCategory() { return !GetCategory().IsEmpty(); }
Type GetType() const { return m_type; } Type GetType() const { return m_type; }
const ConstString &GetFullName() const { return m_full; } ConstString GetFullName() const { return m_full; }
ConstString GetFullNameWithoutCategory(bool empty_if_no_category); ConstString GetFullNameWithoutCategory(bool empty_if_no_category);
bool SetName(const char *name, bool strict); bool SetName(const char *name, bool strict);
bool SetName(llvm::StringRef name, bool strict); bool SetName(llvm::StringRef name, bool strict);
const ConstString &GetClassName(); ConstString GetClassName();
const ConstString &GetClassNameWithCategory(); ConstString GetClassNameWithCategory();
const ConstString &GetCategory(); ConstString GetCategory();
const ConstString &GetSelector(); ConstString GetSelector();
// Get all possible names for a method. Examples: // Get all possible names for a method. Examples:
// If name is "+[NSString(my_additions) myStringWithCString:]" // If name is "+[NSString(my_additions) myStringWithCString:]"
// names[0] => "+[NSString(my_additions) myStringWithCString:]" // names[0] => "+[NSString(my_additions) myStringWithCString:]"
// names[1] => "+[NSString myStringWithCString:]" // names[1] => "+[NSString myStringWithCString:]"
// If name is specified without the leading '+' or '-' like // If name is specified without the leading '+' or '-' like
// "[NSString(my_additions) myStringWithCString:]" // "[NSString(my_additions) myStringWithCString:]"
// names[0] => "+[NSString(my_additions) myStringWithCString:]" // names[0] => "+[NSString(my_additions) myStringWithCString:]"
Show All 16 Lines

lldb/source/Plugins/Language/ObjC/ObjCLanguage.cpp

Show All 16 Lines
} }
return IsValid(strict); return IsValid(strict);
} }
bool ObjCLanguage::MethodName::SetName(const char *name, bool strict) { bool ObjCLanguage::MethodName::SetName(const char *name, bool strict) {
return SetName(llvm::StringRef(name), strict); return SetName(llvm::StringRef(name), strict);
} }
const ConstString &ObjCLanguage::MethodName::GetClassName() { ConstString ObjCLanguage::MethodName::GetClassName() {
if (!m_class) { if (!m_class) {
if (IsValid(false)) { if (IsValid(false)) {
const char *full = m_full.GetCString(); const char *full = m_full.GetCString();
const char *class_start = (full[0] == '[' ? full + 1 : full + 2); const char *class_start = (full[0] == '[' ? full + 1 : full + 2);
const char *paren_pos = strchr(class_start, '('); const char *paren_pos = strchr(class_start, '(');
if (paren_pos) { if (paren_pos) {
m_class.SetCStringWithLength(class_start, paren_pos - class_start); m_class.SetCStringWithLength(class_start, paren_pos - class_start);
} else { } else {
Show All 9 Lines
} }
} }
} }
} }
} }
return m_class; return m_class;
} }
const ConstString &ObjCLanguage::MethodName::GetClassNameWithCategory() { ConstString ObjCLanguage::MethodName::GetClassNameWithCategory() {
if (!m_class_category) { if (!m_class_category) {
if (IsValid(false)) { if (IsValid(false)) {
const char *full = m_full.GetCString(); const char *full = m_full.GetCString();
const char *class_start = (full[0] == '[' ? full + 1 : full + 2); const char *class_start = (full[0] == '[' ? full + 1 : full + 2);
const char *space_pos = strchr(full, ' '); const char *space_pos = strchr(full, ' ');
if (space_pos) { if (space_pos) {
m_class_category.SetCStringWithLength(class_start, m_class_category.SetCStringWithLength(class_start,
space_pos - class_start); space_pos - class_start);
// If m_class hasn't been filled in and the class with category doesn't // If m_class hasn't been filled in and the class with category doesn't
// contain a '(', then we can also fill in the m_class // contain a '(', then we can also fill in the m_class
if (!m_class && strchr(m_class_category.GetCString(), '(') == nullptr) { if (!m_class && strchr(m_class_category.GetCString(), '(') == nullptr) {
m_class = m_class_category; m_class = m_class_category;
// No '(' was found in the full name, we can definitively say that // No '(' was found in the full name, we can definitively say that
// our category was valid (and empty). // our category was valid (and empty).
m_category_is_valid = true; m_category_is_valid = true;
} }
} }
} }
} }
return m_class_category; return m_class_category;
} }
const ConstString &ObjCLanguage::MethodName::GetSelector() { ConstString ObjCLanguage::MethodName::GetSelector() {
if (!m_selector) { if (!m_selector) {
if (IsValid(false)) { if (IsValid(false)) {
const char *full = m_full.GetCString(); const char *full = m_full.GetCString();
const char *space_pos = strchr(full, ' '); const char *space_pos = strchr(full, ' ');
if (space_pos) { if (space_pos) {
++space_pos; // skip the space ++space_pos; // skip the space
m_selector.SetCStringWithLength(space_pos, m_full.GetLength() - m_selector.SetCStringWithLength(space_pos, m_full.GetLength() -
(space_pos - full) - 1); (space_pos - full) - 1);
} }
} }
} }
return m_selector; return m_selector;
} }
const ConstString &ObjCLanguage::MethodName::GetCategory() { ConstString ObjCLanguage::MethodName::GetCategory() {
if (!m_category_is_valid && !m_category) { if (!m_category_is_valid && !m_category) {
if (IsValid(false)) { if (IsValid(false)) {
m_category_is_valid = true; m_category_is_valid = true;
const char *full = m_full.GetCString(); const char *full = m_full.GetCString();
const char *class_start = (full[0] == '[' ? full + 1 : full + 2); const char *class_start = (full[0] == '[' ? full + 1 : full + 2);
const char *open_paren_pos = strchr(class_start, '('); const char *open_paren_pos = strchr(class_start, '(');
if (open_paren_pos) { if (open_paren_pos) {
++open_paren_pos; // Skip the open paren ++open_paren_pos; // Skip the open paren
Show All 32 Lines
size_t ObjCLanguage::MethodName::GetFullNames(std::vector<ConstString> &names, size_t ObjCLanguage::MethodName::GetFullNames(std::vector<ConstString> &names,
bool append) { bool append) {
if (!append) if (!append)
names.clear(); names.clear();
if (IsValid(false)) { if (IsValid(false)) {
StreamString strm; StreamString strm;
const bool is_class_method = m_type == eTypeClassMethod; const bool is_class_method = m_type == eTypeClassMethod;
const bool is_instance_method = m_type == eTypeInstanceMethod; const bool is_instance_method = m_type == eTypeInstanceMethod;
const ConstString &category = GetCategory(); ConstString category = GetCategory();
if (is_class_method || is_instance_method) { if (is_class_method || is_instance_method) {
names.push_back(m_full); names.push_back(m_full);
if (category) { if (category) {
strm.Printf("%c[%s %s]", is_class_method ? '+' : '-', strm.Printf("%c[%s %s]", is_class_method ? '+' : '-',
GetClassName().GetCString(), GetSelector().GetCString()); GetClassName().GetCString(), GetSelector().GetCString());
names.emplace_back(strm.GetString()); names.emplace_back(strm.GetString());
} }
} else { } else {
const ConstString &class_name = GetClassName(); ConstString class_name = GetClassName();
const ConstString &selector = GetSelector(); ConstString selector = GetSelector();
strm.Printf("+[%s %s]", class_name.GetCString(), selector.GetCString()); strm.Printf("+[%s %s]", class_name.GetCString(), selector.GetCString());
names.emplace_back(strm.GetString()); names.emplace_back(strm.GetString());
strm.Clear(); strm.Clear();
strm.Printf("-[%s %s]", class_name.GetCString(), selector.GetCString()); strm.Printf("-[%s %s]", class_name.GetCString(), selector.GetCString());
names.emplace_back(strm.GetString()); names.emplace_back(strm.GetString());
strm.Clear(); strm.Clear();
if (category) { if (category) {
strm.Printf("+[%s(%s) %s]", class_name.GetCString(), strm.Printf("+[%s(%s) %s]", class_name.GetCString(),
Show All 16 Lines

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCDeclVendor.h

Show All 16 Lines
namespace lldb_private { namespace lldb_private {
class AppleObjCExternalASTSource; class AppleObjCExternalASTSource;
class AppleObjCDeclVendor : public DeclVendor { class AppleObjCDeclVendor : public DeclVendor {
public: public:
AppleObjCDeclVendor(ObjCLanguageRuntime &runtime); AppleObjCDeclVendor(ObjCLanguageRuntime &runtime);
uint32_t FindDecls(const ConstString &name, bool append, uint32_t max_matches, uint32_t FindDecls(ConstString name, bool append, uint32_t max_matches,
std::vector<clang::NamedDecl *> &decls) override; std::vector<clang::NamedDecl *> &decls) override;
clang::ExternalASTMerger::ImporterSource GetImporterSource() override; clang::ExternalASTMerger::ImporterSource GetImporterSource() override;
friend class AppleObjCExternalASTSource; friend class AppleObjCExternalASTSource;
private: private:
clang::ObjCInterfaceDecl *GetDeclForISA(ObjCLanguageRuntime::ObjCISA isa); clang::ObjCInterfaceDecl *GetDeclForISA(ObjCLanguageRuntime::ObjCISA isa);
Show All 16 Lines

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCDeclVendor.cpp

Show All 16 Lines
clang::ASTContext *ast_ctx = m_ast_ctx.getASTContext(); clang::ASTContext *ast_ctx = m_ast_ctx.getASTContext();
ObjCLanguageRuntime::ClassDescriptorSP descriptor = ObjCLanguageRuntime::ClassDescriptorSP descriptor =
m_runtime.GetClassDescriptorFromISA(isa); m_runtime.GetClassDescriptorFromISA(isa);
if (!descriptor) if (!descriptor)
return NULL; return NULL;
const ConstString &name(descriptor->GetClassName()); ConstString name(descriptor->GetClassName());
clang::IdentifierInfo &identifier_info = clang::IdentifierInfo &identifier_info =
ast_ctx->Idents.get(name.GetStringRef()); ast_ctx->Idents.get(name.GetStringRef());
clang::ObjCInterfaceDecl *new_iface_decl = clang::ObjCInterfaceDecl::Create( clang::ObjCInterfaceDecl *new_iface_decl = clang::ObjCInterfaceDecl::Create(
*ast_ctx, ast_ctx->getTranslationUnitDecl(), clang::SourceLocation(), *ast_ctx, ast_ctx->getTranslationUnitDecl(), clang::SourceLocation(),
&identifier_info, nullptr, nullptr); &identifier_info, nullptr, nullptr);
Show All 32 Lines
method_dumper.ToLog(log, " [AOTV::FD] "); method_dumper.ToLog(log, " [AOTV::FD] ");
} }
return true; return true;
} }
uint32_t uint32_t
AppleObjCDeclVendor::FindDecls(const ConstString &name, bool append, AppleObjCDeclVendor::FindDecls(ConstString name, bool append,
uint32_t max_matches, uint32_t max_matches,
std::vector<clang::NamedDecl *> &decls) { std::vector<clang::NamedDecl *> &decls) {
static unsigned int invocation_id = 0; static unsigned int invocation_id = 0;
unsigned int current_id = invocation_id++; unsigned int current_id = invocation_id++;
Log *log(GetLogIfAllCategoriesSet( Log *log(GetLogIfAllCategoriesSet(
LIBLLDB_LOG_EXPRESSIONS)); // FIXME - a more appropriate log channel? LIBLLDB_LOG_EXPRESSIONS)); // FIXME - a more appropriate log channel?
Show All 16 Lines

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.h

Show All 16 Lines
ConstString GetActualTypeName(ObjCLanguageRuntime::ObjCISA isa) override; ConstString GetActualTypeName(ObjCLanguageRuntime::ObjCISA isa) override;
ClassDescriptorSP GetClassDescriptor(ValueObject &in_value) override; ClassDescriptorSP GetClassDescriptor(ValueObject &in_value) override;
ClassDescriptorSP GetClassDescriptorFromISA(ObjCISA isa) override; ClassDescriptorSP GetClassDescriptorFromISA(ObjCISA isa) override;
DeclVendor *GetDeclVendor() override; DeclVendor *GetDeclVendor() override;
lldb::addr_t LookupRuntimeSymbol(const ConstString &name) override; lldb::addr_t LookupRuntimeSymbol(ConstString name) override;
EncodingToTypeSP GetEncodingToType() override; EncodingToTypeSP GetEncodingToType() override;
bool IsTaggedPointer(lldb::addr_t ptr) override; bool IsTaggedPointer(lldb::addr_t ptr) override;
TaggedPointerVendor *GetTaggedPointerVendor() override { TaggedPointerVendor *GetTaggedPointerVendor() override {
return m_tagged_pointer_vendor_up.get(); return m_tagged_pointer_vendor_up.get();
} }
Show All 16 Lines

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp

Show All 16 Lines
DeclVendor *AppleObjCRuntimeV2::GetDeclVendor() { DeclVendor *AppleObjCRuntimeV2::GetDeclVendor() {
if (!m_decl_vendor_up) if (!m_decl_vendor_up)
m_decl_vendor_up.reset(new AppleObjCDeclVendor(*this)); m_decl_vendor_up.reset(new AppleObjCDeclVendor(*this));
return m_decl_vendor_up.get(); return m_decl_vendor_up.get();
} }
lldb::addr_t AppleObjCRuntimeV2::LookupRuntimeSymbol(const ConstString &name) { lldb::addr_t AppleObjCRuntimeV2::LookupRuntimeSymbol(ConstString name) {
lldb::addr_t ret = LLDB_INVALID_ADDRESS; lldb::addr_t ret = LLDB_INVALID_ADDRESS;
const char *name_cstr = name.AsCString(); const char *name_cstr = name.AsCString();
if (name_cstr) { if (name_cstr) {
llvm::StringRef name_strref(name_cstr); llvm::StringRef name_strref(name_cstr);
static const llvm::StringRef ivar_prefix("OBJC_IVAR_$_"); static const llvm::StringRef ivar_prefix("OBJC_IVAR_$_");
Show All 16 Lines

lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.h

Show All 16 Lines
ConstString m_name; ConstString m_name;
std::vector<Kernel> m_kernels; std::vector<Kernel> m_kernels;
}; };
typedef std::vector<RSScriptGroupDescriptorSP> RSScriptGroupList; typedef std::vector<RSScriptGroupDescriptorSP> RSScriptGroupList;
class RSScriptGroupBreakpointResolver : public BreakpointResolver { class RSScriptGroupBreakpointResolver : public BreakpointResolver {
public: public:
RSScriptGroupBreakpointResolver(Breakpoint *bp, const ConstString &name, RSScriptGroupBreakpointResolver(Breakpoint *bp, ConstString name,
const RSScriptGroupList &groups, const RSScriptGroupList &groups,
bool stop_on_all) bool stop_on_all)
: BreakpointResolver(bp, BreakpointResolver::NameResolver), : BreakpointResolver(bp, BreakpointResolver::NameResolver),
m_group_name(name), m_script_groups(groups), m_group_name(name), m_script_groups(groups),
m_stop_on_all(stop_on_all) {} m_stop_on_all(stop_on_all) {}
void GetDescription(Stream *strm) override { void GetDescription(Stream *strm) override {
if (strm) if (strm)
Show All 13 Lines
CopyForBreakpoint(Breakpoint &breakpoint) override { CopyForBreakpoint(Breakpoint &breakpoint) override {
lldb::BreakpointResolverSP ret_sp(new RSScriptGroupBreakpointResolver( lldb::BreakpointResolverSP ret_sp(new RSScriptGroupBreakpointResolver(
&breakpoint, m_group_name, m_script_groups, m_stop_on_all)); &breakpoint, m_group_name, m_script_groups, m_stop_on_all));
return ret_sp; return ret_sp;
} }
protected: protected:
const RSScriptGroupDescriptorSP const RSScriptGroupDescriptorSP
FindScriptGroup(const ConstString &name) const { FindScriptGroup(ConstString name) const {
for (auto sg : m_script_groups) { for (auto sg : m_script_groups) {
if (ConstString::Compare(sg->m_name, name) == 0) if (ConstString::Compare(sg->m_name, name) == 0)
return sg; return sg;
} }
return RSScriptGroupDescriptorSP(); return RSScriptGroupDescriptorSP();
} }
ConstString m_group_name; ConstString m_group_name;
Show All 32 Lines
const lldb_renderscript::RSCoordinate *coords = nullptr); const lldb_renderscript::RSCoordinate *coords = nullptr);
bool PlaceBreakpointOnReduction( bool PlaceBreakpointOnReduction(
lldb::TargetSP target, Stream &messages, const char *reduce_name, lldb::TargetSP target, Stream &messages, const char *reduce_name,
const lldb_renderscript::RSCoordinate *coords = nullptr, const lldb_renderscript::RSCoordinate *coords = nullptr,
int kernel_types = ~(0)); int kernel_types = ~(0));
bool PlaceBreakpointOnScriptGroup(lldb::TargetSP target, Stream &strm, bool PlaceBreakpointOnScriptGroup(lldb::TargetSP target, Stream &strm,
const ConstString &name, bool stop_on_all); ConstString name, bool stop_on_all);
void SetBreakAllKernels(bool do_break, lldb::TargetSP target); void SetBreakAllKernels(bool do_break, lldb::TargetSP target);
void DumpStatus(Stream &strm) const; void DumpStatus(Stream &strm) const;
void ModulesDidLoad(const ModuleList &module_list) override; void ModulesDidLoad(const ModuleList &module_list) override;
bool LoadAllocation(Stream &strm, const uint32_t alloc_id, bool LoadAllocation(Stream &strm, const uint32_t alloc_id,
const char *filename, StackFrame *frame_ptr); const char *filename, StackFrame *frame_ptr);
bool SaveAllocation(Stream &strm, const uint32_t alloc_id, bool SaveAllocation(Stream &strm, const uint32_t alloc_id,
const char *filename, StackFrame *frame_ptr); const char *filename, StackFrame *frame_ptr);
void Update(); void Update();
void Initiate(); void Initiate();
const lldb_renderscript::RSScriptGroupList &GetScriptGroups() const { const lldb_renderscript::RSScriptGroupList &GetScriptGroups() const {
return m_scriptGroups; return m_scriptGroups;
}; };
bool IsKnownKernel(const ConstString &name) { bool IsKnownKernel(ConstString name) {
for (const auto &module : m_rsmodules) for (const auto &module : m_rsmodules)
for (const auto &kernel : module->m_kernels) for (const auto &kernel : module->m_kernels)
if (kernel.m_name == name) if (kernel.m_name == name)
return true; return true;
return false; return false;
} }
//------------------------------------------------------------------ //------------------------------------------------------------------
Show All 24 Lines
void LoadRuntimeHooks(lldb::ModuleSP module, ModuleKind kind); void LoadRuntimeHooks(lldb::ModuleSP module, ModuleKind kind);
bool RefreshAllocation(AllocationDetails *alloc, StackFrame *frame_ptr); bool RefreshAllocation(AllocationDetails *alloc, StackFrame *frame_ptr);
bool EvalRSExpression(const char *expression, StackFrame *frame_ptr, bool EvalRSExpression(const char *expression, StackFrame *frame_ptr,
uint64_t *result); uint64_t *result);
lldb::BreakpointSP CreateScriptGroupBreakpoint(const ConstString &name, lldb::BreakpointSP CreateScriptGroupBreakpoint(ConstString name,
bool multi); bool multi);
lldb::BreakpointSP CreateKernelBreakpoint(const ConstString &name); lldb::BreakpointSP CreateKernelBreakpoint(ConstString name);
lldb::BreakpointSP CreateReductionBreakpoint(const ConstString &name, lldb::BreakpointSP CreateReductionBreakpoint(ConstString name,
int kernel_types); int kernel_types);
void BreakOnModuleKernels( void BreakOnModuleKernels(
const lldb_renderscript::RSModuleDescriptorSP rsmodule_sp); const lldb_renderscript::RSModuleDescriptorSP rsmodule_sp);
struct RuntimeHook; struct RuntimeHook;
typedef void (RenderScriptRuntime::*CaptureStateFn)( typedef void (RenderScriptRuntime::*CaptureStateFn)(
RuntimeHook *hook_info, RuntimeHook *hook_info,
Show All 16 Lines

lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp

Show All 16 Lines
type_vec_size; // Vector size of each data point, e.g '4' for uchar4 type_vec_size; // Vector size of each data point, e.g '4' for uchar4
empirical_type<uint32_t> field_count; // Number of Subelements empirical_type<uint32_t> field_count; // Number of Subelements
empirical_type<uint32_t> datum_size; // Size of a single Element with padding empirical_type<uint32_t> datum_size; // Size of a single Element with padding
empirical_type<uint32_t> padding; // Number of padding bytes empirical_type<uint32_t> padding; // Number of padding bytes
empirical_type<uint32_t> empirical_type<uint32_t>
array_size; // Number of items in array, only needed for structs array_size; // Number of items in array, only needed for structs
ConstString type_name; // Name of type, only needed for structs ConstString type_name; // Name of type, only needed for structs
static const ConstString & static ConstString
GetFallbackStructName(); // Print this as the type name of a struct Element GetFallbackStructName(); // Print this as the type name of a struct Element
// If we can't resolve the actual struct name // If we can't resolve the actual struct name
bool ShouldRefresh() const { bool ShouldRefresh() const {
const bool valid_ptr = element_ptr.isValid() && *element_ptr.get() != 0x0; const bool valid_ptr = element_ptr.isValid() && *element_ptr.get() != 0x0;
const bool valid_type = const bool valid_type =
type.isValid() && type_vec_size.isValid() && type_kind.isValid(); type.isValid() && type_vec_size.isValid() && type_kind.isValid();
return !valid_ptr || !valid_type || !datum_size.isValid(); return !valid_ptr || !valid_type || !datum_size.isValid();
Show All 32 Lines
bool ShouldRefresh() const { bool ShouldRefresh() const {
bool valid_ptrs = data_ptr.isValid() && *data_ptr.get() != 0x0; bool valid_ptrs = data_ptr.isValid() && *data_ptr.get() != 0x0;
valid_ptrs = valid_ptrs && type_ptr.isValid() && *type_ptr.get() != 0x0; valid_ptrs = valid_ptrs && type_ptr.isValid() && *type_ptr.get() != 0x0;
return !valid_ptrs || !dimension.isValid() || !size.isValid() || return !valid_ptrs || !dimension.isValid() || !size.isValid() ||
element.ShouldRefresh(); element.ShouldRefresh();
} }
}; };
const ConstString &RenderScriptRuntime::Element::GetFallbackStructName() { ConstString RenderScriptRuntime::Element::GetFallbackStructName() {
static const ConstString FallbackStructName("struct"); static const ConstString FallbackStructName("struct");
return FallbackStructName; return FallbackStructName;
} }
uint32_t RenderScriptRuntime::AllocationDetails::ID = 1; uint32_t RenderScriptRuntime::AllocationDetails::ID = 1;
const char *RenderScriptRuntime::AllocationDetails::RsDataKindToString[] = { const char *RenderScriptRuntime::AllocationDetails::RsDataKindToString[] = {
"User", "Undefined", "Undefined", "Undefined", "User", "Undefined", "Undefined", "Undefined",
Show All 32 Lines
// '#rs_padding_[0-9]+' // '#rs_padding_[0-9]+'
if (found && num_children < elem.children.size()) { if (found && num_children < elem.children.size()) {
const uint32_t size_diff = elem.children.size() - num_children; const uint32_t size_diff = elem.children.size() - num_children;
if (log) if (log)
log->Printf("%s - %" PRIu32 " padding struct entries", __FUNCTION__, log->Printf("%s - %" PRIu32 " padding struct entries", __FUNCTION__,
size_diff); size_diff);
for (uint32_t i = 0; i < size_diff; ++i) { for (uint32_t i = 0; i < size_diff; ++i) {
const ConstString &name = elem.children[num_children + i].type_name; ConstString name = elem.children[num_children + i].type_name;
if (strcmp(name.AsCString(), "#rs_padding") < 0) if (strcmp(name.AsCString(), "#rs_padding") < 0)
found = false; found = false;
} }
} }
// We've found a global variable with matching type // We've found a global variable with matching type
if (found) { if (found) {
// Dereference since our Element type isn't a pointer. // Dereference since our Element type isn't a pointer.
Show All 32 Lines
log->Printf("%s(False) - breakpoints no longer automatically set.", log->Printf("%s(False) - breakpoints no longer automatically set.",
__FUNCTION__); __FUNCTION__);
} }
} }
// Given the name of a kernel this function creates a breakpoint using our own // Given the name of a kernel this function creates a breakpoint using our own
// breakpoint resolver, and returns the Breakpoint shared pointer. // breakpoint resolver, and returns the Breakpoint shared pointer.
BreakpointSP BreakpointSP
RenderScriptRuntime::CreateKernelBreakpoint(const ConstString &name) { RenderScriptRuntime::CreateKernelBreakpoint(ConstString name) {
Log *log( Log *log(
GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE | LIBLLDB_LOG_BREAKPOINTS)); GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE | LIBLLDB_LOG_BREAKPOINTS));
if (!m_filtersp) { if (!m_filtersp) {
if (log) if (log)
log->Printf("%s - error, no breakpoint search filter set.", __FUNCTION__); log->Printf("%s - error, no breakpoint search filter set.", __FUNCTION__);
return nullptr; return nullptr;
} }
Show All 11 Lines
if (log) if (log)
log->Printf("%s - error setting break name, '%s'.", __FUNCTION__, log->Printf("%s - error setting break name, '%s'.", __FUNCTION__,
err.AsCString()); err.AsCString());
return bp; return bp;
} }
BreakpointSP BreakpointSP
RenderScriptRuntime::CreateReductionBreakpoint(const ConstString &name, RenderScriptRuntime::CreateReductionBreakpoint(ConstString name,
int kernel_types) { int kernel_types) {
Log *log( Log *log(
GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE | LIBLLDB_LOG_BREAKPOINTS)); GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE | LIBLLDB_LOG_BREAKPOINTS));
if (!m_filtersp) { if (!m_filtersp) {
if (log) if (log)
log->Printf("%s - error, no breakpoint search filter set.", __FUNCTION__); log->Printf("%s - error, no breakpoint search filter set.", __FUNCTION__);
return nullptr; return nullptr;
Show All 32 Lines
SetConditional(bp, messages, *coord); SetConditional(bp, messages, *coord);
bp->GetDescription(&messages, lldb::eDescriptionLevelInitial, false); bp->GetDescription(&messages, lldb::eDescriptionLevelInitial, false);
return true; return true;
} }
BreakpointSP BreakpointSP
RenderScriptRuntime::CreateScriptGroupBreakpoint(const ConstString &name, RenderScriptRuntime::CreateScriptGroupBreakpoint(ConstString name,
bool stop_on_all) { bool stop_on_all) {
Log *log( Log *log(
GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE | LIBLLDB_LOG_BREAKPOINTS)); GetLogIfAnyCategoriesSet(LIBLLDB_LOG_LANGUAGE | LIBLLDB_LOG_BREAKPOINTS));
if (!m_filtersp) { if (!m_filtersp) {
if (log) if (log)
log->Printf("%s - error, no breakpoint search filter set.", __FUNCTION__); log->Printf("%s - error, no breakpoint search filter set.", __FUNCTION__);
return nullptr; return nullptr;
Show All 13 Lines
err.AsCString()); err.AsCString());
// ask the breakpoint to resolve itself // ask the breakpoint to resolve itself
bp->ResolveBreakpoint(); bp->ResolveBreakpoint();
return bp; return bp;
} }
bool RenderScriptRuntime::PlaceBreakpointOnScriptGroup(TargetSP target, bool RenderScriptRuntime::PlaceBreakpointOnScriptGroup(TargetSP target,
Stream &strm, Stream &strm,
const ConstString &name, ConstString name,
bool multi) { bool multi) {
InitSearchFilter(target); InitSearchFilter(target);
BreakpointSP bp = CreateScriptGroupBreakpoint(name, multi); BreakpointSP bp = CreateScriptGroupBreakpoint(name, multi);
if (bp) if (bp)
bp->GetDescription(&strm, lldb::eDescriptionLevelInitial, false); bp->GetDescription(&strm, lldb::eDescriptionLevelInitial, false);
return bool(bp); return bool(bp);
} }
Show All 16 Lines

lldb/source/Plugins/ObjectContainer/BSD-Archive/ObjectContainerBSDArchive.h

Show All 16 Lines
const Object *GetObjectAtIndex(size_t idx) { const Object *GetObjectAtIndex(size_t idx) {
if (idx < m_objects.size()) if (idx < m_objects.size())
return &m_objects[idx]; return &m_objects[idx];
return NULL; return NULL;
} }
size_t ParseObjects(); size_t ParseObjects();
Object *FindObject(const lldb_private::ConstString &object_name, Object *FindObject(lldb_private::ConstString object_name,
const llvm::sys::TimePoint<> &object_mod_time); const llvm::sys::TimePoint<> &object_mod_time);
lldb::offset_t GetFileOffset() const { return m_file_offset; } lldb::offset_t GetFileOffset() const { return m_file_offset; }
const llvm::sys::TimePoint<> &GetModificationTime() { return m_time; } const llvm::sys::TimePoint<> &GetModificationTime() { return m_time; }
const lldb_private::ArchSpec &GetArchitecture() const { return m_arch; } const lldb_private::ArchSpec &GetArchitecture() const { return m_arch; }
Show All 16 Lines

lldb/source/Plugins/ObjectContainer/BSD-Archive/ObjectContainerBSDArchive.cpp

Show All 16 Lines
// Now sort all of the object name pointers // Now sort all of the object name pointers
m_object_name_to_index_map.Sort(); m_object_name_to_index_map.Sort();
} }
return m_objects.size(); return m_objects.size();
} }
ObjectContainerBSDArchive::Object * ObjectContainerBSDArchive::Object *
ObjectContainerBSDArchive::Archive::FindObject( ObjectContainerBSDArchive::Archive::FindObject(
const ConstString &object_name, ConstString object_name,
const llvm::sys::TimePoint<> &object_mod_time) { const llvm::sys::TimePoint<> &object_mod_time) {
const ObjectNameToIndexMap::Entry *match = const ObjectNameToIndexMap::Entry *match =
m_object_name_to_index_map.FindFirstValueForName(object_name); m_object_name_to_index_map.FindFirstValueForName(object_name);
if (match) { if (match) {
if (object_mod_time != llvm::sys::TimePoint<>()) { if (object_mod_time != llvm::sys::TimePoint<>()) {
const uint64_t object_date = llvm::sys::toTimeT(object_mod_time); const uint64_t object_date = llvm::sys::toTimeT(object_mod_time);
if (m_objects[match->value].ar_date == object_date) if (m_objects[match->value].ar_date == object_date)
return &m_objects[match->value]; return &m_objects[match->value];
Show All 16 Lines

lldb/source/Plugins/ObjectFile/ELF/ObjectFileELF.cpp

Show All 16 Lines
// function will be resolved if it is referenced. // function will be resolved if it is referenced.
symbol_type = eSymbolTypeResolver; symbol_type = eSymbolTypeResolver;
break; break;
} }
} }
if (symbol_type == eSymbolTypeInvalid && symbol.getType() != STT_SECTION) { if (symbol_type == eSymbolTypeInvalid && symbol.getType() != STT_SECTION) {
if (symbol_section_sp) { if (symbol_section_sp) {
const ConstString &sect_name = symbol_section_sp->GetName(); ConstString sect_name = symbol_section_sp->GetName();
if (sect_name == text_section_name || sect_name == init_section_name || if (sect_name == text_section_name || sect_name == init_section_name ||
sect_name == fini_section_name || sect_name == ctors_section_name || sect_name == fini_section_name || sect_name == ctors_section_name ||
sect_name == dtors_section_name) { sect_name == dtors_section_name) {
symbol_type = eSymbolTypeCode; symbol_type = eSymbolTypeCode;
} else if (sect_name == data_section_name || } else if (sect_name == data_section_name ||
sect_name == data2_section_name || sect_name == data2_section_name ||
sect_name == rodata_section_name || sect_name == rodata_section_name ||
sect_name == rodata1_section_name || sect_name == rodata1_section_name ||
Show All 32 Lines
} }
if (symbol_section_sp && if (symbol_section_sp &&
CalculateType() != ObjectFile::Type::eTypeObjectFile) CalculateType() != ObjectFile::Type::eTypeObjectFile)
symbol_value -= symbol_section_sp->GetFileAddress(); symbol_value -= symbol_section_sp->GetFileAddress();
if (symbol_section_sp && module_section_list && if (symbol_section_sp && module_section_list &&
module_section_list != section_list) { module_section_list != section_list) {
const ConstString &sect_name = symbol_section_sp->GetName(); ConstString sect_name = symbol_section_sp->GetName();
auto section_it = section_name_to_section.find(sect_name.GetCString()); auto section_it = section_name_to_section.find(sect_name.GetCString());
if (section_it == section_name_to_section.end()) if (section_it == section_name_to_section.end())
section_it = section_it =
section_name_to_section section_name_to_section
.emplace(sect_name.GetCString(), .emplace(sect_name.GetCString(),
module_section_list->FindSectionByName(sect_name)) module_section_list->FindSectionByName(sect_name))
.first; .first;
if (section_it->second) if (section_it->second)
Show All 16 Lines

lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.h

Show All 16 Lines
lldb::offset_t offset, uint32_t cmd_idx, lldb::offset_t offset, uint32_t cmd_idx,
SegmentParsingContext &context); SegmentParsingContext &context);
void SanitizeSegmentCommand(llvm::MachO::segment_command_64 &seg_cmd, void SanitizeSegmentCommand(llvm::MachO::segment_command_64 &seg_cmd,
uint32_t cmd_idx); uint32_t cmd_idx);
bool SectionIsLoadable(const lldb_private::Section *section); bool SectionIsLoadable(const lldb_private::Section *section);
llvm::MachO::mach_header m_header; llvm::MachO::mach_header m_header;
static const lldb_private::ConstString &GetSegmentNameTEXT(); static lldb_private::ConstString GetSegmentNameTEXT();
static const lldb_private::ConstString &GetSegmentNameDATA(); static lldb_private::ConstString GetSegmentNameDATA();
static const lldb_private::ConstString &GetSegmentNameDATA_DIRTY(); static lldb_private::ConstString GetSegmentNameDATA_DIRTY();
static const lldb_private::ConstString &GetSegmentNameDATA_CONST(); static lldb_private::ConstString GetSegmentNameDATA_CONST();
static const lldb_private::ConstString &GetSegmentNameOBJC(); static lldb_private::ConstString GetSegmentNameOBJC();
static const lldb_private::ConstString &GetSegmentNameLINKEDIT(); static lldb_private::ConstString GetSegmentNameLINKEDIT();
static const lldb_private::ConstString &GetSegmentNameDWARF(); static lldb_private::ConstString GetSegmentNameDWARF();
static const lldb_private::ConstString &GetSectionNameEHFrame(); static lldb_private::ConstString GetSectionNameEHFrame();
llvm::MachO::dysymtab_command m_dysymtab; llvm::MachO::dysymtab_command m_dysymtab;
std::vector<llvm::MachO::segment_command_64> m_mach_segments; std::vector<llvm::MachO::segment_command_64> m_mach_segments;
std::vector<llvm::MachO::section_64> m_mach_sections; std::vector<llvm::MachO::section_64> m_mach_sections;
llvm::Optional<llvm::VersionTuple> m_min_os_version; llvm::Optional<llvm::VersionTuple> m_min_os_version;
std::vector<uint32_t> m_sdk_versions; std::vector<uint32_t> m_sdk_versions;
typedef lldb_private::RangeVector<uint32_t, uint32_t> FileRangeArray; typedef lldb_private::RangeVector<uint32_t, uint32_t> FileRangeArray;
lldb_private::Address m_entry_point_address; lldb_private::Address m_entry_point_address;
FileRangeArray m_thread_context_offsets; FileRangeArray m_thread_context_offsets;
bool m_thread_context_offsets_valid; bool m_thread_context_offsets_valid;
lldb_private::FileSpecList m_reexported_dylibs; lldb_private::FileSpecList m_reexported_dylibs;
bool m_allow_assembly_emulation_unwind_plans; bool m_allow_assembly_emulation_unwind_plans;
}; };
#endif // liblldb_ObjectFileMachO_h_ #endif // liblldb_ObjectFileMachO_h_
Context not available.

lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

Show All 16 Lines
specs.Append(spec); specs.Append(spec);
} }
} }
} }
} }
return specs.GetSize() - initial_count; return specs.GetSize() - initial_count;
} }
const ConstString &ObjectFileMachO::GetSegmentNameTEXT() { ConstString ObjectFileMachO::GetSegmentNameTEXT() {
static ConstString g_segment_name_TEXT("__TEXT"); static ConstString g_segment_name_TEXT("__TEXT");
return g_segment_name_TEXT; return g_segment_name_TEXT;
} }
const ConstString &ObjectFileMachO::GetSegmentNameDATA() { ConstString ObjectFileMachO::GetSegmentNameDATA() {
static ConstString g_segment_name_DATA("__DATA"); static ConstString g_segment_name_DATA("__DATA");
return g_segment_name_DATA; return g_segment_name_DATA;
} }
const ConstString &ObjectFileMachO::GetSegmentNameDATA_DIRTY() { ConstString ObjectFileMachO::GetSegmentNameDATA_DIRTY() {
static ConstString g_segment_name("__DATA_DIRTY"); static ConstString g_segment_name("__DATA_DIRTY");
return g_segment_name; return g_segment_name;
} }
const ConstString &ObjectFileMachO::GetSegmentNameDATA_CONST() { ConstString ObjectFileMachO::GetSegmentNameDATA_CONST() {
static ConstString g_segment_name("__DATA_CONST"); static ConstString g_segment_name("__DATA_CONST");
return g_segment_name; return g_segment_name;
} }
const ConstString &ObjectFileMachO::GetSegmentNameOBJC() { ConstString ObjectFileMachO::GetSegmentNameOBJC() {
static ConstString g_segment_name_OBJC("__OBJC"); static ConstString g_segment_name_OBJC("__OBJC");
return g_segment_name_OBJC; return g_segment_name_OBJC;
} }
const ConstString &ObjectFileMachO::GetSegmentNameLINKEDIT() { ConstString ObjectFileMachO::GetSegmentNameLINKEDIT() {
static ConstString g_section_name_LINKEDIT("__LINKEDIT"); static ConstString g_section_name_LINKEDIT("__LINKEDIT");
return g_section_name_LINKEDIT; return g_section_name_LINKEDIT;
} }
const ConstString &ObjectFileMachO::GetSegmentNameDWARF() { ConstString ObjectFileMachO::GetSegmentNameDWARF() {
static ConstString g_section_name("__DWARF"); static ConstString g_section_name("__DWARF");
return g_section_name; return g_section_name;
} }
const ConstString &ObjectFileMachO::GetSectionNameEHFrame() { ConstString ObjectFileMachO::GetSectionNameEHFrame() {
static ConstString g_section_name_eh_frame("__eh_frame"); static ConstString g_section_name_eh_frame("__eh_frame");
return g_section_name_eh_frame; return g_section_name_eh_frame;
} }
bool ObjectFileMachO::MagicBytesMatch(DataBufferSP &data_sp, bool ObjectFileMachO::MagicBytesMatch(DataBufferSP &data_sp,
lldb::addr_t data_offset, lldb::addr_t data_offset,
lldb::addr_t data_length) { lldb::addr_t data_length) {
DataExtractor data; DataExtractor data;
Show All 32 Lines
} }
} else { } else {
if (log) if (log)
module_sp->LogMessage(log, "failed to read strtab data"); module_sp->LogMessage(log, "failed to read strtab data");
return 0; return 0;
} }
} }
const ConstString &g_segment_name_TEXT = GetSegmentNameTEXT(); ConstString g_segment_name_TEXT = GetSegmentNameTEXT();
const ConstString &g_segment_name_DATA = GetSegmentNameDATA(); ConstString g_segment_name_DATA = GetSegmentNameDATA();
const ConstString &g_segment_name_DATA_DIRTY = GetSegmentNameDATA_DIRTY(); ConstString g_segment_name_DATA_DIRTY = GetSegmentNameDATA_DIRTY();
const ConstString &g_segment_name_DATA_CONST = GetSegmentNameDATA_CONST(); ConstString g_segment_name_DATA_CONST = GetSegmentNameDATA_CONST();
const ConstString &g_segment_name_OBJC = GetSegmentNameOBJC(); ConstString g_segment_name_OBJC = GetSegmentNameOBJC();
const ConstString &g_section_name_eh_frame = GetSectionNameEHFrame(); ConstString g_section_name_eh_frame = GetSectionNameEHFrame();
SectionSP text_section_sp( SectionSP text_section_sp(
section_list->FindSectionByName(g_segment_name_TEXT)); section_list->FindSectionByName(g_segment_name_TEXT));
SectionSP data_section_sp( SectionSP data_section_sp(
section_list->FindSectionByName(g_segment_name_DATA)); section_list->FindSectionByName(g_segment_name_DATA));
SectionSP data_dirty_section_sp( SectionSP data_dirty_section_sp(
section_list->FindSectionByName(g_segment_name_DATA_DIRTY)); section_list->FindSectionByName(g_segment_name_DATA_DIRTY));
SectionSP data_const_section_sp( SectionSP data_const_section_sp(
section_list->FindSectionByName(g_segment_name_DATA_CONST)); section_list->FindSectionByName(g_segment_name_DATA_CONST));
Show All 16 Lines

lldb/source/Plugins/Process/Utility/DynamicRegisterInfo.h

Show All 16 Lines
typedef std::vector<uint32_t> reg_num_collection; typedef std::vector<uint32_t> reg_num_collection;
typedef std::vector<reg_num_collection> set_reg_num_collection; typedef std::vector<reg_num_collection> set_reg_num_collection;
typedef std::vector<lldb_private::ConstString> name_collection; typedef std::vector<lldb_private::ConstString> name_collection;
typedef std::map<uint32_t, reg_num_collection> reg_to_regs_map; typedef std::map<uint32_t, reg_num_collection> reg_to_regs_map;
typedef std::vector<uint8_t> dwarf_opcode; typedef std::vector<uint8_t> dwarf_opcode;
typedef std::map<uint32_t, dwarf_opcode> dynamic_reg_size_map; typedef std::map<uint32_t, dwarf_opcode> dynamic_reg_size_map;
const lldb_private::RegisterInfo * const lldb_private::RegisterInfo *
GetRegisterInfo(const lldb_private::ConstString &reg_name) const; GetRegisterInfo(lldb_private::ConstString reg_name) const;
void MoveFrom(DynamicRegisterInfo &&info); void MoveFrom(DynamicRegisterInfo &&info);
reg_collection m_regs; reg_collection m_regs;
set_collection m_sets; set_collection m_sets;
set_reg_num_collection m_set_reg_nums; set_reg_num_collection m_set_reg_nums;
name_collection m_set_names; name_collection m_set_names;
reg_to_regs_map m_value_regs_map; reg_to_regs_map m_value_regs_map;
reg_to_regs_map m_invalidate_regs_map; reg_to_regs_map m_invalidate_regs_map;
dynamic_reg_size_map m_dynamic_reg_size_map; dynamic_reg_size_map m_dynamic_reg_size_map;
size_t m_reg_data_byte_size = 0u; // The number of bytes required to store size_t m_reg_data_byte_size = 0u; // The number of bytes required to store
// all registers // all registers
bool m_finalized = false; bool m_finalized = false;
}; };
#endif // lldb_DynamicRegisterInfo_h_ #endif // lldb_DynamicRegisterInfo_h_
Context not available.

lldb/source/Plugins/Process/Utility/DynamicRegisterInfo.cpp

Show All 16 Lines
for (size_t idx = 0; idx < m_sets[i].num_registers; ++idx) { for (size_t idx = 0; idx < m_sets[i].num_registers; ++idx) {
s.Printf("%s ", m_regs[m_sets[i].registers[idx]].name); s.Printf("%s ", m_regs[m_sets[i].registers[idx]].name);
} }
s.Printf("]\n"); s.Printf("]\n");
} }
} }
const lldb_private::RegisterInfo *DynamicRegisterInfo::GetRegisterInfo( const lldb_private::RegisterInfo *DynamicRegisterInfo::GetRegisterInfo(
const lldb_private::ConstString &reg_name) const { lldb_private::ConstString reg_name) const {
for (auto &reg_info : m_regs) { for (auto &reg_info : m_regs) {
// We can use pointer comparison since we used a ConstString to set the // We can use pointer comparison since we used a ConstString to set the
// "name" member in AddRegister() // "name" member in AddRegister()
if (reg_info.name == reg_name.GetCString()) { if (reg_info.name == reg_name.GetCString()) {
return &reg_info; return &reg_info;
} }
} }
return NULL; return NULL;
} }
Context not available.

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h

Show All 16 Lines
lldb_private::StructuredData::Array *GetSupportedStructuredDataPlugins(); lldb_private::StructuredData::Array *GetSupportedStructuredDataPlugins();
//------------------------------------------------------------------ //------------------------------------------------------------------
/// Configure a StructuredData feature on the remote end. /// Configure a StructuredData feature on the remote end.
/// ///
/// @see \b Process::ConfigureStructuredData(...) for details. /// @see \b Process::ConfigureStructuredData(...) for details.
//------------------------------------------------------------------ //------------------------------------------------------------------
Status Status
ConfigureRemoteStructuredData(const ConstString &type_name, ConfigureRemoteStructuredData(ConstString type_name,
const StructuredData::ObjectSP &config_sp); const StructuredData::ObjectSP &config_sp);
lldb::user_id_t SendStartTracePacket(const TraceOptions &options, lldb::user_id_t SendStartTracePacket(const TraceOptions &options,
Status &error); Status &error);
Status SendStopTracePacket(lldb::user_id_t uid, lldb::tid_t thread_id); Status SendStopTracePacket(lldb::user_id_t uid, lldb::tid_t thread_id);
Status SendGetDataPacket(lldb::user_id_t uid, lldb::tid_t thread_id, Status SendGetDataPacket(lldb::user_id_t uid, lldb::tid_t thread_id,
Show All 16 Lines

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp

Show All 16 Lines
if (response.IsOKResponse()) { if (response.IsOKResponse()) {
return Status(); return Status();
} else { } else {
return Status("Unknown error happened during sending QPassSignals packet."); return Status("Unknown error happened during sending QPassSignals packet.");
} }
} }
Status GDBRemoteCommunicationClient::ConfigureRemoteStructuredData( Status GDBRemoteCommunicationClient::ConfigureRemoteStructuredData(
const ConstString &type_name, const StructuredData::ObjectSP &config_sp) { ConstString type_name, const StructuredData::ObjectSP &config_sp) {
Status error; Status error;
if (type_name.GetLength() == 0) { if (type_name.GetLength() == 0) {
error.SetErrorString("invalid type_name argument"); error.SetErrorString("invalid type_name argument");
return error; return error;
} }
// Build command: Configure{type_name}: serialized config data. // Build command: Configure{type_name}: serialized config data.
Show All 16 Lines

lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.h

Show All 16 Lines
void ModulesDidLoad(ModuleList &module_list) override; void ModulesDidLoad(ModuleList &module_list) override;
StructuredData::ObjectSP StructuredData::ObjectSP
GetLoadedDynamicLibrariesInfos(lldb::addr_t image_list_address, GetLoadedDynamicLibrariesInfos(lldb::addr_t image_list_address,
lldb::addr_t image_count) override; lldb::addr_t image_count) override;
Status Status
ConfigureStructuredData(const ConstString &type_name, ConfigureStructuredData(ConstString type_name,
const StructuredData::ObjectSP &config_sp) override; const StructuredData::ObjectSP &config_sp) override;
StructuredData::ObjectSP GetLoadedDynamicLibrariesInfos() override; StructuredData::ObjectSP GetLoadedDynamicLibrariesInfos() override;
StructuredData::ObjectSP GetLoadedDynamicLibrariesInfos( StructuredData::ObjectSP GetLoadedDynamicLibrariesInfos(
const std::vector<lldb::addr_t> &load_addresses) override; const std::vector<lldb::addr_t> &load_addresses) override;
StructuredData::ObjectSP StructuredData::ObjectSP
Show All 16 Lines

lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

Show All 16 Lines
} }
} }
} }
} }
return object_sp; return object_sp;
} }
Status ProcessGDBRemote::ConfigureStructuredData( Status ProcessGDBRemote::ConfigureStructuredData(
const ConstString &type_name, const StructuredData::ObjectSP &config_sp) { ConstString type_name, const StructuredData::ObjectSP &config_sp) {
return m_gdb_comm.ConfigureRemoteStructuredData(type_name, config_sp); return m_gdb_comm.ConfigureRemoteStructuredData(type_name, config_sp);
} }
// Establish the largest memory read/write payloads we should use. If the // Establish the largest memory read/write payloads we should use. If the
// remote stub has a max packet size, stay under that size. // remote stub has a max packet size, stay under that size.
// //
// If the remote stub's max packet size is crazy large, use a reasonable // If the remote stub's max packet size is crazy large, use a reasonable
// largeish default. // largeish default.
Show All 16 Lines

lldb/source/Plugins/StructuredData/DarwinLog/StructuredDataDarwinLog.h

Show All 16 Lines
// ------------------------------------------------------------------------- // -------------------------------------------------------------------------
// Public static API // Public static API
// ------------------------------------------------------------------------- // -------------------------------------------------------------------------
static void Initialize(); static void Initialize();
static void Terminate(); static void Terminate();
static const ConstString &GetStaticPluginName(); static ConstString GetStaticPluginName();
// ------------------------------------------------------------------------- // -------------------------------------------------------------------------
/// Return whether the DarwinLog functionality is enabled. /// Return whether the DarwinLog functionality is enabled.
/// ///
/// The DarwinLog functionality is enabled if the user expicitly enabled /// The DarwinLog functionality is enabled if the user expicitly enabled
/// it with the enable command, or if the user has the setting set /// it with the enable command, or if the user has the setting set
/// that controls if we always enable it for newly created/attached /// that controls if we always enable it for newly created/attached
/// processes. /// processes.
Show All 11 Lines
ConstString GetPluginName() override; ConstString GetPluginName() override;
uint32_t GetPluginVersion() override; uint32_t GetPluginVersion() override;
// ------------------------------------------------------------------------- // -------------------------------------------------------------------------
// StructuredDataPlugin API // StructuredDataPlugin API
// ------------------------------------------------------------------------- // -------------------------------------------------------------------------
bool SupportsStructuredDataType(const ConstString &type_name) override; bool SupportsStructuredDataType(ConstString type_name) override;
void HandleArrivalOfStructuredData( void HandleArrivalOfStructuredData(
Process &process, const ConstString &type_name, Process &process, ConstString type_name,
const StructuredData::ObjectSP &object_sp) override; const StructuredData::ObjectSP &object_sp) override;
Status GetDescription(const StructuredData::ObjectSP &object_sp, Status GetDescription(const StructuredData::ObjectSP &object_sp,
lldb_private::Stream &stream) override; lldb_private::Stream &stream) override;
bool GetEnabled(const ConstString &type_name) const override; bool GetEnabled(ConstString type_name) const override;
void ModulesDidLoad(Process &process, ModuleList &module_list) override; void ModulesDidLoad(Process &process, ModuleList &module_list) override;
~StructuredDataDarwinLog(); ~StructuredDataDarwinLog();
private: private:
// ------------------------------------------------------------------------- // -------------------------------------------------------------------------
// Private constructors // Private constructors
Show All 16 Lines

lldb/source/Plugins/StructuredData/DarwinLog/StructuredDataDarwinLog.cpp

Show All 16 Lines
"subsystem" // subsystem of the log message "subsystem" // subsystem of the log message
// Consider implementing this action as it would be cheaper to filter. // Consider implementing this action as it would be cheaper to filter.
// "message" requires always formatting the message, which is a waste of // "message" requires always formatting the message, which is a waste of
// cycles if it ends up being rejected. "format", // format string // cycles if it ends up being rejected. "format", // format string
// used to format message text // used to format message text
}; };
static const ConstString &GetDarwinLogTypeName() { static ConstString GetDarwinLogTypeName() {
static const ConstString s_key_name("DarwinLog"); static const ConstString s_key_name("DarwinLog");
return s_key_name; return s_key_name;
} }
static const ConstString &GetLogEventType() { static ConstString GetLogEventType() {
static const ConstString s_event_type("log"); static const ConstString s_event_type("log");
return s_event_type; return s_event_type;
} }
class FilterRule; class FilterRule;
using FilterRuleSP = std::shared_ptr<FilterRule>; using FilterRuleSP = std::shared_ptr<FilterRule>;
class FilterRule { class FilterRule {
public: public:
virtual ~FilterRule() {} virtual ~FilterRule() {}
using OperationCreationFunc = using OperationCreationFunc =
std::function<FilterRuleSP(bool accept, size_t attribute_index, std::function<FilterRuleSP(bool accept, size_t attribute_index,
const std::string &op_arg, Status &error)>; const std::string &op_arg, Status &error)>;
static void RegisterOperation(const ConstString &operation, static void RegisterOperation(ConstString operation,
const OperationCreationFunc &creation_func) { const OperationCreationFunc &creation_func) {
GetCreationFuncMap().insert(std::make_pair(operation, creation_func)); GetCreationFuncMap().insert(std::make_pair(operation, creation_func));
} }
static FilterRuleSP CreateRule(bool match_accepts, size_t attribute, static FilterRuleSP CreateRule(bool match_accepts, size_t attribute,
const ConstString &operation, ConstString operation,
const std::string &op_arg, Status &error) { const std::string &op_arg, Status &error) {
// Find the creation func for this type of filter rule. // Find the creation func for this type of filter rule.
auto map = GetCreationFuncMap(); auto map = GetCreationFuncMap();
auto find_it = map.find(operation); auto find_it = map.find(operation);
if (find_it == map.end()) { if (find_it == map.end()) {
error.SetErrorStringWithFormat("unknown filter operation \"" error.SetErrorStringWithFormat("unknown filter operation \""
"%s\"", "%s\"",
operation.GetCString()); operation.GetCString());
Show All 21 Lines
// Let the rule add its own specific details here. // Let the rule add its own specific details here.
DoSerialization(*dict_p); DoSerialization(*dict_p);
return StructuredData::ObjectSP(dict_p); return StructuredData::ObjectSP(dict_p);
} }
virtual void Dump(Stream &stream) const = 0; virtual void Dump(Stream &stream) const = 0;
const ConstString &GetOperationType() const { return m_operation; } ConstString GetOperationType() const { return m_operation; }
protected: protected:
FilterRule(bool accept, size_t attribute_index, const ConstString &operation) FilterRule(bool accept, size_t attribute_index, ConstString operation)
: m_accept(accept), m_attribute_index(attribute_index), : m_accept(accept), m_attribute_index(attribute_index),
m_operation(operation) {} m_operation(operation) {}
virtual void DoSerialization(StructuredData::Dictionary &dict) const = 0; virtual void DoSerialization(StructuredData::Dictionary &dict) const = 0;
bool GetMatchAccepts() const { return m_accept; } bool GetMatchAccepts() const { return m_accept; }
const char *GetFilterAttribute() const { const char *GetFilterAttribute() const {
Show All 32 Lines
return FilterRuleSP(); return FilterRuleSP();
} }
// We passed all our checks, this appears fine. // We passed all our checks, this appears fine.
error.Clear(); error.Clear();
return FilterRuleSP(new RegexFilterRule(accept, attribute_index, op_arg)); return FilterRuleSP(new RegexFilterRule(accept, attribute_index, op_arg));
} }
static const ConstString &StaticGetOperation() { static ConstString StaticGetOperation() {
static ConstString s_operation("regex"); static ConstString s_operation("regex");
return s_operation; return s_operation;
} }
RegexFilterRule(bool accept, size_t attribute_index, RegexFilterRule(bool accept, size_t attribute_index,
const std::string &regex_text) const std::string &regex_text)
: FilterRule(accept, attribute_index, StaticGetOperation()), : FilterRule(accept, attribute_index, StaticGetOperation()),
m_regex_text(regex_text) {} m_regex_text(regex_text) {}
Show All 28 Lines
return FilterRuleSP(); return FilterRuleSP();
} }
error.Clear(); error.Clear();
return FilterRuleSP( return FilterRuleSP(
new ExactMatchFilterRule(accept, attribute_index, op_arg)); new ExactMatchFilterRule(accept, attribute_index, op_arg));
} }
static const ConstString &StaticGetOperation() { static ConstString StaticGetOperation() {
static ConstString s_operation("match"); static ConstString s_operation("match");
return s_operation; return s_operation;
} }
ExactMatchFilterRule(bool accept, size_t attribute_index, ExactMatchFilterRule(bool accept, size_t attribute_index,
const std::string &match_text) const std::string &match_text)
: FilterRule(accept, attribute_index, StaticGetOperation()), : FilterRule(accept, attribute_index, StaticGetOperation()),
m_match_text(match_text) {} m_match_text(match_text) {}
Show All 32 Lines
stream.PutCString("Availability: unknown (requires process)\n"); stream.PutCString("Availability: unknown (requires process)\n");
stream.PutCString("Enabled: not applicable " stream.PutCString("Enabled: not applicable "
"(requires process)\n"); "(requires process)\n");
} else { } else {
auto plugin_sp = auto plugin_sp =
process_sp->GetStructuredDataPlugin(GetDarwinLogTypeName()); process_sp->GetStructuredDataPlugin(GetDarwinLogTypeName());
stream.Printf("Availability: %s\n", stream.Printf("Availability: %s\n",
plugin_sp ? "available" : "unavailable"); plugin_sp ? "available" : "unavailable");
auto &plugin_name = StructuredDataDarwinLog::GetStaticPluginName(); ConstString plugin_name = StructuredDataDarwinLog::GetStaticPluginName();
const bool enabled = const bool enabled =
plugin_sp ? plugin_sp->GetEnabled(plugin_name) : false; plugin_sp ? plugin_sp->GetEnabled(plugin_name) : false;
stream.Printf("Enabled: %s\n", enabled ? "true" : "false"); stream.Printf("Enabled: %s\n", enabled ? "true" : "false");
} }
// Display filter settings. // Display filter settings.
DebuggerSP debugger_sp = DebuggerSP debugger_sp =
GetCommandInterpreter().GetDebugger().shared_from_this(); GetCommandInterpreter().GetDebugger().shared_from_this();
Show All 32 Lines
GetStaticPluginName(), "Darwin os_log() and os_activity() support", GetStaticPluginName(), "Darwin os_log() and os_activity() support",
&CreateInstance, &DebuggerInitialize, &FilterLaunchInfo); &CreateInstance, &DebuggerInitialize, &FilterLaunchInfo);
} }
void StructuredDataDarwinLog::Terminate() { void StructuredDataDarwinLog::Terminate() {
PluginManager::UnregisterPlugin(&CreateInstance); PluginManager::UnregisterPlugin(&CreateInstance);
} }
const ConstString &StructuredDataDarwinLog::GetStaticPluginName() { ConstString StructuredDataDarwinLog::GetStaticPluginName() {
static ConstString s_plugin_name("darwin-log"); static ConstString s_plugin_name("darwin-log");
return s_plugin_name; return s_plugin_name;
} }
#pragma mark - #pragma mark -
#pragma mark PluginInterface API #pragma mark PluginInterface API
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
Show All 9 Lines
#pragma mark - #pragma mark -
#pragma mark StructuredDataPlugin API #pragma mark StructuredDataPlugin API
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
// StructuredDataPlugin API // StructuredDataPlugin API
// ----------------------------------------------------------------------------- // -----------------------------------------------------------------------------
bool StructuredDataDarwinLog::SupportsStructuredDataType( bool StructuredDataDarwinLog::SupportsStructuredDataType(
const ConstString &type_name) { ConstString type_name) {
return type_name == GetDarwinLogTypeName(); return type_name == GetDarwinLogTypeName();
} }
void StructuredDataDarwinLog::HandleArrivalOfStructuredData( void StructuredDataDarwinLog::HandleArrivalOfStructuredData(
Process &process, const ConstString &type_name, Process &process, ConstString type_name,
const StructuredData::ObjectSP &object_sp) { const StructuredData::ObjectSP &object_sp) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS)); Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
if (log) { if (log) {
StreamString json_stream; StreamString json_stream;
if (object_sp) if (object_sp)
object_sp->Dump(json_stream); object_sp->Dump(json_stream);
else else
json_stream.PutCString("<null>"); json_stream.PutCString("<null>");
Show All 32 Lines
HandleDisplayOfEvent(*event, stream); HandleDisplayOfEvent(*event, stream);
return true; return true;
}); });
stream.Flush(); stream.Flush();
return error; return error;
} }
bool StructuredDataDarwinLog::GetEnabled(const ConstString &type_name) const { bool StructuredDataDarwinLog::GetEnabled(ConstString type_name) const {
if (type_name == GetStaticPluginName()) if (type_name == GetStaticPluginName())
return m_is_enabled; return m_is_enabled;
else else
return false; return false;
} }
void StructuredDataDarwinLog::SetEnabled(bool enabled) { void StructuredDataDarwinLog::SetEnabled(bool enabled) {
m_is_enabled = enabled; m_is_enabled = enabled;
Show All 16 Lines

lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.h

Show All 16 Lines
bool ParseImportedModules( bool ParseImportedModules(
const SymbolContext &sc, const SymbolContext &sc,
std::vector<lldb_private::SourceModule> &imported_modules) override { std::vector<lldb_private::SourceModule> &imported_modules) override {
return false; return false;
} }
size_t ParseBlocksRecursive(Function &func) override { return 0; } size_t ParseBlocksRecursive(Function &func) override { return 0; }
uint32_t FindGlobalVariables(const ConstString &name, uint32_t FindGlobalVariables(ConstString name,
const CompilerDeclContext *parent_decl_ctx, const CompilerDeclContext *parent_decl_ctx,
uint32_t max_matches, uint32_t max_matches,
VariableList &variables) override { VariableList &variables) override {
return 0; return 0;
} }
size_t ParseVariablesForContext(const SymbolContext &sc) override { size_t ParseVariablesForContext(const SymbolContext &sc) override {
return 0; return 0;
Show All 15 Lines
lldb::SymbolContextItem resolve_scope, lldb::SymbolContextItem resolve_scope,
SymbolContextList &sc_list) override; SymbolContextList &sc_list) override;
size_t GetTypes(SymbolContextScope *sc_scope, lldb::TypeClass type_mask, size_t GetTypes(SymbolContextScope *sc_scope, lldb::TypeClass type_mask,
TypeList &type_list) override { TypeList &type_list) override {
return 0; return 0;
} }
uint32_t FindFunctions(const ConstString &name, uint32_t FindFunctions(ConstString name,
const CompilerDeclContext *parent_decl_ctx, const CompilerDeclContext *parent_decl_ctx,
lldb::FunctionNameType name_type_mask, lldb::FunctionNameType name_type_mask,
bool include_inlines, bool append, bool include_inlines, bool append,
SymbolContextList &sc_list) override; SymbolContextList &sc_list) override;
uint32_t FindFunctions(const RegularExpression &regex, bool include_inlines, uint32_t FindFunctions(const RegularExpression &regex, bool include_inlines,
bool append, SymbolContextList &sc_list) override; bool append, SymbolContextList &sc_list) override;
uint32_t FindTypes(const ConstString &name, uint32_t FindTypes(ConstString name,
const CompilerDeclContext *parent_decl_ctx, bool append, const CompilerDeclContext *parent_decl_ctx, bool append,
uint32_t max_matches, uint32_t max_matches,
llvm::DenseSet<SymbolFile *> &searched_symbol_files, llvm::DenseSet<SymbolFile *> &searched_symbol_files,
TypeMap &types) override; TypeMap &types) override;
size_t FindTypes(const std::vector<CompilerContext> &context, bool append, size_t FindTypes(const std::vector<CompilerContext> &context, bool append,
TypeMap &types) override; TypeMap &types) override;
TypeSystem *GetTypeSystemForLanguage(lldb::LanguageType language) override { TypeSystem *GetTypeSystemForLanguage(lldb::LanguageType language) override {
return nullptr; return nullptr;
} }
CompilerDeclContext CompilerDeclContext
FindNamespace(const ConstString &name, FindNamespace(ConstString name,
const CompilerDeclContext *parent_decl_ctx) override { const CompilerDeclContext *parent_decl_ctx) override {
return CompilerDeclContext(); return CompilerDeclContext();
} }
void AddSymbols(Symtab &symtab) override; void AddSymbols(Symtab &symtab) override;
ConstString GetPluginName() override { return GetPluginNameStatic(); } ConstString GetPluginName() override { return GetPluginNameStatic(); }
uint32_t GetPluginVersion() override { return 1; } uint32_t GetPluginVersion() override { return 1; }
Show All 16 Lines

lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.cpp

Show All 16 Lines
CompileUnit &cu = *GetSymbolVendor().GetCompileUnitAtIndex(i); CompileUnit &cu = *GetSymbolVendor().GetCompileUnitAtIndex(i);
cu.ResolveSymbolContext(file_spec, line, check_inlines, cu.ResolveSymbolContext(file_spec, line, check_inlines,
/*exact*/ false, resolve_scope, sc_list); /*exact*/ false, resolve_scope, sc_list);
} }
return sc_list.GetSize() - old_size; return sc_list.GetSize() - old_size;
} }
uint32_t SymbolFileBreakpad::FindFunctions( uint32_t SymbolFileBreakpad::FindFunctions(
const ConstString &name, const CompilerDeclContext *parent_decl_ctx, ConstString name, const CompilerDeclContext *parent_decl_ctx,
FunctionNameType name_type_mask, bool include_inlines, bool append, FunctionNameType name_type_mask, bool include_inlines, bool append,
SymbolContextList &sc_list) { SymbolContextList &sc_list) {
// TODO // TODO
if (!append) if (!append)
sc_list.Clear(); sc_list.Clear();
return sc_list.GetSize(); return sc_list.GetSize();
} }
uint32_t SymbolFileBreakpad::FindFunctions(const RegularExpression &regex, uint32_t SymbolFileBreakpad::FindFunctions(const RegularExpression &regex,
bool include_inlines, bool append, bool include_inlines, bool append,
SymbolContextList &sc_list) { SymbolContextList &sc_list) {
// TODO // TODO
if (!append) if (!append)
sc_list.Clear(); sc_list.Clear();
return sc_list.GetSize(); return sc_list.GetSize();
} }
uint32_t SymbolFileBreakpad::FindTypes( uint32_t SymbolFileBreakpad::FindTypes(
const ConstString &name, const CompilerDeclContext *parent_decl_ctx, ConstString name, const CompilerDeclContext *parent_decl_ctx,
bool append, uint32_t max_matches, bool append, uint32_t max_matches,
llvm::DenseSet<SymbolFile *> &searched_symbol_files, TypeMap &types) { llvm::DenseSet<SymbolFile *> &searched_symbol_files, TypeMap &types) {
if (!append) if (!append)
types.Clear(); types.Clear();
return types.GetSize(); return types.GetSize();
} }
size_t size_t
Show All 16 Lines

lldb/source/Plugins/SymbolFile/DWARF/NameToDIE.h

Show All 16 Lines
class NameToDIE { class NameToDIE {
public: public:
NameToDIE() : m_map() {} NameToDIE() : m_map() {}
~NameToDIE() {} ~NameToDIE() {}
void Dump(lldb_private::Stream *s); void Dump(lldb_private::Stream *s);
void Insert(const lldb_private::ConstString &name, const DIERef &die_ref); void Insert(lldb_private::ConstString name, const DIERef &die_ref);
void Append(const NameToDIE &other); void Append(const NameToDIE &other);
void Finalize(); void Finalize();
size_t Find(const lldb_private::ConstString &name, size_t Find(lldb_private::ConstString name,
DIEArray &info_array) const; DIEArray &info_array) const;
size_t Find(const lldb_private::RegularExpression &regex, size_t Find(const lldb_private::RegularExpression &regex,
DIEArray &info_array) const; DIEArray &info_array) const;
size_t FindAllEntriesForCompileUnit(dw_offset_t cu_offset, size_t FindAllEntriesForCompileUnit(dw_offset_t cu_offset,
DIEArray &info_array) const; DIEArray &info_array) const;
Show All 10 Lines

lldb/source/Plugins/SymbolFile/DWARF/NameToDIE.cpp

Show All 16 Lines
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
void NameToDIE::Finalize() { void NameToDIE::Finalize() {
m_map.Sort(); m_map.Sort();
m_map.SizeToFit(); m_map.SizeToFit();
} }
void NameToDIE::Insert(const ConstString &name, const DIERef &die_ref) { void NameToDIE::Insert(ConstString name, const DIERef &die_ref) {
m_map.Append(name, die_ref); m_map.Append(name, die_ref);
} }
size_t NameToDIE::Find(const ConstString &name, DIEArray &info_array) const { size_t NameToDIE::Find(ConstString name, DIEArray &info_array) const {
return m_map.GetValues(name, info_array); return m_map.GetValues(name, info_array);
} }
size_t NameToDIE::Find(const RegularExpression &regex, size_t NameToDIE::Find(const RegularExpression &regex,
DIEArray &info_array) const { DIEArray &info_array) const {
return m_map.GetValues(regex, info_array); return m_map.GetValues(regex, info_array);
} }
Show All 16 Lines

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

Show All 16 Lines
uint32_t uint32_t
ResolveSymbolContext(const lldb_private::FileSpec &file_spec, uint32_t line, ResolveSymbolContext(const lldb_private::FileSpec &file_spec, uint32_t line,
bool check_inlines, bool check_inlines,
lldb::SymbolContextItem resolve_scope, lldb::SymbolContextItem resolve_scope,
lldb_private::SymbolContextList &sc_list) override; lldb_private::SymbolContextList &sc_list) override;
uint32_t uint32_t
FindGlobalVariables(const lldb_private::ConstString &name, FindGlobalVariables(lldb_private::ConstString name,
const lldb_private::CompilerDeclContext *parent_decl_ctx, const lldb_private::CompilerDeclContext *parent_decl_ctx,
uint32_t max_matches, uint32_t max_matches,
lldb_private::VariableList &variables) override; lldb_private::VariableList &variables) override;
uint32_t FindGlobalVariables(const lldb_private::RegularExpression &regex, uint32_t FindGlobalVariables(const lldb_private::RegularExpression &regex,
uint32_t max_matches, uint32_t max_matches,
lldb_private::VariableList &variables) override; lldb_private::VariableList &variables) override;
uint32_t uint32_t
FindFunctions(const lldb_private::ConstString &name, FindFunctions(lldb_private::ConstString name,
const lldb_private::CompilerDeclContext *parent_decl_ctx, const lldb_private::CompilerDeclContext *parent_decl_ctx,
lldb::FunctionNameType name_type_mask, bool include_inlines, lldb::FunctionNameType name_type_mask, bool include_inlines,
bool append, lldb_private::SymbolContextList &sc_list) override; bool append, lldb_private::SymbolContextList &sc_list) override;
uint32_t FindFunctions(const lldb_private::RegularExpression &regex, uint32_t FindFunctions(const lldb_private::RegularExpression &regex,
bool include_inlines, bool append, bool include_inlines, bool append,
lldb_private::SymbolContextList &sc_list) override; lldb_private::SymbolContextList &sc_list) override;
void GetMangledNamesForFunction( void GetMangledNamesForFunction(
const std::string &scope_qualified_name, const std::string &scope_qualified_name,
std::vector<lldb_private::ConstString> &mangled_names) override; std::vector<lldb_private::ConstString> &mangled_names) override;
uint32_t uint32_t
FindTypes(const lldb_private::ConstString &name, FindTypes(lldb_private::ConstString name,
const lldb_private::CompilerDeclContext *parent_decl_ctx, const lldb_private::CompilerDeclContext *parent_decl_ctx,
bool append, uint32_t max_matches, bool append, uint32_t max_matches,
llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files, llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
lldb_private::TypeMap &types) override; lldb_private::TypeMap &types) override;
size_t FindTypes(const std::vector<lldb_private::CompilerContext> &context, size_t FindTypes(const std::vector<lldb_private::CompilerContext> &context,
bool append, lldb_private::TypeMap &types) override; bool append, lldb_private::TypeMap &types) override;
lldb_private::TypeList *GetTypeList() override; lldb_private::TypeList *GetTypeList() override;
size_t GetTypes(lldb_private::SymbolContextScope *sc_scope, size_t GetTypes(lldb_private::SymbolContextScope *sc_scope,
lldb::TypeClass type_mask, lldb::TypeClass type_mask,
lldb_private::TypeList &type_list) override; lldb_private::TypeList &type_list) override;
lldb_private::TypeSystem * lldb_private::TypeSystem *
GetTypeSystemForLanguage(lldb::LanguageType language) override; GetTypeSystemForLanguage(lldb::LanguageType language) override;
lldb_private::CompilerDeclContext FindNamespace( lldb_private::CompilerDeclContext FindNamespace(
const lldb_private::ConstString &name, lldb_private::ConstString name,
const lldb_private::CompilerDeclContext *parent_decl_ctx) override; const lldb_private::CompilerDeclContext *parent_decl_ctx) override;
void PreloadSymbols() override; void PreloadSymbols() override;
std::recursive_mutex &GetModuleMutex() const override; std::recursive_mutex &GetModuleMutex() const override;
//------------------------------------------------------------------ //------------------------------------------------------------------
// PluginInterface protocol // PluginInterface protocol
Show All 32 Lines
// Given a die_offset, figure out the symbol context representing that die. // Given a die_offset, figure out the symbol context representing that die.
bool ResolveFunction(const DWARFDIE &die, bool include_inlines, bool ResolveFunction(const DWARFDIE &die, bool include_inlines,
lldb_private::SymbolContextList &sc_list); lldb_private::SymbolContextList &sc_list);
virtual lldb::TypeSP virtual lldb::TypeSP
FindDefinitionTypeForDWARFDeclContext(const DWARFDeclContext &die_decl_ctx); FindDefinitionTypeForDWARFDeclContext(const DWARFDeclContext &die_decl_ctx);
virtual lldb::TypeSP FindCompleteObjCDefinitionTypeForDIE( virtual lldb::TypeSP FindCompleteObjCDefinitionTypeForDIE(
const DWARFDIE &die, const lldb_private::ConstString &type_name, const DWARFDIE &die, lldb_private::ConstString type_name,
bool must_be_implementation); bool must_be_implementation);
lldb_private::Symbol * lldb_private::Symbol *
GetObjCClassSymbol(const lldb_private::ConstString &objc_class_name); GetObjCClassSymbol(lldb_private::ConstString objc_class_name);
lldb::TypeSP GetTypeForDIE(const DWARFDIE &die, lldb::TypeSP GetTypeForDIE(const DWARFDIE &die,
bool resolve_function_context = false); bool resolve_function_context = false);
void SetDebugMapModule(const lldb::ModuleSP &module_sp) { void SetDebugMapModule(const lldb::ModuleSP &module_sp) {
m_debug_map_module_wp = module_sp; m_debug_map_module_wp = module_sp;
} }
SymbolFileDWARFDebugMap *GetDebugMapSymfile(); SymbolFileDWARFDebugMap *GetDebugMapSymfile();
DWARFDIE DWARFDIE
FindBlockContainingSpecification(const DIERef &func_die_ref, FindBlockContainingSpecification(const DIERef &func_die_ref,
dw_offset_t spec_block_die_offset); dw_offset_t spec_block_die_offset);
DWARFDIE DWARFDIE
FindBlockContainingSpecification(const DWARFDIE &die, FindBlockContainingSpecification(const DWARFDIE &die,
dw_offset_t spec_block_die_offset); dw_offset_t spec_block_die_offset);
virtual UniqueDWARFASTTypeMap &GetUniqueDWARFASTTypeMap(); virtual UniqueDWARFASTTypeMap &GetUniqueDWARFASTTypeMap();
bool DIEDeclContextsMatch(const DWARFDIE &die1, const DWARFDIE &die2); bool DIEDeclContextsMatch(const DWARFDIE &die1, const DWARFDIE &die2);
bool ClassContainsSelector(const DWARFDIE &class_die, bool ClassContainsSelector(const DWARFDIE &class_die,
const lldb_private::ConstString &selector); lldb_private::ConstString selector);
bool FixupAddress(lldb_private::Address &addr); bool FixupAddress(lldb_private::Address &addr);
typedef std::set<lldb_private::Type *> TypeSet; typedef std::set<lldb_private::Type *> TypeSet;
void GetTypes(const DWARFDIE &die, dw_offset_t min_die_offset, void GetTypes(const DWARFDIE &die, dw_offset_t min_die_offset,
dw_offset_t max_die_offset, uint32_t type_mask, dw_offset_t max_die_offset, uint32_t type_mask,
TypeSet &type_set); TypeSet &type_set);
Show All 16 Lines

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

Show All 16 Lines
m_data_debug_ranges(), m_data_debug_rnglists(), m_data_debug_str(), m_data_debug_ranges(), m_data_debug_rnglists(), m_data_debug_str(),
m_data_apple_names(), m_data_apple_types(), m_data_apple_namespaces(), m_data_apple_names(), m_data_apple_types(), m_data_apple_namespaces(),
m_abbr(), m_info(), m_line(), m_fetched_external_modules(false), m_abbr(), m_info(), m_line(), m_fetched_external_modules(false),
m_supports_DW_AT_APPLE_objc_complete_type(eLazyBoolCalculate), m_ranges(), m_supports_DW_AT_APPLE_objc_complete_type(eLazyBoolCalculate), m_ranges(),
m_unique_ast_type_map() {} m_unique_ast_type_map() {}
SymbolFileDWARF::~SymbolFileDWARF() {} SymbolFileDWARF::~SymbolFileDWARF() {}
static const ConstString &GetDWARFMachOSegmentName() { static ConstString GetDWARFMachOSegmentName() {
static ConstString g_dwarf_section_name("__DWARF"); static ConstString g_dwarf_section_name("__DWARF");
return g_dwarf_section_name; return g_dwarf_section_name;
} }
UniqueDWARFASTTypeMap &SymbolFileDWARF::GetUniqueDWARFASTTypeMap() { UniqueDWARFASTTypeMap &SymbolFileDWARF::GetUniqueDWARFASTTypeMap() {
SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile(); SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();
if (debug_map_symfile) if (debug_map_symfile)
return debug_map_symfile->GetUniqueDWARFASTTypeMap(); return debug_map_symfile->GetUniqueDWARFASTTypeMap();
Show All 32 Lines
if (log) if (log)
GetObjectFile()->GetModule()->LogMessage( GetObjectFile()->GetModule()->LogMessage(
log, "Valid namespace does not match symbol file"); log, "Valid namespace does not match symbol file");
return false; return false;
} }
uint32_t SymbolFileDWARF::FindGlobalVariables( uint32_t SymbolFileDWARF::FindGlobalVariables(
const ConstString &name, const CompilerDeclContext *parent_decl_ctx, ConstString name, const CompilerDeclContext *parent_decl_ctx,
uint32_t max_matches, VariableList &variables) { uint32_t max_matches, VariableList &variables) {
Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS)); Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
if (log) if (log)
GetObjectFile()->GetModule()->LogMessage( GetObjectFile()->GetModule()->LogMessage(
log, log,
"SymbolFileDWARF::FindGlobalVariables (name=\"%s\", " "SymbolFileDWARF::FindGlobalVariables (name=\"%s\", "
"parent_decl_ctx=%p, max_matches=%u, variables)", "parent_decl_ctx=%p, max_matches=%u, variables)",
Show All 32 Lines
if (actual_decl_ctx) if (actual_decl_ctx)
return actual_decl_ctx == *decl_ctx; return actual_decl_ctx == *decl_ctx;
} }
} }
return false; return false;
} }
uint32_t SymbolFileDWARF::FindFunctions( uint32_t SymbolFileDWARF::FindFunctions(
const ConstString &name, const CompilerDeclContext *parent_decl_ctx, ConstString name, const CompilerDeclContext *parent_decl_ctx,
FunctionNameType name_type_mask, bool include_inlines, bool append, FunctionNameType name_type_mask, bool include_inlines, bool append,
SymbolContextList &sc_list) { SymbolContextList &sc_list) {
static Timer::Category func_cat(LLVM_PRETTY_FUNCTION); static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
Timer scoped_timer(func_cat, "SymbolFileDWARF::FindFunctions (name = '%s')", Timer scoped_timer(func_cat, "SymbolFileDWARF::FindFunctions (name = '%s')",
name.AsCString()); name.AsCString());
// eFunctionNameTypeAuto should be pre-resolved by a call to // eFunctionNameTypeAuto should be pre-resolved by a call to
// Module::LookupInfo::LookupInfo() // Module::LookupInfo::LookupInfo()
Show All 32 Lines
std::set<DIERef>::iterator set_iter; std::set<DIERef>::iterator set_iter;
for (set_iter = set_sp->begin(); set_iter != set_sp->end(); set_iter++) { for (set_iter = set_sp->begin(); set_iter != set_sp->end(); set_iter++) {
DWARFDIE die = DebugInfo()->GetDIE(*set_iter); DWARFDIE die = DebugInfo()->GetDIE(*set_iter);
mangled_names.push_back(ConstString(die.GetMangledName())); mangled_names.push_back(ConstString(die.GetMangledName()));
} }
} }
uint32_t SymbolFileDWARF::FindTypes( uint32_t SymbolFileDWARF::FindTypes(
const ConstString &name, const CompilerDeclContext *parent_decl_ctx, ConstString name, const CompilerDeclContext *parent_decl_ctx,
bool append, uint32_t max_matches, bool append, uint32_t max_matches,
llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files, llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
TypeMap &types) { TypeMap &types) {
// If we aren't appending the results to this list, then clear the list // If we aren't appending the results to this list, then clear the list
if (!append) if (!append)
types.Clear(); types.Clear();
// Make sure we haven't already searched this SymbolFile before... // Make sure we haven't already searched this SymbolFile before...
Show All 32 Lines
} }
} }
return num_matches; return num_matches;
} }
return 0; return 0;
} }
CompilerDeclContext CompilerDeclContext
SymbolFileDWARF::FindNamespace(const ConstString &name, SymbolFileDWARF::FindNamespace(ConstString name,
const CompilerDeclContext *parent_decl_ctx) { const CompilerDeclContext *parent_decl_ctx) {
Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS)); Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
if (log) { if (log) {
GetObjectFile()->GetModule()->LogMessage( GetObjectFile()->GetModule()->LogMessage(
log, "SymbolFileDWARF::FindNamespace (sc, name=\"%s\")", log, "SymbolFileDWARF::FindNamespace (sc, name=\"%s\")",
name.GetCString()); name.GetCString());
} }
Show All 32 Lines
die = die.GetParent(); die = die.GetParent();
} }
} }
return DWARFDIE(); return DWARFDIE();
} }
Symbol * Symbol *
SymbolFileDWARF::GetObjCClassSymbol(const ConstString &objc_class_name) { SymbolFileDWARF::GetObjCClassSymbol(ConstString objc_class_name) {
Symbol *objc_class_symbol = NULL; Symbol *objc_class_symbol = NULL;
if (m_obj_file) { if (m_obj_file) {
Symtab *symtab = m_obj_file->GetSymtab(); Symtab *symtab = m_obj_file->GetSymtab();
if (symtab) { if (symtab) {
objc_class_symbol = symtab->FindFirstSymbolWithNameAndType( objc_class_symbol = symtab->FindFirstSymbolWithNameAndType(
objc_class_name, eSymbolTypeObjCClass, Symtab::eDebugNo, objc_class_name, eSymbolTypeObjCClass, Symtab::eDebugNo,
Symtab::eVisibilityAny); Symtab::eVisibilityAny);
} }
Show All 31 Lines
return m_debug_map_symfile->Supports_DW_AT_APPLE_objc_complete_type(this); return m_debug_map_symfile->Supports_DW_AT_APPLE_objc_complete_type(this);
} }
return m_supports_DW_AT_APPLE_objc_complete_type == eLazyBoolYes; return m_supports_DW_AT_APPLE_objc_complete_type == eLazyBoolYes;
} }
// This function can be used when a DIE is found that is a forward declaration // This function can be used when a DIE is found that is a forward declaration
// DIE and we want to try and find a type that has the complete definition. // DIE and we want to try and find a type that has the complete definition.
TypeSP SymbolFileDWARF::FindCompleteObjCDefinitionTypeForDIE( TypeSP SymbolFileDWARF::FindCompleteObjCDefinitionTypeForDIE(
const DWARFDIE &die, const ConstString &type_name, const DWARFDIE &die, ConstString type_name,
bool must_be_implementation) { bool must_be_implementation) {
TypeSP type_sp; TypeSP type_sp;
if (!type_name || (must_be_implementation && !GetObjCClassSymbol(type_name))) if (!type_name || (must_be_implementation && !GetObjCClassSymbol(type_name)))
return type_sp; return type_sp;
DIEArray die_offsets; DIEArray die_offsets;
Show All 16 Lines

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h

Show All 16 Lines
lldb::SymbolContextItem resolve_scope, lldb::SymbolContextItem resolve_scope,
lldb_private::SymbolContext &sc) override; lldb_private::SymbolContext &sc) override;
uint32_t uint32_t
ResolveSymbolContext(const lldb_private::FileSpec &file_spec, uint32_t line, ResolveSymbolContext(const lldb_private::FileSpec &file_spec, uint32_t line,
bool check_inlines, bool check_inlines,
lldb::SymbolContextItem resolve_scope, lldb::SymbolContextItem resolve_scope,
lldb_private::SymbolContextList &sc_list) override; lldb_private::SymbolContextList &sc_list) override;
uint32_t uint32_t
FindGlobalVariables(const lldb_private::ConstString &name, FindGlobalVariables(lldb_private::ConstString name,
const lldb_private::CompilerDeclContext *parent_decl_ctx, const lldb_private::CompilerDeclContext *parent_decl_ctx,
uint32_t max_matches, uint32_t max_matches,
lldb_private::VariableList &variables) override; lldb_private::VariableList &variables) override;
uint32_t FindGlobalVariables(const lldb_private::RegularExpression &regex, uint32_t FindGlobalVariables(const lldb_private::RegularExpression &regex,
uint32_t max_matches, uint32_t max_matches,
lldb_private::VariableList &variables) override; lldb_private::VariableList &variables) override;
uint32_t uint32_t
FindFunctions(const lldb_private::ConstString &name, FindFunctions(lldb_private::ConstString name,
const lldb_private::CompilerDeclContext *parent_decl_ctx, const lldb_private::CompilerDeclContext *parent_decl_ctx,
lldb::FunctionNameType name_type_mask, bool include_inlines, lldb::FunctionNameType name_type_mask, bool include_inlines,
bool append, lldb_private::SymbolContextList &sc_list) override; bool append, lldb_private::SymbolContextList &sc_list) override;
uint32_t FindFunctions(const lldb_private::RegularExpression &regex, uint32_t FindFunctions(const lldb_private::RegularExpression &regex,
bool include_inlines, bool append, bool include_inlines, bool append,
lldb_private::SymbolContextList &sc_list) override; lldb_private::SymbolContextList &sc_list) override;
uint32_t uint32_t
FindTypes(const lldb_private::ConstString &name, FindTypes(lldb_private::ConstString name,
const lldb_private::CompilerDeclContext *parent_decl_ctx, const lldb_private::CompilerDeclContext *parent_decl_ctx,
bool append, uint32_t max_matches, bool append, uint32_t max_matches,
llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files, llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
lldb_private::TypeMap &types) override; lldb_private::TypeMap &types) override;
lldb_private::CompilerDeclContext FindNamespace( lldb_private::CompilerDeclContext FindNamespace(
const lldb_private::ConstString &name, lldb_private::ConstString name,
const lldb_private::CompilerDeclContext *parent_decl_ctx) override; const lldb_private::CompilerDeclContext *parent_decl_ctx) override;
size_t GetTypes(lldb_private::SymbolContextScope *sc_scope, size_t GetTypes(lldb_private::SymbolContextScope *sc_scope,
lldb::TypeClass type_mask, lldb::TypeClass type_mask,
lldb_private::TypeList &type_list) override; lldb_private::TypeList &type_list) override;
std::vector<lldb_private::CallEdge> std::vector<lldb_private::CallEdge>
ParseCallEdgesInFunction(lldb_private::UserID func_id) override; ParseCallEdgesInFunction(lldb_private::UserID func_id) override;
void DumpClangAST(lldb_private::Stream &s) override; void DumpClangAST(lldb_private::Stream &s) override;
Show All 32 Lines
static int static int
SymbolContainsSymbolWithIndex(uint32_t *symbol_idx_ptr, SymbolContainsSymbolWithIndex(uint32_t *symbol_idx_ptr,
const CompileUnitInfo *comp_unit_info); const CompileUnitInfo *comp_unit_info);
static int SymbolContainsSymbolWithID(lldb::user_id_t *symbol_idx_ptr, static int SymbolContainsSymbolWithID(lldb::user_id_t *symbol_idx_ptr,
const CompileUnitInfo *comp_unit_info); const CompileUnitInfo *comp_unit_info);
uint32_t PrivateFindGlobalVariables( uint32_t PrivateFindGlobalVariables(
const lldb_private::ConstString &name, lldb_private::ConstString name,
const lldb_private::CompilerDeclContext *parent_decl_ctx, const lldb_private::CompilerDeclContext *parent_decl_ctx,
const std::vector<uint32_t> &name_symbol_indexes, uint32_t max_matches, const std::vector<uint32_t> &name_symbol_indexes, uint32_t max_matches,
lldb_private::VariableList &variables); lldb_private::VariableList &variables);
void SetCompileUnit(SymbolFileDWARF *oso_dwarf, void SetCompileUnit(SymbolFileDWARF *oso_dwarf,
const lldb::CompUnitSP &cu_sp); const lldb::CompUnitSP &cu_sp);
lldb::CompUnitSP GetCompileUnit(SymbolFileDWARF *oso_dwarf); lldb::CompUnitSP GetCompileUnit(SymbolFileDWARF *oso_dwarf);
CompileUnitInfo *GetCompileUnitInfo(SymbolFileDWARF *oso_dwarf); CompileUnitInfo *GetCompileUnitInfo(SymbolFileDWARF *oso_dwarf);
lldb::TypeSP lldb::TypeSP
FindDefinitionTypeForDWARFDeclContext(const DWARFDeclContext &die_decl_ctx); FindDefinitionTypeForDWARFDeclContext(const DWARFDeclContext &die_decl_ctx);
bool Supports_DW_AT_APPLE_objc_complete_type(SymbolFileDWARF *skip_dwarf_oso); bool Supports_DW_AT_APPLE_objc_complete_type(SymbolFileDWARF *skip_dwarf_oso);
lldb::TypeSP FindCompleteObjCDefinitionTypeForDIE( lldb::TypeSP FindCompleteObjCDefinitionTypeForDIE(
const DWARFDIE &die, const lldb_private::ConstString &type_name, const DWARFDIE &die, lldb_private::ConstString type_name,
bool must_be_implementation); bool must_be_implementation);
UniqueDWARFASTTypeMap &GetUniqueDWARFASTTypeMap() { UniqueDWARFASTTypeMap &GetUniqueDWARFASTTypeMap() {
return m_unique_ast_type_map; return m_unique_ast_type_map;
} }
//------------------------------------------------------------------ //------------------------------------------------------------------
// OSOEntry // OSOEntry
Show All 16 Lines

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

Show All 16 Lines
if (!oso_module) if (!oso_module)
return file_range_map; return file_range_map;
ObjectFile *oso_objfile = oso_module->GetObjectFile(); ObjectFile *oso_objfile = oso_module->GetObjectFile();
if (!oso_objfile) if (!oso_objfile)
return file_range_map; return file_range_map;
Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_MAP)); Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_MAP));
if (log) { if (log)
ConstString object_name(oso_module->GetObjectName());
log->Printf( log->Printf(
"%p: SymbolFileDWARFDebugMap::CompileUnitInfo::GetFileRangeMap ('%s')", "%p: SymbolFileDWARFDebugMap::CompileUnitInfo::GetFileRangeMap ('%s')",
static_cast<void *>(this), static_cast<void *>(this),
oso_module->GetSpecificationDescription().c_str()); oso_module->GetSpecificationDescription().c_str());
}
std::vector<SymbolFileDWARFDebugMap::CompileUnitInfo *> cu_infos; std::vector<SymbolFileDWARFDebugMap::CompileUnitInfo *> cu_infos;
if (exe_symfile->GetCompUnitInfosForModule(oso_module, cu_infos)) { if (exe_symfile->GetCompUnitInfosForModule(oso_module, cu_infos)) {
for (auto comp_unit_info : cu_infos) { for (auto comp_unit_info : cu_infos) {
Symtab *exe_symtab = exe_symfile->GetObjectFile()->GetSymtab(); Symtab *exe_symtab = exe_symfile->GetObjectFile()->GetSymtab();
ModuleSP oso_module_sp(oso_objfile->GetModule()); ModuleSP oso_module_sp(oso_objfile->GetModule());
Symtab *oso_symtab = oso_objfile->GetSymtab(); Symtab *oso_symtab = oso_objfile->GetSymtab();
Show All 32 Lines
oso_dwarf->ResolveSymbolContext(file_spec, line, check_inlines, oso_dwarf->ResolveSymbolContext(file_spec, line, check_inlines,
resolve_scope, sc_list); resolve_scope, sc_list);
} }
} }
return sc_list.GetSize() - initial; return sc_list.GetSize() - initial;
} }
uint32_t SymbolFileDWARFDebugMap::PrivateFindGlobalVariables( uint32_t SymbolFileDWARFDebugMap::PrivateFindGlobalVariables(
const ConstString &name, const CompilerDeclContext *parent_decl_ctx, ConstString name, const CompilerDeclContext *parent_decl_ctx,
const std::vector<uint32_t> const std::vector<uint32_t>
&indexes, // Indexes into the symbol table that match "name" &indexes, // Indexes into the symbol table that match "name"
uint32_t max_matches, VariableList &variables) { uint32_t max_matches, VariableList &variables) {
const uint32_t original_size = variables.GetSize(); const uint32_t original_size = variables.GetSize();
const size_t match_count = indexes.size(); const size_t match_count = indexes.size();
for (size_t i = 0; i < match_count; ++i) { for (size_t i = 0; i < match_count; ++i) {
uint32_t oso_idx; uint32_t oso_idx;
CompileUnitInfo *comp_unit_info = CompileUnitInfo *comp_unit_info =
GetCompileUnitInfoForSymbolWithIndex(indexes[i], &oso_idx); GetCompileUnitInfoForSymbolWithIndex(indexes[i], &oso_idx);
if (comp_unit_info) { if (comp_unit_info) {
SymbolFileDWARF *oso_dwarf = GetSymbolFileByOSOIndex(oso_idx); SymbolFileDWARF *oso_dwarf = GetSymbolFileByOSOIndex(oso_idx);
if (oso_dwarf) { if (oso_dwarf) {
if (oso_dwarf->FindGlobalVariables(name, parent_decl_ctx, max_matches, if (oso_dwarf->FindGlobalVariables(name, parent_decl_ctx, max_matches,
variables)) variables))
if (variables.GetSize() > max_matches) if (variables.GetSize() > max_matches)
break; break;
} }
} }
} }
return variables.GetSize() - original_size; return variables.GetSize() - original_size;
} }
uint32_t SymbolFileDWARFDebugMap::FindGlobalVariables( uint32_t SymbolFileDWARFDebugMap::FindGlobalVariables(
const ConstString &name, const CompilerDeclContext *parent_decl_ctx, ConstString name, const CompilerDeclContext *parent_decl_ctx,
uint32_t max_matches, VariableList &variables) { uint32_t max_matches, VariableList &variables) {
// Remember how many variables are in the list before we search. // Remember how many variables are in the list before we search.
const uint32_t original_size = variables.GetSize(); const uint32_t original_size = variables.GetSize();
uint32_t total_matches = 0; uint32_t total_matches = 0;
ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool { ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
Show All 32 Lines
continue; continue;
} }
} }
++i; ++i;
} }
} }
uint32_t SymbolFileDWARFDebugMap::FindFunctions( uint32_t SymbolFileDWARFDebugMap::FindFunctions(
const ConstString &name, const CompilerDeclContext *parent_decl_ctx, ConstString name, const CompilerDeclContext *parent_decl_ctx,
FunctionNameType name_type_mask, bool include_inlines, bool append, FunctionNameType name_type_mask, bool include_inlines, bool append,
SymbolContextList &sc_list) { SymbolContextList &sc_list) {
static Timer::Category func_cat(LLVM_PRETTY_FUNCTION); static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
Timer scoped_timer(func_cat, Timer scoped_timer(func_cat,
"SymbolFileDWARFDebugMap::FindFunctions (name = %s)", "SymbolFileDWARFDebugMap::FindFunctions (name = %s)",
name.GetCString()); name.GetCString());
uint32_t initial_size = 0; uint32_t initial_size = 0;
Show All 32 Lines
} }
return false; return false;
}); });
} }
return m_supports_DW_AT_APPLE_objc_complete_type == eLazyBoolYes; return m_supports_DW_AT_APPLE_objc_complete_type == eLazyBoolYes;
} }
TypeSP SymbolFileDWARFDebugMap::FindCompleteObjCDefinitionTypeForDIE( TypeSP SymbolFileDWARFDebugMap::FindCompleteObjCDefinitionTypeForDIE(
const DWARFDIE &die, const ConstString &type_name, const DWARFDIE &die, ConstString type_name,
bool must_be_implementation) { bool must_be_implementation) {
// If we have a debug map, we will have an Objective-C symbol whose name is // If we have a debug map, we will have an Objective-C symbol whose name is
// the type name and whose type is eSymbolTypeObjCClass. If we can find that // the type name and whose type is eSymbolTypeObjCClass. If we can find that
// symbol and find its containing parent, we can locate the .o file that will // symbol and find its containing parent, we can locate the .o file that will
// contain the implementation definition since it will be scoped inside the // contain the implementation definition since it will be scoped inside the
// N_SO and we can then locate the SymbolFileDWARF that corresponds to that // N_SO and we can then locate the SymbolFileDWARF that corresponds to that
// N_SO. // N_SO.
SymbolFileDWARF *oso_dwarf = NULL; SymbolFileDWARF *oso_dwarf = NULL;
Show All 32 Lines
}); });
return type_sp; return type_sp;
} }
return TypeSP(); return TypeSP();
} }
uint32_t SymbolFileDWARFDebugMap::FindTypes( uint32_t SymbolFileDWARFDebugMap::FindTypes(
const ConstString &name, const CompilerDeclContext *parent_decl_ctx, ConstString name, const CompilerDeclContext *parent_decl_ctx,
bool append, uint32_t max_matches, bool append, uint32_t max_matches,
llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files, llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
TypeMap &types) { TypeMap &types) {
if (!append) if (!append)
types.Clear(); types.Clear();
const uint32_t initial_types_size = types.GetSize(); const uint32_t initial_types_size = types.GetSize();
Show All 15 Lines
// SymbolFileDWARF *oso_dwarf = GetSymbolFile (sc); // SymbolFileDWARF *oso_dwarf = GetSymbolFile (sc);
// if (oso_dwarf) // if (oso_dwarf)
// return oso_dwarf->FindTypes (sc, regex, append, max_matches, encoding, // return oso_dwarf->FindTypes (sc, regex, append, max_matches, encoding,
// udt_uid, types); // udt_uid, types);
// return 0; // return 0;
//} //}
CompilerDeclContext SymbolFileDWARFDebugMap::FindNamespace( CompilerDeclContext SymbolFileDWARFDebugMap::FindNamespace(
const lldb_private::ConstString &name, lldb_private::ConstString name,
const CompilerDeclContext *parent_decl_ctx) { const CompilerDeclContext *parent_decl_ctx) {
CompilerDeclContext matching_namespace; CompilerDeclContext matching_namespace;
ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool { ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
matching_namespace = oso_dwarf->FindNamespace(name, parent_decl_ctx); matching_namespace = oso_dwarf->FindNamespace(name, parent_decl_ctx);
return (bool)matching_namespace; return (bool)matching_namespace;
}); });
Show All 16 Lines

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.h

Show All 16 Lines
ClangTypeToDIE &GetForwardDeclClangTypeToDie() override; ClangTypeToDIE &GetForwardDeclClangTypeToDie() override;
UniqueDWARFASTTypeMap &GetUniqueDWARFASTTypeMap() override; UniqueDWARFASTTypeMap &GetUniqueDWARFASTTypeMap() override;
lldb::TypeSP FindDefinitionTypeForDWARFDeclContext( lldb::TypeSP FindDefinitionTypeForDWARFDeclContext(
const DWARFDeclContext &die_decl_ctx) override; const DWARFDeclContext &die_decl_ctx) override;
lldb::TypeSP FindCompleteObjCDefinitionTypeForDIE( lldb::TypeSP FindCompleteObjCDefinitionTypeForDIE(
const DWARFDIE &die, const lldb_private::ConstString &type_name, const DWARFDIE &die, lldb_private::ConstString type_name,
bool must_be_implementation) override; bool must_be_implementation) override;
SymbolFileDWARF *GetBaseSymbolFile(); SymbolFileDWARF *GetBaseSymbolFile();
lldb::ObjectFileSP m_obj_file_sp; lldb::ObjectFileSP m_obj_file_sp;
DWARFUnit *m_base_dwarf_cu; DWARFUnit *m_base_dwarf_cu;
}; };
#endif // SymbolFileDWARFDwo_SymbolFileDWARFDwo_h_ #endif // SymbolFileDWARFDwo_SymbolFileDWARFDwo_h_
Context not available.

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.cpp

Show All 16 Lines
lldb::TypeSP SymbolFileDWARFDwo::FindDefinitionTypeForDWARFDeclContext( lldb::TypeSP SymbolFileDWARFDwo::FindDefinitionTypeForDWARFDeclContext(
const DWARFDeclContext &die_decl_ctx) { const DWARFDeclContext &die_decl_ctx) {
return GetBaseSymbolFile()->FindDefinitionTypeForDWARFDeclContext( return GetBaseSymbolFile()->FindDefinitionTypeForDWARFDeclContext(
die_decl_ctx); die_decl_ctx);
} }
lldb::TypeSP SymbolFileDWARFDwo::FindCompleteObjCDefinitionTypeForDIE( lldb::TypeSP SymbolFileDWARFDwo::FindCompleteObjCDefinitionTypeForDIE(
const DWARFDIE &die, const lldb_private::ConstString &type_name, const DWARFDIE &die, lldb_private::ConstString type_name,
bool must_be_implementation) { bool must_be_implementation) {
return GetBaseSymbolFile()->FindCompleteObjCDefinitionTypeForDIE( return GetBaseSymbolFile()->FindCompleteObjCDefinitionTypeForDIE(
die, type_name, must_be_implementation); die, type_name, must_be_implementation);
} }
DWARFUnit *SymbolFileDWARFDwo::GetBaseCompileUnit() { DWARFUnit *SymbolFileDWARFDwo::GetBaseCompileUnit() {
return m_base_dwarf_cu; return m_base_dwarf_cu;
} }
Show All 16 Lines

lldb/source/Plugins/SymbolFile/DWARF/UniqueDWARFASTType.h

Show All 16 Lines
}; };
class UniqueDWARFASTTypeMap { class UniqueDWARFASTTypeMap {
public: public:
UniqueDWARFASTTypeMap() : m_collection() {} UniqueDWARFASTTypeMap() : m_collection() {}
~UniqueDWARFASTTypeMap() {} ~UniqueDWARFASTTypeMap() {}
void Insert(const lldb_private::ConstString &name, void Insert(lldb_private::ConstString name,
const UniqueDWARFASTType &entry) { const UniqueDWARFASTType &entry) {
m_collection[name.GetCString()].Append(entry); m_collection[name.GetCString()].Append(entry);
} }
bool Find(const lldb_private::ConstString &name, const DWARFDIE &die, bool Find(lldb_private::ConstString name, const DWARFDIE &die,
const lldb_private::Declaration &decl, const int32_t byte_size, const lldb_private::Declaration &decl, const int32_t byte_size,
UniqueDWARFASTType &entry) const { UniqueDWARFASTType &entry) const {
const char *unique_name_cstr = name.GetCString(); const char *unique_name_cstr = name.GetCString();
collection::const_iterator pos = m_collection.find(unique_name_cstr); collection::const_iterator pos = m_collection.find(unique_name_cstr);
if (pos != m_collection.end()) { if (pos != m_collection.end()) {
return pos->second.Find(die, decl, byte_size, entry); return pos->second.Find(die, decl, byte_size, entry);
} }
return false; return false;
Show All 9 Lines

lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.h

Show All 16 Lines
size_t ParseTypes(lldb_private::CompileUnit &comp_unit) override; size_t ParseTypes(lldb_private::CompileUnit &comp_unit) override;
bool ParseImportedModules( bool ParseImportedModules(
const SymbolContext &sc, const SymbolContext &sc,
std::vector<lldb_private::SourceModule> &imported_modules) override; std::vector<lldb_private::SourceModule> &imported_modules) override;
size_t ParseBlocksRecursive(Function &func) override; size_t ParseBlocksRecursive(Function &func) override;
uint32_t FindGlobalVariables(const ConstString &name, uint32_t FindGlobalVariables(ConstString name,
const CompilerDeclContext *parent_decl_ctx, const CompilerDeclContext *parent_decl_ctx,
uint32_t max_matches, uint32_t max_matches,
VariableList &variables) override; VariableList &variables) override;
size_t ParseVariablesForContext(const SymbolContext &sc) override; size_t ParseVariablesForContext(const SymbolContext &sc) override;
void AddSymbols(Symtab &symtab) override; void AddSymbols(Symtab &symtab) override;
Show All 12 Lines
uint32_t ResolveSymbolContext(const FileSpec &file_spec, uint32_t line, uint32_t ResolveSymbolContext(const FileSpec &file_spec, uint32_t line,
bool check_inlines, bool check_inlines,
lldb::SymbolContextItem resolve_scope, lldb::SymbolContextItem resolve_scope,
SymbolContextList &sc_list) override; SymbolContextList &sc_list) override;
size_t GetTypes(SymbolContextScope *sc_scope, lldb::TypeClass type_mask, size_t GetTypes(SymbolContextScope *sc_scope, lldb::TypeClass type_mask,
TypeList &type_list) override; TypeList &type_list) override;
uint32_t FindFunctions(const ConstString &name, uint32_t FindFunctions(ConstString name,
const CompilerDeclContext *parent_decl_ctx, const CompilerDeclContext *parent_decl_ctx,
lldb::FunctionNameType name_type_mask, lldb::FunctionNameType name_type_mask,
bool include_inlines, bool append, bool include_inlines, bool append,
SymbolContextList &sc_list) override; SymbolContextList &sc_list) override;
uint32_t FindFunctions(const RegularExpression &regex, bool include_inlines, uint32_t FindFunctions(const RegularExpression &regex, bool include_inlines,
bool append, SymbolContextList &sc_list) override; bool append, SymbolContextList &sc_list) override;
uint32_t FindTypes(const ConstString &name, uint32_t FindTypes(ConstString name,
const CompilerDeclContext *parent_decl_ctx, bool append, const CompilerDeclContext *parent_decl_ctx, bool append,
uint32_t max_matches, uint32_t max_matches,
llvm::DenseSet<SymbolFile *> &searched_symbol_files, llvm::DenseSet<SymbolFile *> &searched_symbol_files,
TypeMap &types) override; TypeMap &types) override;
size_t FindTypes(const std::vector<CompilerContext> &context, bool append, size_t FindTypes(const std::vector<CompilerContext> &context, bool append,
TypeMap &types) override; TypeMap &types) override;
TypeSystem *GetTypeSystemForLanguage(lldb::LanguageType language) override; TypeSystem *GetTypeSystemForLanguage(lldb::LanguageType language) override;
CompilerDeclContext CompilerDeclContext
FindNamespace(const ConstString &name, FindNamespace(ConstString name,
const CompilerDeclContext *parent_decl_ctx) override; const CompilerDeclContext *parent_decl_ctx) override;
ConstString GetPluginName() override; ConstString GetPluginName() override;
uint32_t GetPluginVersion() override; uint32_t GetPluginVersion() override;
llvm::pdb::PDBFile &GetPDBFile() { return m_index->pdb(); } llvm::pdb::PDBFile &GetPDBFile() { return m_index->pdb(); }
const llvm::pdb::PDBFile &GetPDBFile() const { return m_index->pdb(); } const llvm::pdb::PDBFile &GetPDBFile() const { return m_index->pdb(); }
Show All 16 Lines

lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

Show All 16 Lines
GetOrCreateBlock(PdbSymUid(func.GetID()).asCompilandSym()); GetOrCreateBlock(PdbSymUid(func.GetID()).asCompilandSym());
// FIXME: Parse child blocks // FIXME: Parse child blocks
return 1; return 1;
} }
void SymbolFileNativePDB::DumpClangAST(Stream &s) { m_ast->Dump(s); } void SymbolFileNativePDB::DumpClangAST(Stream &s) { m_ast->Dump(s); }
uint32_t SymbolFileNativePDB::FindGlobalVariables( uint32_t SymbolFileNativePDB::FindGlobalVariables(
const ConstString &name, const CompilerDeclContext *parent_decl_ctx, ConstString name, const CompilerDeclContext *parent_decl_ctx,
uint32_t max_matches, VariableList &variables) { uint32_t max_matches, VariableList &variables) {
using SymbolAndOffset = std::pair<uint32_t, llvm::codeview::CVSymbol>; using SymbolAndOffset = std::pair<uint32_t, llvm::codeview::CVSymbol>;
std::vector<SymbolAndOffset> results = m_index->globals().findRecordsByName( std::vector<SymbolAndOffset> results = m_index->globals().findRecordsByName(
name.GetStringRef(), m_index->symrecords()); name.GetStringRef(), m_index->symrecords());
for (const SymbolAndOffset &result : results) { for (const SymbolAndOffset &result : results) {
VariableSP var; VariableSP var;
switch (result.second.kind()) { switch (result.second.kind()) {
Show All 10 Lines
default: default:
continue; continue;
} }
} }
return variables.GetSize(); return variables.GetSize();
} }
uint32_t SymbolFileNativePDB::FindFunctions( uint32_t SymbolFileNativePDB::FindFunctions(
const ConstString &name, const CompilerDeclContext *parent_decl_ctx, ConstString name, const CompilerDeclContext *parent_decl_ctx,
FunctionNameType name_type_mask, bool include_inlines, bool append, FunctionNameType name_type_mask, bool include_inlines, bool append,
SymbolContextList &sc_list) { SymbolContextList &sc_list) {
// For now we only support lookup by method name. // For now we only support lookup by method name.
if (!(name_type_mask & eFunctionNameTypeMethod)) if (!(name_type_mask & eFunctionNameTypeMethod))
return 0; return 0;
using SymbolAndOffset = std::pair<uint32_t, llvm::codeview::CVSymbol>; using SymbolAndOffset = std::pair<uint32_t, llvm::codeview::CVSymbol>;
Show All 24 Lines
uint32_t SymbolFileNativePDB::FindFunctions(const RegularExpression &regex, uint32_t SymbolFileNativePDB::FindFunctions(const RegularExpression &regex,
bool include_inlines, bool append, bool include_inlines, bool append,
SymbolContextList &sc_list) { SymbolContextList &sc_list) {
return 0; return 0;
} }
uint32_t SymbolFileNativePDB::FindTypes( uint32_t SymbolFileNativePDB::FindTypes(
const ConstString &name, const CompilerDeclContext *parent_decl_ctx, ConstString name, const CompilerDeclContext *parent_decl_ctx,
bool append, uint32_t max_matches, bool append, uint32_t max_matches,
llvm::DenseSet<SymbolFile *> &searched_symbol_files, TypeMap &types) { llvm::DenseSet<SymbolFile *> &searched_symbol_files, TypeMap &types) {
if (!append) if (!append)
types.Clear(); types.Clear();
if (!name) if (!name)
return 0; return 0;
searched_symbol_files.clear(); searched_symbol_files.clear();
Show All 32 Lines
size_t SymbolFileNativePDB::GetTypes(lldb_private::SymbolContextScope *sc_scope, size_t SymbolFileNativePDB::GetTypes(lldb_private::SymbolContextScope *sc_scope,
TypeClass type_mask, TypeClass type_mask,
lldb_private::TypeList &type_list) { lldb_private::TypeList &type_list) {
return 0; return 0;
} }
CompilerDeclContext CompilerDeclContext
SymbolFileNativePDB::FindNamespace(const ConstString &name, SymbolFileNativePDB::FindNamespace(ConstString name,
const CompilerDeclContext *parent_decl_ctx) { const CompilerDeclContext *parent_decl_ctx) {
return {}; return {};
} }
TypeSystem * TypeSystem *
SymbolFileNativePDB::GetTypeSystemForLanguage(lldb::LanguageType language) { SymbolFileNativePDB::GetTypeSystemForLanguage(lldb::LanguageType language) {
auto type_system = auto type_system =
m_obj_file->GetModule()->GetTypeSystemForLanguage(language); m_obj_file->GetModule()->GetTypeSystemForLanguage(language);
Show All 11 Lines

lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.h

Show All 16 Lines
uint32_t uint32_t
ResolveSymbolContext(const lldb_private::FileSpec &file_spec, uint32_t line, ResolveSymbolContext(const lldb_private::FileSpec &file_spec, uint32_t line,
bool check_inlines, bool check_inlines,
lldb::SymbolContextItem resolve_scope, lldb::SymbolContextItem resolve_scope,
lldb_private::SymbolContextList &sc_list) override; lldb_private::SymbolContextList &sc_list) override;
uint32_t uint32_t
FindGlobalVariables(const lldb_private::ConstString &name, FindGlobalVariables(lldb_private::ConstString name,
const lldb_private::CompilerDeclContext *parent_decl_ctx, const lldb_private::CompilerDeclContext *parent_decl_ctx,
uint32_t max_matches, uint32_t max_matches,
lldb_private::VariableList &variables) override; lldb_private::VariableList &variables) override;
uint32_t FindGlobalVariables(const lldb_private::RegularExpression &regex, uint32_t FindGlobalVariables(const lldb_private::RegularExpression &regex,
uint32_t max_matches, uint32_t max_matches,
lldb_private::VariableList &variables) override; lldb_private::VariableList &variables) override;
uint32_t uint32_t
FindFunctions(const lldb_private::ConstString &name, FindFunctions(lldb_private::ConstString name,
const lldb_private::CompilerDeclContext *parent_decl_ctx, const lldb_private::CompilerDeclContext *parent_decl_ctx,
lldb::FunctionNameType name_type_mask, bool include_inlines, lldb::FunctionNameType name_type_mask, bool include_inlines,
bool append, lldb_private::SymbolContextList &sc_list) override; bool append, lldb_private::SymbolContextList &sc_list) override;
uint32_t FindFunctions(const lldb_private::RegularExpression &regex, uint32_t FindFunctions(const lldb_private::RegularExpression &regex,
bool include_inlines, bool append, bool include_inlines, bool append,
lldb_private::SymbolContextList &sc_list) override; lldb_private::SymbolContextList &sc_list) override;
void GetMangledNamesForFunction( void GetMangledNamesForFunction(
const std::string &scope_qualified_name, const std::string &scope_qualified_name,
std::vector<lldb_private::ConstString> &mangled_names) override; std::vector<lldb_private::ConstString> &mangled_names) override;
void AddSymbols(lldb_private::Symtab &symtab) override; void AddSymbols(lldb_private::Symtab &symtab) override;
uint32_t uint32_t
FindTypes(const lldb_private::ConstString &name, FindTypes(lldb_private::ConstString name,
const lldb_private::CompilerDeclContext *parent_decl_ctx, const lldb_private::CompilerDeclContext *parent_decl_ctx,
bool append, uint32_t max_matches, bool append, uint32_t max_matches,
llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files, llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
lldb_private::TypeMap &types) override; lldb_private::TypeMap &types) override;
size_t FindTypes(const std::vector<lldb_private::CompilerContext> &context, size_t FindTypes(const std::vector<lldb_private::CompilerContext> &context,
bool append, lldb_private::TypeMap &types) override; bool append, lldb_private::TypeMap &types) override;
void FindTypesByRegex(const lldb_private::RegularExpression &regex, void FindTypesByRegex(const lldb_private::RegularExpression &regex,
uint32_t max_matches, lldb_private::TypeMap &types); uint32_t max_matches, lldb_private::TypeMap &types);
lldb_private::TypeList *GetTypeList() override; lldb_private::TypeList *GetTypeList() override;
size_t GetTypes(lldb_private::SymbolContextScope *sc_scope, size_t GetTypes(lldb_private::SymbolContextScope *sc_scope,
lldb::TypeClass type_mask, lldb::TypeClass type_mask,
lldb_private::TypeList &type_list) override; lldb_private::TypeList &type_list) override;
lldb_private::TypeSystem * lldb_private::TypeSystem *
GetTypeSystemForLanguage(lldb::LanguageType language) override; GetTypeSystemForLanguage(lldb::LanguageType language) override;
lldb_private::CompilerDeclContext FindNamespace( lldb_private::CompilerDeclContext FindNamespace(
const lldb_private::ConstString &name, lldb_private::ConstString name,
const lldb_private::CompilerDeclContext *parent_decl_ctx) override; const lldb_private::CompilerDeclContext *parent_decl_ctx) override;
lldb_private::ConstString GetPluginName() override; lldb_private::ConstString GetPluginName() override;
uint32_t GetPluginVersion() override; uint32_t GetPluginVersion() override;
llvm::pdb::IPDBSession &GetPDBSession(); llvm::pdb::IPDBSession &GetPDBSession();
Show All 16 Lines

lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp

Show All 16 Lines
while (auto result = results->getNext()) while (auto result = results->getNext())
num_added += ParseVariables(sc, *result, variable_list); num_added += ParseVariables(sc, *result, variable_list);
} }
return num_added; return num_added;
} }
uint32_t SymbolFilePDB::FindGlobalVariables( uint32_t SymbolFilePDB::FindGlobalVariables(
const lldb_private::ConstString &name, lldb_private::ConstString name,
const lldb_private::CompilerDeclContext *parent_decl_ctx, const lldb_private::CompilerDeclContext *parent_decl_ctx,
uint32_t max_matches, lldb_private::VariableList &variables) { uint32_t max_matches, lldb_private::VariableList &variables) {
if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx)) if (!DeclContextMatchesThisSymbolFile(parent_decl_ctx))
return 0; return 0;
if (name.IsEmpty()) if (name.IsEmpty())
return 0; return 0;
auto results = m_global_scope_up->findAllChildren<PDBSymbolData>(); auto results = m_global_scope_up->findAllChildren<PDBSymbolData>();
Show All 32 Lines
m_func_full_names.SizeToFit(); m_func_full_names.SizeToFit();
m_func_method_names.Sort(); m_func_method_names.Sort();
m_func_method_names.SizeToFit(); m_func_method_names.SizeToFit();
m_func_base_names.Sort(); m_func_base_names.Sort();
m_func_base_names.SizeToFit(); m_func_base_names.SizeToFit();
} }
uint32_t SymbolFilePDB::FindFunctions( uint32_t SymbolFilePDB::FindFunctions(
const lldb_private::ConstString &name, lldb_private::ConstString name,
const lldb_private::CompilerDeclContext *parent_decl_ctx, const lldb_private::CompilerDeclContext *parent_decl_ctx,
FunctionNameType name_type_mask, bool include_inlines, bool append, FunctionNameType name_type_mask, bool include_inlines, bool append,
lldb_private::SymbolContextList &sc_list) { lldb_private::SymbolContextList &sc_list) {
if (!append) if (!append)
sc_list.Clear(); sc_list.Clear();
lldbassert((name_type_mask & eFunctionNameTypeAuto) == 0); lldbassert((name_type_mask & eFunctionNameTypeAuto) == 0);
if (name_type_mask == eFunctionNameTypeNone) if (name_type_mask == eFunctionNameTypeNone)
Show All 32 Lines
)); ));
} }
symtab.CalculateSymbolSizes(); symtab.CalculateSymbolSizes();
symtab.Finalize(); symtab.Finalize();
} }
uint32_t SymbolFilePDB::FindTypes( uint32_t SymbolFilePDB::FindTypes(
const lldb_private::ConstString &name, lldb_private::ConstString name,
const lldb_private::CompilerDeclContext *parent_decl_ctx, bool append, const lldb_private::CompilerDeclContext *parent_decl_ctx, bool append,
uint32_t max_matches, uint32_t max_matches,
llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files, llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
lldb_private::TypeMap &types) { lldb_private::TypeMap &types) {
if (!append) if (!append)
types.Clear(); types.Clear();
if (!name) if (!name)
return 0; return 0;
Show All 32 Lines
if (!clang_type_system) if (!clang_type_system)
return nullptr; return nullptr;
return clang_type_system->GetPDBParser(); return clang_type_system->GetPDBParser();
} }
lldb_private::CompilerDeclContext SymbolFilePDB::FindNamespace( lldb_private::CompilerDeclContext SymbolFilePDB::FindNamespace(
const lldb_private::ConstString &name, lldb_private::ConstString name,
const lldb_private::CompilerDeclContext *parent_decl_ctx) { const lldb_private::CompilerDeclContext *parent_decl_ctx) {
auto type_system = GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus); auto type_system = GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
auto clang_type_system = llvm::dyn_cast_or_null<ClangASTContext>(type_system); auto clang_type_system = llvm::dyn_cast_or_null<ClangASTContext>(type_system);
if (!clang_type_system) if (!clang_type_system)
return CompilerDeclContext(); return CompilerDeclContext();
PDBASTParser *pdb = clang_type_system->GetPDBParser(); PDBASTParser *pdb = clang_type_system->GetPDBParser();
if (!pdb) if (!pdb)
Show All 16 Lines

lldb/source/Symbol/ClangASTContext.cpp

Show All 16 Lines
ast, ast->getExtVectorType(ast->UnsignedCharTy, bit_size / 8)); ast, ast->getExtVectorType(ast->UnsignedCharTy, bit_size / 8));
break; break;
} }
return CompilerType(); return CompilerType();
} }
lldb::BasicType lldb::BasicType
ClangASTContext::GetBasicTypeEnumeration(const ConstString &name) { ClangASTContext::GetBasicTypeEnumeration(ConstString name) {
if (name) { if (name) {
typedef UniqueCStringMap<lldb::BasicType> TypeNameToBasicTypeMap; typedef UniqueCStringMap<lldb::BasicType> TypeNameToBasicTypeMap;
static TypeNameToBasicTypeMap g_type_map; static TypeNameToBasicTypeMap g_type_map;
static llvm::once_flag g_once_flag; static llvm::once_flag g_once_flag;
llvm::call_once(g_once_flag, []() { llvm::call_once(g_once_flag, []() {
// "void" // "void"
g_type_map.Append(ConstString("void"), eBasicTypeVoid); g_type_map.Append(ConstString("void"), eBasicTypeVoid);
Show All 32 Lines
}); });
return g_type_map.Find(name, eBasicTypeInvalid); return g_type_map.Find(name, eBasicTypeInvalid);
} }
return eBasicTypeInvalid; return eBasicTypeInvalid;
} }
CompilerType ClangASTContext::GetBasicType(ASTContext *ast, CompilerType ClangASTContext::GetBasicType(ASTContext *ast,
const ConstString &name) { ConstString name) {
if (ast) { if (ast) {
lldb::BasicType basic_type = ClangASTContext::GetBasicTypeEnumeration(name); lldb::BasicType basic_type = ClangASTContext::GetBasicTypeEnumeration(name);
return ClangASTContext::GetBasicType(ast, basic_type); return ClangASTContext::GetBasicType(ast, basic_type);
} }
return CompilerType(); return CompilerType();
} }
uint32_t ClangASTContext::GetPointerByteSize() { uint32_t ClangASTContext::GetPointerByteSize() {
Show All 32 Lines
clang::ArrayType::Normal, 0)); clang::ArrayType::Normal, 0));
} }
} }
} }
return CompilerType(); return CompilerType();
} }
CompilerType ClangASTContext::CreateStructForIdentifier( CompilerType ClangASTContext::CreateStructForIdentifier(
const ConstString &type_name, ConstString type_name,
const std::initializer_list<std::pair<const char *, CompilerType>> const std::initializer_list<std::pair<const char *, CompilerType>>
&type_fields, &type_fields,
bool packed) { bool packed) {
CompilerType type; CompilerType type;
if (!type_name.IsEmpty() && if (!type_name.IsEmpty() &&
(type = GetTypeForIdentifier<clang::CXXRecordDecl>(type_name)) (type = GetTypeForIdentifier<clang::CXXRecordDecl>(type_name))
.IsValid()) { .IsValid()) {
lldbassert(0 && "Trying to create a type for an existing name"); lldbassert(0 && "Trying to create a type for an existing name");
return type; return type;
} }
type = CreateRecordType(nullptr, lldb::eAccessPublic, type_name.GetCString(), type = CreateRecordType(nullptr, lldb::eAccessPublic, type_name.GetCString(),
clang::TTK_Struct, lldb::eLanguageTypeC); clang::TTK_Struct, lldb::eLanguageTypeC);
StartTagDeclarationDefinition(type); StartTagDeclarationDefinition(type);
for (const auto &field : type_fields) for (const auto &field : type_fields)
AddFieldToRecordType(type, field.first, field.second, lldb::eAccessPublic, AddFieldToRecordType(type, field.first, field.second, lldb::eAccessPublic,
0); 0);
if (packed) if (packed)
SetIsPacked(type); SetIsPacked(type);
CompleteTagDeclarationDefinition(type); CompleteTagDeclarationDefinition(type);
return type; return type;
} }
CompilerType ClangASTContext::GetOrCreateStructForIdentifier( CompilerType ClangASTContext::GetOrCreateStructForIdentifier(
const ConstString &type_name, ConstString type_name,
const std::initializer_list<std::pair<const char *, CompilerType>> const std::initializer_list<std::pair<const char *, CompilerType>>
&type_fields, &type_fields,
bool packed) { bool packed) {
CompilerType type; CompilerType type;
if ((type = GetTypeForIdentifier<clang::CXXRecordDecl>(type_name)).IsValid()) if ((type = GetTypeForIdentifier<clang::CXXRecordDecl>(type_name)).IsValid())
return type; return type;
return CreateStructForIdentifier(type_name, type_fields, packed); return CreateStructForIdentifier(type_name, type_fields, packed);
Show All 32 Lines
.GetNumChildren(omit_empty_base_classes, exe_ctx); .GetNumChildren(omit_empty_base_classes, exe_ctx);
break; break;
default: default:
break; break;
} }
return num_children; return num_children;
} }
CompilerType ClangASTContext::GetBuiltinTypeByName(const ConstString &name) { CompilerType ClangASTContext::GetBuiltinTypeByName(ConstString name) {
return GetBasicType(GetBasicTypeEnumeration(name)); return GetBasicType(GetBasicTypeEnumeration(name));
} }
lldb::BasicType lldb::BasicType
ClangASTContext::GetBasicTypeEnumeration(lldb::opaque_compiler_type_t type) { ClangASTContext::GetBasicTypeEnumeration(lldb::opaque_compiler_type_t type) {
if (type) { if (type) {
clang::QualType qual_type(GetQualType(type)); clang::QualType qual_type(GetQualType(type));
const clang::Type::TypeClass type_class = qual_type->getTypeClass(); const clang::Type::TypeClass type_class = qual_type->getTypeClass();
Show All 32 Lines
} }
} }
return eBasicTypeInvalid; return eBasicTypeInvalid;
} }
void ClangASTContext::ForEachEnumerator( void ClangASTContext::ForEachEnumerator(
lldb::opaque_compiler_type_t type, lldb::opaque_compiler_type_t type,
std::function<bool(const CompilerType &integer_type, std::function<bool(const CompilerType &integer_type,
const ConstString &name, ConstString name,
const llvm::APSInt &value)> const &callback) { const llvm::APSInt &value)> const &callback) {
const clang::EnumType *enum_type = const clang::EnumType *enum_type =
llvm::dyn_cast<clang::EnumType>(GetCanonicalQualType(type)); llvm::dyn_cast<clang::EnumType>(GetCanonicalQualType(type));
if (enum_type) { if (enum_type) {
const clang::EnumDecl *enum_decl = enum_type->getDecl(); const clang::EnumDecl *enum_decl = enum_type->getDecl();
if (enum_decl) { if (enum_decl) {
CompilerType integer_type(this, CompilerType integer_type(this,
enum_decl->getIntegerType().getAsOpaquePtr()); enum_decl->getIntegerType().getAsOpaquePtr());
Show All 16 Lines

lldb/source/Symbol/CompilerType.cpp

Show All 16 Lines
lldb::BasicType CompilerType::GetBasicTypeEnumeration() const { lldb::BasicType CompilerType::GetBasicTypeEnumeration() const {
if (IsValid()) if (IsValid())
return m_type_system->GetBasicTypeEnumeration(m_type); return m_type_system->GetBasicTypeEnumeration(m_type);
return eBasicTypeInvalid; return eBasicTypeInvalid;
} }
void CompilerType::ForEachEnumerator( void CompilerType::ForEachEnumerator(
std::function<bool(const CompilerType &integer_type, std::function<bool(const CompilerType &integer_type,
const ConstString &name, ConstString name,
const llvm::APSInt &value)> const &callback) const { const llvm::APSInt &value)> const &callback) const {
if (IsValid()) if (IsValid())
return m_type_system->ForEachEnumerator(m_type, callback); return m_type_system->ForEachEnumerator(m_type, callback);
} }
uint32_t CompilerType::GetNumFields() const { uint32_t CompilerType::GetNumFields() const {
if (!IsValid()) if (!IsValid())
return 0; return 0;
Show All 16 Lines

lldb/source/Symbol/Function.cpp

Show All 16 Lines
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// Basic function information is contained in the FunctionInfo class. It is // Basic function information is contained in the FunctionInfo class. It is
// designed to contain the name, linkage name, and declaration location. // designed to contain the name, linkage name, and declaration location.
//---------------------------------------------------------------------- //----------------------------------------------------------------------
FunctionInfo::FunctionInfo(const char *name, const Declaration *decl_ptr) FunctionInfo::FunctionInfo(const char *name, const Declaration *decl_ptr)
: m_name(name), m_declaration(decl_ptr) {} : m_name(name), m_declaration(decl_ptr) {}
FunctionInfo::FunctionInfo(const ConstString &name, const Declaration *decl_ptr) FunctionInfo::FunctionInfo(ConstString name, const Declaration *decl_ptr)
: m_name(name), m_declaration(decl_ptr) {} : m_name(name), m_declaration(decl_ptr) {}
FunctionInfo::~FunctionInfo() {} FunctionInfo::~FunctionInfo() {}
void FunctionInfo::Dump(Stream *s, bool show_fullpaths) const { void FunctionInfo::Dump(Stream *s, bool show_fullpaths) const {
if (m_name) if (m_name)
*s << ", name = \"" << m_name << "\""; *s << ", name = \"" << m_name << "\"";
m_declaration.Dump(s, show_fullpaths); m_declaration.Dump(s, show_fullpaths);
Show All 20 Lines
} }
InlineFunctionInfo::InlineFunctionInfo(const char *name, const char *mangled, InlineFunctionInfo::InlineFunctionInfo(const char *name, const char *mangled,
const Declaration *decl_ptr, const Declaration *decl_ptr,
const Declaration *call_decl_ptr) const Declaration *call_decl_ptr)
: FunctionInfo(name, decl_ptr), m_mangled(ConstString(mangled), true), : FunctionInfo(name, decl_ptr), m_mangled(ConstString(mangled), true),
m_call_decl(call_decl_ptr) {} m_call_decl(call_decl_ptr) {}
InlineFunctionInfo::InlineFunctionInfo(const ConstString &name, InlineFunctionInfo::InlineFunctionInfo(ConstString name,
const Mangled &mangled, const Mangled &mangled,
const Declaration *decl_ptr, const Declaration *decl_ptr,
const Declaration *call_decl_ptr) const Declaration *call_decl_ptr)
: FunctionInfo(name, decl_ptr), m_mangled(mangled), : FunctionInfo(name, decl_ptr), m_mangled(mangled),
m_call_decl(call_decl_ptr) {} m_call_decl(call_decl_ptr) {}
InlineFunctionInfo::~InlineFunctionInfo() {} InlineFunctionInfo::~InlineFunctionInfo() {}
Show All 16 Lines

lldb/source/Symbol/LocateSymbolFile.cpp

Show All 16 Lines
Target::GetDefaultDebugFileSearchPaths()); Target::GetDefaultDebugFileSearchPaths());
// Add module directory. // Add module directory.
FileSpec module_file_spec = module_spec.GetFileSpec(); FileSpec module_file_spec = module_spec.GetFileSpec();
// We keep the unresolved pathname if it fails. // We keep the unresolved pathname if it fails.
FileSystem::Instance().ResolveSymbolicLink(module_file_spec, FileSystem::Instance().ResolveSymbolicLink(module_file_spec,
module_file_spec); module_file_spec);
const ConstString &file_dir = module_file_spec.GetDirectory(); ConstString file_dir = module_file_spec.GetDirectory();
{ {
FileSpec file_spec(file_dir.AsCString(".")); FileSpec file_spec(file_dir.AsCString("."));
FileSystem::Instance().Resolve(file_spec); FileSystem::Instance().Resolve(file_spec);
debug_file_search_paths.AppendIfUnique(file_spec); debug_file_search_paths.AppendIfUnique(file_spec);
} }
if (ModuleList::GetGlobalModuleListProperties().GetEnableExternalLookup()) { if (ModuleList::GetGlobalModuleListProperties().GetEnableExternalLookup()) {
Show All 16 Lines

lldb/source/Symbol/Symbol.cpp

Show All 16 Lines
// back into a string that is the re-exported name. // back into a string that is the re-exported name.
intptr_t str_ptr = m_addr_range.GetByteSize(); intptr_t str_ptr = m_addr_range.GetByteSize();
if (str_ptr != 0) if (str_ptr != 0)
return FileSpec((const char *)str_ptr); return FileSpec((const char *)str_ptr);
} }
return FileSpec(); return FileSpec();
} }
void Symbol::SetReExportedSymbolName(const ConstString &name) { void Symbol::SetReExportedSymbolName(ConstString name) {
SetType(eSymbolTypeReExported); SetType(eSymbolTypeReExported);
// For eSymbolTypeReExported, the "const char *" from a ConstString is used // For eSymbolTypeReExported, the "const char *" from a ConstString is used
// as the offset in the address range base address. // as the offset in the address range base address.
m_addr_range.GetBaseAddress().SetOffset((uintptr_t)name.GetCString()); m_addr_range.GetBaseAddress().SetOffset((uintptr_t)name.GetCString());
} }
bool Symbol::SetReExportedSymbolSharedLibrary(const FileSpec &fspec) { bool Symbol::SetReExportedSymbolSharedLibrary(const FileSpec &fspec) {
if (m_type == eSymbolTypeReExported) { if (m_type == eSymbolTypeReExported) {
Show All 32 Lines
} }
} }
} }
return m_type_data; return m_type_data;
} }
return 0; return 0;
} }
bool Symbol::Compare(const ConstString &name, SymbolType type) const { bool Symbol::Compare(ConstString name, SymbolType type) const {
if (type == eSymbolTypeAny || m_type == type) if (type == eSymbolTypeAny || m_type == type)
return m_mangled.GetMangledName() == name || return m_mangled.GetMangledName() == name ||
m_mangled.GetDemangledName(GetLanguage()) == name; m_mangled.GetDemangledName(GetLanguage()) == name;
return false; return false;
} }
#define ENUM_TO_CSTRING(x) \ #define ENUM_TO_CSTRING(x) \
case eSymbolType##x: \ case eSymbolType##x: \
Show All 16 Lines

lldb/source/Symbol/SymbolContext.cpp

Show All 16 Lines
lldb::addr_t range_size = end_entry.range.GetBaseAddress().GetFileAddress() - lldb::addr_t range_size = end_entry.range.GetBaseAddress().GetFileAddress() -
range.GetBaseAddress().GetFileAddress(); range.GetBaseAddress().GetFileAddress();
range.SetByteSize(range_size); range.SetByteSize(range_size);
return true; return true;
} }
const Symbol * const Symbol *
SymbolContext::FindBestGlobalDataSymbol(const ConstString &name, Status &error) { SymbolContext::FindBestGlobalDataSymbol(ConstString name, Status &error) {
error.Clear(); error.Clear();
if (!target_sp) { if (!target_sp) {
return nullptr; return nullptr;
} }
Target &target = *target_sp; Target &target = *target_sp;
Module *module = module_sp.get(); Module *module = module_sp.get();
Show All 16 Lines

lldb/source/Symbol/SymbolFile.cpp

Show All 16 Lines
uint32_t SymbolFile::ResolveSymbolContext(const FileSpec &file_spec, uint32_t SymbolFile::ResolveSymbolContext(const FileSpec &file_spec,
uint32_t line, bool check_inlines, uint32_t line, bool check_inlines,
lldb::SymbolContextItem resolve_scope, lldb::SymbolContextItem resolve_scope,
SymbolContextList &sc_list) { SymbolContextList &sc_list) {
return 0; return 0;
} }
uint32_t uint32_t
SymbolFile::FindGlobalVariables(const ConstString &name, SymbolFile::FindGlobalVariables(ConstString name,
const CompilerDeclContext *parent_decl_ctx, const CompilerDeclContext *parent_decl_ctx,
uint32_t max_matches, VariableList &variables) { uint32_t max_matches, VariableList &variables) {
return 0; return 0;
} }
uint32_t SymbolFile::FindGlobalVariables(const RegularExpression &regex, uint32_t SymbolFile::FindGlobalVariables(const RegularExpression &regex,
uint32_t max_matches, uint32_t max_matches,
VariableList &variables) { VariableList &variables) {
return 0; return 0;
} }
uint32_t SymbolFile::FindFunctions(const ConstString &name, uint32_t SymbolFile::FindFunctions(ConstString name,
const CompilerDeclContext *parent_decl_ctx, const CompilerDeclContext *parent_decl_ctx,
lldb::FunctionNameType name_type_mask, lldb::FunctionNameType name_type_mask,
bool include_inlines, bool append, bool include_inlines, bool append,
SymbolContextList &sc_list) { SymbolContextList &sc_list) {
if (!append) if (!append)
sc_list.Clear(); sc_list.Clear();
return 0; return 0;
} }
uint32_t SymbolFile::FindFunctions(const RegularExpression &regex, uint32_t SymbolFile::FindFunctions(const RegularExpression &regex,
bool include_inlines, bool append, bool include_inlines, bool append,
SymbolContextList &sc_list) { SymbolContextList &sc_list) {
if (!append) if (!append)
sc_list.Clear(); sc_list.Clear();
return 0; return 0;
} }
void SymbolFile::GetMangledNamesForFunction( void SymbolFile::GetMangledNamesForFunction(
const std::string &scope_qualified_name, const std::string &scope_qualified_name,
std::vector<ConstString> &mangled_names) { std::vector<ConstString> &mangled_names) {
return; return;
} }
uint32_t SymbolFile::FindTypes( uint32_t SymbolFile::FindTypes(
const ConstString &name, const CompilerDeclContext *parent_decl_ctx, ConstString name, const CompilerDeclContext *parent_decl_ctx,
bool append, uint32_t max_matches, bool append, uint32_t max_matches,
llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files, llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
TypeMap &types) { TypeMap &types) {
if (!append) if (!append)
types.Clear(); types.Clear();
return 0; return 0;
} }
Show All 16 Lines

lldb/source/Symbol/SymbolVendor.cpp

Show All 16 Lines
if (m_sym_file_up) if (m_sym_file_up)
return m_sym_file_up->ResolveSymbolContext(file_spec, line, check_inlines, return m_sym_file_up->ResolveSymbolContext(file_spec, line, check_inlines,
resolve_scope, sc_list); resolve_scope, sc_list);
} }
return 0; return 0;
} }
size_t size_t
SymbolVendor::FindGlobalVariables(const ConstString &name, SymbolVendor::FindGlobalVariables(ConstString name,
const CompilerDeclContext *parent_decl_ctx, const CompilerDeclContext *parent_decl_ctx,
size_t max_matches, VariableList &variables) { size_t max_matches, VariableList &variables) {
ModuleSP module_sp(GetModule()); ModuleSP module_sp(GetModule());
if (module_sp) { if (module_sp) {
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex()); std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
if (m_sym_file_up) if (m_sym_file_up)
return m_sym_file_up->FindGlobalVariables(name, parent_decl_ctx, return m_sym_file_up->FindGlobalVariables(name, parent_decl_ctx,
max_matches, variables); max_matches, variables);
} }
return 0; return 0;
} }
size_t SymbolVendor::FindGlobalVariables(const RegularExpression &regex, size_t SymbolVendor::FindGlobalVariables(const RegularExpression &regex,
size_t max_matches, size_t max_matches,
VariableList &variables) { VariableList &variables) {
ModuleSP module_sp(GetModule()); ModuleSP module_sp(GetModule());
if (module_sp) { if (module_sp) {
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex()); std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
if (m_sym_file_up) if (m_sym_file_up)
return m_sym_file_up->FindGlobalVariables(regex, max_matches, variables); return m_sym_file_up->FindGlobalVariables(regex, max_matches, variables);
} }
return 0; return 0;
} }
size_t SymbolVendor::FindFunctions(const ConstString &name, size_t SymbolVendor::FindFunctions(ConstString name,
const CompilerDeclContext *parent_decl_ctx, const CompilerDeclContext *parent_decl_ctx,
FunctionNameType name_type_mask, FunctionNameType name_type_mask,
bool include_inlines, bool append, bool include_inlines, bool append,
SymbolContextList &sc_list) { SymbolContextList &sc_list) {
ModuleSP module_sp(GetModule()); ModuleSP module_sp(GetModule());
if (module_sp) { if (module_sp) {
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex()); std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
if (m_sym_file_up) if (m_sym_file_up)
Show All 12 Lines
if (m_sym_file_up) if (m_sym_file_up)
return m_sym_file_up->FindFunctions(regex, include_inlines, append, return m_sym_file_up->FindFunctions(regex, include_inlines, append,
sc_list); sc_list);
} }
return 0; return 0;
} }
size_t SymbolVendor::FindTypes( size_t SymbolVendor::FindTypes(
const ConstString &name, const CompilerDeclContext *parent_decl_ctx, ConstString name, const CompilerDeclContext *parent_decl_ctx,
bool append, size_t max_matches, bool append, size_t max_matches,
llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files, llvm::DenseSet<lldb_private::SymbolFile *> &searched_symbol_files,
TypeMap &types) { TypeMap &types) {
ModuleSP module_sp(GetModule()); ModuleSP module_sp(GetModule());
if (module_sp) { if (module_sp) {
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex()); std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
if (m_sym_file_up) if (m_sym_file_up)
return m_sym_file_up->FindTypes(name, parent_decl_ctx, append, return m_sym_file_up->FindTypes(name, parent_decl_ctx, append,
Show All 25 Lines
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex()); std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
if (m_sym_file_up) if (m_sym_file_up)
return m_sym_file_up->GetTypes(sc_scope, type_mask, type_list); return m_sym_file_up->GetTypes(sc_scope, type_mask, type_list);
} }
return 0; return 0;
} }
CompilerDeclContext CompilerDeclContext
SymbolVendor::FindNamespace(const ConstString &name, SymbolVendor::FindNamespace(ConstString name,
const CompilerDeclContext *parent_decl_ctx) { const CompilerDeclContext *parent_decl_ctx) {
CompilerDeclContext namespace_decl_ctx; CompilerDeclContext namespace_decl_ctx;
ModuleSP module_sp(GetModule()); ModuleSP module_sp(GetModule());
if (module_sp) { if (module_sp) {
std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex()); std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
if (m_sym_file_up) if (m_sym_file_up)
namespace_decl_ctx = m_sym_file_up->FindNamespace(name, parent_decl_ctx); namespace_decl_ctx = m_sym_file_up->FindNamespace(name, parent_decl_ctx);
} }
Show All 16 Lines

lldb/source/Symbol/Symtab.cpp

Show All 16 Lines
// Remove any duplicates if requested // Remove any duplicates if requested
if (remove_duplicates) { if (remove_duplicates) {
auto last = std::unique(indexes.begin(), indexes.end()); auto last = std::unique(indexes.begin(), indexes.end());
indexes.erase(last, indexes.end()); indexes.erase(last, indexes.end());
} }
} }
uint32_t Symtab::AppendSymbolIndexesWithName(const ConstString &symbol_name, uint32_t Symtab::AppendSymbolIndexesWithName(ConstString symbol_name,
std::vector<uint32_t> &indexes) { std::vector<uint32_t> &indexes) {
std::lock_guard<std::recursive_mutex> guard(m_mutex); std::lock_guard<std::recursive_mutex> guard(m_mutex);
static Timer::Category func_cat(LLVM_PRETTY_FUNCTION); static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
Timer scoped_timer(func_cat, "%s", LLVM_PRETTY_FUNCTION); Timer scoped_timer(func_cat, "%s", LLVM_PRETTY_FUNCTION);
if (symbol_name) { if (symbol_name) {
if (!m_name_indexes_computed) if (!m_name_indexes_computed)
InitNameIndexes(); InitNameIndexes();
return m_name_to_index.GetValues(symbol_name, indexes); return m_name_to_index.GetValues(symbol_name, indexes);
} }
return 0; return 0;
} }
uint32_t Symtab::AppendSymbolIndexesWithName(const ConstString &symbol_name, uint32_t Symtab::AppendSymbolIndexesWithName(ConstString symbol_name,
Debug symbol_debug_type, Debug symbol_debug_type,
Visibility symbol_visibility, Visibility symbol_visibility,
std::vector<uint32_t> &indexes) { std::vector<uint32_t> &indexes) {
std::lock_guard<std::recursive_mutex> guard(m_mutex); std::lock_guard<std::recursive_mutex> guard(m_mutex);
static Timer::Category func_cat(LLVM_PRETTY_FUNCTION); static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
Timer scoped_timer(func_cat, "%s", LLVM_PRETTY_FUNCTION); Timer scoped_timer(func_cat, "%s", LLVM_PRETTY_FUNCTION);
if (symbol_name) { if (symbol_name) {
Show All 10 Lines
indexes.push_back(all_name_indexes[i]); indexes.push_back(all_name_indexes[i]);
} }
return indexes.size() - old_size; return indexes.size() - old_size;
} }
return 0; return 0;
} }
uint32_t uint32_t
Symtab::AppendSymbolIndexesWithNameAndType(const ConstString &symbol_name, Symtab::AppendSymbolIndexesWithNameAndType(ConstString symbol_name,
SymbolType symbol_type, SymbolType symbol_type,
std::vector<uint32_t> &indexes) { std::vector<uint32_t> &indexes) {
std::lock_guard<std::recursive_mutex> guard(m_mutex); std::lock_guard<std::recursive_mutex> guard(m_mutex);
if (AppendSymbolIndexesWithName(symbol_name, indexes) > 0) { if (AppendSymbolIndexesWithName(symbol_name, indexes) > 0) {
std::vector<uint32_t>::iterator pos = indexes.begin(); std::vector<uint32_t>::iterator pos = indexes.begin();
while (pos != indexes.end()) { while (pos != indexes.end()) {
if (symbol_type == eSymbolTypeAny || if (symbol_type == eSymbolTypeAny ||
m_symbols[*pos].GetType() == symbol_type) m_symbols[*pos].GetType() == symbol_type)
++pos; ++pos;
else else
pos = indexes.erase(pos); pos = indexes.erase(pos);
} }
} }
return indexes.size(); return indexes.size();
} }
uint32_t Symtab::AppendSymbolIndexesWithNameAndType( uint32_t Symtab::AppendSymbolIndexesWithNameAndType(
const ConstString &symbol_name, SymbolType symbol_type, ConstString symbol_name, SymbolType symbol_type,
Debug symbol_debug_type, Visibility symbol_visibility, Debug symbol_debug_type, Visibility symbol_visibility,
std::vector<uint32_t> &indexes) { std::vector<uint32_t> &indexes) {
std::lock_guard<std::recursive_mutex> guard(m_mutex); std::lock_guard<std::recursive_mutex> guard(m_mutex);
if (AppendSymbolIndexesWithName(symbol_name, symbol_debug_type, if (AppendSymbolIndexesWithName(symbol_name, symbol_debug_type,
symbol_visibility, indexes) > 0) { symbol_visibility, indexes) > 0) {
std::vector<uint32_t>::iterator pos = indexes.begin(); std::vector<uint32_t>::iterator pos = indexes.begin();
while (pos != indexes.end()) { while (pos != indexes.end()) {
Show All 32 Lines
return &m_symbols[idx]; return &m_symbols[idx];
} }
} }
} }
return nullptr; return nullptr;
} }
size_t size_t
Symtab::FindAllSymbolsWithNameAndType(const ConstString &name, Symtab::FindAllSymbolsWithNameAndType(ConstString name,
SymbolType symbol_type, SymbolType symbol_type,
std::vector<uint32_t> &symbol_indexes) { std::vector<uint32_t> &symbol_indexes) {
std::lock_guard<std::recursive_mutex> guard(m_mutex); std::lock_guard<std::recursive_mutex> guard(m_mutex);
static Timer::Category func_cat(LLVM_PRETTY_FUNCTION); static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
Timer scoped_timer(func_cat, "%s", LLVM_PRETTY_FUNCTION); Timer scoped_timer(func_cat, "%s", LLVM_PRETTY_FUNCTION);
// Initialize all of the lookup by name indexes before converting NAME to a // Initialize all of the lookup by name indexes before converting NAME to a
// uniqued string NAME_STR below. // uniqued string NAME_STR below.
if (!m_name_indexes_computed) if (!m_name_indexes_computed)
InitNameIndexes(); InitNameIndexes();
if (name) { if (name) {
// The string table did have a string that matched, but we need to check // The string table did have a string that matched, but we need to check
// the symbols and match the symbol_type if any was given. // the symbols and match the symbol_type if any was given.
AppendSymbolIndexesWithNameAndType(name, symbol_type, symbol_indexes); AppendSymbolIndexesWithNameAndType(name, symbol_type, symbol_indexes);
} }
return symbol_indexes.size(); return symbol_indexes.size();
} }
size_t Symtab::FindAllSymbolsWithNameAndType( size_t Symtab::FindAllSymbolsWithNameAndType(
const ConstString &name, SymbolType symbol_type, Debug symbol_debug_type, ConstString name, SymbolType symbol_type, Debug symbol_debug_type,
Visibility symbol_visibility, std::vector<uint32_t> &symbol_indexes) { Visibility symbol_visibility, std::vector<uint32_t> &symbol_indexes) {
std::lock_guard<std::recursive_mutex> guard(m_mutex); std::lock_guard<std::recursive_mutex> guard(m_mutex);
static Timer::Category func_cat(LLVM_PRETTY_FUNCTION); static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
Timer scoped_timer(func_cat, "%s", LLVM_PRETTY_FUNCTION); Timer scoped_timer(func_cat, "%s", LLVM_PRETTY_FUNCTION);
// Initialize all of the lookup by name indexes before converting NAME to a // Initialize all of the lookup by name indexes before converting NAME to a
// uniqued string NAME_STR below. // uniqued string NAME_STR below.
if (!m_name_indexes_computed) if (!m_name_indexes_computed)
Show All 14 Lines
std::vector<uint32_t> &symbol_indexes) { std::vector<uint32_t> &symbol_indexes) {
std::lock_guard<std::recursive_mutex> guard(m_mutex); std::lock_guard<std::recursive_mutex> guard(m_mutex);
AppendSymbolIndexesMatchingRegExAndType(regex, symbol_type, symbol_debug_type, AppendSymbolIndexesMatchingRegExAndType(regex, symbol_type, symbol_debug_type,
symbol_visibility, symbol_indexes); symbol_visibility, symbol_indexes);
return symbol_indexes.size(); return symbol_indexes.size();
} }
Symbol *Symtab::FindFirstSymbolWithNameAndType(const ConstString &name, Symbol *Symtab::FindFirstSymbolWithNameAndType(ConstString name,
SymbolType symbol_type, SymbolType symbol_type,
Debug symbol_debug_type, Debug symbol_debug_type,
Visibility symbol_visibility) { Visibility symbol_visibility) {
std::lock_guard<std::recursive_mutex> guard(m_mutex); std::lock_guard<std::recursive_mutex> guard(m_mutex);
static Timer::Category func_cat(LLVM_PRETTY_FUNCTION); static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
Timer scoped_timer(func_cat, "%s", LLVM_PRETTY_FUNCTION); Timer scoped_timer(func_cat, "%s", LLVM_PRETTY_FUNCTION);
if (!m_name_indexes_computed) if (!m_name_indexes_computed)
Show All 32 Lines
for (size_t i = 0; i < num_indices; i++) { for (size_t i = 0; i < num_indices; i++) {
sc.symbol = SymbolAtIndex(symbol_indexes[i]); sc.symbol = SymbolAtIndex(symbol_indexes[i]);
if (sc.symbol) if (sc.symbol)
sc_list.AppendIfUnique(sc, merge_symbol_into_function); sc_list.AppendIfUnique(sc, merge_symbol_into_function);
} }
} }
} }
size_t Symtab::FindFunctionSymbols(const ConstString &name, size_t Symtab::FindFunctionSymbols(ConstString name,
uint32_t name_type_mask, uint32_t name_type_mask,
SymbolContextList &sc_list) { SymbolContextList &sc_list) {
size_t count = 0; size_t count = 0;
std::vector<uint32_t> symbol_indexes; std::vector<uint32_t> symbol_indexes;
// eFunctionNameTypeAuto should be pre-resolved by a call to // eFunctionNameTypeAuto should be pre-resolved by a call to
// Module::LookupInfo::LookupInfo() // Module::LookupInfo::LookupInfo()
assert((name_type_mask & eFunctionNameTypeAuto) == 0); assert((name_type_mask & eFunctionNameTypeAuto) == 0);
Show All 16 Lines

lldb/source/Symbol/Type.cpp

Show All 16 Lines
Type *resolved_type = m_symbol_file.ResolveTypeUID(GetID()); Type *resolved_type = m_symbol_file.ResolveTypeUID(GetID());
if (resolved_type) if (resolved_type)
m_type_sp = resolved_type->shared_from_this(); m_type_sp = resolved_type->shared_from_this();
} }
return m_type_sp.get(); return m_type_sp.get();
} }
Type::Type(lldb::user_id_t uid, SymbolFile *symbol_file, Type::Type(lldb::user_id_t uid, SymbolFile *symbol_file,
const ConstString &name, llvm::Optional<uint64_t> byte_size, ConstString name, llvm::Optional<uint64_t> byte_size,
SymbolContextScope *context, user_id_t encoding_uid, SymbolContextScope *context, user_id_t encoding_uid,
EncodingDataType encoding_uid_type, const Declaration &decl, EncodingDataType encoding_uid_type, const Declaration &decl,
const CompilerType &compiler_type, const CompilerType &compiler_type,
ResolveState compiler_type_resolve_state) ResolveState compiler_type_resolve_state)
: std::enable_shared_from_this<Type>(), UserID(uid), m_name(name), : std::enable_shared_from_this<Type>(), UserID(uid), m_name(name),
m_symbol_file(symbol_file), m_context(context), m_encoding_type(nullptr), m_symbol_file(symbol_file), m_context(context), m_encoding_type(nullptr),
m_encoding_uid(encoding_uid), m_encoding_uid_type(encoding_uid_type), m_encoding_uid(encoding_uid), m_encoding_uid_type(encoding_uid_type),
m_decl(decl), m_compiler_type(compiler_type) { m_decl(decl), m_compiler_type(compiler_type) {
Show All 29 Lines
m_compiler_type(rhs.m_compiler_type), m_flags(rhs.m_flags) {} m_compiler_type(rhs.m_compiler_type), m_flags(rhs.m_flags) {}
void Type::GetDescription(Stream *s, lldb::DescriptionLevel level, void Type::GetDescription(Stream *s, lldb::DescriptionLevel level,
bool show_name) { bool show_name) {
*s << "id = " << (const UserID &)*this; *s << "id = " << (const UserID &)*this;
// Call the name accessor to make sure we resolve the type name // Call the name accessor to make sure we resolve the type name
if (show_name) { if (show_name) {
const ConstString &type_name = GetName(); ConstString type_name = GetName();
if (type_name) { if (type_name) {
*s << ", name = \"" << type_name << '"'; *s << ", name = \"" << type_name << '"';
ConstString qualified_type_name(GetQualifiedName()); ConstString qualified_type_name(GetQualifiedName());
if (qualified_type_name != type_name) { if (qualified_type_name != type_name) {
*s << ", qualified = \"" << qualified_type_name << '"'; *s << ", qualified = \"" << qualified_type_name << '"';
} }
} }
} }
Show All 32 Lines
} }
// //
// if (m_access) // if (m_access)
// s->Printf(", access = %u", m_access); // s->Printf(", access = %u", m_access);
s->EOL(); s->EOL();
} }
const ConstString &Type::GetName() { ConstString Type::GetName() {
if (!m_name) if (!m_name)
m_name = GetForwardCompilerType().GetConstTypeName(); m_name = GetForwardCompilerType().GetConstTypeName();
return m_name; return m_name;
} }
void Type::DumpTypeName(Stream *s) { GetName().Dump(s, "<invalid-type-name>"); } void Type::DumpTypeName(Stream *s) { GetName().Dump(s, "<invalid-type-name>"); }
void Type::DumpValue(ExecutionContext *exe_ctx, Stream *s, void Type::DumpValue(ExecutionContext *exe_ctx, Stream *s,
Show All 32 Lines
ConstString TypeAndOrName::GetName() const { ConstString TypeAndOrName::GetName() const {
if (m_type_name) if (m_type_name)
return m_type_name; return m_type_name;
if (m_type_pair) if (m_type_pair)
return m_type_pair.GetName(); return m_type_pair.GetName();
return ConstString("<invalid>"); return ConstString("<invalid>");
} }
void TypeAndOrName::SetName(const ConstString &type_name) { void TypeAndOrName::SetName(ConstString type_name) {
m_type_name = type_name; m_type_name = type_name;
} }
void TypeAndOrName::SetName(const char *type_name_cstr) { void TypeAndOrName::SetName(const char *type_name_cstr) {
m_type_name.SetCString(type_name_cstr); m_type_name.SetCString(type_name_cstr);
} }
void TypeAndOrName::SetTypeSP(lldb::TypeSP type_sp) { void TypeAndOrName::SetTypeSP(lldb::TypeSP type_sp) {
Show All 32 Lines
CompilerType TypeMemberFunctionImpl::GetArgumentAtIndex(size_t idx) const { CompilerType TypeMemberFunctionImpl::GetArgumentAtIndex(size_t idx) const {
if (m_type) if (m_type)
return m_type.GetFunctionArgumentAtIndex(idx); return m_type.GetFunctionArgumentAtIndex(idx);
else else
return m_decl.GetFunctionArgumentType(idx); return m_decl.GetFunctionArgumentType(idx);
} }
TypeEnumMemberImpl::TypeEnumMemberImpl(const lldb::TypeImplSP &integer_type_sp, TypeEnumMemberImpl::TypeEnumMemberImpl(const lldb::TypeImplSP &integer_type_sp,
const ConstString &name, ConstString name,
const llvm::APSInt &value) const llvm::APSInt &value)
: m_integer_type_sp(integer_type_sp), m_name(name), m_value(value), : m_integer_type_sp(integer_type_sp), m_name(name), m_value(value),
m_valid((bool)name && (bool)integer_type_sp) m_valid((bool)name && (bool)integer_type_sp)
{} {}
Context not available.

lldb/source/Symbol/TypeList.cpp

Show All 16 Lines
// return pos->second; // return pos->second;
// return TypeSP(); // return TypeSP();
//} //}
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// Find a type by name. // Find a type by name.
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// TypeList // TypeList
// TypeList::FindTypes (const ConstString &name) // TypeList::FindTypes (ConstString name)
//{ //{
// // Do we ever need to make a lookup by name map? Here we are doing // // Do we ever need to make a lookup by name map? Here we are doing
// // a linear search which isn't going to be fast. // // a linear search which isn't going to be fast.
// TypeList types(m_ast.getTargetInfo()->getTriple().getTriple().c_str()); // TypeList types(m_ast.getTargetInfo()->getTriple().getTriple().c_str());
// iterator pos, end; // iterator pos, end;
// for (pos = m_types.begin(), end = m_types.end(); pos != end; ++pos) // for (pos = m_types.begin(), end = m_types.end(); pos != end; ++pos)
// if (pos->second->GetName() == name) // if (pos->second->GetName() == name)
// types.Insert (pos->second); // types.Insert (pos->second);
Show All 16 Lines

lldb/source/Symbol/TypeMap.cpp

Show All 16 Lines
// return pos->second; // return pos->second;
// return TypeSP(); // return TypeSP();
//} //}
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// Find a type by name. // Find a type by name.
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// TypeMap // TypeMap
// TypeMap::FindTypes (const ConstString &name) // TypeMap::FindTypes (ConstString name)
//{ //{
// // Do we ever need to make a lookup by name map? Here we are doing // // Do we ever need to make a lookup by name map? Here we are doing
// // a linear search which isn't going to be fast. // // a linear search which isn't going to be fast.
// TypeMap types(m_ast.getTargetInfo()->getTriple().getTriple().c_str()); // TypeMap types(m_ast.getTargetInfo()->getTriple().getTriple().c_str());
// iterator pos, end; // iterator pos, end;
// for (pos = m_types.begin(), end = m_types.end(); pos != end; ++pos) // for (pos = m_types.begin(), end = m_types.end(); pos != end; ++pos)
// if (pos->second->GetName() == name) // if (pos->second->GetName() == name)
// types.Insert (pos->second); // types.Insert (pos->second);
Show All 16 Lines

lldb/source/Symbol/TypeSystem.cpp

Show All 16 Lines
} }
CompilerType TypeSystem::CreateTypedef(lldb::opaque_compiler_type_t type, CompilerType TypeSystem::CreateTypedef(lldb::opaque_compiler_type_t type,
const char *name, const char *name,
const CompilerDeclContext &decl_ctx) { const CompilerDeclContext &decl_ctx) {
return CompilerType(); return CompilerType();
} }
CompilerType TypeSystem::GetBuiltinTypeByName(const ConstString &name) { CompilerType TypeSystem::GetBuiltinTypeByName(ConstString name) {
return CompilerType(); return CompilerType();
} }
CompilerType TypeSystem::GetTypeForFormatters(void *type) { CompilerType TypeSystem::GetTypeForFormatters(void *type) {
return CompilerType(this, type); return CompilerType(this, type);
} }
size_t TypeSystem::GetNumTemplateArguments(lldb::opaque_compiler_type_t type) { size_t TypeSystem::GetNumTemplateArguments(lldb::opaque_compiler_type_t type) {
Show All 16 Lines

lldb/source/Symbol/Variable.cpp

Show All 16 Lines
ConstString name = m_mangled.GetName(GetLanguage()); ConstString name = m_mangled.GetName(GetLanguage());
if (name) if (name)
return name; return name;
return m_name; return m_name;
} }
ConstString Variable::GetUnqualifiedName() const { return m_name; } ConstString Variable::GetUnqualifiedName() const { return m_name; }
bool Variable::NameMatches(const ConstString &name) const { bool Variable::NameMatches(ConstString name) const {
if (m_name == name) if (m_name == name)
return true; return true;
SymbolContext variable_sc; SymbolContext variable_sc;
m_owner_scope->CalculateSymbolContext(&variable_sc); m_owner_scope->CalculateSymbolContext(&variable_sc);
LanguageType language = eLanguageTypeUnknown; LanguageType language = eLanguageTypeUnknown;
if (variable_sc.comp_unit) if (variable_sc.comp_unit)
language = variable_sc.comp_unit->GetLanguage(); language = variable_sc.comp_unit->GetLanguage();
Show All 16 Lines

lldb/source/Symbol/VariableList.cpp

Show All 16 Lines
iterator pos, end = m_variables.end(); iterator pos, end = m_variables.end();
for (pos = m_variables.begin(); pos != end; ++pos) { for (pos = m_variables.begin(); pos != end; ++pos) {
if (pos->get() == var_sp.get()) if (pos->get() == var_sp.get())
return std::distance(m_variables.begin(), pos); return std::distance(m_variables.begin(), pos);
} }
return UINT32_MAX; return UINT32_MAX;
} }
VariableSP VariableList::FindVariable(const ConstString &name, VariableSP VariableList::FindVariable(ConstString name,
bool include_static_members) { bool include_static_members) {
VariableSP var_sp; VariableSP var_sp;
iterator pos, end = m_variables.end(); iterator pos, end = m_variables.end();
for (pos = m_variables.begin(); pos != end; ++pos) { for (pos = m_variables.begin(); pos != end; ++pos) {
if ((*pos)->NameMatches(name)) { if ((*pos)->NameMatches(name)) {
if (include_static_members || !(*pos)->IsStaticMember()) { if (include_static_members || !(*pos)->IsStaticMember()) {
var_sp = (*pos); var_sp = (*pos);
break; break;
} }
} }
} }
return var_sp; return var_sp;
} }
VariableSP VariableList::FindVariable(const ConstString &name, VariableSP VariableList::FindVariable(ConstString name,
lldb::ValueType value_type, lldb::ValueType value_type,
bool include_static_members) { bool include_static_members) {
VariableSP var_sp; VariableSP var_sp;
iterator pos, end = m_variables.end(); iterator pos, end = m_variables.end();
for (pos = m_variables.begin(); pos != end; ++pos) { for (pos = m_variables.begin(); pos != end; ++pos) {
if ((*pos)->NameMatches(name) && (*pos)->GetScope() == value_type) { if ((*pos)->NameMatches(name) && (*pos)->GetScope() == value_type) {
if (include_static_members || !(*pos)->IsStaticMember()) { if (include_static_members || !(*pos)->IsStaticMember()) {
var_sp = (*pos); var_sp = (*pos);
Show All 16 Lines

lldb/source/Target/ABI.cpp

Show All 16 Lines
return abi_sp; return abi_sp;
} }
abi_sp.reset(); abi_sp.reset();
return abi_sp; return abi_sp;
} }
ABI::~ABI() = default; ABI::~ABI() = default;
bool ABI::GetRegisterInfoByName(const ConstString &name, RegisterInfo &info) { bool ABI::GetRegisterInfoByName(ConstString name, RegisterInfo &info) {
uint32_t count = 0; uint32_t count = 0;
const RegisterInfo *register_info_array = GetRegisterInfoArray(count); const RegisterInfo *register_info_array = GetRegisterInfoArray(count);
if (register_info_array) { if (register_info_array) {
const char *unique_name_cstr = name.GetCString(); const char *unique_name_cstr = name.GetCString();
uint32_t i; uint32_t i;
for (i = 0; i < count; ++i) { for (i = 0; i < count; ++i) {
if (register_info_array[i].name == unique_name_cstr) { if (register_info_array[i].name == unique_name_cstr) {
info = register_info_array[i]; info = register_info_array[i];
Show All 16 Lines

lldb/source/Target/ObjCLanguageRuntime.cpp

Show All 16 Lines
return true; return true;
if ((value % ptr_size) == 0) if ((value % ptr_size) == 0)
return (check_version_specific ? CheckPointer(value, ptr_size) : true); return (check_version_specific ? CheckPointer(value, ptr_size) : true);
else else
return false; return false;
} }
ObjCLanguageRuntime::ObjCISA ObjCLanguageRuntime::ObjCISA
ObjCLanguageRuntime::GetISA(const ConstString &name) { ObjCLanguageRuntime::GetISA(ConstString name) {
ISAToDescriptorIterator pos = GetDescriptorIterator(name); ISAToDescriptorIterator pos = GetDescriptorIterator(name);
if (pos != m_isa_to_descriptor.end()) if (pos != m_isa_to_descriptor.end())
return pos->first; return pos->first;
return 0; return 0;
} }
ObjCLanguageRuntime::ISAToDescriptorIterator ObjCLanguageRuntime::ISAToDescriptorIterator
ObjCLanguageRuntime::GetDescriptorIterator(const ConstString &name) { ObjCLanguageRuntime::GetDescriptorIterator(ConstString name) {
ISAToDescriptorIterator end = m_isa_to_descriptor.end(); ISAToDescriptorIterator end = m_isa_to_descriptor.end();
if (name) { if (name) {
UpdateISAToDescriptorMap(); UpdateISAToDescriptorMap();
if (m_hash_to_isa_map.empty()) { if (m_hash_to_isa_map.empty()) {
// No name hashes were provided, we need to just linearly power through // No name hashes were provided, we need to just linearly power through
// the names and find a match // the names and find a match
for (ISAToDescriptorIterator pos = m_isa_to_descriptor.begin(); for (ISAToDescriptorIterator pos = m_isa_to_descriptor.begin();
Show All 32 Lines
ClassDescriptorSP objc_class_sp(GetNonKVOClassDescriptor(isa)); ClassDescriptorSP objc_class_sp(GetNonKVOClassDescriptor(isa));
if (objc_class_sp) if (objc_class_sp)
return objc_class_sp->GetClassName(); return objc_class_sp->GetClassName();
return ConstString(); return ConstString();
} }
ObjCLanguageRuntime::ClassDescriptorSP ObjCLanguageRuntime::ClassDescriptorSP
ObjCLanguageRuntime::GetClassDescriptorFromClassName( ObjCLanguageRuntime::GetClassDescriptorFromClassName(
const ConstString &class_name) { ConstString class_name) {
ISAToDescriptorIterator pos = GetDescriptorIterator(class_name); ISAToDescriptorIterator pos = GetDescriptorIterator(class_name);
if (pos != m_isa_to_descriptor.end()) if (pos != m_isa_to_descriptor.end())
return pos->second; return pos->second;
return ClassDescriptorSP(); return ClassDescriptorSP();
} }
ObjCLanguageRuntime::ClassDescriptorSP ObjCLanguageRuntime::ClassDescriptorSP
ObjCLanguageRuntime::GetClassDescriptor(ValueObject &valobj) { ObjCLanguageRuntime::GetClassDescriptor(ValueObject &valobj) {
Show All 16 Lines

lldb/source/Target/PathMappingList.cpp

Show All 16 Lines
// things won't always work. We found a case where if we did: // things won't always work. We found a case where if we did:
// (lldb) settings set target.source-map . /tmp // (lldb) settings set target.source-map . /tmp
// We would store a path pairs of "." and "/tmp" as raw strings. If the debug // We would store a path pairs of "." and "/tmp" as raw strings. If the debug
// info contains "./foo/bar.c", the path will get normalized to "foo/bar.c". // info contains "./foo/bar.c", the path will get normalized to "foo/bar.c".
// When PathMappingList::RemapPath() is called, it expects the path to start // When PathMappingList::RemapPath() is called, it expects the path to start
// with the raw path pair, which doesn't work anymore because the paths have // with the raw path pair, which doesn't work anymore because the paths have
// been normalized when the debug info was loaded. So we need to store // been normalized when the debug info was loaded. So we need to store
// nomalized path pairs to ensure things match up. // nomalized path pairs to ensure things match up.
ConstString NormalizePath(const ConstString &path) { ConstString NormalizePath(ConstString path) {
// If we use "path" to construct a FileSpec, it will normalize the path for // If we use "path" to construct a FileSpec, it will normalize the path for
// us. We then grab the string and turn it back into a ConstString. // us. We then grab the string and turn it back into a ConstString.
return ConstString(FileSpec(path.GetStringRef()).GetPath()); return ConstString(FileSpec(path.GetStringRef()).GetPath());
} }
} }
//---------------------------------------------------------------------- //----------------------------------------------------------------------
// PathMappingList constructor // PathMappingList constructor
//---------------------------------------------------------------------- //----------------------------------------------------------------------
Show All 15 Lines
m_callback_baton = nullptr; m_callback_baton = nullptr;
m_mod_id = rhs.m_mod_id; m_mod_id = rhs.m_mod_id;
} }
return *this; return *this;
} }
PathMappingList::~PathMappingList() = default; PathMappingList::~PathMappingList() = default;
void PathMappingList::Append(const ConstString &path, void PathMappingList::Append(ConstString path,
const ConstString &replacement, bool notify) { ConstString replacement, bool notify) {
++m_mod_id; ++m_mod_id;
m_pairs.emplace_back(pair(NormalizePath(path), NormalizePath(replacement))); m_pairs.emplace_back(pair(NormalizePath(path), NormalizePath(replacement)));
if (notify && m_callback) if (notify && m_callback)
m_callback(*this, m_callback_baton); m_callback(*this, m_callback_baton);
} }
void PathMappingList::Append(const PathMappingList &rhs, bool notify) { void PathMappingList::Append(const PathMappingList &rhs, bool notify) {
++m_mod_id; ++m_mod_id;
if (!rhs.m_pairs.empty()) { if (!rhs.m_pairs.empty()) {
const_iterator pos, end = rhs.m_pairs.end(); const_iterator pos, end = rhs.m_pairs.end();
for (pos = rhs.m_pairs.begin(); pos != end; ++pos) for (pos = rhs.m_pairs.begin(); pos != end; ++pos)
m_pairs.push_back(*pos); m_pairs.push_back(*pos);
if (notify && m_callback) if (notify && m_callback)
m_callback(*this, m_callback_baton); m_callback(*this, m_callback_baton);
} }
} }
void PathMappingList::Insert(const ConstString &path, void PathMappingList::Insert(ConstString path,
const ConstString &replacement, uint32_t index, ConstString replacement, uint32_t index,
bool notify) { bool notify) {
++m_mod_id; ++m_mod_id;
iterator insert_iter; iterator insert_iter;
if (index >= m_pairs.size()) if (index >= m_pairs.size())
insert_iter = m_pairs.end(); insert_iter = m_pairs.end();
else else
insert_iter = m_pairs.begin() + index; insert_iter = m_pairs.begin() + index;
m_pairs.emplace(insert_iter, pair(NormalizePath(path), m_pairs.emplace(insert_iter, pair(NormalizePath(path),
NormalizePath(replacement))); NormalizePath(replacement)));
if (notify && m_callback) if (notify && m_callback)
m_callback(*this, m_callback_baton); m_callback(*this, m_callback_baton);
} }
bool PathMappingList::Replace(const ConstString &path, bool PathMappingList::Replace(ConstString path,
const ConstString &replacement, uint32_t index, ConstString replacement, uint32_t index,
bool notify) { bool notify) {
if (index >= m_pairs.size()) if (index >= m_pairs.size())
return false; return false;
++m_mod_id; ++m_mod_id;
m_pairs[index] = pair(NormalizePath(path), NormalizePath(replacement)); m_pairs[index] = pair(NormalizePath(path), NormalizePath(replacement));
if (notify && m_callback) if (notify && m_callback)
m_callback(*this, m_callback_baton); m_callback(*this, m_callback_baton);
return true; return true;
Show All 32 Lines
void PathMappingList::Clear(bool notify) { void PathMappingList::Clear(bool notify) {
if (!m_pairs.empty()) if (!m_pairs.empty())
++m_mod_id; ++m_mod_id;
m_pairs.clear(); m_pairs.clear();
if (notify && m_callback) if (notify && m_callback)
m_callback(*this, m_callback_baton); m_callback(*this, m_callback_baton);
} }
bool PathMappingList::RemapPath(const ConstString &path, bool PathMappingList::RemapPath(ConstString path,
ConstString &new_path) const { ConstString &new_path) const {
std::string remapped; std::string remapped;
if (RemapPath(path.GetStringRef(), remapped)) { if (RemapPath(path.GetStringRef(), remapped)) {
new_path.SetString(remapped); new_path.SetString(remapped);
return true; return true;
} }
return false; return false;
} }
Show All 32 Lines
return true; return true;
} }
} }
new_spec.Clear(); new_spec.Clear();
return false; return false;
} }
bool PathMappingList::Replace(const ConstString &path, bool PathMappingList::Replace(ConstString path,
const ConstString &new_path, bool notify) { ConstString new_path, bool notify) {
uint32_t idx = FindIndexForPath(path); uint32_t idx = FindIndexForPath(path);
if (idx < m_pairs.size()) { if (idx < m_pairs.size()) {
++m_mod_id; ++m_mod_id;
m_pairs[idx].second = new_path; m_pairs[idx].second = new_path;
if (notify && m_callback) if (notify && m_callback)
m_callback(*this, m_callback_baton); m_callback(*this, m_callback_baton);
return true; return true;
} }
return false; return false;
} }
bool PathMappingList::Remove(const ConstString &path, bool notify) { bool PathMappingList::Remove(ConstString path, bool notify) {
iterator pos = FindIteratorForPath(path); iterator pos = FindIteratorForPath(path);
if (pos != m_pairs.end()) { if (pos != m_pairs.end()) {
++m_mod_id; ++m_mod_id;
m_pairs.erase(pos); m_pairs.erase(pos);
if (notify && m_callback) if (notify && m_callback)
m_callback(*this, m_callback_baton); m_callback(*this, m_callback_baton);
return true; return true;
} }
return false; return false;
} }
PathMappingList::const_iterator PathMappingList::const_iterator
PathMappingList::FindIteratorForPath(const ConstString &path) const { PathMappingList::FindIteratorForPath(ConstString path) const {
const_iterator pos; const_iterator pos;
const_iterator begin = m_pairs.begin(); const_iterator begin = m_pairs.begin();
const_iterator end = m_pairs.end(); const_iterator end = m_pairs.end();
for (pos = begin; pos != end; ++pos) { for (pos = begin; pos != end; ++pos) {
if (pos->first == path) if (pos->first == path)
break; break;
} }
return pos; return pos;
} }
PathMappingList::iterator PathMappingList::iterator
PathMappingList::FindIteratorForPath(const ConstString &path) { PathMappingList::FindIteratorForPath(ConstString path) {
iterator pos; iterator pos;
iterator begin = m_pairs.begin(); iterator begin = m_pairs.begin();
iterator end = m_pairs.end(); iterator end = m_pairs.end();
for (pos = begin; pos != end; ++pos) { for (pos = begin; pos != end; ++pos) {
if (pos->first == path) if (pos->first == path)
break; break;
} }
return pos; return pos;
} }
bool PathMappingList::GetPathsAtIndex(uint32_t idx, ConstString &path, bool PathMappingList::GetPathsAtIndex(uint32_t idx, ConstString &path,
ConstString &new_path) const { ConstString &new_path) const {
if (idx < m_pairs.size()) { if (idx < m_pairs.size()) {
path = m_pairs[idx].first; path = m_pairs[idx].first;
new_path = m_pairs[idx].second; new_path = m_pairs[idx].second;
return true; return true;
} }
return false; return false;
} }
uint32_t PathMappingList::FindIndexForPath(const ConstString &orig_path) const { uint32_t PathMappingList::FindIndexForPath(ConstString orig_path) const {
const ConstString path = NormalizePath(orig_path); const ConstString path = NormalizePath(orig_path);
const_iterator pos; const_iterator pos;
const_iterator begin = m_pairs.begin(); const_iterator begin = m_pairs.begin();
const_iterator end = m_pairs.end(); const_iterator end = m_pairs.end();
for (pos = begin; pos != end; ++pos) { for (pos = begin; pos != end; ++pos) {
if (pos->first == path) if (pos->first == path)
return std::distance(begin, pos); return std::distance(begin, pos);
} }
return UINT32_MAX; return UINT32_MAX;
} }
Context not available.

lldb/source/Target/Platform.cpp

Show All 16 Lines
FileSpecList FileSpecList
Platform::LocateExecutableScriptingResources(Target *target, Module &module, Platform::LocateExecutableScriptingResources(Target *target, Module &module,
Stream *feedback_stream) { Stream *feedback_stream) {
return FileSpecList(); return FileSpecList();
} }
// PlatformSP // PlatformSP
// Platform::FindPlugin (Process *process, const ConstString &plugin_name) // Platform::FindPlugin (Process *process, ConstString plugin_name)
//{ //{
// PlatformCreateInstance create_callback = nullptr; // PlatformCreateInstance create_callback = nullptr;
// if (plugin_name) // if (plugin_name)
// { // {
// create_callback = // create_callback =
// PluginManager::GetPlatformCreateCallbackForPluginName (plugin_name); // PluginManager::GetPlatformCreateCallbackForPluginName (plugin_name);
// if (create_callback) // if (create_callback)
// { // {
Show All 32 Lines
module_specs) == 0) module_specs) == 0)
return false; return false;
ModuleSpec matched_module_spec; ModuleSpec matched_module_spec;
return module_specs.FindMatchingModuleSpec(ModuleSpec(module_file_spec, arch), return module_specs.FindMatchingModuleSpec(ModuleSpec(module_file_spec, arch),
module_spec); module_spec);
} }
PlatformSP Platform::Find(const ConstString &name) { PlatformSP Platform::Find(ConstString name) {
if (name) { if (name) {
static ConstString g_host_platform_name("host"); static ConstString g_host_platform_name("host");
if (name == g_host_platform_name) if (name == g_host_platform_name)
return GetHostPlatform(); return GetHostPlatform();
std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex()); std::lock_guard<std::recursive_mutex> guard(GetPlatformListMutex());
for (const auto &platform_sp : GetPlatformList()) { for (const auto &platform_sp : GetPlatformList()) {
if (platform_sp->GetName() == name) if (platform_sp->GetName() == name)
return platform_sp; return platform_sp;
} }
} }
return PlatformSP(); return PlatformSP();
} }
PlatformSP Platform::Create(const ConstString &name, Status &error) { PlatformSP Platform::Create(ConstString name, Status &error) {
PlatformCreateInstance create_callback = nullptr; PlatformCreateInstance create_callback = nullptr;
lldb::PlatformSP platform_sp; lldb::PlatformSP platform_sp;
if (name) { if (name) {
static ConstString g_host_platform_name("host"); static ConstString g_host_platform_name("host");
if (name == g_host_platform_name) if (name == g_host_platform_name)
return GetHostPlatform(); return GetHostPlatform();
create_callback = create_callback =
Show All 16 Lines

lldb/source/Target/Process.cpp

Show All 16 Lines
#ifdef ENABLE_MEMORY_CACHING #ifdef ENABLE_MEMORY_CACHING
#define DISABLE_MEM_CACHE_DEFAULT false #define DISABLE_MEM_CACHE_DEFAULT false
#else #else
#define DISABLE_MEM_CACHE_DEFAULT true #define DISABLE_MEM_CACHE_DEFAULT true
#endif #endif
class ProcessOptionValueProperties : public OptionValueProperties { class ProcessOptionValueProperties : public OptionValueProperties {
public: public:
ProcessOptionValueProperties(const ConstString &name) ProcessOptionValueProperties(ConstString name)
: OptionValueProperties(name) {} : OptionValueProperties(name) {}
// This constructor is used when creating ProcessOptionValueProperties when // This constructor is used when creating ProcessOptionValueProperties when
// it is part of a new lldb_private::Process instance. It will copy all // it is part of a new lldb_private::Process instance. It will copy all
// current global property values as needed // current global property values as needed
ProcessOptionValueProperties(ProcessProperties *global_properties) ProcessOptionValueProperties(ProcessProperties *global_properties)
: OptionValueProperties(*global_properties->GetValueProperties()) {} : OptionValueProperties(*global_properties->GetValueProperties()) {}
Show All 32 Lines
: EventData(), m_process_wp(), m_state(state), m_restarted(false), : EventData(), m_process_wp(), m_state(state), m_restarted(false),
m_update_state(0), m_interrupted(false) { m_update_state(0), m_interrupted(false) {
if (process_sp) if (process_sp)
m_process_wp = process_sp; m_process_wp = process_sp;
} }
Process::ProcessEventData::~ProcessEventData() = default; Process::ProcessEventData::~ProcessEventData() = default;
const ConstString &Process::ProcessEventData::GetFlavorString() { ConstString Process::ProcessEventData::GetFlavorString() {
static ConstString g_flavor("Process::ProcessEventData"); static ConstString g_flavor("Process::ProcessEventData");
return g_flavor; return g_flavor;
} }
const ConstString &Process::ProcessEventData::GetFlavor() const { ConstString Process::ProcessEventData::GetFlavor() const {
return ProcessEventData::GetFlavorString(); return ProcessEventData::GetFlavorString();
} }
void Process::ProcessEventData::DoOnRemoval(Event *event_ptr) { void Process::ProcessEventData::DoOnRemoval(Event *event_ptr) {
ProcessSP process_sp(m_process_wp.lock()); ProcessSP process_sp(m_process_wp.lock());
if (!process_sp) if (!process_sp)
return; return;
Show All 32 Lines
void Process::BroadcastStructuredData(const StructuredData::ObjectSP &object_sp, void Process::BroadcastStructuredData(const StructuredData::ObjectSP &object_sp,
const StructuredDataPluginSP &plugin_sp) { const StructuredDataPluginSP &plugin_sp) {
BroadcastEvent( BroadcastEvent(
eBroadcastBitStructuredData, eBroadcastBitStructuredData,
new EventDataStructuredData(shared_from_this(), object_sp, plugin_sp)); new EventDataStructuredData(shared_from_this(), object_sp, plugin_sp));
} }
StructuredDataPluginSP StructuredDataPluginSP
Process::GetStructuredDataPlugin(const ConstString &type_name) const { Process::GetStructuredDataPlugin(ConstString type_name) const {
auto find_it = m_structured_data_plugin_map.find(type_name); auto find_it = m_structured_data_plugin_map.find(type_name);
if (find_it != m_structured_data_plugin_map.end()) if (find_it != m_structured_data_plugin_map.end())
return find_it->second; return find_it->second;
else else
return StructuredDataPluginSP(); return StructuredDataPluginSP();
} }
size_t Process::GetAsyncProfileData(char *buf, size_t buf_size, Status &error) { size_t Process::GetAsyncProfileData(char *buf, size_t buf_size, Status &error) {
Show All 32 Lines
region_list.push_back(std::move(region_info)); region_list.push_back(std::move(region_info));
} }
} while (range_end != LLDB_INVALID_ADDRESS); } while (range_end != LLDB_INVALID_ADDRESS);
return error; return error;
} }
Status Status
Process::ConfigureStructuredData(const ConstString &type_name, Process::ConfigureStructuredData(ConstString type_name,
const StructuredData::ObjectSP &config_sp) { const StructuredData::ObjectSP &config_sp) {
// If you get this, the Process-derived class needs to implement a method to // If you get this, the Process-derived class needs to implement a method to
// enable an already-reported asynchronous structured data feature. See // enable an already-reported asynchronous structured data feature. See
// ProcessGDBRemote for an example implementation over gdb-remote. // ProcessGDBRemote for an example implementation over gdb-remote.
return Status("unimplemented"); return Status("unimplemented");
} }
void Process::MapSupportedStructuredDataPlugins( void Process::MapSupportedStructuredDataPlugins(
Show All 16 Lines

lldb/source/Target/StackFrameRecognizer.cpp

Show All 16 Lines
new ScriptedRecognizedStackFrame(args_synthesized)); new ScriptedRecognizedStackFrame(args_synthesized));
} }
#endif #endif
class StackFrameRecognizerManagerImpl { class StackFrameRecognizerManagerImpl {
public: public:
void AddRecognizer(StackFrameRecognizerSP recognizer, void AddRecognizer(StackFrameRecognizerSP recognizer,
const ConstString &module, const ConstString &symbol, ConstString module, ConstString symbol,
bool first_instruction_only) { bool first_instruction_only) {
m_recognizers.push_front({(uint32_t)m_recognizers.size(), false, recognizer, false, module, RegularExpressionSP(), m_recognizers.push_front({(uint32_t)m_recognizers.size(), false, recognizer, false, module, RegularExpressionSP(),
symbol, RegularExpressionSP(), symbol, RegularExpressionSP(),
first_instruction_only}); first_instruction_only});
} }
void AddRecognizer(StackFrameRecognizerSP recognizer, void AddRecognizer(StackFrameRecognizerSP recognizer,
RegularExpressionSP module, RegularExpressionSP symbol, RegularExpressionSP module, RegularExpressionSP symbol,
Show All 32 Lines
StackFrameRecognizerManagerImpl &GetStackFrameRecognizerManagerImpl() { StackFrameRecognizerManagerImpl &GetStackFrameRecognizerManagerImpl() {
static StackFrameRecognizerManagerImpl instance = static StackFrameRecognizerManagerImpl instance =
StackFrameRecognizerManagerImpl(); StackFrameRecognizerManagerImpl();
return instance; return instance;
} }
void StackFrameRecognizerManager::AddRecognizer( void StackFrameRecognizerManager::AddRecognizer(
StackFrameRecognizerSP recognizer, const ConstString &module, StackFrameRecognizerSP recognizer, ConstString module,
const ConstString &symbol, bool first_instruction_only) { ConstString symbol, bool first_instruction_only) {
GetStackFrameRecognizerManagerImpl().AddRecognizer(recognizer, module, symbol, GetStackFrameRecognizerManagerImpl().AddRecognizer(recognizer, module, symbol,
first_instruction_only); first_instruction_only);
} }
void StackFrameRecognizerManager::AddRecognizer( void StackFrameRecognizerManager::AddRecognizer(
StackFrameRecognizerSP recognizer, RegularExpressionSP module, StackFrameRecognizerSP recognizer, RegularExpressionSP module,
RegularExpressionSP symbol, bool first_instruction_only) { RegularExpressionSP symbol, bool first_instruction_only) {
GetStackFrameRecognizerManagerImpl().AddRecognizer(recognizer, module, symbol, GetStackFrameRecognizerManagerImpl().AddRecognizer(recognizer, module, symbol,
Show All 16 Lines

lldb/source/Target/StructuredDataPlugin.cpp

Show All 16 Lines
}; };
} }
StructuredDataPlugin::StructuredDataPlugin(const ProcessWP &process_wp) StructuredDataPlugin::StructuredDataPlugin(const ProcessWP &process_wp)
: PluginInterface(), m_process_wp(process_wp) {} : PluginInterface(), m_process_wp(process_wp) {}
StructuredDataPlugin::~StructuredDataPlugin() {} StructuredDataPlugin::~StructuredDataPlugin() {}
bool StructuredDataPlugin::GetEnabled(const ConstString &type_name) const { bool StructuredDataPlugin::GetEnabled(ConstString type_name) const {
// By default, plugins are always enabled. Plugin authors should override // By default, plugins are always enabled. Plugin authors should override
// this if there is an enabled/disabled state for their plugin. // this if there is an enabled/disabled state for their plugin.
return true; return true;
} }
ProcessSP StructuredDataPlugin::GetProcess() const { ProcessSP StructuredDataPlugin::GetProcess() const {
return m_process_wp.lock(); return m_process_wp.lock();
} }
Show All 16 Lines

lldb/source/Target/Target.cpp

Show All 16 Lines
bp_name->ConfigureBreakpoint(bp_sp); bp_name->ConfigureBreakpoint(bp_sp);
bp_sp->AddName(name); bp_sp->AddName(name);
} }
void Target::AddBreakpointName(BreakpointName *bp_name) { void Target::AddBreakpointName(BreakpointName *bp_name) {
m_breakpoint_names.insert(std::make_pair(bp_name->GetName(), bp_name)); m_breakpoint_names.insert(std::make_pair(bp_name->GetName(), bp_name));
} }
BreakpointName *Target::FindBreakpointName(const ConstString &name, BreakpointName *Target::FindBreakpointName(ConstString name,
bool can_create, bool can_create,
Status &error) Status &error)
{ {
BreakpointID::StringIsBreakpointName(name.GetStringRef(), error); BreakpointID::StringIsBreakpointName(name.GetStringRef(), error);
if (!error.Success()) if (!error.Success())
return nullptr; return nullptr;
BreakpointNameList::iterator iter = m_breakpoint_names.find(name); BreakpointNameList::iterator iter = m_breakpoint_names.find(name);
if (iter == m_breakpoint_names.end()) { if (iter == m_breakpoint_names.end()) {
if (!can_create) if (!can_create)
{ {
error.SetErrorStringWithFormat("Breakpoint name \"%s\" doesn't exist and " error.SetErrorStringWithFormat("Breakpoint name \"%s\" doesn't exist and "
"can_create is false.", name.AsCString()); "can_create is false.", name.AsCString());
return nullptr; return nullptr;
} }
iter = m_breakpoint_names.insert(std::make_pair(name, iter = m_breakpoint_names.insert(std::make_pair(name,
new BreakpointName(name))) new BreakpointName(name)))
.first; .first;
} }
return (iter->second); return (iter->second);
} }
void void
Target::DeleteBreakpointName(const ConstString &name) Target::DeleteBreakpointName(ConstString name)
{ {
BreakpointNameList::iterator iter = m_breakpoint_names.find(name); BreakpointNameList::iterator iter = m_breakpoint_names.find(name);
if (iter != m_breakpoint_names.end()) { if (iter != m_breakpoint_names.end()) {
const char *name_cstr = name.AsCString(); const char *name_cstr = name.AsCString();
m_breakpoint_names.erase(iter); m_breakpoint_names.erase(iter);
for (auto bp_sp : m_breakpoint_list.Breakpoints()) for (auto bp_sp : m_breakpoint_list.Breakpoints())
bp_sp->RemoveName(name_cstr); bp_sp->RemoveName(name_cstr);
} }
} }
void Target::RemoveNameFromBreakpoint(lldb::BreakpointSP &bp_sp, void Target::RemoveNameFromBreakpoint(lldb::BreakpointSP &bp_sp,
const ConstString &name) ConstString name)
{ {
bp_sp->RemoveName(name.AsCString()); bp_sp->RemoveName(name.AsCString());
} }
void Target::ConfigureBreakpointName(BreakpointName &bp_name, void Target::ConfigureBreakpointName(BreakpointName &bp_name,
const BreakpointOptions &new_options, const BreakpointOptions &new_options,
const BreakpointName::Permissions &new_permissions) const BreakpointName::Permissions &new_permissions)
{ {
Show All 32 Lines
} }
m_suppress_stop_hooks = old_suppress_value; m_suppress_stop_hooks = old_suppress_value;
return execution_results; return execution_results;
} }
lldb::ExpressionVariableSP lldb::ExpressionVariableSP
Target::GetPersistentVariable(const ConstString &name) { Target::GetPersistentVariable(ConstString name) {
lldb::ExpressionVariableSP variable_sp; lldb::ExpressionVariableSP variable_sp;
m_scratch_type_system_map.ForEach( m_scratch_type_system_map.ForEach(
[name, &variable_sp](TypeSystem *type_system) -> bool { [name, &variable_sp](TypeSystem *type_system) -> bool {
if (PersistentExpressionState *persistent_state = if (PersistentExpressionState *persistent_state =
type_system->GetPersistentExpressionState()) { type_system->GetPersistentExpressionState()) {
variable_sp = persistent_state->GetVariable(name); variable_sp = persistent_state->GetVariable(name);
if (variable_sp) if (variable_sp)
return false; // Stop iterating the ForEach return false; // Stop iterating the ForEach
} }
return true; // Keep iterating the ForEach return true; // Keep iterating the ForEach
}); });
return variable_sp; return variable_sp;
} }
lldb::addr_t Target::GetPersistentSymbol(const ConstString &name) { lldb::addr_t Target::GetPersistentSymbol(ConstString name) {
lldb::addr_t address = LLDB_INVALID_ADDRESS; lldb::addr_t address = LLDB_INVALID_ADDRESS;
m_scratch_type_system_map.ForEach( m_scratch_type_system_map.ForEach(
[name, &address](TypeSystem *type_system) -> bool { [name, &address](TypeSystem *type_system) -> bool {
if (PersistentExpressionState *persistent_state = if (PersistentExpressionState *persistent_state =
type_system->GetPersistentExpressionState()) { type_system->GetPersistentExpressionState()) {
address = persistent_state->LookupSymbol(name); address = persistent_state->LookupSymbol(name);
if (address != LLDB_INVALID_ADDRESS) if (address != LLDB_INVALID_ADDRESS)
Show All 32 Lines
ePropertyDisplayRecognizedArguments, ePropertyDisplayRecognizedArguments,
ePropertyNonStopModeEnabled, ePropertyNonStopModeEnabled,
ePropertyRequireHardwareBreakpoints, ePropertyRequireHardwareBreakpoints,
ePropertyExperimental, ePropertyExperimental,
}; };
class TargetOptionValueProperties : public OptionValueProperties { class TargetOptionValueProperties : public OptionValueProperties {
public: public:
TargetOptionValueProperties(const ConstString &name) TargetOptionValueProperties(ConstString name)
: OptionValueProperties(name), m_target(nullptr), m_got_host_env(false) {} : OptionValueProperties(name), m_target(nullptr), m_got_host_env(false) {}
// This constructor is used when creating TargetOptionValueProperties when it // This constructor is used when creating TargetOptionValueProperties when it
// is part of a new lldb_private::Target instance. It will copy all current // is part of a new lldb_private::Target instance. It will copy all current
// global property values as needed // global property values as needed
TargetOptionValueProperties(Target *target, TargetOptionValueProperties(Target *target,
const TargetPropertiesSP &target_properties_sp) const TargetPropertiesSP &target_properties_sp)
: OptionValueProperties(*target_properties_sp->GetValueProperties()), : OptionValueProperties(*target_properties_sp->GetValueProperties()),
Show All 32 Lines
: EventData(), m_target_sp(target_sp), m_module_list() {} : EventData(), m_target_sp(target_sp), m_module_list() {}
Target::TargetEventData::TargetEventData(const lldb::TargetSP &target_sp, Target::TargetEventData::TargetEventData(const lldb::TargetSP &target_sp,
const ModuleList &module_list) const ModuleList &module_list)
: EventData(), m_target_sp(target_sp), m_module_list(module_list) {} : EventData(), m_target_sp(target_sp), m_module_list(module_list) {}
Target::TargetEventData::~TargetEventData() = default; Target::TargetEventData::~TargetEventData() = default;
const ConstString &Target::TargetEventData::GetFlavorString() { ConstString Target::TargetEventData::GetFlavorString() {
static ConstString g_flavor("Target::TargetEventData"); static ConstString g_flavor("Target::TargetEventData");
return g_flavor; return g_flavor;
} }
void Target::TargetEventData::Dump(Stream *s) const { void Target::TargetEventData::Dump(Stream *s) const {
for (size_t i = 0; i < m_module_list.GetSize(); ++i) { for (size_t i = 0; i < m_module_list.GetSize(); ++i) {
if (i != 0) if (i != 0)
*s << ", "; *s << ", ";
Show All 16 Lines

lldb/source/Target/Thread.cpp

Show All 16 Lines
ePropertyStepAvoidRegex, ePropertyStepAvoidRegex,
ePropertyStepAvoidLibraries, ePropertyStepAvoidLibraries,
ePropertyEnableThreadTrace, ePropertyEnableThreadTrace,
ePropertyMaxBacktraceDepth ePropertyMaxBacktraceDepth
}; };
class ThreadOptionValueProperties : public OptionValueProperties { class ThreadOptionValueProperties : public OptionValueProperties {
public: public:
ThreadOptionValueProperties(const ConstString &name) ThreadOptionValueProperties(ConstString name)
: OptionValueProperties(name) {} : OptionValueProperties(name) {}
// This constructor is used when creating ThreadOptionValueProperties when it // This constructor is used when creating ThreadOptionValueProperties when it
// is part of a new lldb_private::Thread instance. It will copy all current // is part of a new lldb_private::Thread instance. It will copy all current
// global property values as needed // global property values as needed
ThreadOptionValueProperties(ThreadProperties *global_properties) ThreadOptionValueProperties(ThreadProperties *global_properties)
: OptionValueProperties(*global_properties->GetValueProperties()) {} : OptionValueProperties(*global_properties->GetValueProperties()) {}
Show All 32 Lines
return m_collection_sp->GetPropertyAtIndexAsUInt64( return m_collection_sp->GetPropertyAtIndexAsUInt64(
nullptr, idx, g_properties[idx].default_uint_value != 0); nullptr, idx, g_properties[idx].default_uint_value != 0);
} }
//------------------------------------------------------------------ //------------------------------------------------------------------
// Thread Event Data // Thread Event Data
//------------------------------------------------------------------ //------------------------------------------------------------------
const ConstString &Thread::ThreadEventData::GetFlavorString() { ConstString Thread::ThreadEventData::GetFlavorString() {
static ConstString g_flavor("Thread::ThreadEventData"); static ConstString g_flavor("Thread::ThreadEventData");
return g_flavor; return g_flavor;
} }
Thread::ThreadEventData::ThreadEventData(const lldb::ThreadSP thread_sp) Thread::ThreadEventData::ThreadEventData(const lldb::ThreadSP thread_sp)
: m_thread_sp(thread_sp), m_stack_id() {} : m_thread_sp(thread_sp), m_stack_id() {}
Thread::ThreadEventData::ThreadEventData(const lldb::ThreadSP thread_sp, Thread::ThreadEventData::ThreadEventData(const lldb::ThreadSP thread_sp,
Show All 16 Lines

lldb/source/Utility/ArchSpec.cpp

Show All 16 Lines
llvm::Triple::ArchType ArchSpec::GetMachine() const { llvm::Triple::ArchType ArchSpec::GetMachine() const {
const CoreDefinition *core_def = FindCoreDefinition(m_core); const CoreDefinition *core_def = FindCoreDefinition(m_core);
if (core_def) if (core_def)
return core_def->machine; return core_def->machine;
return llvm::Triple::UnknownArch; return llvm::Triple::UnknownArch;
} }
const ConstString &ArchSpec::GetDistributionId() const { ConstString ArchSpec::GetDistributionId() const {
return m_distribution_id; return m_distribution_id;
} }
void ArchSpec::SetDistributionId(const char *distribution_id) { void ArchSpec::SetDistributionId(const char *distribution_id) {
m_distribution_id.SetCString(distribution_id); m_distribution_id.SetCString(distribution_id);
} }
uint32_t ArchSpec::GetAddressByteSize() const { uint32_t ArchSpec::GetAddressByteSize() const {
Show All 16 Lines

lldb/source/Utility/ConstString.cpp

Show All 16 Lines
: m_string(StringPool().GetConstCString(cstr)) {} : m_string(StringPool().GetConstCString(cstr)) {}
ConstString::ConstString(const char *cstr, size_t cstr_len) ConstString::ConstString(const char *cstr, size_t cstr_len)
: m_string(StringPool().GetConstCStringWithLength(cstr, cstr_len)) {} : m_string(StringPool().GetConstCStringWithLength(cstr, cstr_len)) {}
ConstString::ConstString(const llvm::StringRef &s) ConstString::ConstString(const llvm::StringRef &s)
: m_string(StringPool().GetConstCStringWithLength(s.data(), s.size())) {} : m_string(StringPool().GetConstCStringWithLength(s.data(), s.size())) {}
bool ConstString::operator<(const ConstString &rhs) const { bool ConstString::operator<(ConstString rhs) const {
if (m_string == rhs.m_string) if (m_string == rhs.m_string)
return false; return false;
llvm::StringRef lhs_string_ref(GetStringRef()); llvm::StringRef lhs_string_ref(GetStringRef());
llvm::StringRef rhs_string_ref(rhs.GetStringRef()); llvm::StringRef rhs_string_ref(rhs.GetStringRef());
// If both have valid C strings, then return the comparison // If both have valid C strings, then return the comparison
if (lhs_string_ref.data() && rhs_string_ref.data()) if (lhs_string_ref.data() && rhs_string_ref.data())
return lhs_string_ref < rhs_string_ref; return lhs_string_ref < rhs_string_ref;
// Else one of them was nullptr, so if LHS is nullptr then it is less than // Else one of them was nullptr, so if LHS is nullptr then it is less than
return lhs_string_ref.data() == nullptr; return lhs_string_ref.data() == nullptr;
} }
Stream &lldb_private::operator<<(Stream &s, const ConstString &str) { Stream &lldb_private::operator<<(Stream &s, ConstString str) {
const char *cstr = str.GetCString(); const char *cstr = str.GetCString();
if (cstr != nullptr) if (cstr != nullptr)
s << cstr; s << cstr;
return s; return s;
} }
size_t ConstString::GetLength() const { size_t ConstString::GetLength() const {
return Pool::GetConstCStringLength(m_string); return Pool::GetConstCStringLength(m_string);
} }
bool ConstString::Equals(const ConstString &lhs, const ConstString &rhs, bool ConstString::Equals(ConstString lhs, ConstString rhs,
const bool case_sensitive) { const bool case_sensitive) {
if (lhs.m_string == rhs.m_string) if (lhs.m_string == rhs.m_string)
return true; return true;
// Since the pointers weren't equal, and identical ConstStrings always have // Since the pointers weren't equal, and identical ConstStrings always have
// identical pointers, the result must be false for case sensitive equality // identical pointers, the result must be false for case sensitive equality
// test. // test.
if (case_sensitive) if (case_sensitive)
return false; return false;
// perform case insensitive equality test // perform case insensitive equality test
llvm::StringRef lhs_string_ref(lhs.GetStringRef()); llvm::StringRef lhs_string_ref(lhs.GetStringRef());
llvm::StringRef rhs_string_ref(rhs.GetStringRef()); llvm::StringRef rhs_string_ref(rhs.GetStringRef());
return lhs_string_ref.equals_lower(rhs_string_ref); return lhs_string_ref.equals_lower(rhs_string_ref);
} }
int ConstString::Compare(const ConstString &lhs, const ConstString &rhs, int ConstString::Compare(ConstString lhs, ConstString rhs,
const bool case_sensitive) { const bool case_sensitive) {
// If the iterators are the same, this is the same string // If the iterators are the same, this is the same string
const char *lhs_cstr = lhs.m_string; const char *lhs_cstr = lhs.m_string;
const char *rhs_cstr = rhs.m_string; const char *rhs_cstr = rhs.m_string;
if (lhs_cstr == rhs_cstr) if (lhs_cstr == rhs_cstr)
return 0; return 0;
if (lhs_cstr && rhs_cstr) { if (lhs_cstr && rhs_cstr) {
llvm::StringRef lhs_string_ref(lhs.GetStringRef()); llvm::StringRef lhs_string_ref(lhs.GetStringRef());
Show All 32 Lines
m_string = StringPool().GetConstCString(cstr); m_string = StringPool().GetConstCString(cstr);
} }
void ConstString::SetString(const llvm::StringRef &s) { void ConstString::SetString(const llvm::StringRef &s) {
m_string = StringPool().GetConstCStringWithLength(s.data(), s.size()); m_string = StringPool().GetConstCStringWithLength(s.data(), s.size());
} }
void ConstString::SetStringWithMangledCounterpart(llvm::StringRef demangled, void ConstString::SetStringWithMangledCounterpart(llvm::StringRef demangled,
const ConstString &mangled) { ConstString mangled) {
m_string = StringPool().GetConstCStringAndSetMangledCounterPart( m_string = StringPool().GetConstCStringAndSetMangledCounterPart(
demangled, mangled.m_string); demangled, mangled.m_string);
} }
bool ConstString::GetMangledCounterpart(ConstString &counterpart) const { bool ConstString::GetMangledCounterpart(ConstString &counterpart) const {
counterpart.m_string = StringPool().GetMangledCounterpart(m_string); counterpart.m_string = StringPool().GetMangledCounterpart(m_string);
return (bool)counterpart; return (bool)counterpart;
} }
Show All 16 Lines

lldb/source/Utility/Event.cpp

Show All 16 Lines
} }
EventDataBytes::EventDataBytes(const void *src, size_t src_len) : m_bytes() { EventDataBytes::EventDataBytes(const void *src, size_t src_len) : m_bytes() {
SetBytes(src, src_len); SetBytes(src, src_len);
} }
EventDataBytes::~EventDataBytes() = default; EventDataBytes::~EventDataBytes() = default;
const ConstString &EventDataBytes::GetFlavorString() { ConstString EventDataBytes::GetFlavorString() {
static ConstString g_flavor("EventDataBytes"); static ConstString g_flavor("EventDataBytes");
return g_flavor; return g_flavor;
} }
const ConstString &EventDataBytes::GetFlavor() const { ConstString EventDataBytes::GetFlavor() const {
return EventDataBytes::GetFlavorString(); return EventDataBytes::GetFlavorString();
} }
void EventDataBytes::Dump(Stream *s) const { void EventDataBytes::Dump(Stream *s) const {
size_t num_printable_chars = size_t num_printable_chars =
std::count_if(m_bytes.begin(), m_bytes.end(), isprint); std::count_if(m_bytes.begin(), m_bytes.end(), isprint);
if (num_printable_chars == m_bytes.size()) if (num_printable_chars == m_bytes.size())
s->Format("\"{0}\"", m_bytes); s->Format("\"{0}\"", m_bytes);
Show All 32 Lines
m_plugin_sp(plugin_sp) {} m_plugin_sp(plugin_sp) {}
EventDataStructuredData::~EventDataStructuredData() {} EventDataStructuredData::~EventDataStructuredData() {}
//------------------------------------------------------------------ //------------------------------------------------------------------
// EventDataStructuredData member functions // EventDataStructuredData member functions
//------------------------------------------------------------------ //------------------------------------------------------------------
const ConstString &EventDataStructuredData::GetFlavor() const { ConstString EventDataStructuredData::GetFlavor() const {
return EventDataStructuredData::GetFlavorString(); return EventDataStructuredData::GetFlavorString();
} }
void EventDataStructuredData::Dump(Stream *s) const { void EventDataStructuredData::Dump(Stream *s) const {
if (!s) if (!s)
return; return;
if (m_object_sp) if (m_object_sp)
Show All 32 Lines
EventDataStructuredData::GetPluginFromEvent(const Event *event_ptr) { EventDataStructuredData::GetPluginFromEvent(const Event *event_ptr) {
auto event_data = EventDataStructuredData::GetEventDataFromEvent(event_ptr); auto event_data = EventDataStructuredData::GetEventDataFromEvent(event_ptr);
if (event_data) if (event_data)
return event_data->GetStructuredDataPlugin(); return event_data->GetStructuredDataPlugin();
else else
return StructuredDataPluginSP(); return StructuredDataPluginSP();
} }
const ConstString &EventDataStructuredData::GetFlavorString() { ConstString EventDataStructuredData::GetFlavorString() {
static ConstString s_flavor("EventDataStructuredData"); static ConstString s_flavor("EventDataStructuredData");
return s_flavor; return s_flavor;
} }
Context not available.

lldb/source/Utility/FileSpec.cpp

Show All 16 Lines
//------------------------------------------------------------------ //------------------------------------------------------------------
// Directory string get accessor. // Directory string get accessor.
//------------------------------------------------------------------ //------------------------------------------------------------------
ConstString &FileSpec::GetDirectory() { return m_directory; } ConstString &FileSpec::GetDirectory() { return m_directory; }
//------------------------------------------------------------------ //------------------------------------------------------------------
// Directory string const get accessor. // Directory string const get accessor.
//------------------------------------------------------------------ //------------------------------------------------------------------
const ConstString &FileSpec::GetDirectory() const { return m_directory; } ConstString FileSpec::GetDirectory() const { return m_directory; }
//------------------------------------------------------------------ //------------------------------------------------------------------
// Filename string get accessor. // Filename string get accessor.
//------------------------------------------------------------------ //------------------------------------------------------------------
ConstString &FileSpec::GetFilename() { return m_filename; } ConstString &FileSpec::GetFilename() { return m_filename; }
//------------------------------------------------------------------ //------------------------------------------------------------------
// Filename string const get accessor. // Filename string const get accessor.
//------------------------------------------------------------------ //------------------------------------------------------------------
const ConstString &FileSpec::GetFilename() const { return m_filename; } ConstString FileSpec::GetFilename() const { return m_filename; }
//------------------------------------------------------------------ //------------------------------------------------------------------
// Extract the directory and path into a fixed buffer. This is needed as the // Extract the directory and path into a fixed buffer. This is needed as the
// directory and path are stored in separate string values. // directory and path are stored in separate string values.
//------------------------------------------------------------------ //------------------------------------------------------------------
size_t FileSpec::GetPath(char *path, size_t path_max_len, size_t FileSpec::GetPath(char *path, size_t path_max_len,
bool denormalize) const { bool denormalize) const {
if (!path) if (!path)
Show All 16 Lines

lldb/source/Utility/Listener.cpp

Show All 16 Lines
m_event_type_mask(event_type_mask) {} m_event_type_mask(event_type_mask) {}
bool operator()(const EventSP &event_sp) const { bool operator()(const EventSP &event_sp) const {
if (m_broadcaster && !event_sp->BroadcasterIs(m_broadcaster)) if (m_broadcaster && !event_sp->BroadcasterIs(m_broadcaster))
return false; return false;
if (m_broadcaster_names) { if (m_broadcaster_names) {
bool found_source = false; bool found_source = false;
const ConstString &event_broadcaster_name = ConstString event_broadcaster_name =
event_sp->GetBroadcaster()->GetBroadcasterName(); event_sp->GetBroadcaster()->GetBroadcasterName();
for (uint32_t i = 0; i < m_num_broadcaster_names; ++i) { for (uint32_t i = 0; i < m_num_broadcaster_names; ++i) {
if (m_broadcaster_names[i] == event_broadcaster_name) { if (m_broadcaster_names[i] == event_broadcaster_name) {
found_source = true; found_source = true;
break; break;
} }
} }
if (!found_source) if (!found_source)
Show All 16 Lines

lldb/unittests/Core/MangledTest.cpp

Show All 16 Lines
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
TEST(MangledTest, ResultForValidName) { TEST(MangledTest, ResultForValidName) {
ConstString MangledName("_ZN1a1b1cIiiiEEvm"); ConstString MangledName("_ZN1a1b1cIiiiEEvm");
bool IsMangled = true; bool IsMangled = true;
Mangled TheMangled(MangledName, IsMangled); Mangled TheMangled(MangledName, IsMangled);
const ConstString &TheDemangled = ConstString TheDemangled =
TheMangled.GetDemangledName(eLanguageTypeC_plus_plus); TheMangled.GetDemangledName(eLanguageTypeC_plus_plus);
ConstString ExpectedResult("void a::b::c<int, int, int>(unsigned long)"); ConstString ExpectedResult("void a::b::c<int, int, int>(unsigned long)");
EXPECT_STREQ(ExpectedResult.GetCString(), TheDemangled.GetCString()); EXPECT_STREQ(ExpectedResult.GetCString(), TheDemangled.GetCString());
} }
TEST(MangledTest, EmptyForInvalidName) { TEST(MangledTest, EmptyForInvalidName) {
ConstString MangledName("_ZN1a1b1cmxktpEEvm"); ConstString MangledName("_ZN1a1b1cmxktpEEvm");
bool IsMangled = true; bool IsMangled = true;
Mangled TheMangled(MangledName, IsMangled); Mangled TheMangled(MangledName, IsMangled);
const ConstString &TheDemangled = ConstString TheDemangled =
TheMangled.GetDemangledName(eLanguageTypeC_plus_plus); TheMangled.GetDemangledName(eLanguageTypeC_plus_plus);
EXPECT_STREQ("", TheDemangled.GetCString()); EXPECT_STREQ("", TheDemangled.GetCString());
} }
#define ASSERT_NO_ERROR(x) \ #define ASSERT_NO_ERROR(x) \
if (std::error_code ASSERT_NO_ERROR_ec = x) { \ if (std::error_code ASSERT_NO_ERROR_ec = x) { \
llvm::SmallString<128> MessageStorage; \ llvm::SmallString<128> MessageStorage; \
Show All 16 Lines

lldb/www/architecture/varformats.html

Show All 16 Lines
CalculateNumChildren () = 0; CalculateNumChildren () = 0;
</li> </li>
<li> <li>
virtual lldb::ValueObjectSP virtual lldb::ValueObjectSP
GetChildAtIndex (size_t idx) = 0; GetChildAtIndex (size_t idx) = 0;
</li> </li>
<li> <li>
virtual size_t virtual size_t
GetIndexOfChildWithName (const ConstString &amp;name) = 0; GetIndexOfChildWithName (ConstString amp;name) = 0;
jasonmolendaUnsubmitted
Not Done
ReplyInline Actions

big bug! :)

jasonmolenda: big bug! :)
</li> </li>
<li> <li>
virtual bool virtual bool
Update () = 0; Update () = 0;
</li> </li>
<li> <li>
virtual bool virtual bool
MightHaveChildren () = 0; MightHaveChildren () = 0;
Show All 16 Lines