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

Repository
rL LLVM

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 ↗(On Diff #189523)

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/
trunk/
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 189573

lldb/trunk/docs/structured_data/StructuredDataPlugins.md

Show All 29 Lines* The feature may send asynchronous messages in StructuredData format
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 20 Lines • Show All 58 Lines • ▼ Show 20 Lines* The plugin is entirely independent of the type of Process-derived
* 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/trunk/include/lldb/Breakpoint/Breakpoint.h

Show First 20 Lines • Show All 76 Lines • ▼ Show 20 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 20 Lines • Show All 448 Lines • ▼ Show 20 Linespublic:
/// 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 20 Lines • Show All 207 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Breakpoint/BreakpointName.h

Show First 20 Lines • Show All 130 Lines • ▼ Show 20 Lines void MergePermission(const Permissions &incoming,
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 38 Lines

lldb/trunk/include/lldb/Breakpoint/BreakpointResolverName.h

Show First 20 Lines • Show All 81 Lines • ▼ Show 20 Linesprotected:
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_

lldb/trunk/include/lldb/Breakpoint/Watchpoint.h

Show All 25 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 20 Lines • Show All 185 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Core/Debugger.h

Show First 20 Lines • Show All 104 Lines • ▼ Show 20 Linespublic:
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 20 Lines • Show All 183 Lines • ▼ Show 20 Linespublic:
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 20 Lines • Show All 115 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Core/Disassembler.h

Show First 20 Lines • Show All 407 Lines • ▼ Show 20 Lines Disassemble(Debugger &debugger, const ArchSpec &arch, const char *plugin_name,
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 20 Lines • Show All 131 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Core/Mangled.h

Show First 20 Lines • Show All 62 Lines • ▼ Show 20 Linespublic:
/// ///
/// @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 20 Lines • Show All 79 Lines • ▼ Show 20 Linespublic:
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 Linespublic:
/// ///
/// @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 20 Lines • Show All 56 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Core/Module.h

Show First 20 Lines • Show All 287 Lines • ▼ Show 20 Linespublic:
/// 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 40 Linespublic:
/// ///
/// @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 20 Lines • Show All 62 Lines • ▼ Show 20 Linespublic:
/// 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 20 Lines • Show All 42 Lines • ▼ Show 20 Linespublic:
/// ///
/// @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 20 Lines • Show All 91 Lines • ▼ Show 20 Linespublic:
/// @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 20 Lines • Show All 251 Lines • ▼ Show 20 Linespublic:
/// ///
/// @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 20 Lines • Show All 102 Lines • ▼ Show 20 Linespublic:
//---------------------------------------------------------------------- //----------------------------------------------------------------------
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 20 Lines • Show All 126 Lines • ▼ Show 20 Linesprotected:
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_

lldb/trunk/include/lldb/Core/ModuleList.h

Show First 20 Lines • Show All 293 Lines • ▼ Show 20 Linespublic:
/// 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 Linespublic:
/// 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 20 Lines • Show All 51 Lines • ▼ Show 20 Linespublic:
// 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 Linespublic:
/// 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 20 Lines • Show All 135 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Core/ModuleSpec.h

Show First 20 Lines • Show All 118 Lines • ▼ Show 20 Linespublic:
} }
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 20 Lines • Show All 288 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Core/PluginManager.h

Show All 37 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 35 Linespublic:
/// 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_

lldb/trunk/include/lldb/Core/RichManglingContext.h

Show All 27 Lines RichManglingContext() : m_provider(None), m_ipd_buf_size(2048) {
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 20 Lines • Show All 59 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Core/Section.h

Show First 20 Lines • Show All 61 Lines • ▼ Show 20 Linespublic:
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 38 Linespublic:
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 20 Lines • Show All 106 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Core/UserSettingsController.h

Show First 20 Lines • Show All 71 Lines • ▼ Show 20 Linespublic:
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/trunk/include/lldb/Core/ValueObject.h

Show First 20 Lines • Show All 477 Lines • ▼ Show 20 Linespublic:
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 20 Lines • Show All 50 Lines • ▼ Show 20 Linespublic:
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 Linespublic:
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 20 Lines • Show All 357 Lines • ▼ Show 20 Linesprotected:
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 20 Lines • Show All 69 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Core/ValueObjectCast.h

Show All 26 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_

lldb/trunk/include/lldb/Core/ValueObjectChild.h

Show First 20 Lines • Show All 77 Lines • ▼ Show 20 Linesprotected:
// 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_

lldb/trunk/include/lldb/Core/ValueObjectConstResult.h

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 Linespublic:
~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 20 Lines • Show All 54 Lines • ▼ Show 20 Linesprivate:
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_

lldb/trunk/include/lldb/Core/ValueObjectConstResultCast.h

Show All 28 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 31 Lines

lldb/trunk/include/lldb/Core/ValueObjectConstResultChild.h

Show All 32 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 37 Lines

lldb/trunk/include/lldb/Core/ValueObjectRegister.h

Show First 20 Lines • Show All 97 Lines • ▼ Show 20 Linespublic:
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 20 Lines • Show All 73 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Core/ValueObjectSyntheticFilter.h

Show First 20 Lines • Show All 56 Lines • ▼ Show 20 Linespublic:
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 20 Lines • Show All 101 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/DataFormatters/DataVisualization.h

Show First 20 Lines • Show All 69 Lines • ▼ Show 20 Lines#endif
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/trunk/include/lldb/DataFormatters/FormatCache.h

Show First 20 Lines • Show All 65 Lines • ▼ Show 20 Linesprivate:
}; };
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_

lldb/trunk/include/lldb/DataFormatters/FormatManager.h

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Linespublic:
~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 20 Lines • Show All 44 Lines • ▼ Show 20 Lines#endif
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 20 Lines • Show All 74 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/DataFormatters/FormattersContainer.h

Show All 36 Linespublic:
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 20 Lines • Show All 179 Lines • ▼ Show 20 Linesprotected:
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 20 Lines • Show All 94 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/DataFormatters/TypeSynthetic.h

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Linespublic:
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 20 Lines • Show All 46 Lines • ▼ Show 20 Lines SyntheticValueProviderFrontEnd(ValueObject &backend)
: 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 20 Lines • Show All 199 Lines • ▼ Show 20 Lines lldb::ValueObjectSP GetChildAtIndex(size_t idx) override {
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 20 Lines • Show All 81 Lines • ▼ Show 20 Lines public:
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 23 Lines

lldb/trunk/include/lldb/DataFormatters/VectorIterator.h

Show All 25 Linespublic:
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_

lldb/trunk/include/lldb/Expression/ExpressionVariable.h

Show All 32 Linespublic:
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 20 Lines • Show All 92 Lines • ▼ Show 20 Linespublic:
/// ///
/// @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 20 Lines • Show All 43 Lines • ▼ Show 20 Linespublic:
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/trunk/include/lldb/Expression/IRExecutionUnit.h

Show First 20 Lines • Show All 105 Lines • ▼ Show 20 Linespublic:
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 20 Lines • Show All 112 Lines • ▼ Show 20 Linesprivate:
//------------------------------------------------------------------ //------------------------------------------------------------------
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 20 Lines • Show All 163 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Interpreter/OptionGroupPlatform.h

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Linespublic:
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_

lldb/trunk/include/lldb/Interpreter/OptionValueDictionary.h

Show First 20 Lines • Show All 51 Lines • ▼ Show 20 Linespublic:
} }
//--------------------------------------------------------------------- //---------------------------------------------------------------------
// 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_

lldb/trunk/include/lldb/Interpreter/OptionValueProperties.h

Show All 20 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 Linespublic:
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 20 Lines • Show All 81 Lines • ▼ Show 20 Lines bool SetPropertyAtIndexAsFileSpec(const ExecutionContext *exe_ctx,
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/trunk/include/lldb/Interpreter/Property.h

Show All 31 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 31 Lines

lldb/trunk/include/lldb/Symbol/ClangASTContext.h

Show First 20 Lines • Show All 162 Lines • ▼ Show 20 Lines static CompilerType GetBuiltinTypeForEncodingAndBitSize(
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 Linespublic:
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 if (type_name.GetLength()) {
} }
} }
} }
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 20 Lines • Show All 481 Lines • ▼ Show 20 Linespublic:
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 20 Lines • Show All 324 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Symbol/ClangASTImporter.h

Show First 20 Lines • Show All 181 Lines • ▼ Show 20 Linespublic:
// 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 20 Lines • Show All 149 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Symbol/CompilerType.h

Show First 20 Lines • Show All 296 Lines • ▼ Show 20 Linespublic:
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 20 Lines • Show All 119 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Symbol/DeclVendor.h

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Linespublic:
/// @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/trunk/include/lldb/Symbol/Function.h

Show First 20 Lines • Show All 49 Lines • ▼ Show 20 Linespublic:
/// @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 20 Lines • Show All 118 Lines • ▼ Show 20 Linespublic:
/// @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 20 Lines • Show All 469 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Symbol/Symbol.h

Show All 36 Lines Symbol(uint32_t symID, const Mangled &mangled, lldb::SymbolType type,
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 20 Lines • Show All 74 Lines • ▼ Show 20 Linespublic:
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 20 Lines • Show All 132 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Symbol/SymbolContext.h

Show First 20 Lines • Show All 243 Lines • ▼ Show 20 Linespublic:
/// @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 20 Lines • Show All 305 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Symbol/SymbolFile.h

Show First 20 Lines • Show All 172 Lines • ▼ Show 20 Lines virtual uint32_t ResolveSymbolContext(const Address &so_addr,
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 27 Lines

lldb/trunk/include/lldb/Symbol/SymbolVendor.h

Show First 20 Lines • Show All 74 Lines • ▼ Show 20 Lines virtual uint32_t ResolveSymbolContext(const Address &so_addr,
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 20 Lines • Show All 60 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Symbol/Symtab.h

Show First 20 Lines • Show All 70 Lines • ▼ Show 20 Lines uint32_t AppendSymbolIndexesWithTypeAndFlagsValue(
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 20 Lines • Show All 83 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Symbol/Type.h

Show All 21 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 20 Lines • Show All 50 Lines • ▼ Show 20 Linespublic:
// 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 Linespublic:
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 20 Lines • Show All 322 Lines • ▼ Show 20 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 36 Linespublic:
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 20 Lines • Show All 55 Lines • ▼ Show 20 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 32 Lines

lldb/trunk/include/lldb/Symbol/TypeList.h

Show All 27 Linespublic:
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 30 Lines

lldb/trunk/include/lldb/Symbol/TypeMap.h

Show All 24 Linespublic:
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 35 Lines

lldb/trunk/include/lldb/Symbol/TypeSystem.h

Show First 20 Lines • Show All 277 Lines • ▼ Show 20 Lines virtual lldb::Encoding GetEncoding(lldb::opaque_compiler_type_t type,
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 20 Lines • Show All 228 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Symbol/Variable.h

Show First 20 Lines • Show All 51 Lines • ▼ Show 20 Linespublic:
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 20 Lines • Show All 71 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Symbol/VariableList.h

Show All 32 Linespublic:
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 34 Lines

lldb/trunk/include/lldb/Target/ABI.h

Show First 20 Lines • Show All 122 Lines • ▼ Show 20 Lines virtual lldb::addr_t FixCodeAddress(lldb::addr_t pc) {
// 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 18 Lines

lldb/trunk/include/lldb/Target/MemoryRegionInfo.h

Show All 38 Linespublic:
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 20 Lines • Show All 97 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Target/ObjCLanguageRuntime.h

Show First 20 Lines • Show All 194 Lines • ▼ Show 20 Linespublic:
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 36 Linespublic:
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 20 Lines • Show All 99 Lines • ▼ Show 20 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_

lldb/trunk/include/lldb/Target/PathMappingList.h

Show All 28 Linespublic:
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 Linespublic:
/// ///
/// @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_

lldb/trunk/include/lldb/Target/Platform.h

Show First 20 Lines • Show All 102 Lines • ▼ Show 20 Linespublic:
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 Linespublic:
/// 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 20 Lines • Show All 364 Lines • ▼ Show 20 Linespublic:
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 20 Lines • Show All 591 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Target/Process.h

Show First 20 Lines • Show All 443 Lines • ▼ Show 20 Lines class ProcessEventData : public EventData {
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 20 Lines • Show All 2,128 Lines • ▼ Show 20 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 20 Lines • Show All 198 Lines • ▼ Show 20 Linesprotected:
/// 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 20 Lines • Show All 263 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Target/StackFrameRecognizer.h

Show First 20 Lines • Show All 94 Lines • ▼ Show 20 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 20 Lines • Show All 53 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Target/StructuredDataPlugin.h

Show First 20 Lines • Show All 64 Lines • ▼ Show 20 Linespublic:
/// ///
/// @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 Linespublic:
/// ///
/// @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 Linespublic:
/// 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 40 Lines

lldb/trunk/include/lldb/Target/Target.h

Show First 20 Lines • Show All 456 Lines • ▼ Show 20 Linespublic:
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 20 Lines • Show All 199 Lines • ▼ Show 20 Linespublic:
// 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 20 Lines • Show All 409 Lines • ▼ Show 20 Lines void ApplyNameToBreakpoints(BreakpointName &bp_name);
// 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 20 Lines • Show All 241 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Target/Thread.h

Show First 20 Lines • Show All 85 Lines • ▼ Show 20 Lines public:
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 20 Lines • Show All 1,266 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Utility/ArchSpec.h

Show First 20 Lines • Show All 345 Lines • ▼ Show 20 Linespublic:
//------------------------------------------------------------------ //------------------------------------------------------------------
/// 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 20 Lines • Show All 251 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Utility/Broadcaster.h

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 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 20 Lines • Show All 57 Lines • ▼ Show 20 Linesprivate:
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 20 Lines • Show All 206 Lines • ▼ Show 20 Linespublic:
} }
//------------------------------------------------------------------ //------------------------------------------------------------------
/// 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 20 Lines • Show All 235 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Utility/ConstString.h

Show First 20 Lines • Show All 145 Lines • ▼ Show 20 Linespublic:
/// 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 20 Lines • Show All 68 Lines • ▼ Show 20 Linespublic:
/// @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 Linespublic:
/// 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 20 Lines • Show All 63 Lines • ▼ Show 20 Linespublic:
/// @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 20 Lines • Show All 70 Lines • ▼ Show 20 Linesprotected:
// 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_

lldb/trunk/include/lldb/Utility/Event.h

Show All 39 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 Linespublic:
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 EventDataStructuredData(const lldb::ProcessSP &process_sp,
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 Linespublic:
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 20 Lines • Show All 80 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Utility/FileSpec.h

Show First 20 Lines • Show All 280 Lines • ▼ Show 20 Linespublic:
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 20 Lines • Show All 220 Lines • Show Last 20 Lines

lldb/trunk/include/lldb/Utility/Log.h

Show First 20 Lines • Show All 109 Lines • ▼ Show 20 Lines EnableLogChannel(const std::shared_ptr<llvm::raw_ostream> &log_stream_sp,
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 20 Lines • Show All 117 Lines • Show Last 20 Lines

lldb/trunk/source/API/SBType.cpp

Show First 20 Lines • Show All 428 Lines • ▼ Show 20 Lines LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeEnumMemberList, SBType,
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 20 Lines • Show All 434 Lines • Show Last 20 Lines

lldb/trunk/source/Breakpoint/Breakpoint.cpp

Show All 29 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 20 Lines • Show All 920 Lines • ▼ Show 20 Linesvoid Breakpoint::GetDescription(Stream *s, lldb::DescriptionLevel level,
} }
} }
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 20 Lines • Show All 59 Lines • ▼ Show 20 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 20 Lines • Show All 60 Lines • Show Last 20 Lines

lldb/trunk/source/Breakpoint/BreakpointName.cpp

Show All 22 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 20 Lines • Show All 47 Lines • Show Last 20 Lines

lldb/trunk/source/Breakpoint/BreakpointResolverName.cpp

Show First 20 Lines • Show All 211 Lines • ▼ Show 20 Lines options_dict_sp->AddStringItem(
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 20 Lines • Show All 201 Lines • Show Last 20 Lines

lldb/trunk/source/Breakpoint/Watchpoint.cpp

Show First 20 Lines • Show All 319 Lines • ▼ Show 20 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 38 Lines

lldb/trunk/source/Commands/CommandObjectSource.cpp

Show First 20 Lines • Show All 188 Lines • ▼ Show 20 Lines for (uint32_t i = 0; i < num_scs; ++i) {
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 if (cu) {
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 20 Lines • Show All 522 Lines • ▼ Show 20 Lines const char *GetRepeatCommand(Args &current_command_args,
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 20 Lines • Show All 104 Lines • ▼ Show 20 Linesprotected:
// 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 size_t FindMatchingFunctions(Target *target, ConstString name,
} 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 20 Lines • Show All 367 Lines • Show Last 20 Lines

lldb/trunk/source/Commands/CommandObjectType.cpp

Show First 20 Lines • Show All 46 Lines • ▼ Show 20 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 20 Lines • Show All 3,132 Lines • Show Last 20 Lines

lldb/trunk/source/Core/Debugger.cpp

Show First 20 Lines • Show All 705 Lines • ▼ Show 20 Lines for (pos = g_debugger_list_ptr->begin(); pos != end; ++pos) {
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 20 Lines • Show All 1,018 Lines • Show Last 20 Lines

lldb/trunk/source/Core/Disassembler.cpp

Show First 20 Lines • Show All 155 Lines • ▼ Show 20 Lines for (size_t i = 0; i < count; ++i) {
} }
} }
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 20 Lines • Show All 1,282 Lines • Show Last 20 Lines

lldb/trunk/source/Core/Mangled.cpp

Show First 20 Lines • Show All 66 Lines • ▼ Show 20 Linesstatic inline Mangled::ManglingScheme cstring_mangling_scheme(const char *s) {
} }
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 20 Lines • Show All 44 Lines • ▼ Show 20 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 20 Lines • Show All 41 Lines • ▼ Show 20 Lines return ConstString::Compare(
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 20 Lines • Show All 128 Lines • ▼ Show 20 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 20 Lines • Show All 135 Lines • ▼ Show 20 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;
} }

lldb/trunk/source/Core/Module.cpp

Show First 20 Lines • Show All 592 Lines • ▼ Show 20 Linesuint32_t Module::ResolveSymbolContextsForFileSpec(
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 for (size_t i = 0; i < num_compile_units; ++i) {
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 20 Lines • Show All 143 Lines • ▼ Show 20 Lines while (i < sc_list.GetSize()) {
} }
} }
} }
++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 20 Lines • Show All 131 Lines • ▼ Show 20 Lines for (size_t n = 0; n < resolver.GetNumberOfAddresses(); n++) {
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 20 Lines • Show All 58 Lines • ▼ Show 20 Lines if (!m_did_load_symbol_vendor.load() && can_create) {
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 20 Lines • Show All 166 Lines • ▼ Show 20 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 20 Lines • Show All 43 Lines • ▼ Show 20 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 if (num_indices > 0) {
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 20 Lines • Show All 253 Lines • ▼ Show 20 Linesbool Module::MatchesModuleSpec(const ModuleSpec &module_ref) {
} }
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 25 Lines

lldb/trunk/source/Core/ModuleList.cpp

Show First 20 Lines • Show All 338 Lines • ▼ Show 20 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 if (name_type_mask & eFunctionNameTypeAuto) {
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 20 Lines • Show All 42 Lines • ▼ Show 20 Linessize_t ModuleList::FindCompileUnits(const FileSpec &path, bool append,
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 20 Lines • Show All 62 Lines • ▼ Show 20 Lines for (pos = m_modules.begin(); pos != end; ++pos) {
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 20 Lines • Show All 510 Lines • Show Last 20 Lines

lldb/trunk/source/Core/PluginManager.cpp

Show First 20 Lines • Show All 213 Lines • ▼ Show 20 Linesstatic std::recursive_mutex &GetABIInstancesMutex() {
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 LinesABICreateInstance PluginManager::GetABICreateCallbackAtIndex(uint32_t idx) {
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 Linesstatic std::mutex &GetArchitectureMutex() {
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 36 Linesstatic std::recursive_mutex &GetDisassemblerMutex() {
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 LinesPluginManager::GetDisassemblerCreateCallbackAtIndex(uint32_t idx) {
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 LinesPluginManager::GetDynamicLoaderCreateCallbackAtIndex(uint32_t idx) {
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 LinesPluginManager::GetJITLoaderCreateCallbackAtIndex(uint32_t idx) {
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 LinesPluginManager::GetEmulateInstructionCreateCallbackAtIndex(uint32_t idx) {
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 LinesPluginManager::GetOperatingSystemCreateCallbackAtIndex(uint32_t idx) {
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 Linesstatic std::recursive_mutex &GetLanguageMutex() {
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 LinesPluginManager::GetLanguageCreateCallbackAtIndex(uint32_t idx) {
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 37 LinesPluginManager::GetLanguageRuntimeGetCommandObjectAtIndex(uint32_t idx) {
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 LinesPluginManager::GetSystemRuntimeCreateCallbackAtIndex(uint32_t idx) {
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 20 Lines • Show All 50 Lines • ▼ Show 20 LinesPluginManager::GetObjectFileGetModuleSpecificationsCallbackAtIndex(
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 39 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 LinesPluginManager::GetObjectContainerCreateCallbackAtIndex(uint32_t idx) {
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 33 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 20 Lines • Show All 44 Lines • ▼ Show 20 LinesPluginManager::GetPlatformCreateCallbackAtIndex(uint32_t idx) {
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 20 Lines • Show All 41 Lines • ▼ Show 20 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 20 Lines • Show All 42 Lines • ▼ Show 20 LinesPluginManager::GetProcessCreateCallbackAtIndex(uint32_t idx) {
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 20 Lines • Show All 79 Lines • ▼ Show 20 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 LinesPluginManager::GetStructuredDataPluginCreateCallbackAtIndex(uint32_t idx) {
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 38 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 LinesPluginManager::GetSymbolFileCreateCallbackAtIndex(uint32_t idx) {
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 Linesstatic std::recursive_mutex &GetSymbolVendorMutex() {
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 LinesPluginManager::GetSymbolVendorCreateCallbackAtIndex(uint32_t idx) {
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 LinesPluginManager::GetUnwindAssemblyCreateCallbackAtIndex(uint32_t idx) {
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 LinesPluginManager::GetMemoryHistoryCreateCallbackAtIndex(uint32_t idx) {
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 20 Lines • Show All 42 Lines • ▼ Show 20 Lines InstrumentationRuntimeInstances &instances =
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 Linesstatic std::recursive_mutex &GetTypeSystemMutex() {
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 LinesPluginManager::GetTypeSystemCreateCallbackAtIndex(uint32_t idx) {
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 LinesPluginManager::GetTypeSystemEnumerateSupportedLanguagesCallbackAtIndex(
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 LinesREPLCreateInstance PluginManager::GetREPLCreateCallbackAtIndex(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].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 20 Lines • Show All 80 Lines • ▼ Show 20 Lines // Initialize the StructuredDataPlugin plugins
} }
} }
} }
// 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 Linesstatic lldb::OptionValuePropertiesSP GetDebuggerPropertyForPlugins(
} }
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 if (parent_properties_sp) {
} }
} }
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);
} }

lldb/trunk/source/Core/RichManglingContext.cpp

Show All 28 Lines if (m_cxx_method_parser.hasValue()) {
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 20 Lines • Show All 110 Lines • Show Last 20 Lines

lldb/trunk/source/Core/Section.cpp

Show First 20 Lines • Show All 137 Lines • ▼ Show 20 Lines case eSectionTypeDWARFGNUDebugAltLink:
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 20 Lines • Show All 324 Lines • ▼ Show 20 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 20 Lines • Show All 113 Lines • Show Last 20 Lines

lldb/trunk/source/Core/UserSettingsController.cpp

Show First 20 Lines • Show All 88 Lines • ▼ Show 20 LinesProperties::Apropos(llvm::StringRef keyword,
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;
} }

lldb/trunk/source/Core/ValueObject.cpp

Show First 20 Lines • Show All 344 Lines • ▼ Show 20 LinesDataExtractor &ValueObject::GetDataExtractor() {
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 20 Lines • Show All 176 Lines • ▼ Show 20 Lines if (!root) {
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 20 Lines • Show All 51 Lines • ▼ Show 20 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 20 Lines • Show All 1,023 Lines • ▼ Show 20 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 20 Lines • Show All 1,061 Lines • ▼ Show 20 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 20 Lines • Show All 159 Lines • ▼ Show 20 LinesValueObjectSP ValueObject::AddressOf(Status &error) {
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 20 Lines • Show All 480 Lines • Show Last 20 Lines

lldb/trunk/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 20 Lines • Show All 54 Lines • Show Last 20 Lines

lldb/trunk/source/Core/ValueObjectChild.cpp

Show All 22 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 20 Lines • Show All 189 Lines • Show Last 20 Lines

lldb/trunk/source/Core/ValueObjectConstResult.cpp

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 LinesValueObjectConstResult::ValueObjectConstResult(ExecutionContextScope *exe_scope,
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 LinesValueObjectConstResult::ValueObjectConstResult(ExecutionContextScope *exe_scope,
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 20 Lines • Show All 110 Lines • Show Last 20 Lines

lldb/trunk/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 30 Lines

lldb/trunk/source/Core/ValueObjectConstResultChild.cpp

Show All 17 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 40 Lines

lldb/trunk/source/Core/ValueObjectRegister.cpp

Show First 20 Lines • Show All 180 Lines • ▼ Show 20 Lines if (m_reg_ctx_sp && m_reg_set) {
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 20 Lines • Show All 144 Lines • Show Last 20 Lines

lldb/trunk/source/Core/ValueObjectSyntheticFilter.cpp

Show All 30 Lines DummySyntheticFrontEnd(ValueObject &backend)
: 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 20 Lines • Show All 230 Lines • ▼ Show 20 Lines if (log)
"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 20 Lines • Show All 90 Lines • Show Last 20 Lines

lldb/trunk/source/DataFormatters/DataVisualization.cpp

Show First 20 Lines • Show All 90 Lines • ▼ Show 20 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();
} }

lldb/trunk/source/DataFormatters/FormatCache.cpp

Show First 20 Lines • Show All 103 Lines • ▼ Show 20 LinesFormatCache::FormatCache()
: 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();
} }

lldb/trunk/source/DataFormatters/FormatManager.cpp

Show First 20 Lines • Show All 425 Lines • ▼ Show 20 Lines for (const auto &entry : m_language_categories_map) {
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 20 Lines • Show All 125 Lines • ▼ Show 20 Lines if (child_sp->GetNumChildren()) {
// 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 20 Lines • Show All 479 Lines • Show Last 20 Lines

lldb/trunk/source/DataFormatters/TypeSynthetic.cpp

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Linesbool TypeFilterImpl::SetExpressionPathAtIndex(size_t i,
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 20 Lines • Show All 120 Lines • ▼ Show 20 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 23 Lines

lldb/trunk/source/DataFormatters/VectorType.cpp

Show First 20 Lines • Show All 227 Lines • ▼ Show 20 Lines m_child_type = ::GetCompilerTypeForFormat(
: 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 20 Lines • Show All 53 Lines • Show Last 20 Lines

lldb/trunk/source/Expression/ExpressionVariable.cpp

Show All 24 Lines if (byte_size > 0) {
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 20 Lines • Show All 51 Lines • Show Last 20 Lines

lldb/trunk/source/Expression/IRExecutionUnit.cpp

Show First 20 Lines • Show All 206 Lines • ▼ Show 20 Linesstatic void ReportInlineAsmError(const llvm::SMDiagnostic &diagnostic,
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 20 Lines • Show All 177 Lines • ▼ Show 20 Linesvoid IRExecutionUnit::GetRunnableInfo(Status &error, lldb::addr_t &func_addr,
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 20 Lines • Show All 232 Lines • ▼ Show 20 Lines if (m_parent.m_reported_allocations) {
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 20 Lines • Show All 45 Lines • ▼ Show 20 Linesstruct IRExecutionUnit::SearchSpec {
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 20 Lines • Show All 162 Lines • ▼ Show 20 Lines for (const SearchSpec &spec : specs) {
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 20 Lines • Show All 294 Lines • Show Last 20 Lines

lldb/trunk/source/Host/common/FileSystem.cpp

Show First 20 Lines • Show All 299 Lines • ▼ Show 20 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 20 Lines • Show All 142 Lines • Show Last 20 Lines

lldb/trunk/source/Interpreter/OptionValueDictionary.cpp

Show First 20 Lines • Show All 270 Lines • ▼ Show 20 LinesStatus OptionValueDictionary::SetSubValue(const ExecutionContext *exe_ctx,
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/trunk/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 20 Lines • Show All 104 Lines • ▼ Show 20 Lines else {
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 20 Lines • Show All 424 Lines • ▼ Show 20 Lines if (property) {
} }
} }
} }
} }
} }
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();
} }

lldb/trunk/source/Interpreter/Property.cpp

Show First 20 Lines • Show All 212 Lines • ▼ Show 20 Lines // string value
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 20 Lines • Show All 70 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 53 Lines • ▼ Show 20 Linesstatic lldb::addr_t findSymbolAddress(Process *proc, ConstString findName) {
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 20 Lines • Show All 548 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 151 Lines • ▼ Show 20 Lines uint32_t GetAddressByteSize() {
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 20 Lines • Show All 72 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 722 Lines • ▼ Show 20 Lines else
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 20 Lines • Show All 69 Lines • ▼ Show 20 LinesDynamicLoaderDarwin::GetStepThroughTrampolinePlan(Thread &thread,
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 20 Lines • Show All 124 Lines • ▼ Show 20 LinesDynamicLoaderDarwin::GetStepThroughTrampolinePlan(Thread &thread,
} }
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 20 Lines • Show All 170 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 192 Lines • ▼ Show 20 Linespublic:
/// @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 20 Lines • Show All 381 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 1,830 Lines • ▼ Show 20 Lines if (parser_cxx_record.IsValid()) {
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 20 Lines • Show All 362 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 132 Lines • ▼ Show 20 Linespublic:
/// ///
/// @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 20 Lines • Show All 88 Lines • ▼ Show 20 Linespublic:
/// ///
/// @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 20 Lines • Show All 178 Lines • ▼ Show 20 Linesprivate:
/// 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 20 Lines • Show All 153 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 303 Lines • ▼ Show 20 Lines if (m_ast_importer_sp) {
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 20 Lines • Show All 98 Lines • ▼ Show 20 Linesbool ClangExpressionDeclMap::AddPersistentVariable(const NamedDecl *decl,
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 20 Lines • Show All 163 Lines • ▼ Show 20 Linesbool ClangExpressionDeclMap::GetFunctionInfo(const NamedDecl *decl,
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 20 Lines • Show All 81 Lines • ▼ Show 20 Lines if (symbol_load_addr == LLDB_INVALID_ADDRESS && process) {
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 20 Lines • Show All 1,521 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 56 Lines • ▼ Show 20 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 20 Lines • Show All 155 Lines • Show Last 20 Lines

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

Show All 25 LinesClangExpressionVariable::ClangExpressionVariable(
: 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;
} }

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

Show First 20 Lines • Show All 72 Lines • ▼ Show 20 Linespublic:
~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 20 Lines • Show All 245 Lines • ▼ Show 20 Lines for (auto &imported_module : cu.GetImportedModules())
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 20 Lines • Show All 353 Lines • Show Last 20 Lines

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

Show All 38 Linespublic:
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 18 Lines

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

Show All 25 Lines : lldb_private::PersistentExpressionState(LLVMCastKind::eKindClang),
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;
} }

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

Show First 20 Lines • Show All 233 Lines • ▼ Show 20 Linesprivate:
/// ///
/// @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 20 Lines • Show All 409 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Linespublic:
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 21 Lines

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

Show First 20 Lines • Show All 453 Lines • ▼ Show 20 Linesvoid JITLoaderGDB::Terminate() {
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/trunk/source/Plugins/Language/CPlusPlus/BlockPointer.cpp

Show First 20 Lines • Show All 143 Lines • ▼ Show 20 Linespublic:
// 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 20 Lines • Show All 45 Lines • Show Last 20 Lines

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

Show All 25 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 20 Lines • Show All 84 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 60 Lines • ▼ Show 20 Linespublic:
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 Linespublic:
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 20 Lines • Show All 53 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 293 Lines • ▼ Show 20 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 20 Lines • Show All 113 Lines • ▼ Show 20 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 20 Lines • Show All 240 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 93 Lines • ▼ Show 20 Linespublic:
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/trunk/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 20 Lines • Show All 82 Lines • Show Last 20 Lines

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

Show All 27 Linespublic:
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 20 Lines • Show All 58 Lines • ▼ Show 20 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);
} }

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

Show First 20 Lines • Show All 105 Lines • ▼ Show 20 Linesprotected:
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 20 Lines • Show All 320 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 178 Lines • ▼ Show 20 Linespublic:
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 20 Lines • Show All 251 Lines • ▼ Show 20 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);
} }

lldb/trunk/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 20 Lines • Show All 53 Lines • Show Last 20 Lines

lldb/trunk/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 29 Lines

lldb/trunk/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 20 Lines • Show All 51 Lines • Show Last 20 Lines

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

Show All 33 Linespublic:
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 20 Lines • Show All 153 Lines • ▼ Show 20 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);
} }

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

Show First 20 Lines • Show All 167 Lines • ▼ Show 20 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 20 Lines • Show All 71 Lines • Show Last 20 Lines

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

Show All 26 Linespublic:
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 20 Lines • Show All 94 Lines • ▼ Show 20 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 20 Lines • Show All 90 Lines • ▼ Show 20 Linesbool lldb_private::formatters::LibcxxVectorBoolSyntheticFrontEnd::Update() {
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/trunk/source/Plugins/Language/CPlusPlus/LibStdcpp.cpp

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 Linespublic:
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 20 Lines • Show All 54 Lines • ▼ Show 20 Lines if (m_pair_sp)
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 20 Lines • Show All 65 Lines • ▼ Show 20 LinesVectorIteratorSyntheticFrontEnd::GetChildAtIndex(size_t idx) {
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 20 Lines • Show All 133 Lines • ▼ Show 20 Lines else
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 20 Lines • Show All 42 Lines • Show Last 20 Lines

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

Show All 28 Linespublic:
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 20 Lines • Show All 44 Lines • ▼ Show 20 LinesLibStdcppTupleSyntheticFrontEnd::GetChildAtIndex(size_t idx) {
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);
} }

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

Show All 28 Linespublic:
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 20 Lines • Show All 78 Lines • ▼ Show 20 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 30 Lines

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

Show First 20 Lines • Show All 929 Lines • ▼ Show 20 Linespublic:
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 20 Lines • Show All 199 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 51 Lines • ▼ Show 20 Linespublic:
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 20 Lines • Show All 168 Lines • ▼ Show 20 Linespublic:
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 20 Lines • Show All 55 Lines • ▼ Show 20 Linespublic:
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 20 Lines • Show All 196 Lines • ▼ Show 20 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 20 Lines • Show All 72 Lines • ▼ Show 20 Lineslldb_private::formatters::GenericNSArrayISyntheticFrontEnd<D32, D64, Inline>::
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 20 Lines • Show All 73 Lines • ▼ Show 20 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 20 Lines • Show All 109 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 105 Lines • ▼ Show 20 Linespublic:
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 Linespublic:
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 public:
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 20 Lines • Show All 287 Lines • ▼ Show 20 Lineslldb_private::formatters::NSDictionaryISyntheticFrontEnd::
~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 20 Lines • Show All 119 Lines • ▼ Show 20 Lineslldb_private::formatters::NSDictionaryISyntheticFrontEnd::GetChildAtIndex(
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 20 Lines • Show All 71 Lines • ▼ Show 20 Lineslldb_private::formatters::GenericNSDictionaryMSyntheticFrontEnd<D32,D64>::
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 20 Lines • Show All 152 Lines • ▼ Show 20 Lineslldb_private::formatters::Foundation1100::
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 20 Lines • Show All 136 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 157 Lines • ▼ Show 20 Lines m_child_sp = CreateValueObjectFromData(
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 39 Lines

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

Show First 20 Lines • Show All 143 Lines • ▼ Show 20 Lines bool Update() override {
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 20 Lines • Show All 47 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 121 Lines • ▼ Show 20 Lines if (descriptor->GetTaggedPointerInfo(&info_bits, &value_bits, &payload)) {
} }
} }
} }
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 20 Lines • Show All 177 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Linespublic:
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 Linespublic:
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 20 Lines • Show All 99 Lines • ▼ Show 20 Linespublic:
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 20 Lines • Show All 146 Lines • ▼ Show 20 Lineslldb_private::formatters::NSSetISyntheticFrontEnd::~NSSetISyntheticFrontEnd() {
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 20 Lines • Show All 138 Lines • ▼ Show 20 Lineslldb_private::formatters::
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 20 Lines • Show All 140 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 52 Lines • ▼ Show 20 Lines bool IsValid(bool strict) const {
// 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 20 Lines • Show All 85 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 113 Lines • ▼ Show 20 Linesbool ObjCLanguage::MethodName::SetName(llvm::StringRef name, bool strict) {
} }
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 if (IsValid(false)) {
} }
} }
} }
} }
} }
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 20 Lines • Show All 862 Lines • Show Last 20 Lines

lldb/trunk/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 17 Lines

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

Show First 20 Lines • Show All 169 Lines • ▼ Show 20 LinesAppleObjCDeclVendor::GetDeclForISA(ObjCLanguageRuntime::ObjCISA isa) {
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 20 Lines • Show All 355 Lines • ▼ Show 20 Lines if (log) {
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 20 Lines • Show All 102 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 73 Lines • ▼ Show 20 Linespublic:
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 20 Lines • Show All 254 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 1,945 Lines • ▼ Show 20 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 20 Lines • Show All 700 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 239 Lines • ▼ Show 20 Linesstruct RSScriptGroupDescriptor {
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 Linespublic:
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 20 Lines • Show All 73 Lines • ▼ Show 20 Lines bool PlaceBreakpointOnKernel(
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 Linesprotected:
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 20 Lines • Show All 138 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 586 Lines • ▼ Show 20 Lines empirical_type<uint32_t>
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 20 Lines • Show All 83 Lines • ▼ Show 20 Linesstruct RenderScriptRuntime::AllocationDetails {
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 20 Lines • Show All 1,654 Lines • ▼ Show 20 Lines for (uint32_t i = 0; i < var_list.GetSize(); ++i) {
// '#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 20 Lines • Show All 1,214 Lines • ▼ Show 20 Lines if (log)
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 (err.Fail() && log)
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 20 Lines • Show All 224 Lines • ▼ Show 20 Lines if (coord)
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 log->Printf("%s - error setting break name, '%s'.", __FUNCTION__,
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 20 Lines • Show All 1,155 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 130 Lines • ▼ Show 20 Lines public:
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 27 Lines

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

Show First 20 Lines • Show All 163 Lines • ▼ Show 20 Lines if (str == ARMAG) {
// 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 20 Lines • Show All 338 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 2,170 Lines • ▼ Show 20 Lines if (symbol_type != eSymbolTypeUndefined) {
// 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 20 Lines • Show All 127 Lines • ▼ Show 20 Lines for (i = 0; i < num_symbols; ++i) {
} }
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 20 Lines • Show All 1,159 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 187 Lines • ▼ Show 20 Lines void ProcessSegmentCommand(const llvm::MachO::load_command &load_cmd,
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_

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

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 921 Lines • ▼ Show 20 Lines if (ParseHeader(data, &data_offset, header)) {
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 20 Lines • Show All 1,447 Lines • ▼ Show 20 Lines if (!have_strtab_data) {
} }
} 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 20 Lines • Show All 3,937 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 71 Lines • ▼ Show 20 Linesprotected:
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_

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

Show First 20 Lines • Show All 740 Lines • ▼ Show 20 Lines for (size_t i = 0; i < num_sets; ++i) {
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;
} }

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

Show First 20 Lines • Show All 490 Lines • ▼ Show 20 Linespublic:
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 20 Lines • Show All 118 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 3,948 Lines • ▼ Show 20 LinesStatus GDBRemoteCommunicationClient::SendSignalsToIgnore(
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 20 Lines • Show All 46 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 228 Lines • ▼ Show 20 Linespublic:
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 20 Lines • Show All 237 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 4,207 Lines • ▼ Show 20 Lines if (m_gdb_comm.SendPacketAndWaitForResponse(packet.GetString(), response,
} }
} }
} }
} }
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 20 Lines • Show All 1,207 Lines • Show Last 20 Lines

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

Show All 26 Linespublic:
// ------------------------------------------------------------------------- // -------------------------------------------------------------------------
// 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 Linespublic:
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 20 Lines • Show All 58 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 181 Lines • ▼ Show 20 Linesconst char *const s_filter_attributes[] = {
"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 StructuredData::ObjectSP Serialize() const {
// 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 20 Lines • Show All 52 Lines • ▼ Show 20 Lines if (!regex.IsValid()) {
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 if (op_arg.empty()) {
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 20 Lines • Show All 532 Lines • ▼ Show 20 Lines if (!target || !process_sp) {
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 20 Lines • Show All 162 Lines • ▼ Show 20 Lines PluginManager::RegisterPlugin(
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 20 Lines • Show All 122 Lines • ▼ Show 20 Lines events->ForEach(
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 20 Lines • Show All 670 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 71 Lines • ▼ Show 20 Linespublic:
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 uint32_t ResolveSymbolContext(const FileSpec &file_spec, uint32_t line,
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 20 Lines • Show All 68 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 280 Lines • ▼ Show 20 Lines for (size_t i = 0, size = GetNumCompileUnits(); i < size; ++i) {
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 20 Lines • Show All 162 Lines • Show Last 20 Lines

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

Show All 20 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/trunk/source/Plugins/SymbolFile/DWARF/NameToDIE.cpp

Show All 19 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 40 Lines

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

Show First 20 Lines • Show All 163 Lines • ▼ Show 20 Linespublic:
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 20 Lines • Show All 164 Lines • ▼ Show 20 Linesprotected:
// 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 20 Lines • Show All 81 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 361 Lines • ▼ Show 20 Lines : SymbolFile(objfile), UserID(uint64_t(DW_INVALID_OFFSET)
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 20 Lines • Show All 1,636 Lines • ▼ Show 20 Linesbool SymbolFileDWARF::DeclContextMatchesThisSymbolFile(
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 20 Lines • Show All 209 Lines • ▼ Show 20 Lines if (dwarf_ast) {
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 20 Lines • Show All 128 Lines • ▼ Show 20 Linesvoid SymbolFileDWARF::GetMangledNamesForFunction(
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 20 Lines • Show All 132 Lines • ▼ Show 20 Lines for (size_t i = 0; i < num_die_matches; ++i) {
} }
} }
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 20 Lines • Show All 120 Lines • ▼ Show 20 Lines while (die) {
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 if (m_supports_DW_AT_APPLE_objc_complete_type == eLazyBoolNo &&
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 20 Lines • Show All 1,114 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 92 Lines • ▼ Show 20 Lines uint32_t ResolveSymbolContext(const lldb_private::Address &so_addr,
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 20 Lines • Show All 109 Lines • ▼ Show 20 Linesprotected:
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 20 Lines • Show All 114 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 54 Lines • ▼ Show 20 LinesSymbolFileDWARFDebugMap::CompileUnitInfo::GetFileRangeMap(
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 20 Lines • Show All 727 Lines • ▼ Show 20 Lines if (resolve) {
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 20 Lines • Show All 145 Lines • ▼ Show 20 Lines if (sc.function) {
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 20 Lines • Show All 103 Lines • ▼ Show 20 Lines ForEachSymbolFile([&](SymbolFileDWARF *oso_dwarf) -> bool {
} }
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 20 Lines • Show All 47 Lines • ▼ Show 20 Lines if (!must_be_implementation) {
}); });
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 20 Lines • Show All 221 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 63 Lines • ▼ Show 20 Linesprotected:
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_

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

Show First 20 Lines • Show All 101 Lines • ▼ Show 20 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 20 Lines • Show All 51 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 74 Lines • ▼ Show 20 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/trunk/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.h

Show First 20 Lines • Show All 94 Lines • ▼ Show 20 Linespublic:
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 Linespublic:
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 20 Lines • Show All 83 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 1,144 Lines • ▼ Show 20 Linessize_t SymbolFileNativePDB::ParseBlocksRecursive(Function &func) {
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 for (const SymbolAndOffset &result : results) {
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 20 Lines • Show All 315 Lines • ▼ Show 20 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/trunk/source/Plugins/SymbolFile/PDB/SymbolFilePDB.h

Show First 20 Lines • Show All 104 Lines • ▼ Show 20 Linespublic:
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 20 Lines • Show All 93 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 1,040 Lines • ▼ Show 20 Lines if (auto results = pdb_symbol.findAllChildren()) {
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 20 Lines • Show All 183 Lines • ▼ Show 20 Linesvoid SymbolFilePDB::CacheFunctionNames() {
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 20 Lines • Show All 123 Lines • ▼ Show 20 Lines symtab.AddSymbol(
)); ));
} }
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 20 Lines • Show All 225 Lines • ▼ Show 20 LinesPDBASTParser *SymbolFilePDB::GetPDBAstParser() {
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 20 Lines • Show All 365 Lines • Show Last 20 Lines

lldb/trunk/source/Symbol/ClangASTContext.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 1,059 Lines • ▼ Show 20 Lines if (bit_size && !(bit_size & 0x7u))
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 20 Lines • Show All 49 Lines • ▼ Show 20 Lines if (name) {
}); });
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 20 Lines • Show All 1,124 Lines • ▼ Show 20 Lines if (is_vector) {
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 20 Lines • Show All 3,425 Lines • ▼ Show 20 Lines num_children =
.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 20 Lines • Show All 63 Lines • ▼ Show 20 Lines if (type) {
} }
} }
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 20 Lines • Show All 4,536 Lines • Show Last 20 Lines

lldb/trunk/source/Symbol/CompilerType.cpp

Show First 20 Lines • Show All 547 Lines • ▼ Show 20 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 20 Lines • Show All 518 Lines • Show Last 20 Lines

lldb/trunk/source/Symbol/Function.cpp

Show All 25 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 20 Lines • Show All 537 Lines • Show Last 20 Lines

lldb/trunk/source/Symbol/LocateSymbolFile.cpp

Show First 20 Lines • Show All 264 Lines • ▼ Show 20 Lines if (symbol_filename && symbol_filename[0]) {
FileSpecList debug_file_search_paths = default_search_paths; FileSpecList debug_file_search_paths = default_search_paths;
// 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 20 Lines • Show All 108 Lines • Show Last 20 Lines

lldb/trunk/source/Symbol/Symbol.cpp

Show First 20 Lines • Show All 139 Lines • ▼ Show 20 Lines if (m_type == eSymbolTypeReExported) {
// 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 20 Lines • Show All 163 Lines • ▼ Show 20 Lines if (!m_type_data_resolved) {
} }
} }
} }
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 20 Lines • Show All 229 Lines • Show Last 20 Lines

lldb/trunk/source/Symbol/SymbolContext.cpp

Show First 20 Lines • Show All 787 Lines • ▼ Show 20 Linesbool SymbolContext::GetAddressRangeFromHereToEndLine(uint32_t end_line,
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 20 Lines • Show All 551 Lines • Show Last 20 Lines

lldb/trunk/source/Symbol/SymbolFile.cpp

Show First 20 Lines • Show All 96 Lines • ▼ Show 20 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 20 Lines

lldb/trunk/source/Symbol/SymbolVendor.cpp

Show First 20 Lines • Show All 256 Lines • ▼ Show 20 Lines if (module_sp) {
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 (module_sp) {
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 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->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 20 Lines • Show All 130 Lines • Show Last 20 Lines

lldb/trunk/source/Symbol/Symtab.cpp

Show First 20 Lines • Show All 619 Lines • ▼ Show 20 Linesvoid Symtab::SortSymbolIndexesByValue(std::vector<uint32_t> &indexes,
// 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 for (size_t i = 0; i < name_match_count; ++i) {
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 20 Lines • Show All 68 Lines • ▼ Show 20 Lines if (symbol_type == eSymbolTypeAny ||
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 Linessize_t Symtab::FindAllSymbolsMatchingRexExAndType(
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 20 Lines • Show All 210 Lines • ▼ Show 20 Lines if (num_indices > 0) {
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 20 Lines • Show All 94 Lines • Show Last 20 Lines

lldb/trunk/source/Symbol/Type.cpp

Show First 20 Lines • Show All 101 Lines • ▼ Show 20 Lines if (!m_type_sp) {
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 : std::enable_shared_from_this<Type>(rhs), UserID(rhs), m_name(rhs.m_name),
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 20 Lines • Show All 102 Lines • ▼ Show 20 Linesvoid Type::Dump(Stream *s, bool show_context) {
} }
// //
// 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 20 Lines • Show All 445 Lines • ▼ Show 20 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 20 Lines • Show All 353 Lines • ▼ Show 20 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)
{} {}

lldb/trunk/source/Symbol/TypeList.cpp

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 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 20 Lines • Show All 153 Lines • Show Last 20 Lines

lldb/trunk/source/Symbol/TypeMap.cpp

Show First 20 Lines • Show All 71 Lines • ▼ Show 20 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 20 Lines • Show All 168 Lines • Show Last 20 Lines

lldb/trunk/source/Symbol/TypeSystem.cpp

Show First 20 Lines • Show All 86 Lines • ▼ Show 20 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 20 Lines • Show All 159 Lines • Show Last 20 Lines

lldb/trunk/source/Symbol/Variable.cpp

Show First 20 Lines • Show All 68 Lines • ▼ Show 20 LinesConstString Variable::GetName() const {
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 20 Lines • Show All 687 Lines • Show Last 20 Lines

lldb/trunk/source/Symbol/VariableList.cpp

Show First 20 Lines • Show All 67 Lines • ▼ Show 20 Linesuint32_t VariableList::FindVariableIndex(const 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->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 20 Lines • Show All 81 Lines • Show Last 20 Lines

lldb/trunk/source/Target/ABI.cpp

Show All 33 Lines if (abi_sp)
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 20 Lines • Show All 162 Lines • Show Last 20 Lines

lldb/trunk/source/Target/ObjCLanguageRuntime.cpp

Show First 20 Lines • Show All 147 Lines • ▼ Show 20 Lines if ((value % 2) == 1 && allow_tagged)
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 20 Lines • Show All 48 Lines • ▼ Show 20 LinesObjCLanguageRuntime::GetActualTypeName(ObjCLanguageRuntime::ObjCISA isa) {
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 20 Lines • Show All 146 Lines • Show Last 20 Lines

lldb/trunk/source/Target/PathMappingList.cpp

Show All 24 Linesnamespace {
// 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 if (this != &rhs) {
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 20 Lines • Show All 81 Lines • ▼ Show 20 Lines if (orig_ref.consume_front(prefix_ref)) {
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;
} }

lldb/trunk/source/Target/Platform.cpp

Show First 20 Lines • Show All 174 Lines • ▼ Show 20 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 20 Lines • Show All 70 Lines • ▼ Show 20 Lines if (ObjectFile::GetModuleSpecifications(module_file_spec, 0, 0,
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 20 Lines • Show All 1,639 Lines • Show Last 20 Lines

lldb/trunk/source/Target/Process.cpp

Show First 20 Lines • Show All 78 Lines • ▼ Show 20 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 20 Lines • Show All 3,814 Lines • ▼ Show 20 LinesProcess::ProcessEventData::ProcessEventData(const ProcessSP &process_sp,
: 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 20 Lines • Show All 306 Lines • ▼ Show 20 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 20 Lines • Show All 1,607 Lines • ▼ Show 20 Lines if (region_info.GetMapped() == MemoryRegionInfo::eYes) {
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 20 Lines • Show All 122 Lines • Show Last 20 Lines

lldb/trunk/source/Target/StackFrameRecognizer.cpp

Show First 20 Lines • Show All 49 Lines • ▼ Show 20 Lines return RecognizedStackFrameSP(
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 20 Lines • Show All 86 Lines • ▼ Show 20 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 26 Lines

lldb/trunk/source/Target/StructuredDataPlugin.cpp

Show All 26 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 24 Lines

lldb/trunk/source/Target/Target.cpp

Show First 20 Lines • Show All 695 Lines • ▼ Show 20 Linesvoid Target::AddNameToBreakpoint(BreakpointSP &bp_sp,
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 20 Lines • Show All 1,658 Lines • ▼ Show 20 LinesExpressionResults Target::EvaluateExpression(
} }
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 20 Lines • Show All 1,055 Lines • ▼ Show 20 Linesenum {
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 20 Lines • Show All 687 Lines • ▼ Show 20 LinesTarget::TargetEventData::TargetEventData(const lldb::TargetSP &target_sp)
: 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 32 Lines

lldb/trunk/source/Target/Thread.cpp

Show First 20 Lines • Show All 86 Lines • ▼ Show 20 Linesenum {
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 20 Lines • Show All 66 Lines • ▼ Show 20 Linesuint64_t ThreadProperties::GetMaxBacktraceDepth() const {
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 20 Lines • Show All 2,047 Lines • Show Last 20 Lines

lldb/trunk/source/Utility/ArchSpec.cpp

Show First 20 Lines • Show All 757 Lines • ▼ Show 20 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 20 Lines • Show All 723 Lines • Show Last 20 Lines

lldb/trunk/source/Utility/ConstString.cpp

Show First 20 Lines • Show All 200 Lines • ▼ Show 20 LinesConstString::ConstString(const char *cstr)
: 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 35 Linesvoid ConstString::SetCString(const char *cstr) {
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 20 Lines

lldb/trunk/source/Utility/Event.cpp

Show First 20 Lines • Show All 114 Lines • ▼ Show 20 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 20 Lines • Show All 70 Lines • ▼ Show 20 Lines : EventData(), m_process_sp(process_sp), m_object_sp(object_sp),
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 20 Lines • Show All 65 Lines • ▼ Show 20 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;
} }

lldb/trunk/source/Utility/FileSpec.cpp

Show First 20 Lines • Show All 395 Lines • ▼ Show 20 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 20 Lines • Show All 193 Lines • Show Last 20 Lines

lldb/trunk/source/Utility/Listener.cpp

Show First 20 Lines • Show All 232 Lines • ▼ Show 20 Lines EventMatcher(Broadcaster *broadcaster, const ConstString *broadcaster_names,
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 20 Lines • Show All 218 Lines • Show Last 20 Lines

lldb/trunk/unittests/Core/MangledTest.cpp

Show All 25 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 20 Lines • Show All 118 Lines • Show Last 20 Lines

lldb/trunk/www/architecture/varformats.html

Show First 20 Lines • Show All 112 Lines • ▼ Show 20 Lines <div id="middle">
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 name) = 0;
</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 20 Lines • Show All 195 Lines • Show Last 20 Lines