This is an archive of the discontinued LLVM Phabricator instance.

Differential D104041

[lldb] Replace default bodies of special member functions with = default;
ClosedPublic

Authored by JDevlieghere on Jun 10 2021, 9:19 AM.

Details

Reviewers
shafik
teemperor
Group Reviewers
Restricted Project
Commits
rGfd2433e139f7: [lldb] Replace default bodies of special member functions with = default;
Summary

Replace default bodies of special member functions with = default;

$ run-clang-tidy.py -header-filter='lldb' -checks='-*,modernize-use-equals-default' -fix ,

https://clang.llvm.org/extra/clang-tidy/checks/modernize-use-equals-default.html

Diff Detail

Event Timeline

JDevlieghere created this revision.Jun 10 2021, 9:19 AM
Herald added a reviewer: shafik. · View Herald TranscriptJun 10 2021, 9:20 AM
Herald added a reviewer: shafik. · View Herald Transcript
Herald added subscribers: usaxena95, arphaman, atanasyan and 3 others. · View Herald Transcript
JDevlieghere requested review of this revision.Jun 10 2021, 9:20 AM
Herald added subscribers: MaskRay, aheejin. · View Herald TranscriptJun 10 2021, 9:20 AM
JDevlieghere added inline comments.Jun 10 2021, 9:21 AM
lldb/include/lldb/Interpreter/CommandInterpreter.h
103–105

Interesting, I would've expected clang-format to get this.

JDevlieghere updated this revision to Diff 351197.Jun 10 2021, 9:24 AM
Harbormaster completed remote builds in B108639: Diff 351197.Jun 10 2021, 9:50 AM
teemperor added a subscriber: teemperor.Jun 10 2021, 9:50 AM

LGTM beside some minor formatting bugs that got exacerbated by the clang-tidy run. I got bored of writing 'format' everywhere so I translated every comment into a different language via Google translate. I'll already accept this as this is easy to fix.

lldb/include/lldb/Expression/ExpressionParser.h
45

Please drop that when you land it.

lldb/include/lldb/Target/Process.h
227

format

lldb/include/lldb/Target/StackFrameRecognizer.h
41

please remove that pointy boy

67

and that one too

lldb/source/Interpreter/OptionValueFileColonLine.cpp
24

formaat

lldb/source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.h
219

formato

lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.h
111

formatione

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

goodbye

lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetPendingItemsHandler.h
58

フォーマット

lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetQueuesHandler.h
55

хэлбэр хэмжээ

lldb/source/Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.h
193

formoup

215

isimo

JDevlieghere updated this revision to Diff 351215.Jun 10 2021, 10:52 AM
JDevlieghere marked 12 inline comments as done.

Mi traktis la komentojn

lldb/include/lldb/Expression/ExpressionParser.h
45

Dropped.

lldb/include/lldb/Target/Process.h
227

formatted

lldb/include/lldb/Target/StackFrameRecognizer.h
41

pointy boy gone

67

gone too

lldb/source/Interpreter/OptionValueFileColonLine.cpp
24

doone

lldb/source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.h
219

hecho

lldb/source/Plugins/DynamicLoader/MacOSX-DYLD/DynamicLoaderMacOSXDYLD.h
111

factum

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

ciao

lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetPendingItemsHandler.h
58

完了

lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetQueuesHandler.h
55

хэлбэртэй, хэмжээтэй

lldb/source/Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.h
193

doune

215

isimo sixazululiwe

JDevlieghere updated this revision to Diff 351216.Jun 10 2021, 10:55 AM
Harbormaster completed remote builds in B108653: Diff 351216.Jun 10 2021, 11:23 AM
teemperor accepted this revision.Jun 14 2021, 3:14 AM

Not sure what happened to my accept, but I'll LGTM this again. Thanks!

This revision is now accepted and ready to land.Jun 14 2021, 3:14 AM
shafik added a comment.Jun 14 2021, 9:19 AM

I am sure I could find a bunch of other ends and odds but perhaps you have other checks that will cover these coming up.

lldb/include/lldb/Core/ThreadSafeValue.h
21

We can also default this as well, we can use member initializers for these values.

lldb/include/lldb/Core/UserSettingsController.h
35

I believe this should be defaultable as well.

lldb/include/lldb/DataFormatters/DumpValueObjectOptions.h
137

It looks like these members somehow got missed in the last PR that changed to use in class member initializers.

lldb/include/lldb/Host/HostNativeProcessBase.h
27

This looks like another case that got missed in the last PR to change to use in class member init.

lldb/include/lldb/Host/HostNativeThreadBase.h
30

I think we can switch this to =default as well.

48

lldb::thread_t m_thread = LLDB_INVALID_HOST_THREAD

This revision was landed with ongoing or failed builds.Jul 2 2021, 11:31 AM
Closed by commit rGfd2433e139f7: [lldb] Replace default bodies of special member functions with = default; (authored by JDevlieghere). · Explain Why
This revision was automatically updated to reflect the committed changes.
JDevlieghere added a commit: rGfd2433e139f7: [lldb] Replace default bodies of special member functions with = default;.
Herald added a project: Restricted Project. · View Herald TranscriptJul 2 2021, 11:31 AM

Revision Contents

PathSize
lldb/
2 lines
include/
lldb/
Core/
2 lines
2 lines
2 lines
2 lines
2 lines
DataFormatters/
2 lines
2 lines
2 lines
2 lines
2 lines
Expression/
2 lines
2 lines
2 lines
2 lines
Host/
2 lines
4 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
common/
4 lines
2 lines
Interpreter/
4 lines
2 lines
2 lines
2 lines
Symbol/
4 lines
2 lines
2 lines
4 lines
2 lines
2 lines
4 lines
Target/
2 lines
2 lines
4 lines
2 lines
7 lines
2 lines
2 lines
4 lines
2 lines
2 lines
Utility/
4 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
4 lines
2 lines
source/
Breakpoint/
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
Commands/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
Core/
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
DataFormatters/
6 lines
2 lines
2 lines
Expression/
2 lines
4 lines
2 lines
2 lines
2 lines
Host/
common/
2 lines
2 lines
2 lines
2 lines
6 lines
8 lines
macosx/
cfcpp/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
posix/
2 lines
4 lines
Initialization/
4 lines
2 lines
Interpreter/
2 lines
8 lines
Plugins/
DynamicLoader/
Darwin-Kernel/
4 lines
2 lines
Hexagon-DYLD/
2 lines
MacOSX-DYLD/
2 lines
4 lines
POSIX-DYLD/
2 lines
Windows-DYLD/
2 lines
ExpressionParser/
Clang/
2 lines
2 lines
6 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
Instruction/
ARM/
4 lines
2 lines
Language/
CPlusPlus/
2 lines
ObjC/
6 lines
LanguageRuntime/
ObjC/
AppleObjCRuntime/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
7 lines
RenderScript/
RenderScriptRuntime/
2 lines
2 lines
2 lines
ObjectContainer/
BSD-Archive/
4 lines
Universal-Mach-O/
2 lines
ObjectFile/
ELF/
2 lines
JIT/
2 lines
PECOFF/
2 lines
OperatingSystem/
Python/
2 lines
Platform/
Android/
6 lines
2 lines
MacOSX/
2 lines
2 lines
4 lines
2 lines
POSIX/
2 lines
gdb-server/
2 lines
Process/
MacOSX-Kernel/
8 lines
2 lines
2 lines
2 lines
2 lines
Utility/
2 lines
2 lines
2 lines
2 lines
2 lines
6 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
elf-core/
2 lines
2 lines
2 lines
2 lines
2 lines
gdb-remote/
2 lines
2 lines
3 lines
3 lines
2 lines
16 lines
minidump/
4 lines
2 lines
ScriptInterpreter/
Lua/
2 lines
None/
2 lines
Python/
4 lines
2 lines
StructuredData/
DarwinLog/
4 lines
SymbolFile/
Breakpad/
2 lines
DWARF/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
6 lines
NativePDB/
2 lines
2 lines
PDB/
2 lines
2 lines
SystemRuntime/
MacOSX/
2 lines
2 lines
4 lines
2 lines
4 lines
2 lines
2 lines
2 lines
12 lines
UnwindAssembly/
x86/
2 lines
Symbol/
2 lines
2 lines
2 lines
2 lines
6 lines
4 lines
6 lines
2 lines
2 lines
2 lines
4 lines
2 lines
2 lines
2 lines
Target/
2 lines
4 lines
6 lines
2 lines
4 lines
2 lines
2 lines
2 lines
Utility/
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines
2 lines

Diff 351215

lldb/.clang-tidy

Checks: '-readability-identifier-naming,modernize-use-default-member-init' Checks: '-readability-identifier-naming,modernize-use-default-member-init,modernize-use-equals-default'
InheritParentConfig: true InheritParentConfig: true
CheckOptions: CheckOptions:
- key: modernize-use-default-member-init.IgnoreMacros - key: modernize-use-default-member-init.IgnoreMacros
value: '1' value: '1'
- key: modernize-use-default-member-init.UseAssignment - key: modernize-use-default-member-init.UseAssignment
value: '1' value: '1'

lldb/include/lldb/Core/EmulateInstruction.h

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
struct ISAAndImmediateSigned { struct ISAAndImmediateSigned {
uint32_t isa; uint32_t isa;
int32_t signed_data32; // signed immediate data int32_t signed_data32; // signed immediate data
} ISAAndImmediateSigned; } ISAAndImmediateSigned;
uint32_t isa; uint32_t isa;
} info; } info;
Context() {} Context() = default;
void SetRegisterPlusOffset(RegisterInfo base_reg, int64_t signed_offset) { void SetRegisterPlusOffset(RegisterInfo base_reg, int64_t signed_offset) {
info_type = eInfoTypeRegisterPlusOffset; info_type = eInfoTypeRegisterPlusOffset;
info.RegisterPlusOffset.reg = base_reg; info.RegisterPlusOffset.reg = base_reg;
info.RegisterPlusOffset.signed_offset = signed_offset; info.RegisterPlusOffset.signed_offset = signed_offset;
} }
void SetRegisterPlusIndirectOffset(RegisterInfo base_reg, void SetRegisterPlusIndirectOffset(RegisterInfo base_reg,
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/include/lldb/Core/Opcode.h

Show All 32 Lines enum Type {
eType8, eType8,
eType16, eType16,
eType16_2, // a 32-bit Thumb instruction, made up of two words eType16_2, // a 32-bit Thumb instruction, made up of two words
eType32, eType32,
eType64, eType64,
eTypeBytes eTypeBytes
}; };
Opcode() {} Opcode() = default;
Opcode(uint8_t inst, lldb::ByteOrder order) Opcode(uint8_t inst, lldb::ByteOrder order)
: m_byte_order(order), m_type(eType8) { : m_byte_order(order), m_type(eType8) {
m_data.inst8 = inst; m_data.inst8 = inst;
} }
Opcode(uint16_t inst, lldb::ByteOrder order) Opcode(uint16_t inst, lldb::ByteOrder order)
: m_byte_order(order), m_type(eType16) { : m_byte_order(order), m_type(eType16) {
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/include/lldb/Core/StreamBuffer.h

Show All 17 Lines
template <unsigned N> class StreamBuffer : public Stream { template <unsigned N> class StreamBuffer : public Stream {
public: public:
StreamBuffer() : Stream(0, 4, lldb::eByteOrderBig), m_packet() {} StreamBuffer() : Stream(0, 4, lldb::eByteOrderBig), m_packet() {}
StreamBuffer(uint32_t flags, uint32_t addr_size, lldb::ByteOrder byte_order) StreamBuffer(uint32_t flags, uint32_t addr_size, lldb::ByteOrder byte_order)
: Stream(flags, addr_size, byte_order), m_packet() {} : Stream(flags, addr_size, byte_order), m_packet() {}
~StreamBuffer() override {} ~StreamBuffer() override = default;
void Flush() override { void Flush() override {
// Nothing to do when flushing a buffer based stream... // Nothing to do when flushing a buffer based stream...
} }
void Clear() { m_packet.clear(); } void Clear() { m_packet.clear(); }
// Beware, this might not be NULL terminated as you can expect from // Beware, this might not be NULL terminated as you can expect from
Show All 20 Lines

lldb/include/lldb/Core/ThreadSafeValue.h

Show All 12 Lines
#include "lldb/lldb-defines.h" #include "lldb/lldb-defines.h"
namespace lldb_private { namespace lldb_private {
template <class T> class ThreadSafeValue { template <class T> class ThreadSafeValue {
public: public:
// Constructors and Destructors // Constructors and Destructors
ThreadSafeValue() : m_value(), m_mutex() {} ThreadSafeValue() : m_value(), m_mutex() {}
shafikUnsubmitted
Not Done
ReplyInline Actions

We can also default this as well, we can use member initializers for these values.

shafik: We can also default this as well, we can use member initializers for these values.
ThreadSafeValue(const T &value) : m_value(value), m_mutex() {} ThreadSafeValue(const T &value) : m_value(value), m_mutex() {}
~ThreadSafeValue() {} ~ThreadSafeValue() = default;
T GetValue() const { T GetValue() const {
T value; T value;
{ {
std::lock_guard<std::recursive_mutex> guard(m_mutex); std::lock_guard<std::recursive_mutex> guard(m_mutex);
value = m_value; value = m_value;
} }
return value; return value;
Show All 28 Lines

lldb/include/lldb/Core/UserSettingsController.h

Show All 26 Lines
class Property; class Property;
class Stream; class Stream;
} }
namespace lldb_private { namespace lldb_private {
class Properties { class Properties {
public: public:
Properties() : m_collection_sp() {} Properties() : m_collection_sp() {}
shafikUnsubmitted
Not Done
ReplyInline Actions

I believe this should be defaultable as well.

shafik: I believe this should be defaultable as well.
Properties(const lldb::OptionValuePropertiesSP &collection_sp) Properties(const lldb::OptionValuePropertiesSP &collection_sp)
: m_collection_sp(collection_sp) {} : m_collection_sp(collection_sp) {}
virtual ~Properties() {} virtual ~Properties() = default;
virtual lldb::OptionValuePropertiesSP GetValueProperties() const { virtual lldb::OptionValuePropertiesSP GetValueProperties() const {
// This function is virtual in case subclasses want to lazily implement // This function is virtual in case subclasses want to lazily implement
// creating the properties. // creating the properties.
return m_collection_sp; return m_collection_sp;
} }
virtual lldb::OptionValueSP GetPropertyValue(const ExecutionContext *exe_ctx, virtual lldb::OptionValueSP GetPropertyValue(const ExecutionContext *exe_ctx,
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

lldb/include/lldb/DataFormatters/DumpValueObjectOptions.h

Show All 33 Lines struct PointerDepth {
bool CanAllowExpansion() const; bool CanAllowExpansion() const;
}; };
struct PointerAsArraySettings { struct PointerAsArraySettings {
size_t m_element_count = 0; size_t m_element_count = 0;
size_t m_base_element = 0; size_t m_base_element = 0;
size_t m_stride = 0; size_t m_stride = 0;
PointerAsArraySettings() {} PointerAsArraySettings() = default;
PointerAsArraySettings(size_t elem_count, size_t base_elem = 0, PointerAsArraySettings(size_t elem_count, size_t base_elem = 0,
size_t stride = 1) size_t stride = 1)
: m_element_count(elem_count), m_base_element(base_elem), : m_element_count(elem_count), m_base_element(base_elem),
m_stride(stride) {} m_stride(stride) {}
operator bool() { return m_element_count > 0; } operator bool() { return m_element_count > 0; }
}; };
▲ Show 20 Lines • Show All 78 Lines • ▼ Show 20 Linespublic:
uint32_t m_omit_summary_depth = 0; uint32_t m_omit_summary_depth = 0;
lldb::Format m_format = lldb::eFormatDefault; lldb::Format m_format = lldb::eFormatDefault;
lldb::TypeSummaryImplSP m_summary_sp; lldb::TypeSummaryImplSP m_summary_sp;
std::string m_root_valobj_name; std::string m_root_valobj_name;
lldb::LanguageType m_varformat_language = lldb::eLanguageTypeUnknown; lldb::LanguageType m_varformat_language = lldb::eLanguageTypeUnknown;
PointerDepth m_max_ptr_depth; PointerDepth m_max_ptr_depth;
DeclPrintingHelper m_decl_printing_helper; DeclPrintingHelper m_decl_printing_helper;
PointerAsArraySettings m_pointer_as_array; PointerAsArraySettings m_pointer_as_array;
bool m_use_synthetic : 1; bool m_use_synthetic : 1;
shafikUnsubmitted
Not Done
ReplyInline Actions

It looks like these members somehow got missed in the last PR that changed to use in class member initializers.

shafik: It looks like these members somehow got missed in the last PR that changed to use in class…
bool m_scope_already_checked : 1; bool m_scope_already_checked : 1;
bool m_flat_output : 1; bool m_flat_output : 1;
bool m_ignore_cap : 1; bool m_ignore_cap : 1;
bool m_show_types : 1; bool m_show_types : 1;

lldb/include/lldb/DataFormatters/TypeFormat.h

Show All 19 Lines
#include "lldb/Core/ValueObject.h" #include "lldb/Core/ValueObject.h"
namespace lldb_private { namespace lldb_private {
class TypeFormatImpl { class TypeFormatImpl {
public: public:
class Flags { class Flags {
public: public:
Flags() {} Flags() = default;
Flags(const Flags &other) : m_flags(other.m_flags) {} Flags(const Flags &other) : m_flags(other.m_flags) {}
Flags(uint32_t value) : m_flags(value) {} Flags(uint32_t value) : m_flags(value) {}
Flags &operator=(const Flags &rhs) { Flags &operator=(const Flags &rhs) {
if (&rhs != this) if (&rhs != this)
m_flags = rhs.m_flags; m_flags = rhs.m_flags;
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/include/lldb/DataFormatters/TypeSummary.h

Show First 20 Lines • Show All 46 Lines • ▼ Show 20 Linespublic:
enum class Kind { eSummaryString, eScript, eCallback, eInternal }; enum class Kind { eSummaryString, eScript, eCallback, eInternal };
virtual ~TypeSummaryImpl() = default; virtual ~TypeSummaryImpl() = default;
Kind GetKind() const { return m_kind; } Kind GetKind() const { return m_kind; }
class Flags { class Flags {
public: public:
Flags() {} Flags() = default;
Flags(const Flags &other) : m_flags(other.m_flags) {} Flags(const Flags &other) : m_flags(other.m_flags) {}
Flags(uint32_t value) : m_flags(value) {} Flags(uint32_t value) : m_flags(value) {}
Flags &operator=(const Flags &rhs) { Flags &operator=(const Flags &rhs) {
if (&rhs != this) if (&rhs != this)
m_flags = rhs.m_flags; m_flags = rhs.m_flags;
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/include/lldb/DataFormatters/TypeSynthetic.h

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
const SyntheticValueProviderFrontEnd & const SyntheticValueProviderFrontEnd &
operator=(const SyntheticValueProviderFrontEnd &) = delete; operator=(const SyntheticValueProviderFrontEnd &) = delete;
}; };
class SyntheticChildren { class SyntheticChildren {
public: public:
class Flags { class Flags {
public: public:
Flags() {} Flags() = default;
Flags(const Flags &other) : m_flags(other.m_flags) {} Flags(const Flags &other) : m_flags(other.m_flags) {}
Flags(uint32_t value) : m_flags(value) {} Flags(uint32_t value) : m_flags(value) {}
Flags &operator=(const Flags &rhs) { Flags &operator=(const Flags &rhs) {
if (&rhs != this) if (&rhs != this)
m_flags = rhs.m_flags; m_flags = rhs.m_flags;
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/include/lldb/DataFormatters/ValueObjectPrinter.h

Show All 21 Lines
class ValueObjectPrinter { class ValueObjectPrinter {
public: public:
ValueObjectPrinter(ValueObject *valobj, Stream *s); ValueObjectPrinter(ValueObject *valobj, Stream *s);
ValueObjectPrinter(ValueObject *valobj, Stream *s, ValueObjectPrinter(ValueObject *valobj, Stream *s,
const DumpValueObjectOptions &options); const DumpValueObjectOptions &options);
~ValueObjectPrinter() {} ~ValueObjectPrinter() = default;
bool PrintValueObject(); bool PrintValueObject();
protected: protected:
typedef std::set<uint64_t> InstancePointersSet; typedef std::set<uint64_t> InstancePointersSet;
typedef std::shared_ptr<InstancePointersSet> InstancePointersSetSP; typedef std::shared_ptr<InstancePointersSet> InstancePointersSetSP;
InstancePointersSetSP m_printed_instance_pointers; InstancePointersSetSP m_printed_instance_pointers;
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/include/lldb/Expression/Expression.h

Show All 33 Lines
public: public:
enum ResultType { eResultTypeAny, eResultTypeId }; enum ResultType { eResultTypeAny, eResultTypeId };
Expression(Target &target); Expression(Target &target);
Expression(ExecutionContextScope &exe_scope); Expression(ExecutionContextScope &exe_scope);
/// Destructor /// Destructor
virtual ~Expression() {} virtual ~Expression() = default;
/// Return the string that the parser should parse. Must be a full /// Return the string that the parser should parse. Must be a full
/// translation unit. /// translation unit.
virtual const char *Text() = 0; virtual const char *Text() = 0;
/// Return the function name that should be used for executing the /// Return the function name that should be used for executing the
/// expression. Text() should contain the definition of this function. /// expression. Text() should contain the definition of this function.
virtual const char *FunctionName() = 0; virtual const char *FunctionName() = 0;
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

lldb/include/lldb/Expression/ExpressionParser.h

Show All 35 Linespublic:
/// ///
/// \param[in] expr /// \param[in] expr
/// The expression to be parsed. /// The expression to be parsed.
ExpressionParser(ExecutionContextScope *exe_scope, Expression &expr, ExpressionParser(ExecutionContextScope *exe_scope, Expression &expr,
bool generate_debug_info) bool generate_debug_info)
: m_expr(expr), m_generate_debug_info(generate_debug_info) {} : m_expr(expr), m_generate_debug_info(generate_debug_info) {}
/// Destructor /// Destructor
virtual ~ExpressionParser(){}; virtual ~ExpressionParser() = default;
teemperorUnsubmitted
Done
ReplyInline Actions

Please drop that when you land it.

teemperor: Please drop that when you land it.
JDevlieghereAuthorUnsubmitted
Done
ReplyInline Actions

Dropped.

JDevlieghere: Dropped.
/// Attempts to find possible command line completions for the given /// Attempts to find possible command line completions for the given
/// expression. /// expression.
/// ///
/// \param[out] request /// \param[out] request
/// The completion request to fill out. The completion should be a string /// The completion request to fill out. The completion should be a string
/// that would complete the current token at the cursor position. /// that would complete the current token at the cursor position.
/// Note that the string in the list replaces the current token /// Note that the string in the list replaces the current token
/// in the command line. /// in the command line.
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

lldb/include/lldb/Expression/ExpressionTypeSystemHelper.h

Show All 30 Lines enum LLVMCastKind {
eKindGoHelper, eKindGoHelper,
kNumKinds kNumKinds
}; };
LLVMCastKind getKind() const { return m_kind; } LLVMCastKind getKind() const { return m_kind; }
ExpressionTypeSystemHelper(LLVMCastKind kind) : m_kind(kind) {} ExpressionTypeSystemHelper(LLVMCastKind kind) : m_kind(kind) {}
~ExpressionTypeSystemHelper() {} ~ExpressionTypeSystemHelper() = default;
protected: protected:
LLVMCastKind m_kind; LLVMCastKind m_kind;
}; };
} // namespace lldb_private } // namespace lldb_private
#endif // LLDB_EXPRESSION_EXPRESSIONTYPESYSTEMHELPER_H #endif // LLDB_EXPRESSION_EXPRESSIONTYPESYSTEMHELPER_H

lldb/include/lldb/Expression/Materializer.h

Show First 20 Lines • Show All 84 Lines • ▼ Show 20 Linespublic:
uint32_t AddRegister(const RegisterInfo &register_info, Status &err); uint32_t AddRegister(const RegisterInfo &register_info, Status &err);
uint32_t GetStructAlignment() { return m_struct_alignment; } uint32_t GetStructAlignment() { return m_struct_alignment; }
uint32_t GetStructByteSize() { return m_current_offset; } uint32_t GetStructByteSize() { return m_current_offset; }
class Entity { class Entity {
public: public:
Entity() {} Entity() = default;
virtual ~Entity() = default; virtual ~Entity() = default;
virtual void Materialize(lldb::StackFrameSP &frame_sp, IRMemoryMap &map, virtual void Materialize(lldb::StackFrameSP &frame_sp, IRMemoryMap &map,
lldb::addr_t process_address, Status &err) = 0; lldb::addr_t process_address, Status &err) = 0;
virtual void Dematerialize(lldb::StackFrameSP &frame_sp, IRMemoryMap &map, virtual void Dematerialize(lldb::StackFrameSP &frame_sp, IRMemoryMap &map,
lldb::addr_t process_address, lldb::addr_t process_address,
lldb::addr_t frame_top, lldb::addr_t frame_top,
Show All 34 Lines

lldb/include/lldb/Host/FileCache.h

Show All 15 Lines
#include "lldb/Host/File.h" #include "lldb/Host/File.h"
#include "lldb/Utility/FileSpec.h" #include "lldb/Utility/FileSpec.h"
#include "lldb/Utility/Status.h" #include "lldb/Utility/Status.h"
namespace lldb_private { namespace lldb_private {
class FileCache { class FileCache {
private: private:
FileCache() {} FileCache() = default;
typedef std::map<lldb::user_id_t, lldb::FileUP> FDToFileMap; typedef std::map<lldb::user_id_t, lldb::FileUP> FDToFileMap;
public: public:
static FileCache &GetInstance(); static FileCache &GetInstance();
lldb::user_id_t OpenFile(const FileSpec &file_spec, File::OpenOptions flags, lldb::user_id_t OpenFile(const FileSpec &file_spec, File::OpenOptions flags,
uint32_t mode, Status &error); uint32_t mode, Status &error);
Show All 15 Lines

lldb/include/lldb/Host/HostInfoBase.h

Show All 27 Lines
struct SharedCacheImageInfo { struct SharedCacheImageInfo {
UUID uuid; UUID uuid;
lldb::DataBufferSP data_sp; lldb::DataBufferSP data_sp;
}; };
class HostInfoBase { class HostInfoBase {
private: private:
// Static class, unconstructable. // Static class, unconstructable.
HostInfoBase() {} HostInfoBase() = default;
~HostInfoBase() {} ~HostInfoBase() = default;
public: public:
/// A helper function for determining the liblldb location. It receives a /// A helper function for determining the liblldb location. It receives a
/// FileSpec with the location of file containing _this_ code. It can /// FileSpec with the location of file containing _this_ code. It can
/// (optionally) replace it with a file spec pointing to a more canonical /// (optionally) replace it with a file spec pointing to a more canonical
/// copy. /// copy.
using SharedLibraryDirectoryHelper = void(FileSpec &this_file); using SharedLibraryDirectoryHelper = void(FileSpec &this_file);
▲ Show 20 Lines • Show All 90 Lines • Show Last 20 Lines

lldb/include/lldb/Host/HostNativeProcessBase.h

Show All 18 Lines
class HostThread; class HostThread;
class HostNativeProcessBase { class HostNativeProcessBase {
HostNativeProcessBase(const HostNativeProcessBase &) = delete; HostNativeProcessBase(const HostNativeProcessBase &) = delete;
const HostNativeProcessBase & const HostNativeProcessBase &
operator=(const HostNativeProcessBase &) = delete; operator=(const HostNativeProcessBase &) = delete;
public: public:
HostNativeProcessBase() : m_process(LLDB_INVALID_PROCESS) {} HostNativeProcessBase() : m_process(LLDB_INVALID_PROCESS) {}
shafikUnsubmitted
Not Done
ReplyInline Actions

This looks like another case that got missed in the last PR to change to use in class member init.

shafik: This looks like another case that got missed in the last PR to change to use in class member…
explicit HostNativeProcessBase(lldb::process_t process) explicit HostNativeProcessBase(lldb::process_t process)
: m_process(process) {} : m_process(process) {}
virtual ~HostNativeProcessBase() {} virtual ~HostNativeProcessBase() = default;
virtual Status Terminate() = 0; virtual Status Terminate() = 0;
virtual Status GetMainModule(FileSpec &file_spec) const = 0; virtual Status GetMainModule(FileSpec &file_spec) const = 0;
virtual lldb::pid_t GetProcessId() const = 0; virtual lldb::pid_t GetProcessId() const = 0;
virtual bool IsRunning() const = 0; virtual bool IsRunning() const = 0;
lldb::process_t GetSystemHandle() const { return m_process; } lldb::process_t GetSystemHandle() const { return m_process; }
Show All 11 Lines

lldb/include/lldb/Host/HostNativeThreadBase.h

Show All 21 Lines
#endif #endif
class HostNativeThreadBase { class HostNativeThreadBase {
friend class ThreadLauncher; friend class ThreadLauncher;
HostNativeThreadBase(const HostNativeThreadBase &) = delete; HostNativeThreadBase(const HostNativeThreadBase &) = delete;
const HostNativeThreadBase &operator=(const HostNativeThreadBase &) = delete; const HostNativeThreadBase &operator=(const HostNativeThreadBase &) = delete;
public: public:
HostNativeThreadBase(); HostNativeThreadBase();
shafikUnsubmitted
Not Done
ReplyInline Actions

I think we can switch this to =default as well.

shafik: I think we can switch this to `=default` as well.
explicit HostNativeThreadBase(lldb::thread_t thread); explicit HostNativeThreadBase(lldb::thread_t thread);
virtual ~HostNativeThreadBase() {} virtual ~HostNativeThreadBase() = default;
virtual Status Join(lldb::thread_result_t *result) = 0; virtual Status Join(lldb::thread_result_t *result) = 0;
virtual Status Cancel() = 0; virtual Status Cancel() = 0;
virtual bool IsJoinable() const; virtual bool IsJoinable() const;
virtual void Reset(); virtual void Reset();
virtual bool EqualsThread(lldb::thread_t thread) const; virtual bool EqualsThread(lldb::thread_t thread) const;
lldb::thread_t Release(); lldb::thread_t Release();
lldb::thread_t GetSystemHandle() const; lldb::thread_t GetSystemHandle() const;
lldb::thread_result_t GetResult() const; lldb::thread_result_t GetResult() const;
protected: protected:
static lldb::thread_result_t THREAD_ROUTINE static lldb::thread_result_t THREAD_ROUTINE
ThreadCreateTrampoline(lldb::thread_arg_t arg); ThreadCreateTrampoline(lldb::thread_arg_t arg);
lldb::thread_t m_thread; lldb::thread_t m_thread;
shafikUnsubmitted
Not Done
ReplyInline Actions

lldb::thread_t m_thread = LLDB_INVALID_HOST_THREAD

shafik: ` lldb::thread_t m_thread = LLDB_INVALID_HOST_THREAD`
lldb::thread_result_t m_result = 0; lldb::thread_result_t m_result = 0;
}; };
} }
#endif #endif

lldb/include/lldb/Host/MainLoopBase.h

Show All 27 Lines
// //
// This class simply defines the interface common for all platforms, actual // This class simply defines the interface common for all platforms, actual
// implementations are platform-specific. // implementations are platform-specific.
class MainLoopBase { class MainLoopBase {
private: private:
class ReadHandle; class ReadHandle;
public: public:
MainLoopBase() {} MainLoopBase() = default;
virtual ~MainLoopBase() {} virtual ~MainLoopBase() = default;
typedef std::unique_ptr<ReadHandle> ReadHandleUP; typedef std::unique_ptr<ReadHandle> ReadHandleUP;
typedef std::function<void(MainLoopBase &)> Callback; typedef std::function<void(MainLoopBase &)> Callback;
virtual ReadHandleUP RegisterReadObject(const lldb::IOObjectSP &object_sp, virtual ReadHandleUP RegisterReadObject(const lldb::IOObjectSP &object_sp,
const Callback &callback, const Callback &callback,
Status &error) { Status &error) {
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

lldb/include/lldb/Host/ProcessLauncher.h

Show All 11 Lines
namespace lldb_private { namespace lldb_private {
class ProcessLaunchInfo; class ProcessLaunchInfo;
class Status; class Status;
class HostProcess; class HostProcess;
class ProcessLauncher { class ProcessLauncher {
public: public:
virtual ~ProcessLauncher() {} virtual ~ProcessLauncher() = default;
virtual HostProcess LaunchProcess(const ProcessLaunchInfo &launch_info, virtual HostProcess LaunchProcess(const ProcessLaunchInfo &launch_info,
Status &error) = 0; Status &error) = 0;
}; };
} }
#endif #endif

lldb/include/lldb/Host/ProcessRunLock.h

Show All 29 Linespublic:
bool ReadTryLock(); bool ReadTryLock();
bool ReadUnlock(); bool ReadUnlock();
bool SetRunning(); bool SetRunning();
bool TrySetRunning(); bool TrySetRunning();
bool SetStopped(); bool SetStopped();
class ProcessRunLocker { class ProcessRunLocker {
public: public:
ProcessRunLocker() {} ProcessRunLocker() = default;
~ProcessRunLocker() { Unlock(); } ~ProcessRunLocker() { Unlock(); }
// Try to lock the read lock, but only do so if there are no writers. // Try to lock the read lock, but only do so if there are no writers.
bool TryLock(ProcessRunLock *lock) { bool TryLock(ProcessRunLock *lock) {
if (m_lock) { if (m_lock) {
if (m_lock == lock) if (m_lock == lock)
return true; // We already have this lock locked return true; // We already have this lock locked
Show All 39 Lines

lldb/include/lldb/Host/Terminal.h

Show All 15 Lines
struct termios; struct termios;
namespace lldb_private { namespace lldb_private {
class Terminal { class Terminal {
public: public:
Terminal(int fd = -1) : m_fd(fd) {} Terminal(int fd = -1) : m_fd(fd) {}
~Terminal() {} ~Terminal() = default;
bool IsATerminal() const; bool IsATerminal() const;
int GetFileDescriptor() const { return m_fd; } int GetFileDescriptor() const { return m_fd; }
void SetFileDescriptor(int fd) { m_fd = fd; } void SetFileDescriptor(int fd) { m_fd = fd; }
bool FileDescriptorIsValid() const { return m_fd != -1; } bool FileDescriptorIsValid() const { return m_fd != -1; }
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/include/lldb/Host/common/NativeProcessProtocol.h

Show All 40 Linesstruct SVR4LibraryInfo {
lldb::addr_t base_addr; lldb::addr_t base_addr;
lldb::addr_t ld_addr; lldb::addr_t ld_addr;
lldb::addr_t next; lldb::addr_t next;
}; };
// NativeProcessProtocol // NativeProcessProtocol
class NativeProcessProtocol { class NativeProcessProtocol {
public: public:
virtual ~NativeProcessProtocol() {} virtual ~NativeProcessProtocol() = default;
virtual Status Resume(const ResumeActionList &resume_actions) = 0; virtual Status Resume(const ResumeActionList &resume_actions) = 0;
virtual Status Halt() = 0; virtual Status Halt() = 0;
virtual Status Detach() = 0; virtual Status Detach() = 0;
/// Sends a process a UNIX signal \a signal. /// Sends a process a UNIX signal \a signal.
▲ Show 20 Lines • Show All 151 Lines • ▼ Show 20 Linespublic:
// Stop id interface // Stop id interface
uint32_t GetStopID() const; uint32_t GetStopID() const;
// Callbacks for low-level process state changes // Callbacks for low-level process state changes
class NativeDelegate { class NativeDelegate {
public: public:
virtual ~NativeDelegate() {} virtual ~NativeDelegate() = default;
virtual void InitializeDelegate(NativeProcessProtocol *process) = 0; virtual void InitializeDelegate(NativeProcessProtocol *process) = 0;
virtual void ProcessStateChanged(NativeProcessProtocol *process, virtual void ProcessStateChanged(NativeProcessProtocol *process,
lldb::StateType state) = 0; lldb::StateType state) = 0;
virtual void DidExec(NativeProcessProtocol *process) = 0; virtual void DidExec(NativeProcessProtocol *process) = 0;
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/include/lldb/Host/common/NativeThreadProtocol.h

Show All 15 Lines
#include "lldb/lldb-types.h" #include "lldb/lldb-types.h"
namespace lldb_private { namespace lldb_private {
// NativeThreadProtocol // NativeThreadProtocol
class NativeThreadProtocol { class NativeThreadProtocol {
public: public:
NativeThreadProtocol(NativeProcessProtocol &process, lldb::tid_t tid); NativeThreadProtocol(NativeProcessProtocol &process, lldb::tid_t tid);
virtual ~NativeThreadProtocol() {} virtual ~NativeThreadProtocol() = default;
virtual std::string GetName() = 0; virtual std::string GetName() = 0;
virtual lldb::StateType GetState() = 0; virtual lldb::StateType GetState() = 0;
virtual NativeRegisterContext &GetRegisterContext() = 0; virtual NativeRegisterContext &GetRegisterContext() = 0;
virtual bool GetStopReason(ThreadStopInfo &stop_info, virtual bool GetStopReason(ThreadStopInfo &stop_info,
Show All 24 Lines

lldb/include/lldb/Interpreter/CommandInterpreter.h

Show All 27 Lines
#include <mutex> #include <mutex>
#include <stack> #include <stack>
namespace lldb_private { namespace lldb_private {
class CommandInterpreter; class CommandInterpreter;
class CommandInterpreterRunResult { class CommandInterpreterRunResult {
public: public:
CommandInterpreterRunResult() {} CommandInterpreterRunResult() = default;
uint32_t GetNumErrors() const { return m_num_errors; } uint32_t GetNumErrors() const { return m_num_errors; }
lldb::CommandInterpreterResult GetResult() const { return m_result; } lldb::CommandInterpreterResult GetResult() const { return m_result; }
bool IsResult(lldb::CommandInterpreterResult result) { bool IsResult(lldb::CommandInterpreterResult result) {
return m_result == result; return m_result == result;
} }
▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Lines CommandInterpreterRunOptions(LazyBool stop_on_continue,
LazyBool echo_commands, LazyBool echo_comments, LazyBool echo_commands, LazyBool echo_comments,
LazyBool print_results, LazyBool print_errors, LazyBool print_results, LazyBool print_errors,
LazyBool add_to_history) LazyBool add_to_history)
: m_stop_on_continue(stop_on_continue), m_stop_on_error(stop_on_error), : m_stop_on_continue(stop_on_continue), m_stop_on_error(stop_on_error),
m_stop_on_crash(stop_on_crash), m_echo_commands(echo_commands), m_stop_on_crash(stop_on_crash), m_echo_commands(echo_commands),
m_echo_comment_commands(echo_comments), m_print_results(print_results), m_echo_comment_commands(echo_comments), m_print_results(print_results),
m_print_errors(print_errors), m_add_to_history(add_to_history) {} m_print_errors(print_errors), m_add_to_history(add_to_history) {}
CommandInterpreterRunOptions() CommandInterpreterRunOptions()
{} = default;
JDevlieghereAuthorUnsubmitted
Done
ReplyInline Actions

Interesting, I would've expected clang-format to get this.

JDevlieghere: Interesting, I would've expected clang-format to get this.
void SetSilent(bool silent) { void SetSilent(bool silent) {
LazyBool value = silent ? eLazyBoolNo : eLazyBoolYes; LazyBool value = silent ? eLazyBoolNo : eLazyBoolYes;
m_print_results = value; m_print_results = value;
m_print_errors = value; m_print_errors = value;
m_echo_commands = value; m_echo_commands = value;
m_echo_comment_commands = value; m_echo_comment_commands = value;
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/include/lldb/Interpreter/OptionValue.h

Show First 20 Lines • Show All 54 Lines • ▼ Show 20 Lines enum {
eDumpOptionRaw = (1u << 4), eDumpOptionRaw = (1u << 4),
eDumpOptionCommand = (1u << 5), eDumpOptionCommand = (1u << 5),
eDumpGroupValue = (eDumpOptionName | eDumpOptionType | eDumpOptionValue), eDumpGroupValue = (eDumpOptionName | eDumpOptionType | eDumpOptionValue),
eDumpGroupHelp = eDumpGroupHelp =
(eDumpOptionName | eDumpOptionType | eDumpOptionDescription), (eDumpOptionName | eDumpOptionType | eDumpOptionDescription),
eDumpGroupExport = (eDumpOptionCommand | eDumpOptionName | eDumpOptionValue) eDumpGroupExport = (eDumpOptionCommand | eDumpOptionName | eDumpOptionValue)
}; };
OptionValue() {} OptionValue() = default;
virtual ~OptionValue() = default; virtual ~OptionValue() = default;
// Subclasses should override these functions // Subclasses should override these functions
virtual Type GetType() const = 0; virtual Type GetType() const = 0;
// If this value is always hidden, the avoid showing any info on this value, // If this value is always hidden, the avoid showing any info on this value,
// just show the info for the child values. // just show the info for the child values.
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/include/lldb/Interpreter/Options.h

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
// can implement this function to do extra checking // can implement this function to do extra checking
Status error; Status error;
return error; return error;
} }
}; };
class OptionGroupOptions : public Options { class OptionGroupOptions : public Options {
public: public:
OptionGroupOptions() {} OptionGroupOptions() = default;
~OptionGroupOptions() override = default; ~OptionGroupOptions() override = default;
/// Append options from a OptionGroup class. /// Append options from a OptionGroup class.
/// ///
/// Append all options from \a group using the exact same option groups that /// Append all options from \a group using the exact same option groups that
/// each option is defined with. /// each option is defined with.
/// ///
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

lldb/include/lldb/Interpreter/ScriptInterpreter.h

Show First 20 Lines • Show All 88 Lines • ▼ Show 20 Linespublic:
ScriptInterpreter( ScriptInterpreter(
Debugger &debugger, lldb::ScriptLanguage script_lang, Debugger &debugger, lldb::ScriptLanguage script_lang,
lldb::ScriptedProcessInterfaceUP scripted_process_interface_up = {}); lldb::ScriptedProcessInterfaceUP scripted_process_interface_up = {});
~ScriptInterpreter() override = default; ~ScriptInterpreter() override = default;
struct ExecuteScriptOptions { struct ExecuteScriptOptions {
public: public:
ExecuteScriptOptions() {} ExecuteScriptOptions() = default;
bool GetEnableIO() const { return m_enable_io; } bool GetEnableIO() const { return m_enable_io; }
bool GetSetLLDBGlobals() const { return m_set_lldb_globals; } bool GetSetLLDBGlobals() const { return m_set_lldb_globals; }
// If this is true then any exceptions raised by the script will be // If this is true then any exceptions raised by the script will be
// cleared with PyErr_Clear(). If false then they will be left for // cleared with PyErr_Clear(). If false then they will be left for
// the caller to clean up // the caller to clean up
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/include/lldb/Symbol/CompactUnwindInfo.h

Show First 20 Lines • Show All 57 Lines • ▼ Show 20 Lines struct UnwindIndex {
uint32_t lsda_array_start = 0; // The offset (inside unwind_info sect) LSDA uint32_t lsda_array_start = 0; // The offset (inside unwind_info sect) LSDA
// array for this index // array for this index
uint32_t lsda_array_end = uint32_t lsda_array_end =
0; // The offset to the LSDA array for the NEXT index 0; // The offset to the LSDA array for the NEXT index
bool sentinal_entry = false; // There is an empty index at the end which bool sentinal_entry = false; // There is an empty index at the end which
// provides the upper bound of // provides the upper bound of
// function addresses that are described // function addresses that are described
UnwindIndex() {} UnwindIndex() = default;
bool operator<(const CompactUnwindInfo::UnwindIndex &rhs) const { bool operator<(const CompactUnwindInfo::UnwindIndex &rhs) const {
return function_offset < rhs.function_offset; return function_offset < rhs.function_offset;
} }
bool operator==(const CompactUnwindInfo::UnwindIndex &rhs) const { bool operator==(const CompactUnwindInfo::UnwindIndex &rhs) const {
return function_offset == rhs.function_offset; return function_offset == rhs.function_offset;
} }
Show All 16 Linesprivate:
struct UnwindHeader { struct UnwindHeader {
uint32_t version; uint32_t version;
uint32_t common_encodings_array_offset = 0; uint32_t common_encodings_array_offset = 0;
uint32_t common_encodings_array_count = 0; uint32_t common_encodings_array_count = 0;
uint32_t personality_array_offset = 0; uint32_t personality_array_offset = 0;
uint32_t personality_array_count = 0; uint32_t personality_array_count = 0;
UnwindHeader() {} UnwindHeader() = default;
}; };
void ScanIndex(const lldb::ProcessSP &process_sp); void ScanIndex(const lldb::ProcessSP &process_sp);
bool GetCompactUnwindInfoForFunction(Target &target, Address address, bool GetCompactUnwindInfoForFunction(Target &target, Address address,
FunctionInfo &unwind_info); FunctionInfo &unwind_info);
lldb::offset_t lldb::offset_t
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

lldb/include/lldb/Symbol/DeclVendor.h

Show All 22 Lines enum DeclVendorKind {
eClangDeclVendor, eClangDeclVendor,
eClangModuleDeclVendor, eClangModuleDeclVendor,
eAppleObjCDeclVendor, eAppleObjCDeclVendor,
eLastClangDeclVendor, eLastClangDeclVendor,
}; };
// Constructors and Destructors // Constructors and Destructors
DeclVendor(DeclVendorKind kind) : m_kind(kind) {} DeclVendor(DeclVendorKind kind) : m_kind(kind) {}
virtual ~DeclVendor() {} virtual ~DeclVendor() = default;
DeclVendorKind GetKind() const { return m_kind; } DeclVendorKind GetKind() const { return m_kind; }
/// Look up the set of Decls that the DeclVendor currently knows about /// Look up the set of Decls that the DeclVendor currently knows about
/// matching a given name. /// matching a given name.
/// ///
/// \param[in] name /// \param[in] name
/// The name to look for. /// The name to look for.
Show All 39 Lines

lldb/include/lldb/Symbol/Function.h

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
/// \class CallEdge Function.h "lldb/Symbol/Function.h" /// \class CallEdge Function.h "lldb/Symbol/Function.h"
/// ///
/// Represent a call made within a Function. This can be used to find a path /// Represent a call made within a Function. This can be used to find a path
/// in the call graph between two functions, or to evaluate DW_OP_entry_value. /// in the call graph between two functions, or to evaluate DW_OP_entry_value.
class CallEdge { class CallEdge {
public: public:
enum class AddrType : uint8_t { Call, AfterCall }; enum class AddrType : uint8_t { Call, AfterCall };
virtual ~CallEdge() {} virtual ~CallEdge() = default;
/// Get the callee's definition. /// Get the callee's definition.
/// ///
/// Note that this might lazily invoke the DWARF parser. A register context /// Note that this might lazily invoke the DWARF parser. A register context
/// from the caller's activation is needed to find indirect call targets. /// from the caller's activation is needed to find indirect call targets.
virtual Function *GetCallee(ModuleList &images, virtual Function *GetCallee(ModuleList &images,
ExecutionContext &exe_ctx) = 0; ExecutionContext &exe_ctx) = 0;
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/include/lldb/Symbol/ObjectFile.h

Show All 19 Lines
#include "lldb/Utility/UUID.h" #include "lldb/Utility/UUID.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
#include "llvm/Support/VersionTuple.h" #include "llvm/Support/VersionTuple.h"
namespace lldb_private { namespace lldb_private {
class ObjectFileJITDelegate { class ObjectFileJITDelegate {
public: public:
ObjectFileJITDelegate() {} ObjectFileJITDelegate() = default;
virtual ~ObjectFileJITDelegate() {} virtual ~ObjectFileJITDelegate() = default;
virtual lldb::ByteOrder GetByteOrder() const = 0; virtual lldb::ByteOrder GetByteOrder() const = 0;
virtual uint32_t GetAddressByteSize() const = 0; virtual uint32_t GetAddressByteSize() const = 0;
virtual void PopulateSymtab(lldb_private::ObjectFile *obj_file, virtual void PopulateSymtab(lldb_private::ObjectFile *obj_file,
lldb_private::Symtab &symtab) = 0; lldb_private::Symtab &symtab) = 0;
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/include/lldb/Symbol/SymbolFile.h

Show First 20 Lines • Show All 63 Lines • ▼ Show 20 Linespublic:
static SymbolFile *FindPlugin(lldb::ObjectFileSP objfile_sp); static SymbolFile *FindPlugin(lldb::ObjectFileSP objfile_sp);
// Constructors and Destructors // Constructors and Destructors
SymbolFile(lldb::ObjectFileSP objfile_sp) SymbolFile(lldb::ObjectFileSP objfile_sp)
: m_objfile_sp(std::move(objfile_sp)), m_abilities(0), : m_objfile_sp(std::move(objfile_sp)), m_abilities(0),
m_calculated_abilities(false) {} m_calculated_abilities(false) {}
~SymbolFile() override {} ~SymbolFile() override = default;
/// Get a mask of what this symbol file supports for the object file /// Get a mask of what this symbol file supports for the object file
/// that it was constructed with. /// that it was constructed with.
/// ///
/// Each symbol file gets to respond with a mask of abilities that /// Each symbol file gets to respond with a mask of abilities that
/// it supports for each object file. This happens when we are /// it supports for each object file. This happens when we are
/// trying to figure out which symbol file plug-in will get used /// trying to figure out which symbol file plug-in will get used
/// for a given object file. The plug-in that responds with the /// for a given object file. The plug-in that responds with the
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/include/lldb/Symbol/TaggedASTType.h

Show All 21 Linespublic:
TaggedASTType(lldb::opaque_compiler_type_t type, TypeSystem *type_system) TaggedASTType(lldb::opaque_compiler_type_t type, TypeSystem *type_system)
: CompilerType(type_system, type) {} : CompilerType(type_system, type) {}
TaggedASTType(const TaggedASTType<C> &tw) : CompilerType(tw) {} TaggedASTType(const TaggedASTType<C> &tw) : CompilerType(tw) {}
TaggedASTType() : CompilerType() {} TaggedASTType() : CompilerType() {}
virtual ~TaggedASTType() {} virtual ~TaggedASTType() = default;
TaggedASTType<C> &operator=(const TaggedASTType<C> &tw) { TaggedASTType<C> &operator=(const TaggedASTType<C> &tw) {
CompilerType::operator=(tw); CompilerType::operator=(tw);
return *this; return *this;
} }
}; };
// Commonly-used tagged types, so code using them is interoperable // Commonly-used tagged types, so code using them is interoperable
typedef TaggedASTType<0> TypeFromParser; typedef TaggedASTType<0> TypeFromParser;
typedef TaggedASTType<1> TypeFromUser; typedef TaggedASTType<1> TypeFromUser;
} }
#endif #endif

lldb/include/lldb/Symbol/Type.h

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
class SymbolFileType : public std::enable_shared_from_this<SymbolFileType>, class SymbolFileType : public std::enable_shared_from_this<SymbolFileType>,
public UserID { public UserID {
public: public:
SymbolFileType(SymbolFile &symbol_file, lldb::user_id_t uid) SymbolFileType(SymbolFile &symbol_file, lldb::user_id_t uid)
: UserID(uid), m_symbol_file(symbol_file) {} : UserID(uid), m_symbol_file(symbol_file) {}
SymbolFileType(SymbolFile &symbol_file, const lldb::TypeSP &type_sp); SymbolFileType(SymbolFile &symbol_file, const lldb::TypeSP &type_sp);
~SymbolFileType() {} ~SymbolFileType() = default;
Type *operator->() { return GetType(); } Type *operator->() { return GetType(); }
Type *GetType(); Type *GetType();
SymbolFile &GetSymbolFile() const { return m_symbol_file; } SymbolFile &GetSymbolFile() const { return m_symbol_file; }
protected: protected:
SymbolFile &m_symbol_file; SymbolFile &m_symbol_file;
▲ Show 20 Lines • Show All 171 Lines • ▼ Show 20 Lines
// the two classes here are used by the public API as a backend to the SBType // the two classes here are used by the public API as a backend to the SBType
// and SBTypeList classes // and SBTypeList classes
class TypeImpl { class TypeImpl {
public: public:
TypeImpl() = default; TypeImpl() = default;
~TypeImpl() {} ~TypeImpl() = default;
TypeImpl(const lldb::TypeSP &type_sp); TypeImpl(const lldb::TypeSP &type_sp);
TypeImpl(const CompilerType &compiler_type); TypeImpl(const CompilerType &compiler_type);
TypeImpl(const lldb::TypeSP &type_sp, const CompilerType &dynamic); TypeImpl(const lldb::TypeSP &type_sp, const CompilerType &dynamic);
TypeImpl(const CompilerType &compiler_type, const CompilerType &dynamic); TypeImpl(const CompilerType &compiler_type, const CompilerType &dynamic);
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/include/lldb/Target/ExecutionContextScope.h

Show All 25 Lines
/// ///
/// Objects can contain a valid pointer to an instance of this so they can /// Objects can contain a valid pointer to an instance of this so they can
/// reconstruct the execution context. /// reconstruct the execution context.
/// ///
/// Objects that adhere to this protocol can reconstruct enough of a execution /// Objects that adhere to this protocol can reconstruct enough of a execution
/// context to allow functions that take a execution contexts to be called. /// context to allow functions that take a execution contexts to be called.
class ExecutionContextScope { class ExecutionContextScope {
public: public:
virtual ~ExecutionContextScope() {} virtual ~ExecutionContextScope() = default;
virtual lldb::TargetSP CalculateTarget() = 0; virtual lldb::TargetSP CalculateTarget() = 0;
virtual lldb::ProcessSP CalculateProcess() = 0; virtual lldb::ProcessSP CalculateProcess() = 0;
virtual lldb::ThreadSP CalculateThread() = 0; virtual lldb::ThreadSP CalculateThread() = 0;
virtual lldb::StackFrameSP CalculateStackFrame() = 0; virtual lldb::StackFrameSP CalculateStackFrame() = 0;
Show All 16 Lines

lldb/include/lldb/Target/InstrumentationRuntimeStopInfo.h

Show All 12 Lines
#include "lldb/Target/StopInfo.h" #include "lldb/Target/StopInfo.h"
#include "lldb/Utility/StructuredData.h" #include "lldb/Utility/StructuredData.h"
namespace lldb_private { namespace lldb_private {
class InstrumentationRuntimeStopInfo : public StopInfo { class InstrumentationRuntimeStopInfo : public StopInfo {
public: public:
~InstrumentationRuntimeStopInfo() override {} ~InstrumentationRuntimeStopInfo() override = default;
lldb::StopReason GetStopReason() const override { lldb::StopReason GetStopReason() const override {
return lldb::eStopReasonInstrumentation; return lldb::eStopReasonInstrumentation;
} }
const char *GetDescription() override; const char *GetDescription() override;
bool DoShouldNotify(Event *event_ptr) override { return true; } bool DoShouldNotify(Event *event_ptr) override { return true; }
Show All 13 Lines

lldb/include/lldb/Target/Process.h

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
// currently modify the program are running the program (which will up the // currently modify the program are running the program (which will up the
// StopID) and writing memory (which will up the MemoryID.) // StopID) and writing memory (which will up the MemoryID.)
// FIXME: Should we also include modification of register states? // FIXME: Should we also include modification of register states?
class ProcessModID { class ProcessModID {
friend bool operator==(const ProcessModID &lhs, const ProcessModID &rhs); friend bool operator==(const ProcessModID &lhs, const ProcessModID &rhs);
public: public:
ProcessModID() ProcessModID() = default;
{}
ProcessModID(const ProcessModID &rhs) ProcessModID(const ProcessModID &rhs)
teemperorUnsubmitted
Done
ReplyInline Actions

format

teemperor: format
JDevlieghereAuthorUnsubmitted
Done
ReplyInline Actions

formatted

JDevlieghere: formatted
: m_stop_id(rhs.m_stop_id), m_memory_id(rhs.m_memory_id) {} : m_stop_id(rhs.m_stop_id), m_memory_id(rhs.m_memory_id) {}
const ProcessModID &operator=(const ProcessModID &rhs) { const ProcessModID &operator=(const ProcessModID &rhs) {
if (this != &rhs) { if (this != &rhs) {
m_stop_id = rhs.m_stop_id; m_stop_id = rhs.m_stop_id;
m_memory_id = rhs.m_memory_id; m_memory_id = rhs.m_memory_id;
} }
return *this; return *this;
▲ Show 20 Lines • Show All 89 Lines • Show Last 20 Lines

lldb/include/lldb/Target/RegisterCheckpoint.h

Show All 28 Lines enum class Reason {
// The register checkpoint wants the raw register bytes, so they must be // The register checkpoint wants the raw register bytes, so they must be
// read into m_data_sp, or the save/restore checkpoint should fail. // read into m_data_sp, or the save/restore checkpoint should fail.
eDataBackup eDataBackup
}; };
RegisterCheckpoint(Reason reason) RegisterCheckpoint(Reason reason)
: UserID(0), m_data_sp(), m_reason(reason) {} : UserID(0), m_data_sp(), m_reason(reason) {}
~RegisterCheckpoint() {} ~RegisterCheckpoint() = default;
lldb::DataBufferSP &GetData() { return m_data_sp; } lldb::DataBufferSP &GetData() { return m_data_sp; }
const lldb::DataBufferSP &GetData() const { return m_data_sp; } const lldb::DataBufferSP &GetData() const { return m_data_sp; }
protected: protected:
lldb::DataBufferSP m_data_sp; lldb::DataBufferSP m_data_sp;
Reason m_reason; Reason m_reason;
Show All 9 Lines

lldb/include/lldb/Target/StackFrameRecognizer.h

Show All 31 Lines
public: public:
virtual lldb::ValueObjectListSP GetRecognizedArguments() { virtual lldb::ValueObjectListSP GetRecognizedArguments() {
return m_arguments; return m_arguments;
} }
virtual lldb::ValueObjectSP GetExceptionObject() { virtual lldb::ValueObjectSP GetExceptionObject() {
return lldb::ValueObjectSP(); return lldb::ValueObjectSP();
} }
virtual lldb::StackFrameSP GetMostRelevantFrame() { return nullptr; }; virtual lldb::StackFrameSP GetMostRelevantFrame() { return nullptr; };
virtual ~RecognizedStackFrame(){}; virtual ~RecognizedStackFrame() = default;
teemperorUnsubmitted
Done
ReplyInline Actions

please remove that pointy boy

teemperor: please remove that pointy boy
JDevlieghereAuthorUnsubmitted
Done
ReplyInline Actions

pointy boy gone

JDevlieghere: pointy boy gone
std::string GetStopDescription() { return m_stop_desc; } std::string GetStopDescription() { return m_stop_desc; }
protected: protected:
lldb::ValueObjectListSP m_arguments; lldb::ValueObjectListSP m_arguments;
std::string m_stop_desc; std::string m_stop_desc;
}; };
/// \class StackFrameRecognizer /// \class StackFrameRecognizer
/// ///
/// A base class for frame recognizers. Subclasses (actual frame recognizers) /// A base class for frame recognizers. Subclasses (actual frame recognizers)
/// should implement RecognizeFrame to provide a RecognizedStackFrame for a /// should implement RecognizeFrame to provide a RecognizedStackFrame for a
/// given stack frame. /// given stack frame.
class StackFrameRecognizer class StackFrameRecognizer
: public std::enable_shared_from_this<StackFrameRecognizer> { : public std::enable_shared_from_this<StackFrameRecognizer> {
public: public:
virtual lldb::RecognizedStackFrameSP RecognizeFrame( virtual lldb::RecognizedStackFrameSP RecognizeFrame(
lldb::StackFrameSP frame) { lldb::StackFrameSP frame) {
return lldb::RecognizedStackFrameSP(); return lldb::RecognizedStackFrameSP();
}; };
virtual std::string GetName() { virtual std::string GetName() {
return ""; return "";
} }
virtual ~StackFrameRecognizer(){}; virtual ~StackFrameRecognizer() = default;
;
teemperorUnsubmitted
Done
ReplyInline Actions

and that one too

teemperor: and that one too
JDevlieghereAuthorUnsubmitted
Done
ReplyInline Actions

gone too

JDevlieghere: gone too
}; };
/// \class ScriptedStackFrameRecognizer /// \class ScriptedStackFrameRecognizer
/// ///
/// Python implementation for frame recognizers. An instance of this class /// Python implementation for frame recognizers. An instance of this class
/// tracks a particular Python classobject, which will be asked to recognize /// tracks a particular Python classobject, which will be asked to recognize
/// stack frames. /// stack frames.
class ScriptedStackFrameRecognizer : public StackFrameRecognizer { class ScriptedStackFrameRecognizer : public StackFrameRecognizer {
lldb_private::ScriptInterpreter *m_interpreter; lldb_private::ScriptInterpreter *m_interpreter;
lldb_private::StructuredData::ObjectSP m_python_object_sp; lldb_private::StructuredData::ObjectSP m_python_object_sp;
std::string m_python_class; std::string m_python_class;
public: public:
ScriptedStackFrameRecognizer(lldb_private::ScriptInterpreter *interpreter, ScriptedStackFrameRecognizer(lldb_private::ScriptInterpreter *interpreter,
const char *pclass); const char *pclass);
~ScriptedStackFrameRecognizer() override {} ~ScriptedStackFrameRecognizer() override = default;
std::string GetName() override { std::string GetName() override {
return GetPythonClassName(); return GetPythonClassName();
} }
const char *GetPythonClassName() { return m_python_class.c_str(); } const char *GetPythonClassName() { return m_python_class.c_str(); }
lldb::RecognizedStackFrameSP RecognizeFrame( lldb::RecognizedStackFrameSP RecognizeFrame(
▲ Show 20 Lines • Show All 89 Lines • Show Last 20 Lines

lldb/include/lldb/Target/StopInfo.h

Show All 19 Lines
class StopInfo { class StopInfo {
friend class Process::ProcessEventData; friend class Process::ProcessEventData;
friend class ThreadPlanBase; friend class ThreadPlanBase;
public: public:
// Constructors and Destructors // Constructors and Destructors
StopInfo(Thread &thread, uint64_t value); StopInfo(Thread &thread, uint64_t value);
virtual ~StopInfo() {} virtual ~StopInfo() = default;
bool IsValid() const; bool IsValid() const;
void SetThread(const lldb::ThreadSP &thread_sp) { m_thread_wp = thread_sp; } void SetThread(const lldb::ThreadSP &thread_sp) { m_thread_wp = thread_sp; }
lldb::ThreadSP GetThread() const { return m_thread_wp.lock(); } lldb::ThreadSP GetThread() const { return m_thread_wp.lock(); }
// The value of the StopInfo depends on the StopReason. // The value of the StopInfo depends on the StopReason.
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/include/lldb/Target/ThreadCollection.h

Show All 22 Linespublic:
typedef LockingAdaptedIterable<collection, lldb::ThreadSP, vector_adapter, typedef LockingAdaptedIterable<collection, lldb::ThreadSP, vector_adapter,
std::recursive_mutex> std::recursive_mutex>
ThreadIterable; ThreadIterable;
ThreadCollection(); ThreadCollection();
ThreadCollection(collection threads); ThreadCollection(collection threads);
virtual ~ThreadCollection() {} virtual ~ThreadCollection() = default;
uint32_t GetSize(); uint32_t GetSize();
void AddThread(const lldb::ThreadSP &thread_sp); void AddThread(const lldb::ThreadSP &thread_sp);
void AddThreadSortedByIndexID(const lldb::ThreadSP &thread_sp); void AddThreadSortedByIndexID(const lldb::ThreadSP &thread_sp);
void InsertThread(const lldb::ThreadSP &thread_sp, uint32_t idx); void InsertThread(const lldb::ThreadSP &thread_sp, uint32_t idx);
Show All 20 Lines

lldb/include/lldb/Target/ThreadPlanStack.h

Show All 27 Lines
// The ThreadPlanStack holds the ThreadPlans for a given TID. All its methods // The ThreadPlanStack holds the ThreadPlans for a given TID. All its methods
// are private, and it should only be accessed through the owning thread. When // are private, and it should only be accessed through the owning thread. When
// it is detached from a thread, all you can do is reattach it or delete it. // it is detached from a thread, all you can do is reattach it or delete it.
class ThreadPlanStack { class ThreadPlanStack {
friend class lldb_private::Thread; friend class lldb_private::Thread;
public: public:
ThreadPlanStack(const Thread &thread, bool make_empty = false); ThreadPlanStack(const Thread &thread, bool make_empty = false);
~ThreadPlanStack() {} ~ThreadPlanStack() = default;
using PlanStack = std::vector<lldb::ThreadPlanSP>; using PlanStack = std::vector<lldb::ThreadPlanSP>;
void DumpThreadPlans(Stream &s, lldb::DescriptionLevel desc_level, void DumpThreadPlans(Stream &s, lldb::DescriptionLevel desc_level,
bool include_internal) const; bool include_internal) const;
size_t CheckpointCompletedPlans(); size_t CheckpointCompletedPlans();
▲ Show 20 Lines • Show All 65 Lines • ▼ Show 20 Linesprivate:
size_t m_completed_plan_checkpoint = 0; // Monotonically increasing token for size_t m_completed_plan_checkpoint = 0; // Monotonically increasing token for
// completed plan checkpoints. // completed plan checkpoints.
std::unordered_map<size_t, PlanStack> m_completed_plan_store; std::unordered_map<size_t, PlanStack> m_completed_plan_store;
}; };
class ThreadPlanStackMap { class ThreadPlanStackMap {
public: public:
ThreadPlanStackMap(Process &process) : m_process(process) {} ThreadPlanStackMap(Process &process) : m_process(process) {}
~ThreadPlanStackMap() {} ~ThreadPlanStackMap() = default;
// Prune the map using the current_threads list. // Prune the map using the current_threads list.
void Update(ThreadList &current_threads, bool delete_missing, void Update(ThreadList &current_threads, bool delete_missing,
bool check_for_new = true); bool check_for_new = true);
void AddThread(Thread &thread) { void AddThread(Thread &thread) {
lldb::tid_t tid = thread.GetID(); lldb::tid_t tid = thread.GetID();
m_plans_list.emplace(tid, thread); m_plans_list.emplace(tid, thread);
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

lldb/include/lldb/Target/UnixSignals.h

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
ConstString m_name; ConstString m_name;
ConstString m_alias; ConstString m_alias;
std::string m_description; std::string m_description;
bool m_suppress : 1, m_stop : 1, m_notify : 1; bool m_suppress : 1, m_stop : 1, m_notify : 1;
Signal(const char *name, bool default_suppress, bool default_stop, Signal(const char *name, bool default_suppress, bool default_stop,
bool default_notify, const char *description, const char *alias); bool default_notify, const char *description, const char *alias);
~Signal() {} ~Signal() = default;
}; };
virtual void Reset(); virtual void Reset();
typedef std::map<int32_t, Signal> collection; typedef std::map<int32_t, Signal> collection;
collection m_signals; collection m_signals;
Show All 14 Lines

lldb/include/lldb/Target/Unwind.h

Show All 15 Lines
namespace lldb_private { namespace lldb_private {
class Unwind { class Unwind {
protected: protected:
// Classes that inherit from Unwind can see and modify these // Classes that inherit from Unwind can see and modify these
Unwind(Thread &thread) : m_thread(thread), m_unwind_mutex() {} Unwind(Thread &thread) : m_thread(thread), m_unwind_mutex() {}
public: public:
virtual ~Unwind() {} virtual ~Unwind() = default;
void Clear() { void Clear() {
std::lock_guard<std::recursive_mutex> guard(m_unwind_mutex); std::lock_guard<std::recursive_mutex> guard(m_unwind_mutex);
DoClear(); DoClear();
} }
uint32_t GetFrameCount() { uint32_t GetFrameCount() {
std::lock_guard<std::recursive_mutex> guard(m_unwind_mutex); std::lock_guard<std::recursive_mutex> guard(m_unwind_mutex);
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

lldb/include/lldb/Utility/Baton.h

Show All 28 Lines
/// This class is designed to be used by any objects that have a callback /// This class is designed to be used by any objects that have a callback
/// function that takes a baton where the baton might need to /// function that takes a baton where the baton might need to
/// free/delete/close itself. /// free/delete/close itself.
/// ///
/// The default behavior is to not free anything. Subclasses can free any /// The default behavior is to not free anything. Subclasses can free any
/// needed resources in their destructors. /// needed resources in their destructors.
class Baton { class Baton {
public: public:
Baton() {} Baton() = default;
virtual ~Baton() {} virtual ~Baton() = default;
virtual void *data() = 0; virtual void *data() = 0;
virtual void GetDescription(llvm::raw_ostream &s, virtual void GetDescription(llvm::raw_ostream &s,
lldb::DescriptionLevel level, lldb::DescriptionLevel level,
unsigned indentation) const = 0; unsigned indentation) const = 0;
}; };
Show All 33 Lines

lldb/include/lldb/Utility/DataBuffer.h

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 Lines
class DataBuffer { class DataBuffer {
public: public:
/// Destructor /// Destructor
/// ///
/// The destructor is virtual as other classes will inherit from this class /// The destructor is virtual as other classes will inherit from this class
/// and be downcast to the DataBuffer pure virtual interface. The virtual /// and be downcast to the DataBuffer pure virtual interface. The virtual
/// destructor ensures that destructing the base class will destruct the /// destructor ensures that destructing the base class will destruct the
/// class that inherited from it correctly. /// class that inherited from it correctly.
virtual ~DataBuffer() {} virtual ~DataBuffer() = default;
/// Get a pointer to the data. /// Get a pointer to the data.
/// ///
/// \return /// \return
/// A pointer to the bytes owned by this object, or NULL if the /// A pointer to the bytes owned by this object, or NULL if the
/// object contains no bytes. /// object contains no bytes.
virtual uint8_t *GetBytes() = 0; virtual uint8_t *GetBytes() = 0;
Show All 40 Lines

lldb/include/lldb/Utility/Event.h

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
EventDataBytes(const EventDataBytes &) = delete; EventDataBytes(const EventDataBytes &) = delete;
const EventDataBytes &operator=(const EventDataBytes &) = delete; const EventDataBytes &operator=(const EventDataBytes &) = delete;
}; };
class EventDataReceipt : public EventData { class EventDataReceipt : public EventData {
public: public:
EventDataReceipt() : EventData(), m_predicate(false) {} EventDataReceipt() : EventData(), m_predicate(false) {}
~EventDataReceipt() override {} ~EventDataReceipt() override = default;
static ConstString GetFlavorString() { static ConstString GetFlavorString() {
static ConstString g_flavor("Process::ProcessEventData"); static ConstString g_flavor("Process::ProcessEventData");
return g_flavor; return g_flavor;
} }
ConstString GetFlavor() const override { return GetFlavorString(); } ConstString GetFlavor() const override { return GetFlavorString(); }
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/include/lldb/Utility/ReproducerInstrumentation.h

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
Deserialized... d) { Deserialized... d) {
return f(d...); return f(d...);
} }
}; };
}; };
/// The replayer interface. /// The replayer interface.
struct Replayer { struct Replayer {
virtual ~Replayer() {} virtual ~Replayer() = default;
virtual void operator()(Deserializer &deserializer) const = 0; virtual void operator()(Deserializer &deserializer) const = 0;
}; };
/// The default replayer deserializes the arguments and calls the function. /// The default replayer deserializes the arguments and calls the function.
template <typename Signature> struct DefaultReplayer; template <typename Signature> struct DefaultReplayer;
template <typename Result, typename... Args> template <typename Result, typename... Args>
struct DefaultReplayer<Result(Args...)> : public Replayer { struct DefaultReplayer<Result(Args...)> : public Replayer {
DefaultReplayer(Result (*f)(Args...)) : Replayer(), f(f) {} DefaultReplayer(Result (*f)(Args...)) : Replayer(), f(f) {}
▲ Show 20 Lines • Show All 182 Lines • ▼ Show 20 Lines
static void Initialize(Serializer &serializer, Registry &registry); static void Initialize(Serializer &serializer, Registry &registry);
static void Initialize(Deserializer &serializer, Registry &registry); static void Initialize(Deserializer &serializer, Registry &registry);
static InstrumentationData &Instance(); static InstrumentationData &Instance();
protected: protected:
friend llvm::optional_detail::OptionalStorage<InstrumentationData, true>; friend llvm::optional_detail::OptionalStorage<InstrumentationData, true>;
friend llvm::Optional<InstrumentationData>; friend llvm::Optional<InstrumentationData>;
InstrumentationData() {} InstrumentationData() = default;
InstrumentationData(Serializer &serializer, Registry &registry) InstrumentationData(Serializer &serializer, Registry &registry)
: m_serializer(&serializer), m_deserializer(nullptr), : m_serializer(&serializer), m_deserializer(nullptr),
m_registry(&registry) {} m_registry(&registry) {}
InstrumentationData(Deserializer &deserializer, Registry &registry) InstrumentationData(Deserializer &deserializer, Registry &registry)
: m_serializer(nullptr), m_deserializer(&deserializer), : m_serializer(nullptr), m_deserializer(&deserializer),
m_registry(&registry) {} m_registry(&registry) {}
private: private:
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/include/lldb/Utility/StreamTee.h

Show All 39 Linespublic:
StreamTee(const StreamTee &rhs) StreamTee(const StreamTee &rhs)
: Stream(rhs), m_streams_mutex(), m_streams() { : Stream(rhs), m_streams_mutex(), m_streams() {
// Don't copy until we lock down "rhs" // Don't copy until we lock down "rhs"
std::lock_guard<std::recursive_mutex> guard(rhs.m_streams_mutex); std::lock_guard<std::recursive_mutex> guard(rhs.m_streams_mutex);
m_streams = rhs.m_streams; m_streams = rhs.m_streams;
} }
~StreamTee() override {} ~StreamTee() override = default;
StreamTee &operator=(const StreamTee &rhs) { StreamTee &operator=(const StreamTee &rhs) {
if (this != &rhs) { if (this != &rhs) {
Stream::operator=(rhs); Stream::operator=(rhs);
std::lock(m_streams_mutex, rhs.m_streams_mutex); std::lock(m_streams_mutex, rhs.m_streams_mutex);
std::lock_guard<std::recursive_mutex> lhs_locker(m_streams_mutex, std::lock_guard<std::recursive_mutex> lhs_locker(m_streams_mutex,
std::adopt_lock); std::adopt_lock);
std::lock_guard<std::recursive_mutex> rhs_locker(rhs.m_streams_mutex, std::lock_guard<std::recursive_mutex> rhs_locker(rhs.m_streams_mutex,
▲ Show 20 Lines • Show All 85 Lines • Show Last 20 Lines

lldb/include/lldb/Utility/TraceGDBRemotePackets.h

Show First 20 Lines • Show All 51 Lines • ▼ Show 20 Linesbool fromJSON(const llvm::json::Value &value, TraceStartRequest &packet,
llvm::json::Path path); llvm::json::Path path);
llvm::json::Value toJSON(const TraceStartRequest &packet); llvm::json::Value toJSON(const TraceStartRequest &packet);
/// \} /// \}
/// jLLDBTraceStop gdb-remote packet /// jLLDBTraceStop gdb-remote packet
/// \{ /// \{
struct TraceStopRequest { struct TraceStopRequest {
TraceStopRequest() {} TraceStopRequest() = default;
TraceStopRequest(llvm::StringRef type, const std::vector<lldb::tid_t> &tids); TraceStopRequest(llvm::StringRef type, const std::vector<lldb::tid_t> &tids);
TraceStopRequest(llvm::StringRef type) : type(type){}; TraceStopRequest(llvm::StringRef type) : type(type){};
bool IsProcessTracing() const; bool IsProcessTracing() const;
/// Tracing technology name, e.g. intel-pt, arm-coresight. /// Tracing technology name, e.g. intel-pt, arm-coresight.
▲ Show 20 Lines • Show All 83 Lines • Show Last 20 Lines

lldb/include/lldb/Utility/UserID.h

Show All 27 Lines
/// Symbol table entries can use this to store the original symbol table /// Symbol table entries can use this to store the original symbol table
/// index, functions can use it to store the symbol table index or the /// index, functions can use it to store the symbol table index or the
/// DWARF offset. /// DWARF offset.
struct UserID { struct UserID {
/// Construct with optional user ID. /// Construct with optional user ID.
UserID(lldb::user_id_t uid = LLDB_INVALID_UID) : m_uid(uid) {} UserID(lldb::user_id_t uid = LLDB_INVALID_UID) : m_uid(uid) {}
/// Destructor. /// Destructor.
~UserID() {} ~UserID() = default;
/// Clears the object state. /// Clears the object state.
/// ///
/// Clears the object contents back to a default invalid state. /// Clears the object contents back to a default invalid state.
void Clear() { m_uid = LLDB_INVALID_UID; } void Clear() { m_uid = LLDB_INVALID_UID; }
/// Get accessor for the user ID. /// Get accessor for the user ID.
/// ///
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

lldb/include/lldb/Utility/VMRange.h

Show All 20 Lines
// A vm address range. These can represent offsets ranges or actual // A vm address range. These can represent offsets ranges or actual
// addresses. // addresses.
class VMRange { class VMRange {
public: public:
typedef std::vector<VMRange> collection; typedef std::vector<VMRange> collection;
typedef collection::iterator iterator; typedef collection::iterator iterator;
typedef collection::const_iterator const_iterator; typedef collection::const_iterator const_iterator;
VMRange() {} VMRange() = default;
VMRange(lldb::addr_t start_addr, lldb::addr_t end_addr) VMRange(lldb::addr_t start_addr, lldb::addr_t end_addr)
: m_base_addr(start_addr), : m_base_addr(start_addr),
m_byte_size(end_addr > start_addr ? end_addr - start_addr : 0) {} m_byte_size(end_addr > start_addr ? end_addr - start_addr : 0) {}
~VMRange() {} ~VMRange() = default;
void Clear() { void Clear() {
m_base_addr = 0; m_base_addr = 0;
m_byte_size = 0; m_byte_size = 0;
} }
// Set the start and end values // Set the start and end values
void Reset(lldb::addr_t start_addr, lldb::addr_t end_addr) { void Reset(lldb::addr_t start_addr, lldb::addr_t end_addr) {
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

lldb/include/lldb/lldb-private-types.h

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
int64_t value; int64_t value;
const char *string_value; const char *string_value;
const char *usage; const char *usage;
}; };
using OptionEnumValues = llvm::ArrayRef<OptionEnumValueElement>; using OptionEnumValues = llvm::ArrayRef<OptionEnumValueElement>;
struct OptionValidator { struct OptionValidator {
virtual ~OptionValidator() {} virtual ~OptionValidator() = default;
virtual bool IsValid(Platform &platform, virtual bool IsValid(Platform &platform,
const ExecutionContext &target) const = 0; const ExecutionContext &target) const = 0;
virtual const char *ShortConditionString() const = 0; virtual const char *ShortConditionString() const = 0;
virtual const char *LongConditionString() const = 0; virtual const char *LongConditionString() const = 0;
}; };
typedef struct type128 { uint64_t x[2]; } type128; typedef struct type128 { uint64_t x[2]; } type128;
typedef struct type256 { uint64_t x[4]; } type256; typedef struct type256 { uint64_t x[4]; } type256;
} // namespace lldb_private } // namespace lldb_private
#endif // #if defined(__cplusplus) #endif // #if defined(__cplusplus)
#endif // LLDB_LLDB_PRIVATE_TYPES_H #endif // LLDB_LLDB_PRIVATE_TYPES_H
Context not available.

lldb/source/Breakpoint/BreakpointList.cpp

Show All 20 Lines if (target.EventTypeHasListeners(Target::eBroadcastBitBreakpointChanged))
target.BroadcastEvent(Target::eBroadcastBitBreakpointChanged, target.BroadcastEvent(Target::eBroadcastBitBreakpointChanged,
new Breakpoint::BreakpointEventData(event, bp)); new Breakpoint::BreakpointEventData(event, bp));
} }
BreakpointList::BreakpointList(bool is_internal) BreakpointList::BreakpointList(bool is_internal)
: m_mutex(), m_breakpoints(), m_next_break_id(0), : m_mutex(), m_breakpoints(), m_next_break_id(0),
m_is_internal(is_internal) {} m_is_internal(is_internal) {}
BreakpointList::~BreakpointList() {} BreakpointList::~BreakpointList() = default;
break_id_t BreakpointList::Add(BreakpointSP &bp_sp, bool notify) { break_id_t BreakpointList::Add(BreakpointSP &bp_sp, bool notify) {
std::lock_guard<std::recursive_mutex> guard(m_mutex); std::lock_guard<std::recursive_mutex> guard(m_mutex);
// Internal breakpoint IDs are negative, normal ones are positive // Internal breakpoint IDs are negative, normal ones are positive
bp_sp->SetID(m_is_internal ? --m_next_break_id : ++m_next_break_id); bp_sp->SetID(m_is_internal ? --m_next_break_id : ++m_next_break_id);
m_breakpoints.push_back(bp_sp); m_breakpoints.push_back(bp_sp);
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Breakpoint/BreakpointLocationCollection.cpp

Show All 15 Lines
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
// BreakpointLocationCollection constructor // BreakpointLocationCollection constructor
BreakpointLocationCollection::BreakpointLocationCollection() BreakpointLocationCollection::BreakpointLocationCollection()
: m_break_loc_collection(), m_collection_mutex() {} : m_break_loc_collection(), m_collection_mutex() {}
// Destructor // Destructor
BreakpointLocationCollection::~BreakpointLocationCollection() {} BreakpointLocationCollection::~BreakpointLocationCollection() = default;
void BreakpointLocationCollection::Add(const BreakpointLocationSP &bp_loc) { void BreakpointLocationCollection::Add(const BreakpointLocationSP &bp_loc) {
std::lock_guard<std::mutex> guard(m_collection_mutex); std::lock_guard<std::mutex> guard(m_collection_mutex);
BreakpointLocationSP old_bp_loc = BreakpointLocationSP old_bp_loc =
FindByIDPair(bp_loc->GetBreakpoint().GetID(), bp_loc->GetID()); FindByIDPair(bp_loc->GetBreakpoint().GetID(), bp_loc->GetID());
if (!old_bp_loc.get()) if (!old_bp_loc.get())
m_break_loc_collection.push_back(bp_loc); m_break_loc_collection.push_back(bp_loc);
} }
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Breakpoint/BreakpointResolver.cpp

Show First 20 Lines • Show All 59 Lines • ▼ Show 20 LinesBreakpointResolver::NameToResolverTy(llvm::StringRef name) {
return UnknownResolver; return UnknownResolver;
} }
BreakpointResolver::BreakpointResolver(const BreakpointSP &bkpt, BreakpointResolver::BreakpointResolver(const BreakpointSP &bkpt,
const unsigned char resolverTy, const unsigned char resolverTy,
lldb::addr_t offset) lldb::addr_t offset)
: m_breakpoint(bkpt), m_offset(offset), SubclassID(resolverTy) {} : m_breakpoint(bkpt), m_offset(offset), SubclassID(resolverTy) {}
BreakpointResolver::~BreakpointResolver() {} BreakpointResolver::~BreakpointResolver() = default;
BreakpointResolverSP BreakpointResolver::CreateFromStructuredData( BreakpointResolverSP BreakpointResolver::CreateFromStructuredData(
const StructuredData::Dictionary &resolver_dict, Status &error) { const StructuredData::Dictionary &resolver_dict, Status &error) {
BreakpointResolverSP result_sp; BreakpointResolverSP result_sp;
if (!resolver_dict.IsValid()) { if (!resolver_dict.IsValid()) {
error.SetErrorString("Can't deserialize from an invalid data object."); error.SetErrorString("Can't deserialize from an invalid data object.");
return result_sp; return result_sp;
} }
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Breakpoint/BreakpointSiteList.cpp

Show All 10 Lines
#include "lldb/Utility/Stream.h" #include "lldb/Utility/Stream.h"
#include <algorithm> #include <algorithm>
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
BreakpointSiteList::BreakpointSiteList() : m_mutex(), m_bp_site_list() {} BreakpointSiteList::BreakpointSiteList() : m_mutex(), m_bp_site_list() {}
BreakpointSiteList::~BreakpointSiteList() {} BreakpointSiteList::~BreakpointSiteList() = default;
// Add breakpoint site to the list. However, if the element already exists in // Add breakpoint site to the list. However, if the element already exists in
// the list, then we don't add it, and return LLDB_INVALID_BREAK_ID. // the list, then we don't add it, and return LLDB_INVALID_BREAK_ID.
lldb::break_id_t BreakpointSiteList::Add(const BreakpointSiteSP &bp) { lldb::break_id_t BreakpointSiteList::Add(const BreakpointSiteSP &bp) {
lldb::addr_t bp_site_load_addr = bp->GetLoadAddress(); lldb::addr_t bp_site_load_addr = bp->GetLoadAddress();
std::lock_guard<std::recursive_mutex> guard(m_mutex); std::lock_guard<std::recursive_mutex> guard(m_mutex);
collection::iterator iter = m_bp_site_list.find(bp_site_load_addr); collection::iterator iter = m_bp_site_list.find(bp_site_load_addr);
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Breakpoint/Stoppoint.cpp

//===-- Stoppoint.cpp -----------------------------------------------------===// //===-- Stoppoint.cpp -----------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Breakpoint/Stoppoint.h" #include "lldb/Breakpoint/Stoppoint.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
// Stoppoint constructor // Stoppoint constructor
Stoppoint::Stoppoint() {} Stoppoint::Stoppoint() = default;
// Destructor // Destructor
Stoppoint::~Stoppoint() {} Stoppoint::~Stoppoint() = default;
break_id_t Stoppoint::GetID() const { return m_bid; } break_id_t Stoppoint::GetID() const { return m_bid; }
void Stoppoint::SetID(break_id_t bid) { m_bid = bid; } void Stoppoint::SetID(break_id_t bid) { m_bid = bid; }

lldb/source/Breakpoint/WatchpointList.cpp

//===-- WatchpointList.cpp ------------------------------------------------===// //===-- WatchpointList.cpp ------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Breakpoint/WatchpointList.h" #include "lldb/Breakpoint/WatchpointList.h"
#include "lldb/Breakpoint/Watchpoint.h" #include "lldb/Breakpoint/Watchpoint.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
WatchpointList::WatchpointList() : m_watchpoints(), m_mutex() {} WatchpointList::WatchpointList() : m_watchpoints(), m_mutex() {}
WatchpointList::~WatchpointList() {} WatchpointList::~WatchpointList() = default;
// Add a watchpoint to the list. // Add a watchpoint to the list.
lldb::watch_id_t WatchpointList::Add(const WatchpointSP &wp_sp, bool notify) { lldb::watch_id_t WatchpointList::Add(const WatchpointSP &wp_sp, bool notify) {
std::lock_guard<std::recursive_mutex> guard(m_mutex); std::lock_guard<std::recursive_mutex> guard(m_mutex);
wp_sp->SetID(++m_next_wp_id); wp_sp->SetID(++m_next_wp_id);
m_watchpoints.push_back(wp_sp); m_watchpoints.push_back(wp_sp);
if (notify) { if (notify) {
if (wp_sp->GetTarget().EventTypeHasListeners( if (wp_sp->GetTarget().EventTypeHasListeners(
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Commands/CommandObjectGUI.cpp

Show All 16 Lines
using namespace lldb_private; using namespace lldb_private;
// CommandObjectGUI // CommandObjectGUI
CommandObjectGUI::CommandObjectGUI(CommandInterpreter &interpreter) CommandObjectGUI::CommandObjectGUI(CommandInterpreter &interpreter)
: CommandObjectParsed(interpreter, "gui", : CommandObjectParsed(interpreter, "gui",
"Switch into the curses based GUI mode.", "gui") {} "Switch into the curses based GUI mode.", "gui") {}
CommandObjectGUI::~CommandObjectGUI() {} CommandObjectGUI::~CommandObjectGUI() = default;
bool CommandObjectGUI::DoExecute(Args &args, CommandReturnObject &result) { bool CommandObjectGUI::DoExecute(Args &args, CommandReturnObject &result) {
#if LLDB_ENABLE_CURSES #if LLDB_ENABLE_CURSES
if (args.GetArgumentCount() == 0) { if (args.GetArgumentCount() == 0) {
Debugger &debugger = GetDebugger(); Debugger &debugger = GetDebugger();
File &input = debugger.GetInputFile(); File &input = debugger.GetInputFile();
File &output = debugger.GetOutputFile(); File &output = debugger.GetOutputFile();
Show All 20 Lines

lldb/source/Commands/CommandObjectHelp.h

Show All 28 Lines static void GenerateAdditionalHelpAvenuesMessage(
Stream *s, llvm::StringRef command, llvm::StringRef prefix, Stream *s, llvm::StringRef command, llvm::StringRef prefix,
llvm::StringRef subcommand, bool include_upropos = true, llvm::StringRef subcommand, bool include_upropos = true,
bool include_type_lookup = true); bool include_type_lookup = true);
class CommandOptions : public Options { class CommandOptions : public Options {
public: public:
CommandOptions() : Options() {} CommandOptions() : Options() {}
~CommandOptions() override {} ~CommandOptions() override = default;
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
ExecutionContext *execution_context) override { ExecutionContext *execution_context) override {
Status error; Status error;
const int short_option = m_getopt_table[option_idx].val; const int short_option = m_getopt_table[option_idx].val;
switch (short_option) { switch (short_option) {
case 'a': case 'a':
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

lldb/source/Commands/CommandObjectLanguage.cpp

Show All 17 Lines
CommandObjectLanguage::CommandObjectLanguage(CommandInterpreter &interpreter) CommandObjectLanguage::CommandObjectLanguage(CommandInterpreter &interpreter)
: CommandObjectMultiword( : CommandObjectMultiword(
interpreter, "language", "Commands specific to a source language.", interpreter, "language", "Commands specific to a source language.",
"language <language-name> <subcommand> [<subcommand-options>]") { "language <language-name> <subcommand> [<subcommand-options>]") {
// Let the LanguageRuntime populates this command with subcommands // Let the LanguageRuntime populates this command with subcommands
LanguageRuntime::InitializeCommands(this); LanguageRuntime::InitializeCommands(this);
} }
CommandObjectLanguage::~CommandObjectLanguage() {} CommandObjectLanguage::~CommandObjectLanguage() = default;

lldb/source/Commands/CommandObjectPlatform.cpp

Show First 20 Lines • Show All 54 Lines • ▼ Show 20 Linesstatic mode_t ParsePermissionString(llvm::StringRef permissions) {
return user | group | world; return user | group | world;
} }
#define LLDB_OPTIONS_permissions #define LLDB_OPTIONS_permissions
#include "CommandOptions.inc" #include "CommandOptions.inc"
class OptionPermissions : public OptionGroup { class OptionPermissions : public OptionGroup {
public: public:
OptionPermissions() {} OptionPermissions() = default;
~OptionPermissions() override = default; ~OptionPermissions() override = default;
lldb_private::Status lldb_private::Status
SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
ExecutionContext *execution_context) override { ExecutionContext *execution_context) override {
Status error; Status error;
char short_option = (char)GetDefinitions()[option_idx].short_option; char short_option = (char)GetDefinitions()[option_idx].short_option;
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Commands/CommandObjectQuit.cpp

Show All 16 Lines
using namespace lldb_private; using namespace lldb_private;
// CommandObjectQuit // CommandObjectQuit
CommandObjectQuit::CommandObjectQuit(CommandInterpreter &interpreter) CommandObjectQuit::CommandObjectQuit(CommandInterpreter &interpreter)
: CommandObjectParsed(interpreter, "quit", "Quit the LLDB debugger.", : CommandObjectParsed(interpreter, "quit", "Quit the LLDB debugger.",
"quit [exit-code]") {} "quit [exit-code]") {}
CommandObjectQuit::~CommandObjectQuit() {} CommandObjectQuit::~CommandObjectQuit() = default;
// returns true if there is at least one alive process is_a_detach will be true // returns true if there is at least one alive process is_a_detach will be true
// if all alive processes will be detached when you quit and false if at least // if all alive processes will be detached when you quit and false if at least
// one process will be killed instead // one process will be killed instead
bool CommandObjectQuit::ShouldAskForConfirmation(bool &is_a_detach) { bool CommandObjectQuit::ShouldAskForConfirmation(bool &is_a_detach) {
if (!m_interpreter.GetPromptOnQuit()) if (!m_interpreter.GetPromptOnQuit())
return false; return false;
bool should_prompt = false; bool should_prompt = false;
▲ Show 20 Lines • Show All 78 Lines • Show Last 20 Lines

lldb/source/Commands/CommandObjectRegexCommand.cpp

Show All 17 LinesCommandObjectRegexCommand::CommandObjectRegexCommand(
CommandInterpreter &interpreter, llvm::StringRef name, llvm::StringRef help, CommandInterpreter &interpreter, llvm::StringRef name, llvm::StringRef help,
llvm::StringRef syntax, uint32_t max_matches, uint32_t completion_type_mask, llvm::StringRef syntax, uint32_t max_matches, uint32_t completion_type_mask,
bool is_removable) bool is_removable)
: CommandObjectRaw(interpreter, name, help, syntax), : CommandObjectRaw(interpreter, name, help, syntax),
m_max_matches(max_matches), m_completion_type_mask(completion_type_mask), m_max_matches(max_matches), m_completion_type_mask(completion_type_mask),
m_entries(), m_is_removable(is_removable) {} m_entries(), m_is_removable(is_removable) {}
// Destructor // Destructor
CommandObjectRegexCommand::~CommandObjectRegexCommand() {} CommandObjectRegexCommand::~CommandObjectRegexCommand() = default;
bool CommandObjectRegexCommand::DoExecute(llvm::StringRef command, bool CommandObjectRegexCommand::DoExecute(llvm::StringRef command,
CommandReturnObject &result) { CommandReturnObject &result) {
EntryCollection::const_iterator pos, end = m_entries.end(); EntryCollection::const_iterator pos, end = m_entries.end();
for (pos = m_entries.begin(); pos != end; ++pos) { for (pos = m_entries.begin(); pos != end; ++pos) {
llvm::SmallVector<llvm::StringRef, 4> matches; llvm::SmallVector<llvm::StringRef, 4> matches;
if (pos->regex.Execute(command, &matches)) { if (pos->regex.Execute(command, &matches)) {
std::string new_command(pos->command); std::string new_command(pos->command);
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines

lldb/source/Commands/CommandObjectScript.cpp

Show First 20 Lines • Show All 78 Lines • ▼ Show 20 Lines
CommandObjectScript::CommandObjectScript(CommandInterpreter &interpreter) CommandObjectScript::CommandObjectScript(CommandInterpreter &interpreter)
: CommandObjectRaw( : CommandObjectRaw(
interpreter, "script", interpreter, "script",
"Invoke the script interpreter with provided code and display any " "Invoke the script interpreter with provided code and display any "
"results. Start the interactive interpreter if no code is supplied.", "results. Start the interactive interpreter if no code is supplied.",
"script [--language <scripting-language> --] [<script-code>]") {} "script [--language <scripting-language> --] [<script-code>]") {}
CommandObjectScript::~CommandObjectScript() {} CommandObjectScript::~CommandObjectScript() = default;
bool CommandObjectScript::DoExecute(llvm::StringRef command, bool CommandObjectScript::DoExecute(llvm::StringRef command,
CommandReturnObject &result) { CommandReturnObject &result) {
// Try parsing the language option but when the command contains a raw part // Try parsing the language option but when the command contains a raw part
// separated by the -- delimiter. // separated by the -- delimiter.
OptionsWithRaw raw_args(command); OptionsWithRaw raw_args(command);
if (raw_args.HasArgs()) { if (raw_args.HasArgs()) {
if (!ParseOptions(raw_args.GetArgs(), result)) if (!ParseOptions(raw_args.GetArgs(), result))
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

lldb/source/Commands/CommandObjectTarget.cpp

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
}, },
}; };
#define LLDB_OPTIONS_target_dependents #define LLDB_OPTIONS_target_dependents
#include "CommandOptions.inc" #include "CommandOptions.inc"
class OptionGroupDependents : public OptionGroup { class OptionGroupDependents : public OptionGroup {
public: public:
OptionGroupDependents() {} OptionGroupDependents() = default;
~OptionGroupDependents() override {} ~OptionGroupDependents() override = default;
llvm::ArrayRef<OptionDefinition> GetDefinitions() override { llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
return llvm::makeArrayRef(g_target_dependents_options); return llvm::makeArrayRef(g_target_dependents_options);
} }
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value, Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
ExecutionContext *execution_context) override { ExecutionContext *execution_context) override {
Status error; Status error;
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Commands/CommandObjectVersion.cpp

Show All 14 Lines
using namespace lldb_private; using namespace lldb_private;
// CommandObjectVersion // CommandObjectVersion
CommandObjectVersion::CommandObjectVersion(CommandInterpreter &interpreter) CommandObjectVersion::CommandObjectVersion(CommandInterpreter &interpreter)
: CommandObjectParsed(interpreter, "version", : CommandObjectParsed(interpreter, "version",
"Show the LLDB debugger version.", "version") {} "Show the LLDB debugger version.", "version") {}
CommandObjectVersion::~CommandObjectVersion() {} CommandObjectVersion::~CommandObjectVersion() = default;
bool CommandObjectVersion::DoExecute(Args &args, CommandReturnObject &result) { bool CommandObjectVersion::DoExecute(Args &args, CommandReturnObject &result) {
if (args.GetArgumentCount() == 0) { if (args.GetArgumentCount() == 0) {
result.AppendMessageWithFormat("%s\n", lldb_private::GetVersion()); result.AppendMessageWithFormat("%s\n", lldb_private::GetVersion());
result.SetStatus(eReturnStatusSuccessFinishResult); result.SetStatus(eReturnStatusSuccessFinishResult);
} else { } else {
result.AppendError("the version command takes no arguments."); result.AppendError("the version command takes no arguments.");
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
} }
return true; return true;
} }

lldb/source/Core/AddressRange.cpp

Show All 35 Lines
AddressRange::AddressRange(const lldb::SectionSP &section, addr_t offset, AddressRange::AddressRange(const lldb::SectionSP &section, addr_t offset,
addr_t byte_size) addr_t byte_size)
: m_base_addr(section, offset), m_byte_size(byte_size) {} : m_base_addr(section, offset), m_byte_size(byte_size) {}
AddressRange::AddressRange(const Address &so_addr, addr_t byte_size) AddressRange::AddressRange(const Address &so_addr, addr_t byte_size)
: m_base_addr(so_addr), m_byte_size(byte_size) {} : m_base_addr(so_addr), m_byte_size(byte_size) {}
AddressRange::~AddressRange() {} AddressRange::~AddressRange() = default;
bool AddressRange::Contains(const Address &addr) const { bool AddressRange::Contains(const Address &addr) const {
SectionSP range_sect_sp = GetBaseAddress().GetSection(); SectionSP range_sect_sp = GetBaseAddress().GetSection();
SectionSP addr_sect_sp = addr.GetSection(); SectionSP addr_sect_sp = addr.GetSection();
if (range_sect_sp) { if (range_sect_sp) {
if (!addr_sect_sp || if (!addr_sect_sp ||
range_sect_sp->GetModule() != addr_sect_sp->GetModule()) range_sect_sp->GetModule() != addr_sect_sp->GetModule())
return false; // Modules do not match. return false; // Modules do not match.
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Core/AddressResolver.cpp

Show All 11 Lines
namespace lldb_private { namespace lldb_private {
class ModuleList; class ModuleList;
} }
using namespace lldb_private; using namespace lldb_private;
// AddressResolver: // AddressResolver:
AddressResolver::AddressResolver() {} AddressResolver::AddressResolver() = default;
AddressResolver::~AddressResolver() {} AddressResolver::~AddressResolver() = default;
void AddressResolver::ResolveAddressInModules(SearchFilter &filter, void AddressResolver::ResolveAddressInModules(SearchFilter &filter,
ModuleList &modules) { ModuleList &modules) {
filter.SearchInModuleList(*this, modules); filter.SearchInModuleList(*this, modules);
} }
void AddressResolver::ResolveAddress(SearchFilter &filter) { void AddressResolver::ResolveAddress(SearchFilter &filter) {
filter.Search(*this); filter.Search(*this);
Show All 13 Lines

lldb/source/Core/AddressResolverFileLine.cpp

Show All 26 Lines
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
// AddressResolverFileLine: // AddressResolverFileLine:
AddressResolverFileLine::AddressResolverFileLine( AddressResolverFileLine::AddressResolverFileLine(
SourceLocationSpec location_spec) SourceLocationSpec location_spec)
: AddressResolver(), m_src_location_spec(location_spec) {} : AddressResolver(), m_src_location_spec(location_spec) {}
AddressResolverFileLine::~AddressResolverFileLine() {} AddressResolverFileLine::~AddressResolverFileLine() = default;
Searcher::CallbackReturn Searcher::CallbackReturn
AddressResolverFileLine::SearchCallback(SearchFilter &filter, AddressResolverFileLine::SearchCallback(SearchFilter &filter,
SymbolContext &context, Address *addr) { SymbolContext &context, Address *addr) {
SymbolContextList sc_list; SymbolContextList sc_list;
CompileUnit *cu = context.comp_unit; CompileUnit *cu = context.comp_unit;
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS)); Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
Show All 37 Lines

lldb/source/Core/FileLineResolver.cpp

Show All 23 Lines
using namespace lldb_private; using namespace lldb_private;
// FileLineResolver: // FileLineResolver:
FileLineResolver::FileLineResolver(const FileSpec &file_spec, uint32_t line_no, FileLineResolver::FileLineResolver(const FileSpec &file_spec, uint32_t line_no,
bool check_inlines) bool check_inlines)
: Searcher(), m_file_spec(file_spec), m_line_number(line_no), : Searcher(), m_file_spec(file_spec), m_line_number(line_no),
m_inlines(check_inlines) {} m_inlines(check_inlines) {}
FileLineResolver::~FileLineResolver() {} FileLineResolver::~FileLineResolver() = default;
Searcher::CallbackReturn Searcher::CallbackReturn
FileLineResolver::SearchCallback(SearchFilter &filter, SymbolContext &context, FileLineResolver::SearchCallback(SearchFilter &filter, SymbolContext &context,
Address *addr) { Address *addr) {
CompileUnit *cu = context.comp_unit; CompileUnit *cu = context.comp_unit;
if (m_inlines || m_file_spec.Compare(cu->GetPrimaryFile(), m_file_spec, if (m_inlines || m_file_spec.Compare(cu->GetPrimaryFile(), m_file_spec,
(bool)m_file_spec.GetDirectory())) { (bool)m_file_spec.GetDirectory())) {
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

lldb/source/Core/ModuleChild.cpp

//===-- ModuleChild.cpp ---------------------------------------------------===// //===-- ModuleChild.cpp ---------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Core/ModuleChild.h" #include "lldb/Core/ModuleChild.h"
using namespace lldb_private; using namespace lldb_private;
ModuleChild::ModuleChild(const lldb::ModuleSP &module_sp) ModuleChild::ModuleChild(const lldb::ModuleSP &module_sp)
: m_module_wp(module_sp) {} : m_module_wp(module_sp) {}
ModuleChild::~ModuleChild() {} ModuleChild::~ModuleChild() = default;
const ModuleChild &ModuleChild::operator=(const ModuleChild &rhs) { const ModuleChild &ModuleChild::operator=(const ModuleChild &rhs) {
if (this != &rhs) if (this != &rhs)
m_module_wp = rhs.m_module_wp; m_module_wp = rhs.m_module_wp;
return *this; return *this;
} }
lldb::ModuleSP ModuleChild::GetModule() const { return m_module_wp.lock(); } lldb::ModuleSP ModuleChild::GetModule() const { return m_module_wp.lock(); }
void ModuleChild::SetModule(const lldb::ModuleSP &module_sp) { void ModuleChild::SetModule(const lldb::ModuleSP &module_sp) {
m_module_wp = module_sp; m_module_wp = module_sp;
} }

lldb/source/Core/PluginManager.cpp

Show All 32 Lines
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
typedef bool (*PluginInitCallback)(); typedef bool (*PluginInitCallback)();
typedef void (*PluginTermCallback)(); typedef void (*PluginTermCallback)();
struct PluginInfo { struct PluginInfo {
PluginInfo() {} PluginInfo() = default;
llvm::sys::DynamicLibrary library; llvm::sys::DynamicLibrary library;
PluginInitCallback plugin_init_callback = nullptr; PluginInitCallback plugin_init_callback = nullptr;
PluginTermCallback plugin_term_callback = nullptr; PluginTermCallback plugin_term_callback = nullptr;
}; };
typedef std::map<FileSpec, PluginInfo> PluginTerminateMap; typedef std::map<FileSpec, PluginInfo> PluginTerminateMap;
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Core/SourceManager.cpp

Show First 20 Lines • Show All 55 Lines • ▼ Show 20 Lines : m_last_line(0), m_last_count(0), m_default_set(false),
m_target_wp(target_sp), m_target_wp(target_sp),
m_debugger_wp(target_sp->GetDebugger().shared_from_this()) {} m_debugger_wp(target_sp->GetDebugger().shared_from_this()) {}
SourceManager::SourceManager(const DebuggerSP &debugger_sp) SourceManager::SourceManager(const DebuggerSP &debugger_sp)
: m_last_line(0), m_last_count(0), m_default_set(false), m_target_wp(), : m_last_line(0), m_last_count(0), m_default_set(false), m_target_wp(),
m_debugger_wp(debugger_sp) {} m_debugger_wp(debugger_sp) {}
// Destructor // Destructor
SourceManager::~SourceManager() {} SourceManager::~SourceManager() = default;
SourceManager::FileSP SourceManager::GetFile(const FileSpec &file_spec) { SourceManager::FileSP SourceManager::GetFile(const FileSpec &file_spec) {
if (!file_spec) if (!file_spec)
return nullptr; return nullptr;
DebuggerSP debugger_sp(m_debugger_wp.lock()); DebuggerSP debugger_sp(m_debugger_wp.lock());
FileSP file_sp; FileSP file_sp;
if (debugger_sp && debugger_sp->GetUseSourceCache()) if (debugger_sp && debugger_sp->GetUseSourceCache())
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Core/StreamFile.cpp

Show All 37 LinesStreamFile::StreamFile(const char *path, File::OpenOptions options,
else { else {
// TODO refactor this so the error gets popagated up instead of logged here. // TODO refactor this so the error gets popagated up instead of logged here.
LLDB_LOG_ERROR(GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST), file.takeError(), LLDB_LOG_ERROR(GetLogIfAllCategoriesSet(LIBLLDB_LOG_HOST), file.takeError(),
"Cannot open {1}: {0}", path); "Cannot open {1}: {0}", path);
m_file_sp = std::make_shared<File>(); m_file_sp = std::make_shared<File>();
} }
} }
StreamFile::~StreamFile() {} StreamFile::~StreamFile() = default;
void StreamFile::Flush() { m_file_sp->Flush(); } void StreamFile::Flush() { m_file_sp->Flush(); }
size_t StreamFile::WriteImpl(const void *s, size_t length) { size_t StreamFile::WriteImpl(const void *s, size_t length) {
m_file_sp->Write(s, length); m_file_sp->Write(s, length);
return length; return length;
} }

lldb/source/Core/ValueObject.cpp

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
m_data.SetByteOrder(arch.GetByteOrder()); m_data.SetByteOrder(arch.GetByteOrder());
m_data.SetAddressByteSize(arch.GetAddressByteSize()); m_data.SetAddressByteSize(arch.GetAddressByteSize());
} }
} }
m_manager->ManageObject(this); m_manager->ManageObject(this);
} }
// Destructor // Destructor
ValueObject::~ValueObject() {} ValueObject::~ValueObject() = default;
bool ValueObject::UpdateValueIfNeeded(bool update_format) { bool ValueObject::UpdateValueIfNeeded(bool update_format) {
bool did_change_formats = false; bool did_change_formats = false;
if (update_format) if (update_format)
did_change_formats = UpdateFormatsIfNeeded(); did_change_formats = UpdateFormatsIfNeeded();
▲ Show 20 Lines • Show All 182 Lines • ▼ Show 20 Lines
} }
} }
} }
ValueObject::EvaluationPoint::EvaluationPoint( ValueObject::EvaluationPoint::EvaluationPoint(
const ValueObject::EvaluationPoint &rhs) const ValueObject::EvaluationPoint &rhs)
: m_mod_id(), m_exe_ctx_ref(rhs.m_exe_ctx_ref), m_needs_update(true) {} : m_mod_id(), m_exe_ctx_ref(rhs.m_exe_ctx_ref), m_needs_update(true) {}
ValueObject::EvaluationPoint::~EvaluationPoint() {} ValueObject::EvaluationPoint::~EvaluationPoint() = default;
// This function checks the EvaluationPoint against the current process state. // This function checks the EvaluationPoint against the current process state.
// If the current state matches the evaluation point, or the evaluation point // If the current state matches the evaluation point, or the evaluation point
// is already invalid, then we return false, meaning "no change". If the // is already invalid, then we return false, meaning "no change". If the
// current state is different, we update our state, and return true meaning // current state is different, we update our state, and return true meaning
// "yes, change". If we did see a change, we also set m_needs_update to true, // "yes, change". If we did see a change, we also set m_needs_update to true,
// so future calls to NeedsUpdate will return true. exe_scope will be set to // so future calls to NeedsUpdate will return true. exe_scope will be set to
// the current execution context scope. // the current execution context scope.
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Core/ValueObjectCast.cpp

Show All 30 Lines
ValueObjectCast::ValueObjectCast(ValueObject &parent, 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.SetCompilerType(cast_type); m_value.SetCompilerType(cast_type);
} }
ValueObjectCast::~ValueObjectCast() {} ValueObjectCast::~ValueObjectCast() = default;
CompilerType ValueObjectCast::GetCompilerTypeImpl() { return m_cast_type; } CompilerType ValueObjectCast::GetCompilerTypeImpl() { return m_cast_type; }
size_t ValueObjectCast::CalculateNumChildren(uint32_t max) { size_t ValueObjectCast::CalculateNumChildren(uint32_t max) {
ExecutionContext exe_ctx(GetExecutionContextRef()); ExecutionContext exe_ctx(GetExecutionContextRef());
auto children_count = GetCompilerType().GetNumChildren( auto children_count = GetCompilerType().GetNumChildren(
true, &exe_ctx); true, &exe_ctx);
return children_count <= max ? children_count : max; return children_count <= max ? children_count : max;
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

lldb/source/Core/ValueObjectChild.cpp

Show All 37 Lines : ValueObject(parent), m_compiler_type(compiler_type),
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),
m_can_update_with_invalid_exe_ctx() { m_can_update_with_invalid_exe_ctx() {
m_name = name; m_name = name;
SetAddressTypeOfChildren(child_ptr_or_ref_addr_type); SetAddressTypeOfChildren(child_ptr_or_ref_addr_type);
SetLanguageFlags(language_flags); SetLanguageFlags(language_flags);
} }
ValueObjectChild::~ValueObjectChild() {} ValueObjectChild::~ValueObjectChild() = default;
lldb::ValueType ValueObjectChild::GetValueType() const { lldb::ValueType ValueObjectChild::GetValueType() const {
return m_parent->GetValueType(); return m_parent->GetValueType();
} }
size_t ValueObjectChild::CalculateNumChildren(uint32_t max) { size_t ValueObjectChild::CalculateNumChildren(uint32_t max) {
ExecutionContext exe_ctx(GetExecutionContextRef()); ExecutionContext exe_ctx(GetExecutionContextRef());
auto children_count = GetCompilerType().GetNumChildren(true, &exe_ctx); auto children_count = GetCompilerType().GetNumChildren(true, &exe_ctx);
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Core/ValueObjectConstResult.cpp

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
: ValueObject(exe_scope, manager), m_impl(this) { : ValueObject(exe_scope, manager), 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, module); m_error = m_value.GetValueAsData(&exe_ctx, m_data, module);
} }
ValueObjectConstResult::~ValueObjectConstResult() {} ValueObjectConstResult::~ValueObjectConstResult() = default;
CompilerType ValueObjectConstResult::GetCompilerTypeImpl() { CompilerType ValueObjectConstResult::GetCompilerTypeImpl() {
return m_value.GetCompilerType(); return m_value.GetCompilerType();
} }
lldb::ValueType ValueObjectConstResult::GetValueType() const { lldb::ValueType ValueObjectConstResult::GetValueType() const {
return eValueTypeConstResult; return eValueTypeConstResult;
} }
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Core/ValueObjectConstResultCast.cpp

Show All 21 Lines
ValueObjectConstResultCast::ValueObjectConstResultCast( ValueObjectConstResultCast::ValueObjectConstResultCast(
ValueObject &parent, 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() = default;
lldb::ValueObjectSP ValueObjectConstResultCast::Dereference(Status &error) { lldb::ValueObjectSP ValueObjectConstResultCast::Dereference(Status &error) {
return m_impl.Dereference(error); return m_impl.Dereference(error);
} }
lldb::ValueObjectSP ValueObjectConstResultCast::GetSyntheticChildAtOffset( lldb::ValueObjectSP ValueObjectConstResultCast::GetSyntheticChildAtOffset(
uint32_t offset, const CompilerType &type, bool can_create, uint32_t offset, const CompilerType &type, bool can_create,
ConstString name_const_str) { ConstString name_const_str) {
Show All 24 Lines

lldb/source/Core/ValueObjectConstResultChild.cpp

Show All 28 LinesValueObjectConstResultChild::ValueObjectConstResultChild(
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;
} }
ValueObjectConstResultChild::~ValueObjectConstResultChild() {} ValueObjectConstResultChild::~ValueObjectConstResultChild() = default;
lldb::ValueObjectSP ValueObjectConstResultChild::Dereference(Status &error) { lldb::ValueObjectSP ValueObjectConstResultChild::Dereference(Status &error) {
return m_impl.Dereference(error); return m_impl.Dereference(error);
} }
lldb::ValueObjectSP ValueObjectConstResultChild::GetSyntheticChildAtOffset( lldb::ValueObjectSP ValueObjectConstResultChild::GetSyntheticChildAtOffset(
uint32_t offset, const CompilerType &type, bool can_create, uint32_t offset, const CompilerType &type, bool can_create,
ConstString name_const_str) { ConstString name_const_str) {
Show All 29 Lines

lldb/source/Core/ValueObjectMemory.cpp

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
m_value.GetScalar() = file_address; m_value.GetScalar() = file_address;
} else { } else {
m_value.GetScalar() = m_address.GetOffset(); m_value.GetScalar() = m_address.GetOffset();
m_value.SetValueType(Value::ValueType::Scalar); m_value.SetValueType(Value::ValueType::Scalar);
} }
} }
} }
ValueObjectMemory::~ValueObjectMemory() {} ValueObjectMemory::~ValueObjectMemory() = default;
CompilerType ValueObjectMemory::GetCompilerTypeImpl() { CompilerType ValueObjectMemory::GetCompilerTypeImpl() {
if (m_type_sp) if (m_type_sp)
return m_type_sp->GetForwardCompilerType(); return m_type_sp->GetForwardCompilerType();
return m_compiler_type; return m_compiler_type;
} }
ConstString ValueObjectMemory::GetTypeName() { ConstString ValueObjectMemory::GetTypeName() {
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Core/ValueObjectRegister.cpp

Show First 20 Lines • Show All 54 Lines • ▼ Show 20 Lines : ValueObject(exe_scope, manager), m_reg_ctx_sp(reg_ctx),
m_reg_set(nullptr), m_reg_set_idx(reg_set_idx) { m_reg_set(nullptr), m_reg_set_idx(reg_set_idx) {
assert(reg_ctx); assert(reg_ctx);
m_reg_set = reg_ctx->GetRegisterSet(m_reg_set_idx); m_reg_set = reg_ctx->GetRegisterSet(m_reg_set_idx);
if (m_reg_set) { if (m_reg_set) {
m_name.SetCString(m_reg_set->name); m_name.SetCString(m_reg_set->name);
} }
} }
ValueObjectRegisterSet::~ValueObjectRegisterSet() {} ValueObjectRegisterSet::~ValueObjectRegisterSet() = default;
CompilerType ValueObjectRegisterSet::GetCompilerTypeImpl() { CompilerType ValueObjectRegisterSet::GetCompilerTypeImpl() {
return CompilerType(); return CompilerType();
} }
ConstString ValueObjectRegisterSet::GetTypeName() { return ConstString(); } ConstString ValueObjectRegisterSet::GetTypeName() { return ConstString(); }
ConstString ValueObjectRegisterSet::GetQualifiedTypeName() { ConstString ValueObjectRegisterSet::GetQualifiedTypeName() {
▲ Show 20 Lines • Show All 116 Lines • ▼ Show 20 LinesValueObjectRegister::ValueObjectRegister(ExecutionContextScope *exe_scope,
lldb::RegisterContextSP &reg_ctx, lldb::RegisterContextSP &reg_ctx,
uint32_t reg_num) uint32_t reg_num)
: ValueObject(exe_scope, manager), m_reg_ctx_sp(reg_ctx), m_reg_info(), : ValueObject(exe_scope, manager), m_reg_ctx_sp(reg_ctx), m_reg_info(),
m_reg_value(), m_type_name(), m_compiler_type() { m_reg_value(), m_type_name(), m_compiler_type() {
assert(reg_ctx); assert(reg_ctx);
ConstructObject(reg_num); ConstructObject(reg_num);
} }
ValueObjectRegister::~ValueObjectRegister() {} ValueObjectRegister::~ValueObjectRegister() = default;
CompilerType ValueObjectRegister::GetCompilerTypeImpl() { CompilerType ValueObjectRegister::GetCompilerTypeImpl() {
if (!m_compiler_type.IsValid()) { if (!m_compiler_type.IsValid()) {
ExecutionContext exe_ctx(GetExecutionContextRef()); ExecutionContext exe_ctx(GetExecutionContextRef());
if (auto *target = exe_ctx.GetTargetPtr()) { if (auto *target = exe_ctx.GetTargetPtr()) {
if (auto *exe_module = target->GetExecutableModulePointer()) { if (auto *exe_module = target->GetExecutableModulePointer()) {
auto type_system_or_err = auto type_system_or_err =
exe_module->GetTypeSystemForLanguage(eLanguageTypeC); exe_module->GetTypeSystemForLanguage(eLanguageTypeC);
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Core/ValueObjectVariable.cpp

Show First 20 Lines • Show All 57 Lines • ▼ Show 20 LinesValueObjectVariable::ValueObjectVariable(ExecutionContextScope *exe_scope,
ValueObjectManager &manager, ValueObjectManager &manager,
const lldb::VariableSP &var_sp) const lldb::VariableSP &var_sp)
: ValueObject(exe_scope, manager), m_variable_sp(var_sp) { : ValueObject(exe_scope, manager), m_variable_sp(var_sp) {
// Do not attempt to construct one of these objects with no variable! // Do not attempt to construct one of these objects with no variable!
assert(m_variable_sp.get() != nullptr); assert(m_variable_sp.get() != nullptr);
m_name = var_sp->GetName(); m_name = var_sp->GetName();
} }
ValueObjectVariable::~ValueObjectVariable() {} ValueObjectVariable::~ValueObjectVariable() = default;
CompilerType ValueObjectVariable::GetCompilerTypeImpl() { CompilerType ValueObjectVariable::GetCompilerTypeImpl() {
Type *var_type = m_variable_sp->GetType(); Type *var_type = m_variable_sp->GetType();
if (var_type) if (var_type)
return var_type->GetForwardCompilerType(); return var_type->GetForwardCompilerType();
return CompilerType(); return CompilerType();
} }
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/DataFormatters/TypeFormat.cpp

Show All 23 Lines
#include "lldb/Utility/DataExtractor.h" #include "lldb/Utility/DataExtractor.h"
#include "lldb/Utility/StreamString.h" #include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
TypeFormatImpl::TypeFormatImpl(const Flags &flags) : m_flags(flags) {} TypeFormatImpl::TypeFormatImpl(const Flags &flags) : m_flags(flags) {}
TypeFormatImpl::~TypeFormatImpl() {} TypeFormatImpl::~TypeFormatImpl() = default;
TypeFormatImpl_Format::TypeFormatImpl_Format(lldb::Format f, TypeFormatImpl_Format::TypeFormatImpl_Format(lldb::Format f,
const TypeFormatImpl::Flags &flags) const TypeFormatImpl::Flags &flags)
: TypeFormatImpl(flags), m_format(f) {} : TypeFormatImpl(flags), m_format(f) {}
TypeFormatImpl_Format::~TypeFormatImpl_Format() {} TypeFormatImpl_Format::~TypeFormatImpl_Format() = default;
bool TypeFormatImpl_Format::FormatObject(ValueObject *valobj, bool TypeFormatImpl_Format::FormatObject(ValueObject *valobj,
std::string &dest) const { std::string &dest) const {
if (!valobj) if (!valobj)
return false; return false;
if (valobj->CanProvideValue()) { if (valobj->CanProvideValue()) {
Value &value(valobj->GetValue()); Value &value(valobj->GetValue());
const Value::ContextType context_type = value.GetContextType(); const Value::ContextType context_type = value.GetContextType();
▲ Show 20 Lines • Show All 82 Lines • ▼ Show 20 Lines sstr.Printf("%s%s%s%s", FormatManager::GetFormatAsCString(GetFormat()),
SkipsReferences() ? " (skip references)" : ""); SkipsReferences() ? " (skip references)" : "");
return std::string(sstr.GetString()); return std::string(sstr.GetString());
} }
TypeFormatImpl_EnumType::TypeFormatImpl_EnumType( TypeFormatImpl_EnumType::TypeFormatImpl_EnumType(
ConstString type_name, const TypeFormatImpl::Flags &flags) ConstString type_name, const TypeFormatImpl::Flags &flags)
: TypeFormatImpl(flags), m_enum_type(type_name), m_types() {} : TypeFormatImpl(flags), m_enum_type(type_name), m_types() {}
TypeFormatImpl_EnumType::~TypeFormatImpl_EnumType() {} TypeFormatImpl_EnumType::~TypeFormatImpl_EnumType() = default;
bool TypeFormatImpl_EnumType::FormatObject(ValueObject *valobj, bool TypeFormatImpl_EnumType::FormatObject(ValueObject *valobj,
std::string &dest) const { std::string &dest) const {
dest.clear(); dest.clear();
if (!valobj) if (!valobj)
return false; return false;
if (!valobj->CanProvideValue()) if (!valobj->CanProvideValue())
return false; return false;
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

lldb/source/DataFormatters/TypeSummary.cpp

Show All 20 Lines
#include "lldb/Symbol/CompilerType.h" #include "lldb/Symbol/CompilerType.h"
#include "lldb/Target/StackFrame.h" #include "lldb/Target/StackFrame.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/StreamString.h" #include "lldb/Utility/StreamString.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
TypeSummaryOptions::TypeSummaryOptions() {} TypeSummaryOptions::TypeSummaryOptions() = default;
lldb::LanguageType TypeSummaryOptions::GetLanguage() const { return m_lang; } lldb::LanguageType TypeSummaryOptions::GetLanguage() const { return m_lang; }
lldb::TypeSummaryCapping TypeSummaryOptions::GetCapping() const { lldb::TypeSummaryCapping TypeSummaryOptions::GetCapping() const {
return m_capping; return m_capping;
} }
TypeSummaryOptions &TypeSummaryOptions::SetLanguage(lldb::LanguageType lang) { TypeSummaryOptions &TypeSummaryOptions::SetLanguage(lldb::LanguageType lang) {
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/DataFormatters/TypeSynthetic.cpp

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
m_interpreter = target_sp->GetDebugger().GetScriptInterpreter(); m_interpreter = target_sp->GetDebugger().GetScriptInterpreter();
if (m_interpreter != nullptr) if (m_interpreter != nullptr)
m_wrapper_sp = m_interpreter->CreateSyntheticScriptedProvider( m_wrapper_sp = m_interpreter->CreateSyntheticScriptedProvider(
m_python_class.c_str(), backend.GetSP()); m_python_class.c_str(), backend.GetSP());
} }
ScriptedSyntheticChildren::FrontEnd::~FrontEnd() {} ScriptedSyntheticChildren::FrontEnd::~FrontEnd() = default;
lldb::ValueObjectSP lldb::ValueObjectSP
ScriptedSyntheticChildren::FrontEnd::GetChildAtIndex(size_t idx) { ScriptedSyntheticChildren::FrontEnd::GetChildAtIndex(size_t idx) {
if (!m_wrapper_sp || !m_interpreter) if (!m_wrapper_sp || !m_interpreter)
return lldb::ValueObjectSP(); return lldb::ValueObjectSP();
return m_interpreter->GetChildAtIndex(m_wrapper_sp, idx); return m_interpreter->GetChildAtIndex(m_wrapper_sp, idx);
} }
▲ Show 20 Lines • Show All 62 Lines • Show Last 20 Lines

lldb/source/Expression/DWARFExpression.cpp

Show First 20 Lines • Show All 61 Lines • ▼ Show 20 LinesDWARFExpression::DWARFExpression(lldb::ModuleSP module_sp,
const DWARFUnit *dwarf_cu) const DWARFUnit *dwarf_cu)
: m_module_wp(), m_data(data), m_dwarf_cu(dwarf_cu), : m_module_wp(), m_data(data), m_dwarf_cu(dwarf_cu),
m_reg_kind(eRegisterKindDWARF) { m_reg_kind(eRegisterKindDWARF) {
if (module_sp) if (module_sp)
m_module_wp = module_sp; m_module_wp = module_sp;
} }
// Destructor // Destructor
DWARFExpression::~DWARFExpression() {} DWARFExpression::~DWARFExpression() = default;
bool DWARFExpression::IsValid() const { return m_data.GetByteSize() > 0; } bool DWARFExpression::IsValid() const { return m_data.GetByteSize() > 0; }
void DWARFExpression::UpdateValue(uint64_t const_value, void DWARFExpression::UpdateValue(uint64_t const_value,
lldb::offset_t const_value_byte_size, lldb::offset_t const_value_byte_size,
uint8_t addr_byte_size) { uint8_t addr_byte_size) {
if (!const_value_byte_size) if (!const_value_byte_size)
return; return;
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Expression/ExpressionVariable.cpp

//===-- ExpressionVariable.cpp --------------------------------------------===// //===-- ExpressionVariable.cpp --------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Expression/ExpressionVariable.h" #include "lldb/Expression/ExpressionVariable.h"
#include "lldb/Expression/IRExecutionUnit.h" #include "lldb/Expression/IRExecutionUnit.h"
#include "lldb/Target/Target.h" #include "lldb/Target/Target.h"
#include "lldb/Utility/Log.h" #include "lldb/Utility/Log.h"
using namespace lldb_private; using namespace lldb_private;
ExpressionVariable::~ExpressionVariable() {} ExpressionVariable::~ExpressionVariable() = default;
uint8_t *ExpressionVariable::GetValueBytes() { uint8_t *ExpressionVariable::GetValueBytes() {
llvm::Optional<uint64_t> byte_size = m_frozen_sp->GetByteSize(); llvm::Optional<uint64_t> byte_size = m_frozen_sp->GetByteSize();
if (byte_size && *byte_size) { if (byte_size && *byte_size) {
if (m_frozen_sp->GetDataExtractor().GetByteSize() < *byte_size) { if (m_frozen_sp->GetDataExtractor().GetByteSize() < *byte_size) {
m_frozen_sp->GetValue().ResizeData(*byte_size); m_frozen_sp->GetValue().ResizeData(*byte_size);
m_frozen_sp->GetValue().GetData(m_frozen_sp->GetDataExtractor()); m_frozen_sp->GetValue().GetData(m_frozen_sp->GetDataExtractor());
} }
return const_cast<uint8_t *>( return const_cast<uint8_t *>(
m_frozen_sp->GetDataExtractor().GetDataStart()); m_frozen_sp->GetDataExtractor().GetDataStart());
} }
return nullptr; return nullptr;
} }
PersistentExpressionState::~PersistentExpressionState() {} PersistentExpressionState::~PersistentExpressionState() = default;
lldb::addr_t PersistentExpressionState::LookupSymbol(ConstString name) { lldb::addr_t PersistentExpressionState::LookupSymbol(ConstString name) {
SymbolMap::iterator si = m_symbol_map.find(name.GetCString()); SymbolMap::iterator si = m_symbol_map.find(name.GetCString());
if (si != m_symbol_map.end()) if (si != m_symbol_map.end())
return si->second; return si->second;
else else
return LLDB_INVALID_ADDRESS; return LLDB_INVALID_ADDRESS;
Show All 39 Lines

lldb/source/Expression/IRExecutionUnit.cpp

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
m_module_up.reset(); m_module_up.reset();
m_execution_engine_up.reset(); m_execution_engine_up.reset();
m_context_up.reset(); m_context_up.reset();
} }
IRExecutionUnit::MemoryManager::MemoryManager(IRExecutionUnit &parent) IRExecutionUnit::MemoryManager::MemoryManager(IRExecutionUnit &parent)
: m_default_mm_up(new llvm::SectionMemoryManager()), m_parent(parent) {} : m_default_mm_up(new llvm::SectionMemoryManager()), m_parent(parent) {}
IRExecutionUnit::MemoryManager::~MemoryManager() {} IRExecutionUnit::MemoryManager::~MemoryManager() = default;
lldb::SectionType IRExecutionUnit::GetSectionTypeFromSectionName( lldb::SectionType IRExecutionUnit::GetSectionTypeFromSectionName(
const llvm::StringRef &name, IRExecutionUnit::AllocationKind alloc_kind) { const llvm::StringRef &name, IRExecutionUnit::AllocationKind alloc_kind) {
lldb::SectionType sect_type = lldb::eSectionTypeCode; lldb::SectionType sect_type = lldb::eSectionTypeCode;
switch (alloc_kind) { switch (alloc_kind) {
case AllocationKind::Stub: case AllocationKind::Stub:
sect_type = lldb::eSectionTypeCode; sect_type = lldb::eSectionTypeCode;
break; break;
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Expression/IRInterpreter.cpp

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
: lldb::eByteOrderBig); : lldb::eByteOrderBig);
m_addr_byte_size = (target_data.getPointerSize(0)); m_addr_byte_size = (target_data.getPointerSize(0));
m_frame_process_address = stack_frame_bottom; m_frame_process_address = stack_frame_bottom;
m_frame_size = stack_frame_top - stack_frame_bottom; m_frame_size = stack_frame_top - stack_frame_bottom;
m_stack_pointer = stack_frame_top; m_stack_pointer = stack_frame_top;
} }
~InterpreterStackFrame() {} ~InterpreterStackFrame() = default;
void Jump(const BasicBlock *bb) { void Jump(const BasicBlock *bb) {
m_prev_bb = m_bb; m_prev_bb = m_bb;
m_bb = bb; m_bb = bb;
m_ii = m_bb->begin(); m_ii = m_bb->begin();
m_ie = m_bb->end(); m_ie = m_bb->end();
} }
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Expression/UserExpression.cpp

Show First 20 Lines • Show All 51 Lines • ▼ Show 20 LinesUserExpression::UserExpression(ExecutionContextScope &exe_scope,
llvm::StringRef expr, llvm::StringRef prefix, llvm::StringRef expr, llvm::StringRef prefix,
lldb::LanguageType language, lldb::LanguageType language,
ResultType desired_type, ResultType desired_type,
const EvaluateExpressionOptions &options) const EvaluateExpressionOptions &options)
: Expression(exe_scope), m_expr_text(std::string(expr)), : Expression(exe_scope), m_expr_text(std::string(expr)),
m_expr_prefix(std::string(prefix)), m_language(language), m_expr_prefix(std::string(prefix)), m_language(language),
m_desired_type(desired_type), m_options(options) {} m_desired_type(desired_type), m_options(options) {}
UserExpression::~UserExpression() {} UserExpression::~UserExpression() = default;
void UserExpression::InstallContext(ExecutionContext &exe_ctx) { void UserExpression::InstallContext(ExecutionContext &exe_ctx) {
m_jit_process_wp = exe_ctx.GetProcessSP(); m_jit_process_wp = exe_ctx.GetProcessSP();
lldb::StackFrameSP frame_sp = exe_ctx.GetFrameSP(); lldb::StackFrameSP frame_sp = exe_ctx.GetFrameSP();
if (frame_sp) if (frame_sp)
m_address = frame_sp->GetFrameCodeAddress(); m_address = frame_sp->GetFrameCodeAddress();
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Host/common/HostProcess.cpp

Show All 12 Lines
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
HostProcess::HostProcess() : m_native_process(new HostNativeProcess) {} HostProcess::HostProcess() : m_native_process(new HostNativeProcess) {}
HostProcess::HostProcess(lldb::process_t process) HostProcess::HostProcess(lldb::process_t process)
: m_native_process(new HostNativeProcess(process)) {} : m_native_process(new HostNativeProcess(process)) {}
HostProcess::~HostProcess() {} HostProcess::~HostProcess() = default;
Status HostProcess::Terminate() { return m_native_process->Terminate(); } Status HostProcess::Terminate() { return m_native_process->Terminate(); }
Status HostProcess::GetMainModule(FileSpec &file_spec) const { Status HostProcess::GetMainModule(FileSpec &file_spec) const {
return m_native_process->GetMainModule(file_spec); return m_native_process->GetMainModule(file_spec);
} }
lldb::pid_t HostProcess::GetProcessId() const { lldb::pid_t HostProcess::GetProcessId() const {
Show All 18 Lines

lldb/source/Host/common/NativeRegisterContext.cpp

Show All 16 Lines
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
NativeRegisterContext::NativeRegisterContext(NativeThreadProtocol &thread) NativeRegisterContext::NativeRegisterContext(NativeThreadProtocol &thread)
: m_thread(thread) {} : m_thread(thread) {}
// Destructor // Destructor
NativeRegisterContext::~NativeRegisterContext() {} NativeRegisterContext::~NativeRegisterContext() = default;
// FIXME revisit invalidation, process stop ids, etc. Right now we don't // FIXME revisit invalidation, process stop ids, etc. Right now we don't
// support caching in NativeRegisterContext. We can do this later by utilizing // support caching in NativeRegisterContext. We can do this later by utilizing
// NativeProcessProtocol::GetStopID () and adding a stop id to // NativeProcessProtocol::GetStopID () and adding a stop id to
// NativeRegisterContext. // NativeRegisterContext.
// void // void
// NativeRegisterContext::InvalidateIfNeeded (bool force) { // NativeRegisterContext::InvalidateIfNeeded (bool force) {
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Host/common/PseudoTerminal.cpp

Show All 23 Lines
#if defined(__ANDROID__) #if defined(__ANDROID__)
int posix_openpt(int flags); int posix_openpt(int flags);
#endif #endif
using namespace lldb_private; using namespace lldb_private;
// PseudoTerminal constructor // PseudoTerminal constructor
PseudoTerminal::PseudoTerminal() {} PseudoTerminal::PseudoTerminal() = default;
// Destructor // Destructor
// //
// The destructor will close the primary and secondary file descriptors if they // The destructor will close the primary and secondary file descriptors if they
// are valid and ownership has not been released using the // are valid and ownership has not been released using the
// ReleasePrimaryFileDescriptor() or the ReleaseSaveFileDescriptor() member // ReleasePrimaryFileDescriptor() or the ReleaseSaveFileDescriptor() member
// functions. // functions.
PseudoTerminal::~PseudoTerminal() { PseudoTerminal::~PseudoTerminal() {
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Host/common/SocketAddress.cpp

Show First 20 Lines • Show All 87 Lines • ▼ Show 20 LinesSocketAddress::SocketAddress(const struct sockaddr_storage &s) {
m_socket_addr.sa_storage = s; m_socket_addr.sa_storage = s;
} }
SocketAddress::SocketAddress(const struct addrinfo *addr_info) { SocketAddress::SocketAddress(const struct addrinfo *addr_info) {
*this = addr_info; *this = addr_info;
} }
// Destructor // Destructor
SocketAddress::~SocketAddress() {} SocketAddress::~SocketAddress() = default;
void SocketAddress::Clear() { void SocketAddress::Clear() {
memset(&m_socket_addr, 0, sizeof(m_socket_addr)); memset(&m_socket_addr, 0, sizeof(m_socket_addr));
} }
bool SocketAddress::IsValid() const { return GetLength() != 0; } bool SocketAddress::IsValid() const { return GetLength() != 0; }
static socklen_t GetFamilyLength(sa_family_t family) { static socklen_t GetFamilyLength(sa_family_t family) {
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Host/common/Terminal.cpp

Show First 20 Lines • Show All 86 Lines • ▼ Show 20 Lines
#if LLDB_ENABLE_TERMIOS #if LLDB_ENABLE_TERMIOS
, ,
m_termios_up() m_termios_up()
#endif #endif
{ {
} }
// Destructor // Destructor
TerminalState::~TerminalState() {} TerminalState::~TerminalState() = default;
void TerminalState::Clear() { void TerminalState::Clear() {
m_tty.Clear(); m_tty.Clear();
m_tflags = -1; m_tflags = -1;
#if LLDB_ENABLE_TERMIOS #if LLDB_ENABLE_TERMIOS
m_termios_up.reset(); m_termios_up.reset();
#endif #endif
m_process_group = -1; m_process_group = -1;
▲ Show 20 Lines • Show All 81 Lines • ▼ Show 20 Lines
} }
// Returns true if m_process_group is valid // Returns true if m_process_group is valid
bool TerminalState::ProcessGroupIsValid() const { bool TerminalState::ProcessGroupIsValid() const {
return static_cast<int32_t>(m_process_group) != -1; return static_cast<int32_t>(m_process_group) != -1;
} }
// Constructor // Constructor
TerminalStateSwitcher::TerminalStateSwitcher() {} TerminalStateSwitcher::TerminalStateSwitcher() = default;
// Destructor // Destructor
TerminalStateSwitcher::~TerminalStateSwitcher() {} TerminalStateSwitcher::~TerminalStateSwitcher() = default;
// Returns the number of states that this switcher contains // Returns the number of states that this switcher contains
uint32_t TerminalStateSwitcher::GetNumberOfStates() const { uint32_t TerminalStateSwitcher::GetNumberOfStates() const {
return llvm::array_lengthof(m_ttystates); return llvm::array_lengthof(m_ttystates);
} }
// Restore the state at index "idx". // Restore the state at index "idx".
// //
Show All 33 Lines

lldb/source/Host/common/XML.cpp

Show All 11 Lines
#include "lldb/Host/StringConvert.h" #include "lldb/Host/StringConvert.h"
#include "lldb/Host/XML.h" #include "lldb/Host/XML.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
#pragma mark-- XMLDocument #pragma mark-- XMLDocument
XMLDocument::XMLDocument() {} XMLDocument::XMLDocument() = default;
XMLDocument::~XMLDocument() { Clear(); } XMLDocument::~XMLDocument() { Clear(); }
void XMLDocument::Clear() { void XMLDocument::Clear() {
#if LLDB_ENABLE_LIBXML2 #if LLDB_ENABLE_LIBXML2
if (m_document) { if (m_document) {
xmlDocPtr doc = m_document; xmlDocPtr doc = m_document;
m_document = nullptr; m_document = nullptr;
▲ Show 20 Lines • Show All 57 Lines • ▼ Show 20 Lines
return true; return true;
#else #else
return false; return false;
#endif #endif
} }
#pragma mark-- XMLNode #pragma mark-- XMLNode
XMLNode::XMLNode() {} XMLNode::XMLNode() = default;
XMLNode::XMLNode(XMLNodeImpl node) : m_node(node) {} XMLNode::XMLNode(XMLNodeImpl node) : m_node(node) {}
XMLNode::~XMLNode() {} XMLNode::~XMLNode() = default;
void XMLNode::Clear() { m_node = nullptr; } void XMLNode::Clear() { m_node = nullptr; }
XMLNode XMLNode::GetParent() const { XMLNode XMLNode::GetParent() const {
#if LLDB_ENABLE_LIBXML2 #if LLDB_ENABLE_LIBXML2
if (IsValid()) if (IsValid())
return XMLNode(m_node->parent); return XMLNode(m_node->parent);
else else
▲ Show 20 Lines • Show All 182 Lines • ▼ Show 20 Lines
ApplePropertyList::ApplePropertyList() : m_xml_doc(), m_dict_node() {} ApplePropertyList::ApplePropertyList() : m_xml_doc(), m_dict_node() {}
ApplePropertyList::ApplePropertyList(const char *path) ApplePropertyList::ApplePropertyList(const char *path)
: m_xml_doc(), m_dict_node() { : m_xml_doc(), m_dict_node() {
ParseFile(path); ParseFile(path);
} }
ApplePropertyList::~ApplePropertyList() {} ApplePropertyList::~ApplePropertyList() = default;
llvm::StringRef ApplePropertyList::GetErrors() const { llvm::StringRef ApplePropertyList::GetErrors() const {
return m_xml_doc.GetErrors(); return m_xml_doc.GetErrors();
} }
bool ApplePropertyList::ParseFile(const char *path) { bool ApplePropertyList::ParseFile(const char *path) {
if (m_xml_doc.ParseFile(path)) { if (m_xml_doc.ParseFile(path)) {
XMLNode plist = m_xml_doc.GetRootElement("plist"); XMLNode plist = m_xml_doc.GetRootElement("plist");
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Host/macosx/cfcpp/CFCBundle.cpp

Show All 13 LinesCFCBundle::CFCBundle(const char *path) : CFCReleaser<CFBundleRef>() {
if (path && path[0]) if (path && path[0])
SetPath(path); SetPath(path);
} }
CFCBundle::CFCBundle(CFURLRef url) CFCBundle::CFCBundle(CFURLRef url)
: CFCReleaser<CFBundleRef>(url ? CFBundleCreate(NULL, url) : NULL) {} : CFCReleaser<CFBundleRef>(url ? CFBundleCreate(NULL, url) : NULL) {}
// Destructor // Destructor
CFCBundle::~CFCBundle() {} CFCBundle::~CFCBundle() = default;
// Set the path for a bundle by supplying a // Set the path for a bundle by supplying a
bool CFCBundle::SetPath(const char *path) { bool CFCBundle::SetPath(const char *path) {
CFAllocatorRef alloc = kCFAllocatorDefault; CFAllocatorRef alloc = kCFAllocatorDefault;
// Release our old bundle and URL // Release our old bundle and URL
reset(); reset();
// Make a CFStringRef from the supplied path // Make a CFStringRef from the supplied path
▲ Show 20 Lines • Show All 46 Lines • Show Last 20 Lines

lldb/source/Host/macosx/cfcpp/CFCData.cpp

Show All 18 Lines
{ {
if (this != &rhs) if (this != &rhs)
*this = rhs; *this = rhs;
return *this; return *this;
} }
// Destructor // Destructor
CFCData::~CFCData() {} CFCData::~CFCData() = default;
CFIndex CFCData::GetLength() const { CFIndex CFCData::GetLength() const {
CFDataRef data = get(); CFDataRef data = get();
if (data) if (data)
return CFDataGetLength(data); return CFDataGetLength(data);
return 0; return 0;
} }
Show All 22 Lines

lldb/source/Host/macosx/cfcpp/CFCMutableArray.cpp

Show All 23 Lines
CFCMutableArray &CFCMutableArray::operator=(const CFCMutableArray &rhs) { CFCMutableArray &CFCMutableArray::operator=(const CFCMutableArray &rhs) {
if (this != &rhs) if (this != &rhs)
*this = rhs; // NOTE: this operator won't make a copy of the array, just add *this = rhs; // NOTE: this operator won't make a copy of the array, just add
// a new reference to it // a new reference to it
return *this; return *this;
} }
// Destructor // Destructor
CFCMutableArray::~CFCMutableArray() {} CFCMutableArray::~CFCMutableArray() = default;
CFIndex CFCMutableArray::GetCount() const { CFIndex CFCMutableArray::GetCount() const {
CFMutableArrayRef array = get(); CFMutableArrayRef array = get();
if (array) if (array)
return ::CFArrayGetCount(array); return ::CFArrayGetCount(array);
return 0; return 0;
} }
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Host/macosx/cfcpp/CFCMutableDictionary.cpp

Show All 19 Lines
const CFCMutableDictionary &CFCMutableDictionary:: const CFCMutableDictionary &CFCMutableDictionary::
operator=(const CFCMutableDictionary &rhs) { operator=(const CFCMutableDictionary &rhs) {
if (this != &rhs) if (this != &rhs)
*this = rhs; *this = rhs;
return *this; return *this;
} }
// Destructor // Destructor
CFCMutableDictionary::~CFCMutableDictionary() {} CFCMutableDictionary::~CFCMutableDictionary() = default;
CFIndex CFCMutableDictionary::GetCount() const { CFIndex CFCMutableDictionary::GetCount() const {
CFMutableDictionaryRef dict = get(); CFMutableDictionaryRef dict = get();
if (dict) if (dict)
return ::CFDictionaryGetCount(dict); return ::CFDictionaryGetCount(dict);
return 0; return 0;
} }
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Host/macosx/cfcpp/CFCMutableSet.cpp

Show All 19 Lines
// CFCMutableSet copy constructor // CFCMutableSet copy constructor
const CFCMutableSet &CFCMutableSet::operator=(const CFCMutableSet &rhs) { const CFCMutableSet &CFCMutableSet::operator=(const CFCMutableSet &rhs) {
if (this != &rhs) if (this != &rhs)
*this = rhs; *this = rhs;
return *this; return *this;
} }
// Destructor // Destructor
CFCMutableSet::~CFCMutableSet() {} CFCMutableSet::~CFCMutableSet() = default;
CFIndex CFCMutableSet::GetCount() const { CFIndex CFCMutableSet::GetCount() const {
CFMutableSetRef set = get(); CFMutableSetRef set = get();
if (set) if (set)
return ::CFSetGetCount(set); return ::CFSetGetCount(set);
return 0; return 0;
} }
Show All 40 Lines

lldb/source/Host/macosx/cfcpp/CFCString.cpp

Show All 26 LinesCFCString::CFCString(const char *cstr, CFStringEncoding cstr_encoding)
: CFCReleaser<CFStringRef>() { : CFCReleaser<CFStringRef>() {
if (cstr && cstr[0]) { if (cstr && cstr[0]) {
reset( reset(
::CFStringCreateWithCString(kCFAllocatorDefault, cstr, cstr_encoding)); ::CFStringCreateWithCString(kCFAllocatorDefault, cstr, cstr_encoding));
} }
} }
// Destructor // Destructor
CFCString::~CFCString() {} CFCString::~CFCString() = default;
const char *CFCString::GetFileSystemRepresentation(std::string &s) { const char *CFCString::GetFileSystemRepresentation(std::string &s) {
return CFCString::FileSystemRepresentation(get(), s); return CFCString::FileSystemRepresentation(get(), s);
} }
CFStringRef CFCString::SetFileSystemRepresentation(const char *path) { CFStringRef CFCString::SetFileSystemRepresentation(const char *path) {
CFStringRef new_value = NULL; CFStringRef new_value = NULL;
if (path && path[0]) if (path && path[0])
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Host/posix/HostProcessPosix.cpp

Show All 22 Lines
} }
HostProcessPosix::HostProcessPosix() HostProcessPosix::HostProcessPosix()
: HostNativeProcessBase(kInvalidPosixProcess) {} : HostNativeProcessBase(kInvalidPosixProcess) {}
HostProcessPosix::HostProcessPosix(lldb::process_t process) HostProcessPosix::HostProcessPosix(lldb::process_t process)
: HostNativeProcessBase(process) {} : HostNativeProcessBase(process) {}
HostProcessPosix::~HostProcessPosix() {} HostProcessPosix::~HostProcessPosix() = default;
Status HostProcessPosix::Signal(int signo) const { Status HostProcessPosix::Signal(int signo) const {
if (m_process == kInvalidPosixProcess) { if (m_process == kInvalidPosixProcess) {
Status error; Status error;
error.SetErrorString("HostProcessPosix refers to an invalid process"); error.SetErrorString("HostProcessPosix refers to an invalid process");
return error; return error;
} }
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

lldb/source/Host/posix/HostThreadPosix.cpp

Show All 9 Lines
#include "lldb/Utility/Status.h" #include "lldb/Utility/Status.h"
#include <cerrno> #include <cerrno>
#include <pthread.h> #include <pthread.h>
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
HostThreadPosix::HostThreadPosix() {} HostThreadPosix::HostThreadPosix() = default;
HostThreadPosix::HostThreadPosix(lldb::thread_t thread) HostThreadPosix::HostThreadPosix(lldb::thread_t thread)
: HostNativeThreadBase(thread) {} : HostNativeThreadBase(thread) {}
HostThreadPosix::~HostThreadPosix() {} HostThreadPosix::~HostThreadPosix() = default;
Status HostThreadPosix::Join(lldb::thread_result_t *result) { Status HostThreadPosix::Join(lldb::thread_result_t *result) {
Status error; Status error;
if (IsJoinable()) { if (IsJoinable()) {
int err = ::pthread_join(m_thread, result); int err = ::pthread_join(m_thread, result);
error.SetError(err, lldb::eErrorTypePOSIX); error.SetError(err, lldb::eErrorTypePOSIX);
} else { } else {
if (result) if (result)
Show All 30 Lines

lldb/source/Initialization/SystemInitializer.cpp

//===-- SystemInitializer.cpp ---------------------------------------------===// //===-- SystemInitializer.cpp ---------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "lldb/Initialization/SystemInitializer.h" #include "lldb/Initialization/SystemInitializer.h"
using namespace lldb_private; using namespace lldb_private;
SystemInitializer::SystemInitializer() {} SystemInitializer::SystemInitializer() = default;
SystemInitializer::~SystemInitializer() {} SystemInitializer::~SystemInitializer() = default;

lldb/source/Initialization/SystemInitializerCommon.cpp

Show All 32 Lines
using namespace lldb_private; using namespace lldb_private;
using namespace lldb_private::repro; using namespace lldb_private::repro;
SystemInitializerCommon::SystemInitializerCommon( SystemInitializerCommon::SystemInitializerCommon(
HostInfo::SharedLibraryDirectoryHelper *helper) HostInfo::SharedLibraryDirectoryHelper *helper)
: m_shlib_dir_helper(helper) {} : m_shlib_dir_helper(helper) {}
SystemInitializerCommon::~SystemInitializerCommon() {} SystemInitializerCommon::~SystemInitializerCommon() = default;
/// Initialize the FileSystem based on the current reproducer mode. /// Initialize the FileSystem based on the current reproducer mode.
static llvm::Error InitializeFileSystem() { static llvm::Error InitializeFileSystem() {
auto &r = repro::Reproducer::Instance(); auto &r = repro::Reproducer::Instance();
if (repro::Loader *loader = r.GetLoader()) { if (repro::Loader *loader = r.GetLoader()) {
FileSpec vfs_mapping = loader->GetFile<FileProvider::Info>(); FileSpec vfs_mapping = loader->GetFile<FileProvider::Info>();
if (vfs_mapping) { if (vfs_mapping) {
if (llvm::Error e = FileSystem::Initialize(vfs_mapping)) if (llvm::Error e = FileSystem::Initialize(vfs_mapping))
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Interpreter/OptionGroupFile.cpp

Show First 20 Lines • Show All 53 Lines • ▼ Show 20 LinesOptionGroupFileList::OptionGroupFileList(
m_option_definition.validator = nullptr; m_option_definition.validator = nullptr;
m_option_definition.option_has_arg = OptionParser::eRequiredArgument; m_option_definition.option_has_arg = OptionParser::eRequiredArgument;
m_option_definition.enum_values = {}; m_option_definition.enum_values = {};
m_option_definition.completion_type = completion_type; m_option_definition.completion_type = completion_type;
m_option_definition.argument_type = argument_type; m_option_definition.argument_type = argument_type;
m_option_definition.usage_text = usage_text; m_option_definition.usage_text = usage_text;
} }
OptionGroupFileList::~OptionGroupFileList() {} OptionGroupFileList::~OptionGroupFileList() = default;
Status Status
OptionGroupFileList::SetOptionValue(uint32_t option_idx, OptionGroupFileList::SetOptionValue(uint32_t option_idx,
llvm::StringRef option_value, llvm::StringRef option_value,
ExecutionContext *execution_context) { ExecutionContext *execution_context) {
Status error(m_file_list.SetValueFromString(option_value)); Status error(m_file_list.SetValueFromString(option_value));
return error; return error;
} }
void OptionGroupFileList::OptionParsingStarting( void OptionGroupFileList::OptionParsingStarting(
ExecutionContext *execution_context) { ExecutionContext *execution_context) {
m_file_list.Clear(); m_file_list.Clear();
} }

lldb/source/Interpreter/OptionValueFileColonLine.cpp

Show All 15 Lines
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
// This is an OptionValue for parsing file:line:column specifications. // This is an OptionValue for parsing file:line:column specifications.
// I set the completer to "source file" which isn't quite right, but we can // I set the completer to "source file" which isn't quite right, but we can
// only usefully complete in the file name part of it so it should be good // only usefully complete in the file name part of it so it should be good
// enough. // enough.
OptionValueFileColonLine::OptionValueFileColonLine() OptionValueFileColonLine::OptionValueFileColonLine() = default;
teemperorUnsubmitted
Done
ReplyInline Actions

formaat

teemperor: formaat
JDevlieghereAuthorUnsubmitted
Done
ReplyInline Actions

doone

JDevlieghere: doone
{}
OptionValueFileColonLine::OptionValueFileColonLine(llvm::StringRef input) OptionValueFileColonLine::OptionValueFileColonLine(llvm::StringRef input)
: m_line_number(LLDB_INVALID_LINE_NUMBER), : m_line_number(LLDB_INVALID_LINE_NUMBER),
m_column_number(LLDB_INVALID_COLUMN_NUMBER), m_column_number(LLDB_INVALID_COLUMN_NUMBER),
m_completion_mask(CommandCompletions::eSourceFileCompletion) { m_completion_mask(CommandCompletions::eSourceFileCompletion) {
SetValueFromString(input, eVarSetOperationAssign); SetValueFromString(input, eVarSetOperationAssign);
} }
▲ Show 20 Lines • Show All 51 Lines • ▼ Show 20 Lines if (value.size() > 0) {
// Then check whether the middle piece is an integer. If it is, then it // Then check whether the middle piece is an integer. If it is, then it
// was the line number, and if it isn't we're going to assume that there // was the line number, and if it isn't we're going to assume that there
// was a colon in the filename (see note at the beginning of the function) // was a colon in the filename (see note at the beginning of the function)
// and ignore it. // and ignore it.
llvm::StringRef file_name; llvm::StringRef file_name;
llvm::StringRef middle_piece; llvm::StringRef middle_piece;
std::tie(file_name, middle_piece) = left_of_last_piece.rsplit(':'); std::tie(file_name, middle_piece) = left_of_last_piece.rsplit(':');
if (middle_piece.empty() || !llvm::to_integer(middle_piece, if (middle_piece.empty() ||
m_line_number)) { !llvm::to_integer(middle_piece, m_line_number)) {
// The middle piece was empty or not an integer, so there were only two // The middle piece was empty or not an integer, so there were only two
// legit pieces; our original division was right. Reassign the file // legit pieces; our original division was right. Reassign the file
// name and pull out the line number: // name and pull out the line number:
file_name = left_of_last_piece; file_name = left_of_last_piece;
if (!llvm::to_integer(last_piece, m_line_number)) { if (!llvm::to_integer(last_piece, m_line_number)) {
error.SetErrorStringWithFormat("Bad line number value '%s' in: '%s'", error.SetErrorStringWithFormat("Bad line number value '%s' in: '%s'",
last_piece.str().c_str(), last_piece.str().c_str(),
value.str().c_str()); value.str().c_str());
Show All 37 Lines

lldb/source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.h

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
}; };
struct OSKextLoadedKextSummaryHeader { struct OSKextLoadedKextSummaryHeader {
uint32_t version = 0; uint32_t version = 0;
uint32_t entry_size = 0; uint32_t entry_size = 0;
uint32_t entry_count = 0; uint32_t entry_count = 0;
lldb::addr_t image_infos_addr = LLDB_INVALID_ADDRESS; lldb::addr_t image_infos_addr = LLDB_INVALID_ADDRESS;
OSKextLoadedKextSummaryHeader() OSKextLoadedKextSummaryHeader() = default;
{}
uint32_t GetSize() { uint32_t GetSize() {
teemperorUnsubmitted
Done
ReplyInline Actions

formato

teemperor: formato
JDevlieghereAuthorUnsubmitted
Done
ReplyInline Actions

hecho

JDevlieghere: hecho
switch (version) { switch (version) {
case 0: case 0:
return 0; // Can't know the size without a valid version return 0; // Can't know the size without a valid version
case 1: case 1:
return 8; // Version 1 only had a version + entry_count return 8; // Version 1 only had a version + entry_count
default: default:
break; break;
} }
▲ Show 20 Lines • Show All 73 Lines • Show Last 20 Lines

lldb/source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.cpp

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
return g_setting_name; return g_setting_name;
} }
DynamicLoaderDarwinKernelProperties() : Properties() { DynamicLoaderDarwinKernelProperties() : Properties() {
m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName()); m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
m_collection_sp->Initialize(g_dynamicloaderdarwinkernel_properties); m_collection_sp->Initialize(g_dynamicloaderdarwinkernel_properties);
} }
~DynamicLoaderDarwinKernelProperties() override {} ~DynamicLoaderDarwinKernelProperties() override = default;
bool GetLoadKexts() const { bool GetLoadKexts() const {
const uint32_t idx = ePropertyLoadKexts; const uint32_t idx = ePropertyLoadKexts;
return m_collection_sp->GetPropertyAtIndexAsBoolean( return m_collection_sp->GetPropertyAtIndexAsBoolean(
nullptr, idx, nullptr, idx,
g_dynamicloaderdarwinkernel_properties[idx].default_uint_value != 0); g_dynamicloaderdarwinkernel_properties[idx].default_uint_value != 0);
} }
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Plugins/DynamicLoader/Hexagon-DYLD/HexagonDYLDRendezvous.h

Show All 35 Linesclass HexagonDYLDRendezvous {
// enough to hold the information on both 32 and 64 bit platforms. // enough to hold the information on both 32 and 64 bit platforms.
struct Rendezvous { struct Rendezvous {
uint64_t version = 0; uint64_t version = 0;
lldb::addr_t map_addr = LLDB_INVALID_ADDRESS; lldb::addr_t map_addr = LLDB_INVALID_ADDRESS;
lldb::addr_t brk = LLDB_INVALID_ADDRESS; lldb::addr_t brk = LLDB_INVALID_ADDRESS;
uint64_t state = 0; uint64_t state = 0;
lldb::addr_t ldbase = 0; lldb::addr_t ldbase = 0;
Rendezvous() {} Rendezvous() = default;
}; };
public: public:
// Various metadata supplied by the inferior's threading library to describe // Various metadata supplied by the inferior's threading library to describe
// the per-thread state. // the per-thread state.
struct ThreadInfo { struct ThreadInfo {
bool valid; // whether we read valid metadata bool valid; // whether we read valid metadata
uint32_t dtv_offset; // offset of DTV pointer within pthread uint32_t dtv_offset; // offset of DTV pointer within pthread
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 54 Lines • ▼ Show 20 Lines
// Constructor // Constructor
DynamicLoaderDarwin::DynamicLoaderDarwin(Process *process) DynamicLoaderDarwin::DynamicLoaderDarwin(Process *process)
: DynamicLoader(process), m_dyld_module_wp(), m_libpthread_module_wp(), : DynamicLoader(process), m_dyld_module_wp(), m_libpthread_module_wp(),
m_pthread_getspecific_addr(), m_tid_to_tls_map(), m_dyld_image_infos(), m_pthread_getspecific_addr(), m_tid_to_tls_map(), m_dyld_image_infos(),
m_dyld_image_infos_stop_id(UINT32_MAX), m_dyld(), m_mutex() {} m_dyld_image_infos_stop_id(UINT32_MAX), m_dyld(), m_mutex() {}
// Destructor // Destructor
DynamicLoaderDarwin::~DynamicLoaderDarwin() {} DynamicLoaderDarwin::~DynamicLoaderDarwin() = default;
/// Called after attaching a process. /// Called after attaching a process.
/// ///
/// Allow DynamicLoader plug-ins to execute some code after /// Allow DynamicLoader plug-ins to execute some code after
/// attaching to a process. /// attaching to a process.
void DynamicLoaderDarwin::DidAttach() { void DynamicLoaderDarwin::DidAttach() {
PrivateInitialize(m_process); PrivateInitialize(m_process);
DoInitialImageFetch(); DoInitialImageFetch();
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
uint32_t version = 0; uint32_t version = 0;
uint32_t dylib_info_count = 0; // Version >= 1 uint32_t dylib_info_count = 0; // Version >= 1
lldb::addr_t dylib_info_addr = LLDB_INVALID_ADDRESS; // Version >= 1 lldb::addr_t dylib_info_addr = LLDB_INVALID_ADDRESS; // Version >= 1
lldb::addr_t notification = LLDB_INVALID_ADDRESS; // Version >= 1 lldb::addr_t notification = LLDB_INVALID_ADDRESS; // Version >= 1
bool processDetachedFromSharedRegion = false; // Version >= 1 bool processDetachedFromSharedRegion = false; // Version >= 1
bool libSystemInitialized = false; // Version >= 2 bool libSystemInitialized = false; // Version >= 2
lldb::addr_t dyldImageLoadAddress = LLDB_INVALID_ADDRESS; // Version >= 2 lldb::addr_t dyldImageLoadAddress = LLDB_INVALID_ADDRESS; // Version >= 2
DYLDAllImageInfos() DYLDAllImageInfos() = default;
{}
void Clear() { void Clear() {
teemperorUnsubmitted
Done
ReplyInline Actions

formatione

teemperor: formatione
JDevlieghereAuthorUnsubmitted
Done
ReplyInline Actions

factum

JDevlieghere: factum
version = 0; version = 0;
dylib_info_count = 0; dylib_info_count = 0;
dylib_info_addr = LLDB_INVALID_ADDRESS; dylib_info_addr = LLDB_INVALID_ADDRESS;
notification = LLDB_INVALID_ADDRESS; notification = LLDB_INVALID_ADDRESS;
processDetachedFromSharedRegion = false; processDetachedFromSharedRegion = false;
libSystemInitialized = false; libSystemInitialized = false;
dyldImageLoadAddress = LLDB_INVALID_ADDRESS; dyldImageLoadAddress = LLDB_INVALID_ADDRESS;
} }
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DYLDRendezvous.h

Show All 38 Linesclass DYLDRendezvous {
// enough to hold the information on both 32 and 64 bit platforms. // enough to hold the information on both 32 and 64 bit platforms.
struct Rendezvous { struct Rendezvous {
uint64_t version = 0; uint64_t version = 0;
lldb::addr_t map_addr = 0; lldb::addr_t map_addr = 0;
lldb::addr_t brk = 0; lldb::addr_t brk = 0;
uint64_t state = 0; uint64_t state = 0;
lldb::addr_t ldbase = 0; lldb::addr_t ldbase = 0;
Rendezvous() {} Rendezvous() = default;
}; };
public: public:
// Various metadata supplied by the inferior's threading library to describe // Various metadata supplied by the inferior's threading library to describe
// the per-thread state. // the per-thread state.
struct ThreadInfo { struct ThreadInfo {
bool valid; // whether we read valid metadata bool valid; // whether we read valid metadata
uint32_t dtv_offset; // offset of DTV pointer within pthread uint32_t dtv_offset; // offset of DTV pointer within pthread
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Plugins/DynamicLoader/Windows-DYLD/DynamicLoaderWindowsDYLD.cpp

Show All 22 Lines
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
LLDB_PLUGIN_DEFINE(DynamicLoaderWindowsDYLD) LLDB_PLUGIN_DEFINE(DynamicLoaderWindowsDYLD)
DynamicLoaderWindowsDYLD::DynamicLoaderWindowsDYLD(Process *process) DynamicLoaderWindowsDYLD::DynamicLoaderWindowsDYLD(Process *process)
: DynamicLoader(process) {} : DynamicLoader(process) {}
DynamicLoaderWindowsDYLD::~DynamicLoaderWindowsDYLD() {} DynamicLoaderWindowsDYLD::~DynamicLoaderWindowsDYLD() = default;
void DynamicLoaderWindowsDYLD::Initialize() { void DynamicLoaderWindowsDYLD::Initialize() {
PluginManager::RegisterPlugin(GetPluginNameStatic(), PluginManager::RegisterPlugin(GetPluginNameStatic(),
GetPluginDescriptionStatic(), CreateInstance); GetPluginDescriptionStatic(), CreateInstance);
} }
void DynamicLoaderWindowsDYLD::Terminate() {} void DynamicLoaderWindowsDYLD::Terminate() {}
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

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

Show All 37 Lines : m_ast_context(nullptr), m_passthrough(passthrough),
m_passthrough_sema(nullptr), m_target(target), m_sema(nullptr), m_passthrough_sema(nullptr), m_target(target), m_sema(nullptr),
m_top_level(top_level) { m_top_level(top_level) {
if (!m_passthrough) if (!m_passthrough)
return; return;
m_passthrough_sema = dyn_cast<SemaConsumer>(passthrough); m_passthrough_sema = dyn_cast<SemaConsumer>(passthrough);
} }
ASTResultSynthesizer::~ASTResultSynthesizer() {} ASTResultSynthesizer::~ASTResultSynthesizer() = default;
void ASTResultSynthesizer::Initialize(ASTContext &Context) { void ASTResultSynthesizer::Initialize(ASTContext &Context) {
m_ast_context = &Context; m_ast_context = &Context;
if (m_passthrough) if (m_passthrough)
m_passthrough->Initialize(Context); m_passthrough->Initialize(Context);
} }
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

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

Show All 32 Lines : m_ast_context(nullptr), m_passthrough(passthrough),
m_passthrough_sema(nullptr), m_sema(nullptr), m_function(function), m_passthrough_sema(nullptr), m_sema(nullptr), m_function(function),
m_struct_name(struct_name) { m_struct_name(struct_name) {
if (!m_passthrough) if (!m_passthrough)
return; return;
m_passthrough_sema = dyn_cast<SemaConsumer>(passthrough); m_passthrough_sema = dyn_cast<SemaConsumer>(passthrough);
} }
ASTStructExtractor::~ASTStructExtractor() {} ASTStructExtractor::~ASTStructExtractor() = default;
void ASTStructExtractor::Initialize(ASTContext &Context) { void ASTStructExtractor::Initialize(ASTContext &Context) {
m_ast_context = &Context; m_ast_context = &Context;
if (m_passthrough) if (m_passthrough)
m_passthrough->Initialize(Context); m_passthrough->Initialize(Context);
} }
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

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

//===-- ASTUtils.cpp ------------------------------------------------------===// //===-- ASTUtils.cpp ------------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "ASTUtils.h" #include "ASTUtils.h"
lldb_private::ExternalASTSourceWrapper::~ExternalASTSourceWrapper() {} lldb_private::ExternalASTSourceWrapper::~ExternalASTSourceWrapper() = default;
void lldb_private::ExternalASTSourceWrapper::PrintStats() { void lldb_private::ExternalASTSourceWrapper::PrintStats() {
m_Source->PrintStats(); m_Source->PrintStats();
} }
lldb_private::ASTConsumerForwarder::~ASTConsumerForwarder() {} lldb_private::ASTConsumerForwarder::~ASTConsumerForwarder() = default;
void lldb_private::ASTConsumerForwarder::PrintStats() { m_c->PrintStats(); } void lldb_private::ASTConsumerForwarder::PrintStats() { m_c->PrintStats(); }
lldb_private::SemaSourceWithPriorities::~SemaSourceWithPriorities() {} lldb_private::SemaSourceWithPriorities::~SemaSourceWithPriorities() = default;
void lldb_private::SemaSourceWithPriorities::PrintStats() { void lldb_private::SemaSourceWithPriorities::PrintStats() {
for (size_t i = 0; i < Sources.size(); ++i) for (size_t i = 0; i < Sources.size(); ++i)
Sources[i]->PrintStats(); Sources[i]->PrintStats();
} }

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

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
context_md->m_map_completer = &completer; context_md->m_map_completer = &completer;
} }
void ForgetDestination(clang::ASTContext *dst_ctx); void ForgetDestination(clang::ASTContext *dst_ctx);
void ForgetSource(clang::ASTContext *dst_ctx, clang::ASTContext *src_ctx); void ForgetSource(clang::ASTContext *dst_ctx, clang::ASTContext *src_ctx);
struct DeclOrigin { struct DeclOrigin {
DeclOrigin() {} DeclOrigin() = default;
DeclOrigin(clang::ASTContext *_ctx, clang::Decl *_decl) DeclOrigin(clang::ASTContext *_ctx, clang::Decl *_decl)
: ctx(_ctx), decl(_decl) { : ctx(_ctx), decl(_decl) {
// The decl has to be in its associated ASTContext. // The decl has to be in its associated ASTContext.
assert(_decl == nullptr || &_decl->getASTContext() == _ctx); assert(_decl == nullptr || &_decl->getASTContext() == _ctx);
} }
DeclOrigin(const DeclOrigin &rhs) { DeclOrigin(const DeclOrigin &rhs) {
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
escaped_child); escaped_child);
lldbassert(0 && "Couldn't override!"); lldbassert(0 && "Couldn't override!");
} }
OverrideOne(decl); OverrideOne(decl);
} }
public: public:
DeclContextOverride() {} DeclContextOverride() = default;
void OverrideAllDeclsFromContainingFunction(clang::Decl *decl) { void OverrideAllDeclsFromContainingFunction(clang::Decl *decl) {
for (DeclContext *decl_context = decl->getLexicalDeclContext(); for (DeclContext *decl_context = decl->getLexicalDeclContext();
decl_context; decl_context = decl_context->getLexicalParent()) { decl_context; decl_context = decl_context->getLexicalParent()) {
DeclContext *redecl_context = decl_context->getRedeclContext(); DeclContext *redecl_context = decl_context->getRedeclContext();
if (llvm::isa<FunctionDecl>(redecl_context) && if (llvm::isa<FunctionDecl>(redecl_context) &&
llvm::isa<TranslationUnitDecl>(redecl_context->getLexicalParent())) { llvm::isa<TranslationUnitDecl>(redecl_context->getLexicalParent())) {
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

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

Show All 16 Lines
namespace lldb_private { namespace lldb_private {
// A clang specialized extension to DeclVendor. // A clang specialized extension to DeclVendor.
class ClangDeclVendor : public DeclVendor { class ClangDeclVendor : public DeclVendor {
public: public:
ClangDeclVendor(DeclVendorKind kind) : DeclVendor(kind) {} ClangDeclVendor(DeclVendorKind kind) : DeclVendor(kind) {}
virtual ~ClangDeclVendor() {} virtual ~ClangDeclVendor() = default;
using DeclVendor::FindDecls; using DeclVendor::FindDecls;
uint32_t FindDecls(ConstString name, bool append, uint32_t max_matches, uint32_t FindDecls(ConstString name, bool append, uint32_t max_matches,
std::vector<clang::NamedDecl *> &decls); std::vector<clang::NamedDecl *> &decls);
static bool classof(const DeclVendor *vendor) { static bool classof(const DeclVendor *vendor) {
return vendor->GetKind() >= eClangDeclVendor && return vendor->GetKind() >= eClangDeclVendor &&
Show All 10 Lines

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

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
lldb::addr_t GetSymbolAddress(ConstString name, lldb::addr_t GetSymbolAddress(ConstString name,
lldb::SymbolType symbol_type); lldb::SymbolType symbol_type);
struct TargetInfo { struct TargetInfo {
lldb::ByteOrder byte_order = lldb::eByteOrderInvalid; lldb::ByteOrder byte_order = lldb::eByteOrderInvalid;
size_t address_byte_size = 0; size_t address_byte_size = 0;
TargetInfo() {} TargetInfo() = default;
bool IsValid() { bool IsValid() {
return (byte_order != lldb::eByteOrderInvalid && address_byte_size != 0); return (byte_order != lldb::eByteOrderInvalid && address_byte_size != 0);
} }
}; };
TargetInfo GetTargetInfo(); TargetInfo GetTargetInfo();
/// [Used by ClangASTSource] Find all entities matching a given name, using /// [Used by ClangASTSource] Find all entities matching a given name, using
Show All 40 Lines
ValueObject *m_ctx_obj; ///< If not empty, then expression is ValueObject *m_ctx_obj; ///< If not empty, then expression is
///evaluated in context of this object. ///evaluated in context of this object.
///For details see the comment to ///For details see the comment to
///`UserExpression::Evaluate`. ///`UserExpression::Evaluate`.
/// The following values should not live beyond parsing /// The following values should not live beyond parsing
class ParserVars { class ParserVars {
public: public:
ParserVars() {} ParserVars() = default;
Target *GetTarget() { Target *GetTarget() {
if (m_exe_ctx.GetTargetPtr()) if (m_exe_ctx.GetTargetPtr())
return m_exe_ctx.GetTargetPtr(); return m_exe_ctx.GetTargetPtr();
else if (m_sym_ctx.target_sp) else if (m_sym_ctx.target_sp)
return m_sym_ctx.target_sp.get(); return m_sym_ctx.target_sp.get();
return nullptr; return nullptr;
} }
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

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

Show All 32 Lines static bool classof(const ExpressionTypeSystemHelper *ts) {
return ts->getKind() == eKindClangHelper; return ts->getKind() == eKindClangHelper;
} }
ClangExpressionHelper() ClangExpressionHelper()
: ExpressionTypeSystemHelper( : ExpressionTypeSystemHelper(
ExpressionTypeSystemHelper::LLVMCastKind::eKindClangHelper) {} ExpressionTypeSystemHelper::LLVMCastKind::eKindClangHelper) {}
/// Destructor /// Destructor
virtual ~ClangExpressionHelper() {} virtual ~ClangExpressionHelper() = default;
/// Return the object that the parser should use when resolving external /// Return the object that the parser should use when resolving external
/// values. May be NULL if everything should be self-contained. /// values. May be NULL if everything should be self-contained.
virtual ClangExpressionDeclMap *DeclMap() = 0; virtual ClangExpressionDeclMap *DeclMap() = 0;
/// Return the object that the parser should allow to access ASTs. /// Return the object that the parser should allow to access ASTs.
/// May be NULL if the ASTs do not need to be transformed. /// May be NULL if the ASTs do not need to be transformed.
/// ///
Show All 14 Lines

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

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
m_llvm_context = std::make_unique<LLVMContext>(); m_llvm_context = std::make_unique<LLVMContext>();
m_code_generator.reset(CreateLLVMCodeGen( m_code_generator.reset(CreateLLVMCodeGen(
m_compiler->getDiagnostics(), module_name, m_compiler->getDiagnostics(), module_name,
m_compiler->getHeaderSearchOpts(), m_compiler->getPreprocessorOpts(), m_compiler->getHeaderSearchOpts(), m_compiler->getPreprocessorOpts(),
m_compiler->getCodeGenOpts(), *m_llvm_context)); m_compiler->getCodeGenOpts(), *m_llvm_context));
} }
ClangExpressionParser::~ClangExpressionParser() {} ClangExpressionParser::~ClangExpressionParser() = default;
namespace { namespace {
/// \class CodeComplete /// \class CodeComplete
/// ///
/// A code completion consumer for the clang Sema that is responsible for /// A code completion consumer for the clang Sema that is responsible for
/// creating the completion suggestions when a user requests completion /// creating the completion suggestions when a user requests completion
/// of an incomplete `expr` invocation. /// of an incomplete `expr` invocation.
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
if (i == m_parser_vars.end()) if (i == m_parser_vars.end())
return nullptr; return nullptr;
else else
return &i->second; return &i->second;
} }
/// The following values are valid if the variable is used by JIT code /// The following values are valid if the variable is used by JIT code
struct JITVars { struct JITVars {
JITVars() {} JITVars() = default;
lldb::offset_t m_alignment = lldb::offset_t m_alignment =
0; ///< The required alignment of the variable, in bytes 0; ///< The required alignment of the variable, in bytes
size_t m_size = 0; ///< The space required for the variable, in bytes size_t m_size = 0; ///< The space required for the variable, in bytes
lldb::offset_t m_offset = lldb::offset_t m_offset =
0; ///< The offset of the variable in the struct, in bytes 0; ///< The offset of the variable in the struct, in bytes
}; };
Show All 39 Lines

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

Show First 20 Lines • Show All 53 Lines • ▼ Show 20 Lines : FunctionCaller(exe_scope, return_type, functionAddress, arg_value_list,
name), name),
m_type_system_helper(*this) { m_type_system_helper(*this) {
m_jit_process_wp = lldb::ProcessWP(exe_scope.CalculateProcess()); m_jit_process_wp = lldb::ProcessWP(exe_scope.CalculateProcess());
// Can't make a ClangFunctionCaller without a process. // Can't make a ClangFunctionCaller without a process.
assert(m_jit_process_wp.lock()); assert(m_jit_process_wp.lock());
} }
// Destructor // Destructor
ClangFunctionCaller::~ClangFunctionCaller() {} ClangFunctionCaller::~ClangFunctionCaller() = default;
unsigned unsigned
ClangFunctionCaller::CompileFunction(lldb::ThreadSP thread_to_use_sp, ClangFunctionCaller::CompileFunction(lldb::ThreadSP thread_to_use_sp,
DiagnosticManager &diagnostic_manager) { DiagnosticManager &diagnostic_manager) {
if (m_compiled) if (m_compiled)
return 0; return 0;
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
void StoringDiagnosticConsumer::EndSourceFile() { void StoringDiagnosticConsumer::EndSourceFile() {
m_diag_printer->EndSourceFile(); m_diag_printer->EndSourceFile();
} }
ClangModulesDeclVendor::ClangModulesDeclVendor() ClangModulesDeclVendor::ClangModulesDeclVendor()
: ClangDeclVendor(eClangModuleDeclVendor) {} : ClangDeclVendor(eClangModuleDeclVendor) {}
ClangModulesDeclVendor::~ClangModulesDeclVendor() {} ClangModulesDeclVendor::~ClangModulesDeclVendor() = default;
ClangModulesDeclVendorImpl::ClangModulesDeclVendorImpl( ClangModulesDeclVendorImpl::ClangModulesDeclVendorImpl(
llvm::IntrusiveRefCntPtr<clang::DiagnosticsEngine> diagnostics_engine, llvm::IntrusiveRefCntPtr<clang::DiagnosticsEngine> diagnostics_engine,
std::shared_ptr<clang::CompilerInvocation> compiler_invocation, std::shared_ptr<clang::CompilerInvocation> compiler_invocation,
std::unique_ptr<clang::CompilerInstance> compiler_instance, std::unique_ptr<clang::CompilerInstance> compiler_instance,
std::unique_ptr<clang::Parser> parser) std::unique_ptr<clang::Parser> parser)
: m_diagnostics_engine(std::move(diagnostics_engine)), : m_diagnostics_engine(std::move(diagnostics_engine)),
m_compiler_invocation(std::move(compiler_invocation)), m_compiler_invocation(std::move(compiler_invocation)),
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 84 Lines • ▼ Show 20 LinesClangUserExpression::ClangUserExpression(
case lldb::eLanguageTypeObjC_plus_plus: case lldb::eLanguageTypeObjC_plus_plus:
default: default:
m_allow_cxx = true; m_allow_cxx = true;
m_allow_objc = true; m_allow_objc = true;
break; break;
} }
} }
ClangUserExpression::~ClangUserExpression() {} ClangUserExpression::~ClangUserExpression() = default;
void ClangUserExpression::ScanContext(ExecutionContext &exe_ctx, Status &err) { void ClangUserExpression::ScanContext(ExecutionContext &exe_ctx, Status &err) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
LLDB_LOGF(log, "ClangUserExpression::ScanContext()"); LLDB_LOGF(log, "ClangUserExpression::ScanContext()");
m_target = exe_ctx.GetTargetPtr(); m_target = exe_ctx.GetTargetPtr();
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 68 Lines • ▼ Show 20 Linespublic:
} }
bool Install(DiagnosticManager &diagnostic_manager, bool Install(DiagnosticManager &diagnostic_manager,
ExecutionContext &exe_ctx) override; ExecutionContext &exe_ctx) override;
private: private:
class ClangUtilityFunctionHelper : public ClangExpressionHelper { class ClangUtilityFunctionHelper : public ClangExpressionHelper {
public: public:
ClangUtilityFunctionHelper() {} ClangUtilityFunctionHelper() = default;
~ClangUtilityFunctionHelper() override {} ~ClangUtilityFunctionHelper() override = default;
/// Return the object that the parser should use when resolving external /// Return the object that the parser should use when resolving external
/// values. May be NULL if everything should be self-contained. /// values. May be NULL if everything should be self-contained.
ClangExpressionDeclMap *DeclMap() override { ClangExpressionDeclMap *DeclMap() override {
return m_expr_decl_map_up.get(); return m_expr_decl_map_up.get();
} }
void ResetDeclMap() { m_expr_decl_map_up.reset(); } void ResetDeclMap() { m_expr_decl_map_up.reset(); }
Show All 25 Lines

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

Show First 20 Lines • Show All 59 Lines • ▼ Show 20 Lines if (temp_fd != -1) {
std::string(ClangExpressionSourceCode::g_expression_prefix) + text + std::string(ClangExpressionSourceCode::g_expression_prefix) + text +
std::string(ClangExpressionSourceCode::g_expression_suffix); std::string(ClangExpressionSourceCode::g_expression_suffix);
} }
file.Close(); file.Close();
} }
} }
} }
ClangUtilityFunction::~ClangUtilityFunction() {} ClangUtilityFunction::~ClangUtilityFunction() = default;
/// Install the utility function into a process /// Install the utility function into a process
/// ///
/// \param[in] diagnostic_manager /// \param[in] diagnostic_manager
/// A diagnostic manager to report errors and warnings to. /// A diagnostic manager to report errors and warnings to.
/// ///
/// \param[in] exe_ctx /// \param[in] exe_ctx
/// The execution context to install the utility function to. /// The execution context to install the utility function to.
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 53 Lines • ▼ Show 20 Linesclass CppModuleConfiguration {
/// Returns false iff there was a fatal error that makes analyzing any /// Returns false iff there was a fatal error that makes analyzing any
/// further files pointless as the configuration is now invalid. /// further files pointless as the configuration is now invalid.
bool analyzeFile(const FileSpec &f); bool analyzeFile(const FileSpec &f);
public: public:
/// Creates a configuration by analyzing the given list of used source files. /// Creates a configuration by analyzing the given list of used source files.
explicit CppModuleConfiguration(const FileSpecList &support_files); explicit CppModuleConfiguration(const FileSpecList &support_files);
/// Creates an empty and invalid configuration. /// Creates an empty and invalid configuration.
CppModuleConfiguration() {} CppModuleConfiguration() = default;
/// Returns true iff this is a valid configuration that can be used to /// Returns true iff this is a valid configuration that can be used to
/// load and compile modules. /// load and compile modules.
bool hasValidConfig(); bool hasValidConfig();
/// Returns a list of include directories that should be used when using this /// Returns a list of include directories that should be used when using this
/// configuration (e.g. {"/usr/include", "/usr/include/c++/v1"}). /// configuration (e.g. {"/usr/include", "/usr/include/c++/v1"}).
llvm::ArrayRef<std::string> GetIncludeDirs() const { return m_include_dirs; } llvm::ArrayRef<std::string> GetIncludeDirs() const { return m_include_dirs; }
Show All 11 Lines

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

Show All 40 Lines
using namespace llvm; using namespace llvm;
typedef SmallVector<Instruction *, 2> InstrList; typedef SmallVector<Instruction *, 2> InstrList;
IRForTarget::FunctionValueCache::FunctionValueCache(Maker const &maker) IRForTarget::FunctionValueCache::FunctionValueCache(Maker const &maker)
: m_maker(maker), m_values() {} : m_maker(maker), m_values() {}
IRForTarget::FunctionValueCache::~FunctionValueCache() {} IRForTarget::FunctionValueCache::~FunctionValueCache() = default;
llvm::Value * llvm::Value *
IRForTarget::FunctionValueCache::GetValue(llvm::Function *function) { IRForTarget::FunctionValueCache::GetValue(llvm::Function *function) {
if (!m_values.count(function)) { if (!m_values.count(function)) {
llvm::Value *ret = m_maker(function); llvm::Value *ret = m_maker(function);
m_values[function] = ret; m_values[function] = ret;
return ret; return ret;
} }
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Plugins/Instruction/ARM/EmulateInstructionARM.h

Show All 13 Lines
#include "lldb/Utility/ConstString.h" #include "lldb/Utility/ConstString.h"
#include "lldb/Utility/Status.h" #include "lldb/Utility/Status.h"
namespace lldb_private { namespace lldb_private {
// ITSession - Keep track of the IT Block progression. // ITSession - Keep track of the IT Block progression.
class ITSession { class ITSession {
public: public:
ITSession() {} ITSession() = default;
~ITSession() {} ~ITSession() = default;
// InitIT - Initializes ITCounter/ITState. // InitIT - Initializes ITCounter/ITState.
bool InitIT(uint32_t bits7_0); bool InitIT(uint32_t bits7_0);
// ITAdvance - Updates ITCounter/ITState as IT Block progresses. // ITAdvance - Updates ITCounter/ITState as IT Block progresses.
void ITAdvance(); void ITAdvance();
// InITBlock - Returns true if we're inside an IT Block. // InITBlock - Returns true if we're inside an IT Block.
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Plugins/Instruction/ARM/EmulationStateARM.cpp

Show All 18 Lines
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
EmulationStateARM::EmulationStateARM() : m_vfp_regs(), m_memory() { EmulationStateARM::EmulationStateARM() : m_vfp_regs(), m_memory() {
ClearPseudoRegisters(); ClearPseudoRegisters();
} }
EmulationStateARM::~EmulationStateARM() {} EmulationStateARM::~EmulationStateARM() = default;
bool EmulationStateARM::LoadPseudoRegistersFromFrame(StackFrame &frame) { bool EmulationStateARM::LoadPseudoRegistersFromFrame(StackFrame &frame) {
RegisterContext *reg_ctx = frame.GetRegisterContext().get(); RegisterContext *reg_ctx = frame.GetRegisterContext().get();
bool success = true; bool success = true;
uint32_t reg_num; uint32_t reg_num;
for (int i = dwarf_r0; i < dwarf_r0 + 17; ++i) { for (int i = dwarf_r0; i < dwarf_r0 + 17; ++i) {
reg_num = reg_num =
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 63 Lines • ▼ Show 20 Linesprivate:
// Index of the next token to look at from m_tokens. // Index of the next token to look at from m_tokens.
size_t m_next_token_index = 0; size_t m_next_token_index = 0;
// Range of tokens saved in m_next_token_index. // Range of tokens saved in m_next_token_index.
struct Range { struct Range {
size_t begin_index = 0; size_t begin_index = 0;
size_t end_index = 0; size_t end_index = 0;
Range() {} Range() = default;
Range(size_t begin, size_t end) : begin_index(begin), end_index(end) { Range(size_t begin, size_t end) : begin_index(begin), end_index(end) {
assert(end >= begin); assert(end >= begin);
} }
size_t size() const { return end_index - begin_index; } size_t size() const { return end_index - begin_index; }
bool empty() const { return size() == 0; } bool empty() const { return size() == 0; }
}; };
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
void Clear() { void Clear() {
m_indexes = 0; m_indexes = 0;
m_count = 0; m_count = 0;
m_ptr_size = 0; m_ptr_size = 0;
m_process = nullptr; m_process = nullptr;
} }
InlinedIndexes() {} InlinedIndexes() = default;
private: private:
uint64_t m_indexes = 0; uint64_t m_indexes = 0;
size_t m_count = 0; size_t m_count = 0;
uint32_t m_ptr_size = 0; uint32_t m_ptr_size = 0;
Process *m_process = nullptr; Process *m_process = nullptr;
// cfr. Foundation for the details of this code // cfr. Foundation for the details of this code
▲ Show 20 Lines • Show All 44 Lines • ▼ Show 20 Lines
return nullptr; return nullptr;
} }
void Clear() { void Clear() {
m_indexes = nullptr; m_indexes = nullptr;
m_count = 0; m_count = 0;
} }
OutsourcedIndexes() {} OutsourcedIndexes() = default;
ValueObject *m_indexes = nullptr; ValueObject *m_indexes = nullptr;
size_t m_count = 0; size_t m_count = 0;
}; };
union { union {
struct InlinedIndexes m_inlined; struct InlinedIndexes m_inlined;
struct OutsourcedIndexes m_outsourced; struct OutsourcedIndexes m_outsourced;
}; };
void Clear() { void Clear() {
m_mode = Mode::Invalid; m_mode = Mode::Invalid;
m_inlined.Clear(); m_inlined.Clear();
m_outsourced.Clear(); m_outsourced.Clear();
} }
Impl() {} Impl() = default;
Mode m_mode = Mode::Invalid; Mode m_mode = Mode::Invalid;
} m_impl; } m_impl;
uint32_t m_ptr_size; uint32_t m_ptr_size;
CompilerType m_uint_star_type; CompilerType m_uint_star_type;
}; };
Show All 13 Lines

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

Show First 20 Lines • Show All 78 Lines • ▼ Show 20 Linesprivate:
struct objc_class_t { struct objc_class_t {
ObjCLanguageRuntime::ObjCISA m_isa = 0; // The class's metaclass. ObjCLanguageRuntime::ObjCISA m_isa = 0; // The class's metaclass.
ObjCLanguageRuntime::ObjCISA m_superclass = 0; ObjCLanguageRuntime::ObjCISA m_superclass = 0;
lldb::addr_t m_cache_ptr = 0; lldb::addr_t m_cache_ptr = 0;
lldb::addr_t m_vtable_ptr = 0; lldb::addr_t m_vtable_ptr = 0;
lldb::addr_t m_data_ptr = 0; lldb::addr_t m_data_ptr = 0;
uint8_t m_flags = 0; uint8_t m_flags = 0;
objc_class_t() {} objc_class_t() = default;
void Clear() { void Clear() {
m_isa = 0; m_isa = 0;
m_superclass = 0; m_superclass = 0;
m_cache_ptr = 0; m_cache_ptr = 0;
m_vtable_ptr = 0; m_vtable_ptr = 0;
m_data_ptr = 0; m_data_ptr = 0;
m_flags = 0; m_flags = 0;
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 42 Lines • ▼ Show 20 Lines
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
LLDB_PLUGIN_DEFINE(AppleObjCRuntime) LLDB_PLUGIN_DEFINE(AppleObjCRuntime)
char AppleObjCRuntime::ID = 0; char AppleObjCRuntime::ID = 0;
AppleObjCRuntime::~AppleObjCRuntime() {} AppleObjCRuntime::~AppleObjCRuntime() = default;
AppleObjCRuntime::AppleObjCRuntime(Process *process) AppleObjCRuntime::AppleObjCRuntime(Process *process)
: ObjCLanguageRuntime(process), m_read_objc_library(false), : ObjCLanguageRuntime(process), m_read_objc_library(false),
m_objc_trampoline_handler_up(), m_Foundation_major() { m_objc_trampoline_handler_up(), m_Foundation_major() {
ReadObjCLibraryIfNeeded(process->GetTarget().GetImages()); ReadObjCLibraryIfNeeded(process->GetTarget().GetImages());
} }
void AppleObjCRuntime::Initialize() { void AppleObjCRuntime::Initialize() {
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
protected: protected:
lldb::BreakpointResolverSP lldb::BreakpointResolverSP
CreateExceptionResolver(const lldb::BreakpointSP &bkpt, CreateExceptionResolver(const lldb::BreakpointSP &bkpt,
bool catch_bp, bool throw_bp) override; bool catch_bp, bool throw_bp) override;
class HashTableSignature { class HashTableSignature {
public: public:
HashTableSignature() {} HashTableSignature() = default;
bool NeedsUpdate(uint32_t count, uint32_t num_buckets, bool NeedsUpdate(uint32_t count, uint32_t num_buckets,
lldb::addr_t buckets_ptr) { lldb::addr_t buckets_ptr) {
return m_count != count || m_num_buckets != num_buckets || return m_count != count || m_num_buckets != num_buckets ||
m_buckets_ptr != buckets_ptr; m_buckets_ptr != buckets_ptr;
} }
void UpdateSignature(uint32_t count, uint32_t num_buckets, void UpdateSignature(uint32_t count, uint32_t num_buckets,
Show All 25 Lines

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

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
lldb::addr_t m_buckets_ptr = LLDB_INVALID_ADDRESS; lldb::addr_t m_buckets_ptr = LLDB_INVALID_ADDRESS;
lldb_private::Process *m_process = nullptr; lldb_private::Process *m_process = nullptr;
const_iterator m_end_iterator; const_iterator m_end_iterator;
lldb::addr_t m_load_addr = LLDB_INVALID_ADDRESS; lldb::addr_t m_load_addr = LLDB_INVALID_ADDRESS;
size_t m_map_pair_size = 0; size_t m_map_pair_size = 0;
lldb::addr_t m_invalid_key = 0; lldb::addr_t m_invalid_key = 0;
}; };
AppleObjCRuntimeV2::HashTableSignature::HashTableSignature() {} AppleObjCRuntimeV2::HashTableSignature::HashTableSignature() = default;
void AppleObjCRuntimeV2::HashTableSignature::UpdateSignature( void AppleObjCRuntimeV2::HashTableSignature::UpdateSignature(
const RemoteNXMapTable &hash_table) { const RemoteNXMapTable &hash_table) {
m_count = hash_table.GetCount(); m_count = hash_table.GetCount();
m_num_buckets = hash_table.GetBucketCount(); m_num_buckets = hash_table.GetBucketCount();
m_buckets_ptr = hash_table.GetBucketDataPointer(); m_buckets_ptr = hash_table.GetBucketDataPointer();
} }
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 70 Lines • ▼ Show 20 Lines struct VTableDescriptor {
: flags(in_flags), code_start(in_code_start) {} : flags(in_flags), code_start(in_code_start) {}
uint32_t flags; uint32_t flags;
lldb::addr_t code_start; lldb::addr_t code_start;
}; };
class VTableRegion { class VTableRegion {
public: public:
VTableRegion() {} VTableRegion() = default;
VTableRegion(AppleObjCVTables *owner, lldb::addr_t header_addr); VTableRegion(AppleObjCVTables *owner, lldb::addr_t header_addr);
void SetUpRegion(); void SetUpRegion();
lldb::addr_t GetNextRegionAddr() { return m_next_region; } lldb::addr_t GetNextRegionAddr() { return m_next_region; }
lldb::addr_t GetCodeStart() { return m_code_start_addr; } lldb::addr_t GetCodeStart() { return m_code_start_addr; }
▲ Show 20 Lines • Show All 72 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
AppleObjCTrampolineHandler::AppleObjCVTables::VTableRegion::VTableRegion( AppleObjCTrampolineHandler::AppleObjCVTables::VTableRegion::VTableRegion(
AppleObjCVTables *owner, lldb::addr_t header_addr) AppleObjCVTables *owner, lldb::addr_t header_addr)
: m_valid(true), m_owner(owner), m_header_addr(header_addr), : m_valid(true), m_owner(owner), m_header_addr(header_addr),
m_code_start_addr(0), m_code_end_addr(0), m_next_region(0) { m_code_start_addr(0), m_code_end_addr(0), m_next_region(0) {
SetUpRegion(); SetUpRegion();
} }
AppleObjCTrampolineHandler::~AppleObjCTrampolineHandler() {} AppleObjCTrampolineHandler::~AppleObjCTrampolineHandler() = default;
void AppleObjCTrampolineHandler::AppleObjCVTables::VTableRegion::SetUpRegion() { void AppleObjCTrampolineHandler::AppleObjCVTables::VTableRegion::SetUpRegion() {
// The header looks like: // The header looks like:
// //
// uint16_t headerSize // uint16_t headerSize
// uint16_t descSize // uint16_t descSize
// uint32_t descCount // uint32_t descCount
// void * next // void * next
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

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

Show All 34 Lines : ThreadPlan(ThreadPlan::eKindGeneric,
"MacOSX Step through ObjC Trampoline", thread, eVoteNoOpinion, "MacOSX Step through ObjC Trampoline", thread, eVoteNoOpinion,
eVoteNoOpinion), eVoteNoOpinion),
m_trampoline_handler(trampoline_handler), m_trampoline_handler(trampoline_handler),
m_args_addr(LLDB_INVALID_ADDRESS), m_input_values(input_values), m_args_addr(LLDB_INVALID_ADDRESS), m_input_values(input_values),
m_isa_addr(isa_addr), m_sel_addr(sel_addr), m_impl_function(nullptr) {} m_isa_addr(isa_addr), m_sel_addr(sel_addr), m_impl_function(nullptr) {}
// Destructor // Destructor
AppleThreadPlanStepThroughObjCTrampoline:: AppleThreadPlanStepThroughObjCTrampoline::
~AppleThreadPlanStepThroughObjCTrampoline() {} ~AppleThreadPlanStepThroughObjCTrampoline() = default;
void AppleThreadPlanStepThroughObjCTrampoline::DidPush() { void AppleThreadPlanStepThroughObjCTrampoline::DidPush() {
// Setting up the memory space for the called function text might require // Setting up the memory space for the called function text might require
// allocations, i.e. a nested function call. This needs to be done as a // allocations, i.e. a nested function call. This needs to be done as a
// PreResumeAction. // PreResumeAction.
m_process.AddPreResumeAction(PreResumeInitializeFunctionCaller, (void *)this); m_process.AddPreResumeAction(PreResumeInitializeFunctionCaller, (void *)this);
} }
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.cpp

Show All 26 Lines
#include "llvm/Support/DJB.h" #include "llvm/Support/DJB.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
char ObjCLanguageRuntime::ID = 0; char ObjCLanguageRuntime::ID = 0;
// Destructor // Destructor
ObjCLanguageRuntime::~ObjCLanguageRuntime() {} ObjCLanguageRuntime::~ObjCLanguageRuntime() = default;
ObjCLanguageRuntime::ObjCLanguageRuntime(Process *process) ObjCLanguageRuntime::ObjCLanguageRuntime(Process *process)
: LanguageRuntime(process), m_impl_cache(), : LanguageRuntime(process), m_impl_cache(),
m_has_new_literals_and_indexing(eLazyBoolCalculate), m_has_new_literals_and_indexing(eLazyBoolCalculate),
m_isa_to_descriptor(), m_hash_to_isa_map(), m_type_size_cache(), m_isa_to_descriptor(), m_hash_to_isa_map(), m_type_size_cache(),
m_isa_to_descriptor_stop_id(UINT32_MAX), m_complete_class_cache(), m_isa_to_descriptor_stop_id(UINT32_MAX), m_complete_class_cache(),
m_negative_complete_class_cache() {} m_negative_complete_class_cache() {}
▲ Show 20 Lines • Show All 182 Lines • ▼ Show 20 Lines
CompilerType CompilerType
ObjCLanguageRuntime::EncodingToType::RealizeType(const char *name, ObjCLanguageRuntime::EncodingToType::RealizeType(const char *name,
bool for_expression) { bool for_expression) {
if (m_scratch_ast_ctx_up) if (m_scratch_ast_ctx_up)
return RealizeType(*m_scratch_ast_ctx_up, name, for_expression); return RealizeType(*m_scratch_ast_ctx_up, name, for_expression);
return CompilerType(); return CompilerType();
} }
ObjCLanguageRuntime::EncodingToType::~EncodingToType() {} ObjCLanguageRuntime::EncodingToType::~EncodingToType() = default;
ObjCLanguageRuntime::EncodingToTypeSP ObjCLanguageRuntime::GetEncodingToType() { ObjCLanguageRuntime::EncodingToTypeSP ObjCLanguageRuntime::GetEncodingToType() {
return nullptr; return nullptr;
} }
bool ObjCLanguageRuntime::GetTypeBitSize(const CompilerType &compiler_type, bool ObjCLanguageRuntime::GetTypeBitSize(const CompilerType &compiler_type,
uint64_t &size) { uint64_t &size) {
void *opaque_ptr = compiler_type.GetOpaqueQualType(); void *opaque_ptr = compiler_type.GetOpaqueQualType();
▲ Show 20 Lines • Show All 41 Lines • ▼ Show 20 Lines
} }
// Exception breakpoint Precondition class for ObjC: // Exception breakpoint Precondition class for ObjC:
void ObjCLanguageRuntime::ObjCExceptionPrecondition::AddClassName( void ObjCLanguageRuntime::ObjCExceptionPrecondition::AddClassName(
const char *class_name) { const char *class_name) {
m_class_names.insert(class_name); m_class_names.insert(class_name);
} }
ObjCLanguageRuntime::ObjCExceptionPrecondition::ObjCExceptionPrecondition() {} ObjCLanguageRuntime::ObjCExceptionPrecondition::ObjCExceptionPrecondition() =
default;
bool ObjCLanguageRuntime::ObjCExceptionPrecondition::EvaluatePrecondition( bool ObjCLanguageRuntime::ObjCExceptionPrecondition::EvaluatePrecondition(
StoppointCallbackContext &context) { StoppointCallbackContext &context) {
return true; return true;
} }
void ObjCLanguageRuntime::ObjCExceptionPrecondition::GetDescription( void ObjCLanguageRuntime::ObjCExceptionPrecondition::GetDescription(
Stream &stream, lldb::DescriptionLevel level) {} Stream &stream, lldb::DescriptionLevel level) {}
▲ Show 20 Lines • Show All 44 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
IRPasses(); IRPasses();
assert(process); assert(process);
EarlyPasses = std::make_shared<llvm::legacy::PassManager>(); EarlyPasses = std::make_shared<llvm::legacy::PassManager>();
assert(EarlyPasses); assert(EarlyPasses);
EarlyPasses->add(new RenderScriptRuntimeModulePass(process)); EarlyPasses->add(new RenderScriptRuntimeModulePass(process));
} }
RSIRPasses::~RSIRPasses() {} RSIRPasses::~RSIRPasses() = default;
} // namespace lldb_renderscript } // namespace lldb_renderscript
} // namespace lldb_private } // namespace lldb_private
Context not available.

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

Show All 40 Lines
typedef std::shared_ptr<RSModuleDescriptor> RSModuleDescriptorSP; typedef std::shared_ptr<RSModuleDescriptor> RSModuleDescriptorSP;
typedef std::shared_ptr<RSGlobalDescriptor> RSGlobalDescriptorSP; typedef std::shared_ptr<RSGlobalDescriptor> RSGlobalDescriptorSP;
typedef std::shared_ptr<RSKernelDescriptor> RSKernelDescriptorSP; typedef std::shared_ptr<RSKernelDescriptor> RSKernelDescriptorSP;
typedef std::shared_ptr<RSScriptGroupDescriptor> RSScriptGroupDescriptorSP; typedef std::shared_ptr<RSScriptGroupDescriptor> RSScriptGroupDescriptorSP;
struct RSCoordinate { struct RSCoordinate {
uint32_t x = 0, y = 0, z = 0; uint32_t x = 0, y = 0, z = 0;
RSCoordinate(){}; RSCoordinate() = default;
teemperorUnsubmitted
Done
ReplyInline Actions

goodbye

teemperor: goodbye
JDevlieghereAuthorUnsubmitted
Done
ReplyInline Actions

ciao

JDevlieghere: ciao
bool operator==(const lldb_renderscript::RSCoordinate &rhs) { bool operator==(const lldb_renderscript::RSCoordinate &rhs) {
return x == rhs.x && y == rhs.y && z == rhs.z; return x == rhs.x && y == rhs.y && z == rhs.z;
} }
}; };
// Breakpoint Resolvers decide where a breakpoint is placed, so having our own // Breakpoint Resolvers decide where a breakpoint is placed, so having our own
// allows us to limit the search scope to RS kernel modules. As well as check // allows us to limit the search scope to RS kernel modules. As well as check
// for .expand kernels as a fallback. // for .expand kernels as a fallback.
▲ Show 20 Lines • Show All 90 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 55 Lines • ▼ Show 20 Lines
// The empirical_type adds a basic level of validation to arbitrary data // The empirical_type adds a basic level of validation to arbitrary data
// allowing us to track if data has been discovered and stored or not. An // allowing us to track if data has been discovered and stored or not. An
// empirical_type will be marked as valid only if it has been explicitly // empirical_type will be marked as valid only if it has been explicitly
// assigned to. // assigned to.
template <typename type_t> class empirical_type { template <typename type_t> class empirical_type {
public: public:
// Ctor. Contents is invalid when constructed. // Ctor. Contents is invalid when constructed.
empirical_type() {} empirical_type() = default;
// Return true and copy contents to out if valid, else return false. // Return true and copy contents to out if valid, else return false.
bool get(type_t &out) const { bool get(type_t &out) const {
if (valid) if (valid)
out = data; out = data;
return valid; return valid;
} }
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
ObjectContainerBSDArchive::Archive::Archive(const lldb_private::ArchSpec &arch, ObjectContainerBSDArchive::Archive::Archive(const lldb_private::ArchSpec &arch,
const llvm::sys::TimePoint<> &time, const llvm::sys::TimePoint<> &time,
lldb::offset_t file_offset, lldb::offset_t file_offset,
lldb_private::DataExtractor &data) lldb_private::DataExtractor &data)
: m_arch(arch), m_modification_time(time), m_file_offset(file_offset), : m_arch(arch), m_modification_time(time), m_file_offset(file_offset),
m_objects(), m_data(data) {} m_objects(), m_data(data) {}
ObjectContainerBSDArchive::Archive::~Archive() {} ObjectContainerBSDArchive::Archive::~Archive() = default;
size_t ObjectContainerBSDArchive::Archive::ParseObjects() { size_t ObjectContainerBSDArchive::Archive::ParseObjects() {
DataExtractor &data = m_data; DataExtractor &data = m_data;
std::string str; std::string str;
lldb::offset_t offset = 0; lldb::offset_t offset = 0;
str.assign((const char *)data.GetData(&offset, SARMAG), SARMAG); str.assign((const char *)data.GetData(&offset, SARMAG), SARMAG);
if (str == ARMAG) { if (str == ARMAG) {
Object obj; Object obj;
▲ Show 20 Lines • Show All 182 Lines • ▼ Show 20 Lines
lldb::offset_t data_offset, const lldb_private::FileSpec *file, lldb::offset_t data_offset, const lldb_private::FileSpec *file,
lldb::offset_t file_offset, lldb::offset_t size) lldb::offset_t file_offset, lldb::offset_t size)
: ObjectContainer(module_sp, file, file_offset, size, data_sp, data_offset), : ObjectContainer(module_sp, file, file_offset, size, data_sp, data_offset),
m_archive_sp() {} m_archive_sp() {}
void ObjectContainerBSDArchive::SetArchive(Archive::shared_ptr &archive_sp) { void ObjectContainerBSDArchive::SetArchive(Archive::shared_ptr &archive_sp) {
m_archive_sp = archive_sp; m_archive_sp = archive_sp;
} }
ObjectContainerBSDArchive::~ObjectContainerBSDArchive() {} ObjectContainerBSDArchive::~ObjectContainerBSDArchive() = default;
bool ObjectContainerBSDArchive::ParseHeader() { bool ObjectContainerBSDArchive::ParseHeader() {
if (m_archive_sp.get() == nullptr) { if (m_archive_sp.get() == nullptr) {
if (m_data.GetByteSize() > 0) { if (m_data.GetByteSize() > 0) {
ModuleSP module_sp(GetModule()); ModuleSP module_sp(GetModule());
if (module_sp) { if (module_sp) {
m_archive_sp = Archive::ParseAndCacheArchiveForFile( m_archive_sp = Archive::ParseAndCacheArchiveForFile(
m_file, module_sp->GetArchitecture(), m_file, module_sp->GetArchitecture(),
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Plugins/ObjectContainer/Universal-Mach-O/ObjectContainerUniversalMachO.cpp

Show First 20 Lines • Show All 73 Lines • ▼ Show 20 LinesObjectContainerUniversalMachO::ObjectContainerUniversalMachO(
lldb::offset_t data_offset, const FileSpec *file, lldb::offset_t data_offset, const FileSpec *file,
lldb::offset_t file_offset, lldb::offset_t length) lldb::offset_t file_offset, lldb::offset_t length)
: ObjectContainer(module_sp, file, file_offset, length, data_sp, : ObjectContainer(module_sp, file, file_offset, length, data_sp,
data_offset), data_offset),
m_header(), m_fat_archs() { m_header(), m_fat_archs() {
memset(&m_header, 0, sizeof(m_header)); memset(&m_header, 0, sizeof(m_header));
} }
ObjectContainerUniversalMachO::~ObjectContainerUniversalMachO() {} ObjectContainerUniversalMachO::~ObjectContainerUniversalMachO() = default;
bool ObjectContainerUniversalMachO::ParseHeader() { bool ObjectContainerUniversalMachO::ParseHeader() {
bool success = ParseHeader(m_data, m_header, m_fat_archs); bool success = ParseHeader(m_data, m_header, m_fat_archs);
// We no longer need any data, we parsed all we needed to parse and cached it // We no longer need any data, we parsed all we needed to parse and cached it
// in m_header and m_fat_archs // in m_header and m_fat_archs
m_data.Clear(); m_data.Clear();
return success; return success;
} }
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

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

Show All 22 Lines
struct ELFNote { struct ELFNote {
elf::elf_word n_namesz = 0; elf::elf_word n_namesz = 0;
elf::elf_word n_descsz = 0; elf::elf_word n_descsz = 0;
elf::elf_word n_type = 0; elf::elf_word n_type = 0;
std::string n_name; std::string n_name;
ELFNote() {} ELFNote() = default;
/// Parse an ELFNote entry from the given DataExtractor starting at position /// Parse an ELFNote entry from the given DataExtractor starting at position
/// \p offset. /// \p offset.
/// ///
/// \param[in] data /// \param[in] data
/// The DataExtractor to read from. /// The DataExtractor to read from.
/// ///
/// \param[in,out] offset /// \param[in,out] offset
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Plugins/ObjectFile/JIT/ObjectFileJIT.cpp

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
: ObjectFile(module_sp, nullptr, 0, 0, DataBufferSP(), 0), m_delegate_wp() { : ObjectFile(module_sp, nullptr, 0, 0, DataBufferSP(), 0), m_delegate_wp() {
if (delegate_sp) { if (delegate_sp) {
m_delegate_wp = delegate_sp; m_delegate_wp = delegate_sp;
m_data.SetByteOrder(delegate_sp->GetByteOrder()); m_data.SetByteOrder(delegate_sp->GetByteOrder());
m_data.SetAddressByteSize(delegate_sp->GetAddressByteSize()); m_data.SetAddressByteSize(delegate_sp->GetAddressByteSize());
} }
} }
ObjectFileJIT::~ObjectFileJIT() {} ObjectFileJIT::~ObjectFileJIT() = default;
bool ObjectFileJIT::ParseHeader() { bool ObjectFileJIT::ParseHeader() {
// JIT code is never in a file, nor is it required to have any header // JIT code is never in a file, nor is it required to have any header
return false; return false;
} }
ByteOrder ObjectFileJIT::GetByteOrder() const { return m_data.GetByteOrder(); } ByteOrder ObjectFileJIT::GetByteOrder() const { return m_data.GetByteOrder(); }
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
addr_t header_addr) addr_t header_addr)
: ObjectFile(module_sp, process_sp, header_addr, header_data_sp), : ObjectFile(module_sp, process_sp, header_addr, header_data_sp),
m_dos_header(), m_coff_header(), m_sect_headers(), m_dos_header(), m_coff_header(), m_sect_headers(),
m_entry_point_address(), m_deps_filespec() { m_entry_point_address(), m_deps_filespec() {
::memset(&m_dos_header, 0, sizeof(m_dos_header)); ::memset(&m_dos_header, 0, sizeof(m_dos_header));
::memset(&m_coff_header, 0, sizeof(m_coff_header)); ::memset(&m_coff_header, 0, sizeof(m_coff_header));
} }
ObjectFilePECOFF::~ObjectFilePECOFF() {} ObjectFilePECOFF::~ObjectFilePECOFF() = default;
bool ObjectFilePECOFF::ParseHeader() { bool ObjectFilePECOFF::ParseHeader() {
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());
m_sect_headers.clear(); m_sect_headers.clear();
m_data.SetByteOrder(eByteOrderLittle); m_data.SetByteOrder(eByteOrderLittle);
lldb::offset_t offset = 0; lldb::offset_t offset = 0;
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Plugins/OperatingSystem/Python/OperatingSystemPython.cpp

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
os_plugin_class_name.c_str(), process->CalculateProcess()); os_plugin_class_name.c_str(), process->CalculateProcess());
if (object_sp && object_sp->IsValid()) if (object_sp && object_sp->IsValid())
m_python_object_sp = object_sp; m_python_object_sp = object_sp;
} }
} }
} }
} }
OperatingSystemPython::~OperatingSystemPython() {} OperatingSystemPython::~OperatingSystemPython() = default;
DynamicRegisterInfo *OperatingSystemPython::GetDynamicRegisterInfo() { DynamicRegisterInfo *OperatingSystemPython::GetDynamicRegisterInfo() {
if (m_register_info_up == nullptr) { if (m_register_info_up == nullptr) {
if (!m_interpreter || !m_python_object_sp) if (!m_interpreter || !m_python_object_sp)
return nullptr; return nullptr;
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OS)); Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_OS));
LLDB_LOGF(log, LLDB_LOGF(log,
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Plugins/Platform/Android/AdbClient.cpp

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
connected_devices.size()); connected_devices.size());
adb.SetDeviceID(connected_devices.front()); adb.SetDeviceID(connected_devices.front());
} else { } else {
adb.SetDeviceID(android_serial); adb.SetDeviceID(android_serial);
} }
return error; return error;
} }
AdbClient::AdbClient() {} AdbClient::AdbClient() = default;
AdbClient::AdbClient(const std::string &device_id) : m_device_id(device_id) {} AdbClient::AdbClient(const std::string &device_id) : m_device_id(device_id) {}
AdbClient::~AdbClient() {} AdbClient::~AdbClient() = default;
void AdbClient::SetDeviceID(const std::string &device_id) { void AdbClient::SetDeviceID(const std::string &device_id) {
m_device_id = device_id; m_device_id = device_id;
} }
const std::string &AdbClient::GetDeviceID() const { return m_device_id; } const std::string &AdbClient::GetDeviceID() const { return m_device_id; }
Status AdbClient::Connect() { Status AdbClient::Connect() {
▲ Show 20 Lines • Show All 182 Lines • ▼ Show 20 Lines
const auto error = cmd(); const auto error = cmd();
if (error.Fail()) if (error.Fail())
m_conn.reset(); m_conn.reset();
return error; return error;
} }
AdbClient::SyncService::~SyncService() {} AdbClient::SyncService::~SyncService() = default;
Status AdbClient::SyncService::SendSyncRequest(const char *request_id, Status AdbClient::SyncService::SendSyncRequest(const char *request_id,
const uint32_t data_len, const uint32_t data_len,
const void *data) { const void *data) {
const DataBufferSP data_sp(new DataBufferHeap(kSyncPacketLen, 0)); const DataBufferSP data_sp(new DataBufferHeap(kSyncPacketLen, 0));
DataEncoder encoder(data_sp, eByteOrderLittle, sizeof(void *)); DataEncoder encoder(data_sp, eByteOrderLittle, sizeof(void *));
auto offset = encoder.PutData(0, request_id, strlen(request_id)); auto offset = encoder.PutData(0, request_id, strlen(request_id));
encoder.PutUnsigned(offset, 4, data_len); encoder.PutUnsigned(offset, 4, data_len);
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

lldb/source/Plugins/Platform/Android/PlatformAndroidRemoteGDBServer.cpp

Show First 20 Lines • Show All 67 Lines • ▼ Show 20 Linesstatic Status FindUnusedPort(uint16_t &port) {
error = tcp_socket->Listen("127.0.0.1:0", 1); error = tcp_socket->Listen("127.0.0.1:0", 1);
if (error.Success()) if (error.Success())
port = tcp_socket->GetLocalPortNumber(); port = tcp_socket->GetLocalPortNumber();
return error; return error;
} }
PlatformAndroidRemoteGDBServer::PlatformAndroidRemoteGDBServer() {} PlatformAndroidRemoteGDBServer::PlatformAndroidRemoteGDBServer() = default;
PlatformAndroidRemoteGDBServer::~PlatformAndroidRemoteGDBServer() { PlatformAndroidRemoteGDBServer::~PlatformAndroidRemoteGDBServer() {
for (const auto &it : m_port_forwards) for (const auto &it : m_port_forwards)
DeleteForwardPortWithAdb(it.second, m_device_id); DeleteForwardPortWithAdb(it.second, m_device_id);
} }
bool PlatformAndroidRemoteGDBServer::LaunchGDBServer(lldb::pid_t &pid, bool PlatformAndroidRemoteGDBServer::LaunchGDBServer(lldb::pid_t &pid,
std::string &connect_url) { std::string &connect_url) {
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Plugins/Platform/MacOSX/PlatformAppleSimulator.cpp

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 Lines : PlatformDarwin(true), m_class_name(class_name),
m_description(description), m_plugin_name(plugin_name), m_kind(kind), m_description(description), m_plugin_name(plugin_name), m_kind(kind),
m_os_type(preferred_os), m_supported_triples(supported_triples), m_os_type(preferred_os), m_supported_triples(supported_triples),
m_sdk(sdk), m_sdk_type(sdk_type) {} m_sdk(sdk), m_sdk_type(sdk_type) {}
/// Destructor. /// Destructor.
/// ///
/// The destructor is virtual since this class is designed to be /// The destructor is virtual since this class is designed to be
/// inherited from by the plug-in instance. /// inherited from by the plug-in instance.
PlatformAppleSimulator::~PlatformAppleSimulator() {} PlatformAppleSimulator::~PlatformAppleSimulator() = default;
lldb_private::Status PlatformAppleSimulator::LaunchProcess( lldb_private::Status PlatformAppleSimulator::LaunchProcess(
lldb_private::ProcessLaunchInfo &launch_info) { lldb_private::ProcessLaunchInfo &launch_info) {
#if defined(__APPLE__) #if defined(__APPLE__)
LoadCoreSimulator(); LoadCoreSimulator();
CoreSimulatorSupport::Device device(GetSimulatorDevice()); CoreSimulatorSupport::Device device(GetSimulatorDevice());
if (device.GetState() != CoreSimulatorSupport::Device::State::Booted) { if (device.GetState() != CoreSimulatorSupport::Device::State::Booted) {
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Plugins/Platform/MacOSX/PlatformDarwin.cpp

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Lines
/// Default Constructor /// Default Constructor
PlatformDarwin::PlatformDarwin(bool is_host) : PlatformPOSIX(is_host) {} PlatformDarwin::PlatformDarwin(bool is_host) : PlatformPOSIX(is_host) {}
/// Destructor. /// Destructor.
/// ///
/// The destructor is virtual since this class is designed to be /// The destructor is virtual since this class is designed to be
/// inherited from by the plug-in instance. /// inherited from by the plug-in instance.
PlatformDarwin::~PlatformDarwin() {} PlatformDarwin::~PlatformDarwin() = default;
lldb_private::Status lldb_private::Status
PlatformDarwin::PutFile(const lldb_private::FileSpec &source, PlatformDarwin::PutFile(const lldb_private::FileSpec &source,
const lldb_private::FileSpec &destination, uint32_t uid, const lldb_private::FileSpec &destination, uint32_t uid,
uint32_t gid) { uint32_t gid) {
// Unconditionally unlink the destination. If it is an executable, // Unconditionally unlink the destination. If it is an executable,
// simply opening it and truncating its contents would invalidate // simply opening it and truncating its contents would invalidate
// its cached code signature. // its cached code signature.
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Plugins/Platform/MacOSX/PlatformDarwinKernel.cpp

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
return g_setting_name; return g_setting_name;
} }
PlatformDarwinKernelProperties() : Properties() { PlatformDarwinKernelProperties() : Properties() {
m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName()); m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
m_collection_sp->Initialize(g_platformdarwinkernel_properties); m_collection_sp->Initialize(g_platformdarwinkernel_properties);
} }
virtual ~PlatformDarwinKernelProperties() {} virtual ~PlatformDarwinKernelProperties() = default;
FileSpecList GetKextDirectories() const { FileSpecList GetKextDirectories() const {
const uint32_t idx = ePropertyKextDirectories; const uint32_t idx = ePropertyKextDirectories;
const OptionValueFileSpecList *option_value = const OptionValueFileSpecList *option_value =
m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpecList( m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpecList(
NULL, false, idx); NULL, false, idx);
assert(option_value); assert(option_value);
return option_value->GetCurrentValue(); return option_value->GetCurrentValue();
Show All 36 Lines
CollectKextAndKernelDirectories(); CollectKextAndKernelDirectories();
SearchForKextsAndKernelsRecursively(); SearchForKextsAndKernelsRecursively();
} }
/// Destructor. /// Destructor.
/// ///
/// The destructor is virtual since this class is designed to be /// The destructor is virtual since this class is designed to be
/// inherited from by the plug-in instance. /// inherited from by the plug-in instance.
PlatformDarwinKernel::~PlatformDarwinKernel() {} PlatformDarwinKernel::~PlatformDarwinKernel() = default;
void PlatformDarwinKernel::GetStatus(Stream &strm) { void PlatformDarwinKernel::GetStatus(Stream &strm) {
Platform::GetStatus(strm); Platform::GetStatus(strm);
strm.Printf(" Debug session type: "); strm.Printf(" Debug session type: ");
if (m_ios_debug_session == eLazyBoolYes) if (m_ios_debug_session == eLazyBoolYes)
strm.Printf("iOS kernel debugging\n"); strm.Printf("iOS kernel debugging\n");
else if (m_ios_debug_session == eLazyBoolNo) else if (m_ios_debug_session == eLazyBoolNo)
strm.Printf("Mac OS X kernel debugging\n"); strm.Printf("Mac OS X kernel debugging\n");
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Plugins/Platform/MacOSX/PlatformRemoteDarwinDevice.cpp

Show All 39 LinesPlatformRemoteDarwinDevice::PlatformRemoteDarwinDevice()
: PlatformDarwin(false), // This is a remote platform : PlatformDarwin(false), // This is a remote platform
m_sdk_directory_infos(), m_device_support_directory(), m_sdk_directory_infos(), m_device_support_directory(),
m_device_support_directory_for_os_version(), m_build_update() {} m_device_support_directory_for_os_version(), m_build_update() {}
/// Destructor. /// Destructor.
/// ///
/// The destructor is virtual since this class is designed to be /// The destructor is virtual since this class is designed to be
/// inherited from by the plug-in instance. /// inherited from by the plug-in instance.
PlatformRemoteDarwinDevice::~PlatformRemoteDarwinDevice() {} PlatformRemoteDarwinDevice::~PlatformRemoteDarwinDevice() = default;
void PlatformRemoteDarwinDevice::GetStatus(Stream &strm) { void PlatformRemoteDarwinDevice::GetStatus(Stream &strm) {
Platform::GetStatus(strm); Platform::GetStatus(strm);
const char *sdk_directory = GetDeviceSupportDirectoryForOSVersion(); const char *sdk_directory = GetDeviceSupportDirectoryForOSVersion();
if (sdk_directory) if (sdk_directory)
strm.Printf(" SDK Path: \"%s\"\n", sdk_directory); strm.Printf(" SDK Path: \"%s\"\n", sdk_directory);
else else
strm.PutCString(" SDK Path: error: unable to locate SDK\n"); strm.PutCString(" SDK Path: error: unable to locate SDK\n");
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Plugins/Platform/POSIX/PlatformPOSIX.cpp

Show All 40 Lines : RemoteAwarePlatform(is_host), // This is the local host platform
m_option_group_platform_rsync(new OptionGroupPlatformRSync()), m_option_group_platform_rsync(new OptionGroupPlatformRSync()),
m_option_group_platform_ssh(new OptionGroupPlatformSSH()), m_option_group_platform_ssh(new OptionGroupPlatformSSH()),
m_option_group_platform_caching(new OptionGroupPlatformCaching()) {} m_option_group_platform_caching(new OptionGroupPlatformCaching()) {}
/// Destructor. /// Destructor.
/// ///
/// The destructor is virtual since this class is designed to be /// The destructor is virtual since this class is designed to be
/// inherited from by the plug-in instance. /// inherited from by the plug-in instance.
PlatformPOSIX::~PlatformPOSIX() {} PlatformPOSIX::~PlatformPOSIX() = default;
lldb_private::OptionGroupOptions *PlatformPOSIX::GetConnectionOptions( lldb_private::OptionGroupOptions *PlatformPOSIX::GetConnectionOptions(
lldb_private::CommandInterpreter &interpreter) { lldb_private::CommandInterpreter &interpreter) {
auto iter = m_options.find(&interpreter), end = m_options.end(); auto iter = m_options.find(&interpreter), end = m_options.end();
if (iter == end) { if (iter == end) {
std::unique_ptr<lldb_private::OptionGroupOptions> options( std::unique_ptr<lldb_private::OptionGroupOptions> options(
new OptionGroupOptions()); new OptionGroupOptions());
options->Append(m_option_group_platform_rsync.get()); options->Append(m_option_group_platform_rsync.get());
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.cpp

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
m_gdb_client.SetPacketTimeout( m_gdb_client.SetPacketTimeout(
process_gdb_remote::ProcessGDBRemote::GetPacketTimeout()); process_gdb_remote::ProcessGDBRemote::GetPacketTimeout());
} }
/// Destructor. /// Destructor.
/// ///
/// The destructor is virtual since this class is designed to be /// The destructor is virtual since this class is designed to be
/// inherited from by the plug-in instance. /// inherited from by the plug-in instance.
PlatformRemoteGDBServer::~PlatformRemoteGDBServer() {} PlatformRemoteGDBServer::~PlatformRemoteGDBServer() = default;
bool PlatformRemoteGDBServer::GetSupportedArchitectureAtIndex(uint32_t idx, bool PlatformRemoteGDBServer::GetSupportedArchitectureAtIndex(uint32_t idx,
ArchSpec &arch) { ArchSpec &arch) {
ArchSpec remote_arch = m_gdb_client.GetSystemArchitecture(); ArchSpec remote_arch = m_gdb_client.GetSystemArchitecture();
if (idx == 0) { if (idx == 0) {
arch = remote_arch; arch = remote_arch;
return arch.IsValid(); return arch.IsValid();
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp

Show First 20 Lines • Show All 67 Lines • ▼ Show 20 Lines
return ProcessKDP::GetPluginNameStatic(); return ProcessKDP::GetPluginNameStatic();
} }
PluginProperties() : Properties() { PluginProperties() : Properties() {
m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName()); m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
m_collection_sp->Initialize(g_processkdp_properties); m_collection_sp->Initialize(g_processkdp_properties);
} }
virtual ~PluginProperties() {} virtual ~PluginProperties() = default;
uint64_t GetPacketTimeout() { uint64_t GetPacketTimeout() {
const uint32_t idx = ePropertyKDPPacketTimeout; const uint32_t idx = ePropertyKDPPacketTimeout;
return m_collection_sp->GetPropertyAtIndexAsUInt64( return m_collection_sp->GetPropertyAtIndexAsUInt64(
NULL, idx, g_processkdp_properties[idx].default_uint_value); NULL, idx, g_processkdp_properties[idx].default_uint_value);
} }
}; };
▲ Show 20 Lines • Show All 182 Lines • ▼ Show 20 Lines
"Specify packet payload bytes as a hex ASCII string with " "Specify packet payload bytes as a hex ASCII string with "
"no spaces or hex prefixes.", "no spaces or hex prefixes.",
NULL) { NULL) {
m_option_group.Append(&m_command_byte, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1); m_option_group.Append(&m_command_byte, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
m_option_group.Append(&m_packet_data, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1); m_option_group.Append(&m_packet_data, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
m_option_group.Finalize(); m_option_group.Finalize();
} }
~CommandObjectProcessKDPPacketSend() {} ~CommandObjectProcessKDPPacketSend() = default;
bool DoExecute(Args &command, CommandReturnObject &result) override { bool DoExecute(Args &command, CommandReturnObject &result) override {
const size_t argc = command.GetArgumentCount(); const size_t argc = command.GetArgumentCount();
if (argc == 0) { if (argc == 0) {
if (!m_command_byte.GetOptionValue().OptionWasSet()) { if (!m_command_byte.GetOptionValue().OptionWasSet()) {
result.AppendError( result.AppendError(
"the --command option must be set to a valid command byte"); "the --command option must be set to a valid command byte");
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
▲ Show 20 Lines • Show All 92 Lines • ▼ Show 20 Lines
: CommandObjectMultiword(interpreter, "process plugin packet", : CommandObjectMultiword(interpreter, "process plugin packet",
"Commands that deal with KDP remote packets.", "Commands that deal with KDP remote packets.",
NULL) { NULL) {
LoadSubCommand( LoadSubCommand(
"send", "send",
CommandObjectSP(new CommandObjectProcessKDPPacketSend(interpreter))); CommandObjectSP(new CommandObjectProcessKDPPacketSend(interpreter)));
} }
~CommandObjectProcessKDPPacket() {} ~CommandObjectProcessKDPPacket() = default;
}; };
class CommandObjectMultiwordProcessKDP : public CommandObjectMultiword { class CommandObjectMultiwordProcessKDP : public CommandObjectMultiword {
public: public:
CommandObjectMultiwordProcessKDP(CommandInterpreter &interpreter) CommandObjectMultiwordProcessKDP(CommandInterpreter &interpreter)
: CommandObjectMultiword( : CommandObjectMultiword(
interpreter, "process plugin", interpreter, "process plugin",
"Commands for operating on a ProcessKDP process.", "Commands for operating on a ProcessKDP process.",
"process plugin <subcommand> [<subcommand-options>]") { "process plugin <subcommand> [<subcommand-options>]") {
LoadSubCommand("packet", CommandObjectSP(new CommandObjectProcessKDPPacket( LoadSubCommand("packet", CommandObjectSP(new CommandObjectProcessKDPPacket(
interpreter))); interpreter)));
} }
~CommandObjectMultiwordProcessKDP() {} ~CommandObjectMultiwordProcessKDP() = default;
}; };
CommandObject *ProcessKDP::GetPluginCommandObject() { CommandObject *ProcessKDP::GetPluginCommandObject() {
if (!m_command_sp) if (!m_command_sp)
m_command_sp = std::make_shared<CommandObjectMultiwordProcessKDP>( m_command_sp = std::make_shared<CommandObjectMultiwordProcessKDP>(
GetTarget().GetDebugger().GetCommandInterpreter()); GetTarget().GetDebugger().GetCommandInterpreter());
return m_command_sp.get(); return m_command_sp.get();
} }
Context not available.

lldb/source/Plugins/Process/MacOSX-Kernel/RegisterContextKDP_arm.cpp

Show All 13 Lines
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
RegisterContextKDP_arm::RegisterContextKDP_arm(ThreadKDP &thread, RegisterContextKDP_arm::RegisterContextKDP_arm(ThreadKDP &thread,
uint32_t concrete_frame_idx) uint32_t concrete_frame_idx)
: RegisterContextDarwin_arm(thread, concrete_frame_idx), : RegisterContextDarwin_arm(thread, concrete_frame_idx),
m_kdp_thread(thread) {} m_kdp_thread(thread) {}
RegisterContextKDP_arm::~RegisterContextKDP_arm() {} RegisterContextKDP_arm::~RegisterContextKDP_arm() = default;
int RegisterContextKDP_arm::DoReadGPR(lldb::tid_t tid, int flavor, GPR &gpr) { int RegisterContextKDP_arm::DoReadGPR(lldb::tid_t tid, int flavor, GPR &gpr) {
ProcessSP process_sp(CalculateProcess()); ProcessSP process_sp(CalculateProcess());
if (process_sp) { if (process_sp) {
Status error; Status error;
if (static_cast<ProcessKDP *>(process_sp.get()) if (static_cast<ProcessKDP *>(process_sp.get())
->GetCommunication() ->GetCommunication()
.SendRequestReadRegisters(tid, GPRRegSet, &gpr, sizeof(gpr), .SendRequestReadRegisters(tid, GPRRegSet, &gpr, sizeof(gpr),
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Plugins/Process/MacOSX-Kernel/RegisterContextKDP_arm64.cpp

Show All 13 Lines
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
RegisterContextKDP_arm64::RegisterContextKDP_arm64(ThreadKDP &thread, RegisterContextKDP_arm64::RegisterContextKDP_arm64(ThreadKDP &thread,
uint32_t concrete_frame_idx) uint32_t concrete_frame_idx)
: RegisterContextDarwin_arm64(thread, concrete_frame_idx), : RegisterContextDarwin_arm64(thread, concrete_frame_idx),
m_kdp_thread(thread) {} m_kdp_thread(thread) {}
RegisterContextKDP_arm64::~RegisterContextKDP_arm64() {} RegisterContextKDP_arm64::~RegisterContextKDP_arm64() = default;
int RegisterContextKDP_arm64::DoReadGPR(lldb::tid_t tid, int flavor, GPR &gpr) { int RegisterContextKDP_arm64::DoReadGPR(lldb::tid_t tid, int flavor, GPR &gpr) {
ProcessSP process_sp(CalculateProcess()); ProcessSP process_sp(CalculateProcess());
if (process_sp) { if (process_sp) {
Status error; Status error;
if (static_cast<ProcessKDP *>(process_sp.get()) if (static_cast<ProcessKDP *>(process_sp.get())
->GetCommunication() ->GetCommunication()
.SendRequestReadRegisters(tid, GPRRegSet, &gpr, sizeof(gpr), .SendRequestReadRegisters(tid, GPRRegSet, &gpr, sizeof(gpr),
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Plugins/Process/MacOSX-Kernel/RegisterContextKDP_i386.cpp

Show All 12 Lines
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
RegisterContextKDP_i386::RegisterContextKDP_i386(ThreadKDP &thread, RegisterContextKDP_i386::RegisterContextKDP_i386(ThreadKDP &thread,
uint32_t concrete_frame_idx) uint32_t concrete_frame_idx)
: RegisterContextDarwin_i386(thread, concrete_frame_idx), : RegisterContextDarwin_i386(thread, concrete_frame_idx),
m_kdp_thread(thread) {} m_kdp_thread(thread) {}
RegisterContextKDP_i386::~RegisterContextKDP_i386() {} RegisterContextKDP_i386::~RegisterContextKDP_i386() = default;
int RegisterContextKDP_i386::DoReadGPR(lldb::tid_t tid, int flavor, GPR &gpr) { int RegisterContextKDP_i386::DoReadGPR(lldb::tid_t tid, int flavor, GPR &gpr) {
ProcessSP process_sp(CalculateProcess()); ProcessSP process_sp(CalculateProcess());
if (process_sp) { if (process_sp) {
Status error; Status error;
if (static_cast<ProcessKDP *>(process_sp.get()) if (static_cast<ProcessKDP *>(process_sp.get())
->GetCommunication() ->GetCommunication()
.SendRequestReadRegisters(tid, GPRRegSet, &gpr, sizeof(gpr), .SendRequestReadRegisters(tid, GPRRegSet, &gpr, sizeof(gpr),
▲ Show 20 Lines • Show All 85 Lines • Show Last 20 Lines

lldb/source/Plugins/Process/MacOSX-Kernel/RegisterContextKDP_x86_64.cpp

Show All 12 Lines
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
RegisterContextKDP_x86_64::RegisterContextKDP_x86_64( RegisterContextKDP_x86_64::RegisterContextKDP_x86_64(
ThreadKDP &thread, uint32_t concrete_frame_idx) ThreadKDP &thread, uint32_t concrete_frame_idx)
: RegisterContextDarwin_x86_64(thread, concrete_frame_idx), : RegisterContextDarwin_x86_64(thread, concrete_frame_idx),
m_kdp_thread(thread) {} m_kdp_thread(thread) {}
RegisterContextKDP_x86_64::~RegisterContextKDP_x86_64() {} RegisterContextKDP_x86_64::~RegisterContextKDP_x86_64() = default;
int RegisterContextKDP_x86_64::DoReadGPR(lldb::tid_t tid, int flavor, int RegisterContextKDP_x86_64::DoReadGPR(lldb::tid_t tid, int flavor,
GPR &gpr) { GPR &gpr) {
ProcessSP process_sp(CalculateProcess()); ProcessSP process_sp(CalculateProcess());
if (process_sp) { if (process_sp) {
Status error; Status error;
if (static_cast<ProcessKDP *>(process_sp.get()) if (static_cast<ProcessKDP *>(process_sp.get())
->GetCommunication() ->GetCommunication()
▲ Show 20 Lines • Show All 88 Lines • Show Last 20 Lines

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

Show All 24 Lines
HistoryUnwind::HistoryUnwind(Thread &thread, std::vector<lldb::addr_t> pcs, HistoryUnwind::HistoryUnwind(Thread &thread, std::vector<lldb::addr_t> pcs,
bool pcs_are_call_addresses) bool pcs_are_call_addresses)
: Unwind(thread), m_pcs(pcs), : Unwind(thread), m_pcs(pcs),
m_pcs_are_call_addresses(pcs_are_call_addresses) {} m_pcs_are_call_addresses(pcs_are_call_addresses) {}
// Destructor // Destructor
HistoryUnwind::~HistoryUnwind() {} HistoryUnwind::~HistoryUnwind() = default;
void HistoryUnwind::DoClear() { void HistoryUnwind::DoClear() {
std::lock_guard<std::recursive_mutex> guard(m_unwind_mutex); std::lock_guard<std::recursive_mutex> guard(m_unwind_mutex);
m_pcs.clear(); m_pcs.clear();
} }
lldb::RegisterContextSP lldb::RegisterContextSP
HistoryUnwind::DoCreateRegisterContextForFrame(StackFrame *frame) { HistoryUnwind::DoCreateRegisterContextForFrame(StackFrame *frame) {
Show All 32 Lines

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

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
uint32_t i; uint32_t i;
for (i = 0; i < kNumErrors; i++) { for (i = 0; i < kNumErrors; i++) {
gpr_errs[i] = -1; gpr_errs[i] = -1;
fpu_errs[i] = -1; fpu_errs[i] = -1;
exc_errs[i] = -1; exc_errs[i] = -1;
} }
} }
RegisterContextDarwin_arm::~RegisterContextDarwin_arm() {} RegisterContextDarwin_arm::~RegisterContextDarwin_arm() = default;
void RegisterContextDarwin_arm::InvalidateAllRegisters() { void RegisterContextDarwin_arm::InvalidateAllRegisters() {
InvalidateAllRegisterStates(); InvalidateAllRegisterStates();
} }
size_t RegisterContextDarwin_arm::GetRegisterCount() { size_t RegisterContextDarwin_arm::GetRegisterCount() {
assert(k_num_register_infos == k_num_registers); assert(k_num_register_infos == k_num_registers);
return k_num_registers; return k_num_registers;
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
uint32_t i; uint32_t i;
for (i = 0; i < kNumErrors; i++) { for (i = 0; i < kNumErrors; i++) {
gpr_errs[i] = -1; gpr_errs[i] = -1;
fpu_errs[i] = -1; fpu_errs[i] = -1;
exc_errs[i] = -1; exc_errs[i] = -1;
} }
} }
RegisterContextDarwin_arm64::~RegisterContextDarwin_arm64() {} RegisterContextDarwin_arm64::~RegisterContextDarwin_arm64() = default;
void RegisterContextDarwin_arm64::InvalidateAllRegisters() { void RegisterContextDarwin_arm64::InvalidateAllRegisters() {
InvalidateAllRegisterStates(); InvalidateAllRegisterStates();
} }
size_t RegisterContextDarwin_arm64::GetRegisterCount() { size_t RegisterContextDarwin_arm64::GetRegisterCount() {
assert(k_num_register_infos == k_num_registers); assert(k_num_register_infos == k_num_registers);
return k_num_registers; return k_num_registers;
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
uint32_t i; uint32_t i;
for (i = 0; i < kNumErrors; i++) { for (i = 0; i < kNumErrors; i++) {
gpr_errs[i] = -1; gpr_errs[i] = -1;
fpu_errs[i] = -1; fpu_errs[i] = -1;
exc_errs[i] = -1; exc_errs[i] = -1;
} }
} }
RegisterContextDarwin_i386::~RegisterContextDarwin_i386() {} RegisterContextDarwin_i386::~RegisterContextDarwin_i386() = default;
void RegisterContextDarwin_i386::InvalidateAllRegisters() { void RegisterContextDarwin_i386::InvalidateAllRegisters() {
InvalidateAllRegisterStates(); InvalidateAllRegisterStates();
} }
size_t RegisterContextDarwin_i386::GetRegisterCount() { size_t RegisterContextDarwin_i386::GetRegisterCount() {
assert(k_num_register_infos == k_num_registers); assert(k_num_register_infos == k_num_registers);
return k_num_registers; return k_num_registers;
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
uint32_t i; uint32_t i;
for (i = 0; i < kNumErrors; i++) { for (i = 0; i < kNumErrors; i++) {
gpr_errs[i] = -1; gpr_errs[i] = -1;
fpu_errs[i] = -1; fpu_errs[i] = -1;
exc_errs[i] = -1; exc_errs[i] = -1;
} }
} }
RegisterContextDarwin_x86_64::~RegisterContextDarwin_x86_64() {} RegisterContextDarwin_x86_64::~RegisterContextDarwin_x86_64() = default;
void RegisterContextDarwin_x86_64::InvalidateAllRegisters() { void RegisterContextDarwin_x86_64::InvalidateAllRegisters() {
InvalidateAllRegisterStates(); InvalidateAllRegisterStates();
} }
size_t RegisterContextDarwin_x86_64::GetRegisterCount() { size_t RegisterContextDarwin_x86_64::GetRegisterCount() {
assert(k_num_register_infos == k_num_registers); assert(k_num_register_infos == k_num_registers);
return k_num_registers; return k_num_registers;
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
#define DECLARE_REGISTER_INFOS_POWERPC_STRUCT #define DECLARE_REGISTER_INFOS_POWERPC_STRUCT
#include "RegisterInfos_powerpc.h" #include "RegisterInfos_powerpc.h"
#undef DECLARE_REGISTER_INFOS_POWERPC_STRUCT #undef DECLARE_REGISTER_INFOS_POWERPC_STRUCT
RegisterContextFreeBSD_powerpc::RegisterContextFreeBSD_powerpc( RegisterContextFreeBSD_powerpc::RegisterContextFreeBSD_powerpc(
const ArchSpec &target_arch) const ArchSpec &target_arch)
: RegisterInfoInterface(target_arch) {} : RegisterInfoInterface(target_arch) {}
RegisterContextFreeBSD_powerpc::~RegisterContextFreeBSD_powerpc() {} RegisterContextFreeBSD_powerpc::~RegisterContextFreeBSD_powerpc() = default;
size_t RegisterContextFreeBSD_powerpc::GetGPRSize() const { size_t RegisterContextFreeBSD_powerpc::GetGPRSize() const {
// This is an 'abstract' base, so no GPR struct. // This is an 'abstract' base, so no GPR struct.
return 0; return 0;
} }
const RegisterInfo *RegisterContextFreeBSD_powerpc::GetRegisterInfo() const { const RegisterInfo *RegisterContextFreeBSD_powerpc::GetRegisterInfo() const {
// assert (m_target_arch.GetCore() == ArchSpec::eCore_powerpc); // assert (m_target_arch.GetCore() == ArchSpec::eCore_powerpc);
llvm_unreachable("Abstract class!"); llvm_unreachable("Abstract class!");
return nullptr; return nullptr;
} }
uint32_t RegisterContextFreeBSD_powerpc::GetRegisterCount() const { return 0; } uint32_t RegisterContextFreeBSD_powerpc::GetRegisterCount() const { return 0; }
RegisterContextFreeBSD_powerpc32::RegisterContextFreeBSD_powerpc32( RegisterContextFreeBSD_powerpc32::RegisterContextFreeBSD_powerpc32(
const ArchSpec &target_arch) const ArchSpec &target_arch)
: RegisterContextFreeBSD_powerpc(target_arch) {} : RegisterContextFreeBSD_powerpc(target_arch) {}
RegisterContextFreeBSD_powerpc32::~RegisterContextFreeBSD_powerpc32() {} RegisterContextFreeBSD_powerpc32::~RegisterContextFreeBSD_powerpc32() = default;
size_t RegisterContextFreeBSD_powerpc32::GetGPRSize() const { size_t RegisterContextFreeBSD_powerpc32::GetGPRSize() const {
return sizeof(GPR32); return sizeof(GPR32);
} }
const RegisterInfo *RegisterContextFreeBSD_powerpc32::GetRegisterInfo() const { const RegisterInfo *RegisterContextFreeBSD_powerpc32::GetRegisterInfo() const {
// assert (m_target_arch.GetCore() == ArchSpec::eCore_powerpc); // assert (m_target_arch.GetCore() == ArchSpec::eCore_powerpc);
return g_register_infos_powerpc32; return g_register_infos_powerpc32;
} }
uint32_t RegisterContextFreeBSD_powerpc32::GetRegisterCount() const { uint32_t RegisterContextFreeBSD_powerpc32::GetRegisterCount() const {
return static_cast<uint32_t>(sizeof(g_register_infos_powerpc32) / return static_cast<uint32_t>(sizeof(g_register_infos_powerpc32) /
sizeof(g_register_infos_powerpc32[0])); sizeof(g_register_infos_powerpc32[0]));
} }
RegisterContextFreeBSD_powerpc64::RegisterContextFreeBSD_powerpc64( RegisterContextFreeBSD_powerpc64::RegisterContextFreeBSD_powerpc64(
const ArchSpec &target_arch) const ArchSpec &target_arch)
: RegisterContextFreeBSD_powerpc(target_arch) {} : RegisterContextFreeBSD_powerpc(target_arch) {}
RegisterContextFreeBSD_powerpc64::~RegisterContextFreeBSD_powerpc64() {} RegisterContextFreeBSD_powerpc64::~RegisterContextFreeBSD_powerpc64() = default;
size_t RegisterContextFreeBSD_powerpc64::GetGPRSize() const { size_t RegisterContextFreeBSD_powerpc64::GetGPRSize() const {
return sizeof(GPR64); return sizeof(GPR64);
} }
const RegisterInfo *RegisterContextFreeBSD_powerpc64::GetRegisterInfo() const { const RegisterInfo *RegisterContextFreeBSD_powerpc64::GetRegisterInfo() const {
// assert (m_target_arch.GetCore() == ArchSpec::eCore_powerpc); // assert (m_target_arch.GetCore() == ArchSpec::eCore_powerpc);
if (m_target_arch.GetMachine() == llvm::Triple::ppc) if (m_target_arch.GetMachine() == llvm::Triple::ppc)
return g_register_infos_powerpc64_32; return g_register_infos_powerpc64_32;
return g_register_infos_powerpc64; return g_register_infos_powerpc64;
} }
uint32_t RegisterContextFreeBSD_powerpc64::GetRegisterCount() const { uint32_t RegisterContextFreeBSD_powerpc64::GetRegisterCount() const {
return static_cast<uint32_t>(sizeof(g_register_infos_powerpc64) / return static_cast<uint32_t>(sizeof(g_register_infos_powerpc64) /
sizeof(g_register_infos_powerpc64[0])); sizeof(g_register_infos_powerpc64[0]));
} }
Context not available.

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

Show All 15 Lines
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
RegisterContextMach_arm::RegisterContextMach_arm(Thread &thread, RegisterContextMach_arm::RegisterContextMach_arm(Thread &thread,
uint32_t concrete_frame_idx) uint32_t concrete_frame_idx)
: RegisterContextDarwin_arm(thread, concrete_frame_idx) {} : RegisterContextDarwin_arm(thread, concrete_frame_idx) {}
RegisterContextMach_arm::~RegisterContextMach_arm() {} RegisterContextMach_arm::~RegisterContextMach_arm() = default;
int RegisterContextMach_arm::DoReadGPR(lldb::tid_t tid, int flavor, GPR &gpr) { int RegisterContextMach_arm::DoReadGPR(lldb::tid_t tid, int flavor, GPR &gpr) {
mach_msg_type_number_t count = GPRWordCount; mach_msg_type_number_t count = GPRWordCount;
return ::thread_get_state(tid, flavor, (thread_state_t)&gpr, &count); return ::thread_get_state(tid, flavor, (thread_state_t)&gpr, &count);
} }
int RegisterContextMach_arm::DoReadFPU(lldb::tid_t tid, int flavor, FPU &fpu) { int RegisterContextMach_arm::DoReadFPU(lldb::tid_t tid, int flavor, FPU &fpu) {
mach_msg_type_number_t count = FPUWordCount; mach_msg_type_number_t count = FPUWordCount;
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

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

Show All 13 Lines
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
RegisterContextMach_i386::RegisterContextMach_i386(Thread &thread, RegisterContextMach_i386::RegisterContextMach_i386(Thread &thread,
uint32_t concrete_frame_idx) uint32_t concrete_frame_idx)
: RegisterContextDarwin_i386(thread, concrete_frame_idx) {} : RegisterContextDarwin_i386(thread, concrete_frame_idx) {}
RegisterContextMach_i386::~RegisterContextMach_i386() {} RegisterContextMach_i386::~RegisterContextMach_i386() = default;
int RegisterContextMach_i386::DoReadGPR(lldb::tid_t tid, int flavor, GPR &gpr) { int RegisterContextMach_i386::DoReadGPR(lldb::tid_t tid, int flavor, GPR &gpr) {
mach_msg_type_number_t count = GPRWordCount; mach_msg_type_number_t count = GPRWordCount;
return ::thread_get_state(tid, flavor, (thread_state_t)&gpr, &count); return ::thread_get_state(tid, flavor, (thread_state_t)&gpr, &count);
} }
int RegisterContextMach_i386::DoReadFPU(lldb::tid_t tid, int flavor, FPU &fpu) { int RegisterContextMach_i386::DoReadFPU(lldb::tid_t tid, int flavor, FPU &fpu) {
mach_msg_type_number_t count = FPUWordCount; mach_msg_type_number_t count = FPUWordCount;
Show All 30 Lines

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

Show All 13 Lines
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
RegisterContextMach_x86_64::RegisterContextMach_x86_64( RegisterContextMach_x86_64::RegisterContextMach_x86_64(
Thread &thread, uint32_t concrete_frame_idx) Thread &thread, uint32_t concrete_frame_idx)
: RegisterContextDarwin_x86_64(thread, concrete_frame_idx) {} : RegisterContextDarwin_x86_64(thread, concrete_frame_idx) {}
RegisterContextMach_x86_64::~RegisterContextMach_x86_64() {} RegisterContextMach_x86_64::~RegisterContextMach_x86_64() = default;
int RegisterContextMach_x86_64::DoReadGPR(lldb::tid_t tid, int flavor, int RegisterContextMach_x86_64::DoReadGPR(lldb::tid_t tid, int flavor,
GPR &gpr) { GPR &gpr) {
mach_msg_type_number_t count = GPRWordCount; mach_msg_type_number_t count = GPRWordCount;
return ::thread_get_state(tid, flavor, (thread_state_t)&gpr, &count); return ::thread_get_state(tid, flavor, (thread_state_t)&gpr, &count);
} }
int RegisterContextMach_x86_64::DoReadFPU(lldb::tid_t tid, int flavor, int RegisterContextMach_x86_64::DoReadFPU(lldb::tid_t tid, int flavor,
Show All 33 Lines

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

Show All 33 LinesRegisterContextMemory::RegisterContextMemory(Thread &thread,
// Make a heap based buffer that is big enough to store all registers // Make a heap based buffer that is big enough to store all registers
DataBufferSP reg_data_sp( DataBufferSP reg_data_sp(
new DataBufferHeap(reg_infos.GetRegisterDataByteSize(), 0)); new DataBufferHeap(reg_infos.GetRegisterDataByteSize(), 0));
m_reg_data.SetData(reg_data_sp); m_reg_data.SetData(reg_data_sp);
} }
// Destructor // Destructor
RegisterContextMemory::~RegisterContextMemory() {} RegisterContextMemory::~RegisterContextMemory() = default;
void RegisterContextMemory::InvalidateAllRegisters() { void RegisterContextMemory::InvalidateAllRegisters() {
if (m_reg_data_addr != LLDB_INVALID_ADDRESS) if (m_reg_data_addr != LLDB_INVALID_ADDRESS)
SetAllRegisterValid(false); SetAllRegisterValid(false);
} }
void RegisterContextMemory::SetAllRegisterValid(bool b) { void RegisterContextMemory::SetAllRegisterValid(bool b) {
std::vector<bool>::iterator pos, end = m_reg_valid.end(); std::vector<bool>::iterator pos, end = m_reg_valid.end();
▲ Show 20 Lines • Show All 89 Lines • Show Last 20 Lines

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

Show All 39 Lines
} }
RegisterContextPOSIX_arm::RegisterContextPOSIX_arm( RegisterContextPOSIX_arm::RegisterContextPOSIX_arm(
lldb_private::Thread &thread, lldb_private::Thread &thread,
std::unique_ptr<RegisterInfoPOSIX_arm> register_info) std::unique_ptr<RegisterInfoPOSIX_arm> register_info)
: lldb_private::RegisterContext(thread, 0), : lldb_private::RegisterContext(thread, 0),
m_register_info_up(std::move(register_info)) {} m_register_info_up(std::move(register_info)) {}
RegisterContextPOSIX_arm::~RegisterContextPOSIX_arm() {} RegisterContextPOSIX_arm::~RegisterContextPOSIX_arm() = default;
void RegisterContextPOSIX_arm::Invalidate() {} void RegisterContextPOSIX_arm::Invalidate() {}
void RegisterContextPOSIX_arm::InvalidateAllRegisters() {} void RegisterContextPOSIX_arm::InvalidateAllRegisters() {}
unsigned RegisterContextPOSIX_arm::GetRegisterOffset(unsigned reg) { unsigned RegisterContextPOSIX_arm::GetRegisterOffset(unsigned reg) {
return m_register_info_up->GetRegisterInfo()[reg].byte_offset; return m_register_info_up->GetRegisterInfo()[reg].byte_offset;
} }
▲ Show 20 Lines • Show All 42 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 47 Lines • ▼ Show 20 Lines
} }
RegisterContextPOSIX_arm64::RegisterContextPOSIX_arm64( RegisterContextPOSIX_arm64::RegisterContextPOSIX_arm64(
lldb_private::Thread &thread, lldb_private::Thread &thread,
std::unique_ptr<RegisterInfoPOSIX_arm64> register_info) std::unique_ptr<RegisterInfoPOSIX_arm64> register_info)
: lldb_private::RegisterContext(thread, 0), : lldb_private::RegisterContext(thread, 0),
m_register_info_up(std::move(register_info)) {} m_register_info_up(std::move(register_info)) {}
RegisterContextPOSIX_arm64::~RegisterContextPOSIX_arm64() {} RegisterContextPOSIX_arm64::~RegisterContextPOSIX_arm64() = default;
void RegisterContextPOSIX_arm64::Invalidate() {} void RegisterContextPOSIX_arm64::Invalidate() {}
void RegisterContextPOSIX_arm64::InvalidateAllRegisters() {} void RegisterContextPOSIX_arm64::InvalidateAllRegisters() {}
unsigned RegisterContextPOSIX_arm64::GetRegisterOffset(unsigned reg) { unsigned RegisterContextPOSIX_arm64::GetRegisterOffset(unsigned reg) {
return m_register_info_up->GetRegisterInfo()[reg].byte_offset; return m_register_info_up->GetRegisterInfo()[reg].byte_offset;
} }
▲ Show 20 Lines • Show All 43 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 52 Lines • ▼ Show 20 LinesRegisterContextPOSIX_mips64::RegisterContextPOSIX_mips64(
} }
assert(m_num_registers == assert(m_num_registers ==
static_cast<uint32_t>(m_registers_count[gpr_registers_count] + static_cast<uint32_t>(m_registers_count[gpr_registers_count] +
m_registers_count[fpr_registers_count] + m_registers_count[fpr_registers_count] +
m_registers_count[msa_registers_count])); m_registers_count[msa_registers_count]));
} }
RegisterContextPOSIX_mips64::~RegisterContextPOSIX_mips64() {} RegisterContextPOSIX_mips64::~RegisterContextPOSIX_mips64() = default;
void RegisterContextPOSIX_mips64::Invalidate() {} void RegisterContextPOSIX_mips64::Invalidate() {}
void RegisterContextPOSIX_mips64::InvalidateAllRegisters() {} void RegisterContextPOSIX_mips64::InvalidateAllRegisters() {}
unsigned RegisterContextPOSIX_mips64::GetRegisterOffset(unsigned reg) { unsigned RegisterContextPOSIX_mips64::GetRegisterOffset(unsigned reg) {
assert(reg < m_num_registers && "Invalid register number."); assert(reg < m_num_registers && "Invalid register number.");
return GetRegisterInfo()[reg].byte_offset; return GetRegisterInfo()[reg].byte_offset;
▲ Show 20 Lines • Show All 80 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 89 Lines • ▼ Show 20 Lines
RegisterContextPOSIX_powerpc::RegisterContextPOSIX_powerpc( RegisterContextPOSIX_powerpc::RegisterContextPOSIX_powerpc(
Thread &thread, uint32_t concrete_frame_idx, Thread &thread, uint32_t concrete_frame_idx,
RegisterInfoInterface *register_info) RegisterInfoInterface *register_info)
: RegisterContext(thread, concrete_frame_idx) { : RegisterContext(thread, concrete_frame_idx) {
m_register_info_up.reset(register_info); m_register_info_up.reset(register_info);
} }
RegisterContextPOSIX_powerpc::~RegisterContextPOSIX_powerpc() {} RegisterContextPOSIX_powerpc::~RegisterContextPOSIX_powerpc() = default;
void RegisterContextPOSIX_powerpc::Invalidate() {} void RegisterContextPOSIX_powerpc::Invalidate() {}
void RegisterContextPOSIX_powerpc::InvalidateAllRegisters() {} void RegisterContextPOSIX_powerpc::InvalidateAllRegisters() {}
unsigned RegisterContextPOSIX_powerpc::GetRegisterOffset(unsigned reg) { unsigned RegisterContextPOSIX_powerpc::GetRegisterOffset(unsigned reg) {
assert(reg < k_num_registers_powerpc && "Invalid register number."); assert(reg < k_num_registers_powerpc && "Invalid register number.");
return GetRegisterInfo()[reg].byte_offset; return GetRegisterInfo()[reg].byte_offset;
▲ Show 20 Lines • Show All 58 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
m_reg_info.last_fpr = k_last_fpr_s390x; m_reg_info.last_fpr = k_last_fpr_s390x;
break; break;
default: default:
assert(false && "Unhandled target architecture."); assert(false && "Unhandled target architecture.");
break; break;
} }
} }
RegisterContextPOSIX_s390x::~RegisterContextPOSIX_s390x() {} RegisterContextPOSIX_s390x::~RegisterContextPOSIX_s390x() = default;
void RegisterContextPOSIX_s390x::Invalidate() {} void RegisterContextPOSIX_s390x::Invalidate() {}
void RegisterContextPOSIX_s390x::InvalidateAllRegisters() {} void RegisterContextPOSIX_s390x::InvalidateAllRegisters() {}
const RegisterInfo *RegisterContextPOSIX_s390x::GetRegisterInfo() { const RegisterInfo *RegisterContextPOSIX_s390x::GetRegisterInfo() {
return m_register_info_up->GetRegisterInfo(); return m_register_info_up->GetRegisterInfo();
} }
▲ Show 20 Lines • Show All 54 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
break; break;
} }
::memset(&m_fpr, 0, sizeof(FPR)); ::memset(&m_fpr, 0, sizeof(FPR));
m_fpr_type = eNotValid; m_fpr_type = eNotValid;
} }
RegisterContextPOSIX_x86::~RegisterContextPOSIX_x86() {} RegisterContextPOSIX_x86::~RegisterContextPOSIX_x86() = default;
RegisterContextPOSIX_x86::FPRType RegisterContextPOSIX_x86::GetFPRType() { RegisterContextPOSIX_x86::FPRType RegisterContextPOSIX_x86::GetFPRType() {
if (m_fpr_type == eNotValid) { if (m_fpr_type == eNotValid) {
// TODO: Use assembly to call cpuid on the inferior and query ebx or ecx // TODO: Use assembly to call cpuid on the inferior and query ebx or ecx
m_fpr_type = eXSAVE; // extended floating-point registers, if available m_fpr_type = eXSAVE; // extended floating-point registers, if available
if (!ReadFPR()) if (!ReadFPR())
m_fpr_type = eFXSAVE; // assume generic floating-point registers m_fpr_type = eFXSAVE; // assume generic floating-point registers
} }
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

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

Show All 16 Lines
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
RegisterContextThreadMemory::RegisterContextThreadMemory( RegisterContextThreadMemory::RegisterContextThreadMemory(
Thread &thread, lldb::addr_t register_data_addr) Thread &thread, lldb::addr_t register_data_addr)
: RegisterContext(thread, 0), m_thread_wp(thread.shared_from_this()), : RegisterContext(thread, 0), m_thread_wp(thread.shared_from_this()),
m_reg_ctx_sp(), m_register_data_addr(register_data_addr), m_stop_id(0) {} m_reg_ctx_sp(), m_register_data_addr(register_data_addr), m_stop_id(0) {}
RegisterContextThreadMemory::~RegisterContextThreadMemory() {} RegisterContextThreadMemory::~RegisterContextThreadMemory() = default;
void RegisterContextThreadMemory::UpdateRegisterContext() { void RegisterContextThreadMemory::UpdateRegisterContext() {
ThreadSP thread_sp(m_thread_wp.lock()); ThreadSP thread_sp(m_thread_wp.lock());
if (thread_sp) { if (thread_sp) {
ProcessSP process_sp(thread_sp->GetProcess()); ProcessSP process_sp(thread_sp->GetProcess());
if (process_sp) { if (process_sp) {
const uint32_t stop_id = process_sp->GetModID().GetStopID(); const uint32_t stop_id = process_sp->GetModID().GetStopID();
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

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

Show All 16 Lines
/// \class RegisterInfoInterface /// \class RegisterInfoInterface
/// ///
/// RegisterInfo interface to patch RegisterInfo structure for archs. /// RegisterInfo interface to patch RegisterInfo structure for archs.
class RegisterInfoInterface { class RegisterInfoInterface {
public: public:
RegisterInfoInterface(const lldb_private::ArchSpec &target_arch) RegisterInfoInterface(const lldb_private::ArchSpec &target_arch)
: m_target_arch(target_arch) {} : m_target_arch(target_arch) {}
virtual ~RegisterInfoInterface() {} virtual ~RegisterInfoInterface() = default;
virtual size_t GetGPRSize() const = 0; virtual size_t GetGPRSize() const = 0;
virtual const lldb_private::RegisterInfo *GetRegisterInfo() const = 0; virtual const lldb_private::RegisterInfo *GetRegisterInfo() const = 0;
// Returns the number of registers including the user registers and the // Returns the number of registers including the user registers and the
// lldb internal registers also // lldb internal registers also
virtual uint32_t GetRegisterCount() const = 0; virtual uint32_t GetRegisterCount() const = 0;
Show All 36 Lines

lldb/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_arm.cpp

Show All 19 LinesRegisterContextCorePOSIX_arm::RegisterContextCorePOSIX_arm(
const DataExtractor &gpregset, llvm::ArrayRef<CoreNote> notes) const DataExtractor &gpregset, llvm::ArrayRef<CoreNote> notes)
: RegisterContextPOSIX_arm(thread, std::move(register_info)) { : RegisterContextPOSIX_arm(thread, std::move(register_info)) {
m_gpr_buffer = std::make_shared<DataBufferHeap>(gpregset.GetDataStart(), m_gpr_buffer = std::make_shared<DataBufferHeap>(gpregset.GetDataStart(),
gpregset.GetByteSize()); gpregset.GetByteSize());
m_gpr.SetData(m_gpr_buffer); m_gpr.SetData(m_gpr_buffer);
m_gpr.SetByteOrder(gpregset.GetByteOrder()); m_gpr.SetByteOrder(gpregset.GetByteOrder());
} }
RegisterContextCorePOSIX_arm::~RegisterContextCorePOSIX_arm() {} RegisterContextCorePOSIX_arm::~RegisterContextCorePOSIX_arm() = default;
bool RegisterContextCorePOSIX_arm::ReadGPR() { return true; } bool RegisterContextCorePOSIX_arm::ReadGPR() { return true; }
bool RegisterContextCorePOSIX_arm::ReadFPR() { return false; } bool RegisterContextCorePOSIX_arm::ReadFPR() { return false; }
bool RegisterContextCorePOSIX_arm::WriteGPR() { bool RegisterContextCorePOSIX_arm::WriteGPR() {
assert(0); assert(0);
return false; return false;
Show All 38 Lines

lldb/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_arm64.cpp

Show First 20 Lines • Show All 56 Lines • ▼ Show 20 Lines if (m_register_info_up->IsSVEEnabled())
m_sve_data = getRegset(notes, target_triple, AARCH64_SVE_Desc); m_sve_data = getRegset(notes, target_triple, AARCH64_SVE_Desc);
if (m_register_info_up->IsPAuthEnabled()) if (m_register_info_up->IsPAuthEnabled())
m_pac_data = getRegset(notes, target_triple, AARCH64_PAC_Desc); m_pac_data = getRegset(notes, target_triple, AARCH64_PAC_Desc);
ConfigureRegisterContext(); ConfigureRegisterContext();
} }
RegisterContextCorePOSIX_arm64::~RegisterContextCorePOSIX_arm64() {} RegisterContextCorePOSIX_arm64::~RegisterContextCorePOSIX_arm64() = default;
bool RegisterContextCorePOSIX_arm64::ReadGPR() { return true; } bool RegisterContextCorePOSIX_arm64::ReadGPR() { return true; }
bool RegisterContextCorePOSIX_arm64::ReadFPR() { return false; } bool RegisterContextCorePOSIX_arm64::ReadFPR() { return false; }
bool RegisterContextCorePOSIX_arm64::WriteGPR() { bool RegisterContextCorePOSIX_arm64::WriteGPR() {
assert(0); assert(0);
return false; return false;
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_mips64.cpp

Show All 26 LinesRegisterContextCorePOSIX_mips64::RegisterContextCorePOSIX_mips64(
DataExtractor fpregset = getRegset( DataExtractor fpregset = getRegset(
notes, register_info->GetTargetArchitecture().GetTriple(), FPR_Desc); notes, register_info->GetTargetArchitecture().GetTriple(), FPR_Desc);
m_fpr_buffer = std::make_shared<DataBufferHeap>(fpregset.GetDataStart(), m_fpr_buffer = std::make_shared<DataBufferHeap>(fpregset.GetDataStart(),
fpregset.GetByteSize()); fpregset.GetByteSize());
m_fpr.SetData(m_fpr_buffer); m_fpr.SetData(m_fpr_buffer);
m_fpr.SetByteOrder(fpregset.GetByteOrder()); m_fpr.SetByteOrder(fpregset.GetByteOrder());
} }
RegisterContextCorePOSIX_mips64::~RegisterContextCorePOSIX_mips64() {} RegisterContextCorePOSIX_mips64::~RegisterContextCorePOSIX_mips64() = default;
bool RegisterContextCorePOSIX_mips64::ReadGPR() { return true; } bool RegisterContextCorePOSIX_mips64::ReadGPR() { return true; }
bool RegisterContextCorePOSIX_mips64::ReadFPR() { return false; } bool RegisterContextCorePOSIX_mips64::ReadFPR() { return false; }
bool RegisterContextCorePOSIX_mips64::WriteGPR() { bool RegisterContextCorePOSIX_mips64::WriteGPR() {
assert(0); assert(0);
return false; return false;
▲ Show 20 Lines • Show All 48 Lines • Show Last 20 Lines

lldb/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_powerpc.cpp

Show All 33 LinesRegisterContextCorePOSIX_powerpc::RegisterContextCorePOSIX_powerpc(
DataExtractor vregset = getRegset(notes, arch.GetTriple(), PPC_VMX_Desc); DataExtractor vregset = getRegset(notes, arch.GetTriple(), PPC_VMX_Desc);
m_vec_buffer = std::make_shared<DataBufferHeap>(vregset.GetDataStart(), m_vec_buffer = std::make_shared<DataBufferHeap>(vregset.GetDataStart(),
vregset.GetByteSize()); vregset.GetByteSize());
m_vec.SetData(m_vec_buffer); m_vec.SetData(m_vec_buffer);
m_vec.SetByteOrder(vregset.GetByteOrder()); m_vec.SetByteOrder(vregset.GetByteOrder());
} }
RegisterContextCorePOSIX_powerpc::~RegisterContextCorePOSIX_powerpc() {} RegisterContextCorePOSIX_powerpc::~RegisterContextCorePOSIX_powerpc() = default;
bool RegisterContextCorePOSIX_powerpc::ReadGPR() { return true; } bool RegisterContextCorePOSIX_powerpc::ReadGPR() { return true; }
bool RegisterContextCorePOSIX_powerpc::ReadFPR() { return true; } bool RegisterContextCorePOSIX_powerpc::ReadFPR() { return true; }
bool RegisterContextCorePOSIX_powerpc::ReadVMX() { return true; } bool RegisterContextCorePOSIX_powerpc::ReadVMX() { return true; }
bool RegisterContextCorePOSIX_powerpc::WriteGPR() { bool RegisterContextCorePOSIX_powerpc::WriteGPR() {
▲ Show 20 Lines • Show All 61 Lines • Show Last 20 Lines

lldb/source/Plugins/Process/elf-core/RegisterContextPOSIXCore_s390x.cpp

Show All 27 LinesRegisterContextCorePOSIX_s390x::RegisterContextCorePOSIX_s390x(
DataExtractor fpregset = getRegset( DataExtractor fpregset = getRegset(
notes, register_info->GetTargetArchitecture().GetTriple(), FPR_Desc); notes, register_info->GetTargetArchitecture().GetTriple(), FPR_Desc);
m_fpr_buffer = std::make_shared<DataBufferHeap>(fpregset.GetDataStart(), m_fpr_buffer = std::make_shared<DataBufferHeap>(fpregset.GetDataStart(),
fpregset.GetByteSize()); fpregset.GetByteSize());
m_fpr.SetData(m_fpr_buffer); m_fpr.SetData(m_fpr_buffer);
m_fpr.SetByteOrder(fpregset.GetByteOrder()); m_fpr.SetByteOrder(fpregset.GetByteOrder());
} }
RegisterContextCorePOSIX_s390x::~RegisterContextCorePOSIX_s390x() {} RegisterContextCorePOSIX_s390x::~RegisterContextCorePOSIX_s390x() = default;
bool RegisterContextCorePOSIX_s390x::ReadGPR() { return true; } bool RegisterContextCorePOSIX_s390x::ReadGPR() { return true; }
bool RegisterContextCorePOSIX_s390x::ReadFPR() { return true; } bool RegisterContextCorePOSIX_s390x::ReadFPR() { return true; }
bool RegisterContextCorePOSIX_s390x::WriteGPR() { bool RegisterContextCorePOSIX_s390x::WriteGPR() {
assert(0); assert(0);
return false; return false;
▲ Show 20 Lines • Show All 52 Lines • Show Last 20 Lines

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

Show All 18 Lines
using namespace lldb_private::process_gdb_remote; using namespace lldb_private::process_gdb_remote;
GDBRemoteCommunicationHistory::GDBRemoteCommunicationHistory(uint32_t size) GDBRemoteCommunicationHistory::GDBRemoteCommunicationHistory(uint32_t size)
: m_packets() { : m_packets() {
if (size) if (size)
m_packets.resize(size); m_packets.resize(size);
} }
GDBRemoteCommunicationHistory::~GDBRemoteCommunicationHistory() {} GDBRemoteCommunicationHistory::~GDBRemoteCommunicationHistory() = default;
void GDBRemoteCommunicationHistory::AddPacket(char packet_char, void GDBRemoteCommunicationHistory::AddPacket(char packet_char,
GDBRemotePacket::Type type, GDBRemotePacket::Type type,
uint32_t bytes_transmitted) { uint32_t bytes_transmitted) {
const size_t size = m_packets.size(); const size_t size = m_packets.size();
if (size == 0) if (size == 0)
return; return;
▲ Show 20 Lines • Show All 65 Lines • Show Last 20 Lines

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

Show All 27 LinesGDBRemoteCommunicationServer::GDBRemoteCommunicationServer(
const char *comm_name, const char *listener_name) const char *comm_name, const char *listener_name)
: GDBRemoteCommunication(comm_name, listener_name), m_exit_now(false) { : GDBRemoteCommunication(comm_name, listener_name), m_exit_now(false) {
RegisterPacketHandler( RegisterPacketHandler(
StringExtractorGDBRemote::eServerPacketType_QEnableErrorStrings, StringExtractorGDBRemote::eServerPacketType_QEnableErrorStrings,
[this](StringExtractorGDBRemote packet, Status &error, bool &interrupt, [this](StringExtractorGDBRemote packet, Status &error, bool &interrupt,
bool &quit) { return this->Handle_QErrorStringEnable(packet); }); bool &quit) { return this->Handle_QErrorStringEnable(packet); });
} }
GDBRemoteCommunicationServer::~GDBRemoteCommunicationServer() {} GDBRemoteCommunicationServer::~GDBRemoteCommunicationServer() = default;
void GDBRemoteCommunicationServer::RegisterPacketHandler( void GDBRemoteCommunicationServer::RegisterPacketHandler(
StringExtractorGDBRemote::ServerPacketType packet_type, StringExtractorGDBRemote::ServerPacketType packet_type,
PacketHandler handler) { PacketHandler handler) {
m_packet_handlers[packet_type] = std::move(handler); m_packet_handlers[packet_type] = std::move(handler);
} }
GDBRemoteCommunication::PacketResult GDBRemoteCommunication::PacketResult
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
StringExtractorGDBRemote::eServerPacketType_vFile_symlink, StringExtractorGDBRemote::eServerPacketType_vFile_symlink,
&GDBRemoteCommunicationServerCommon::Handle_vFile_symlink); &GDBRemoteCommunicationServerCommon::Handle_vFile_symlink);
RegisterMemberFunctionHandler( RegisterMemberFunctionHandler(
StringExtractorGDBRemote::eServerPacketType_vFile_unlink, StringExtractorGDBRemote::eServerPacketType_vFile_unlink,
&GDBRemoteCommunicationServerCommon::Handle_vFile_unlink); &GDBRemoteCommunicationServerCommon::Handle_vFile_unlink);
} }
// Destructor // Destructor
GDBRemoteCommunicationServerCommon::~GDBRemoteCommunicationServerCommon() {} GDBRemoteCommunicationServerCommon::~GDBRemoteCommunicationServerCommon() =
default;
GDBRemoteCommunication::PacketResult GDBRemoteCommunication::PacketResult
GDBRemoteCommunicationServerCommon::Handle_qHostInfo( GDBRemoteCommunicationServerCommon::Handle_qHostInfo(
StringExtractorGDBRemote &packet) { StringExtractorGDBRemote &packet) {
StreamString response; StreamString response;
// $cputype:16777223;cpusubtype:3;ostype:Darwin;vendor:apple;endian:little;ptrsize:8;#00 // $cputype:16777223;cpusubtype:3;ostype:Darwin;vendor:apple;endian:little;ptrsize:8;#00
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
bool &interrupt, bool &quit) { bool &interrupt, bool &quit) {
error.SetErrorString("interrupt received"); error.SetErrorString("interrupt received");
interrupt = true; interrupt = true;
return PacketResult::Success; return PacketResult::Success;
}); });
} }
// Destructor // Destructor
GDBRemoteCommunicationServerPlatform::~GDBRemoteCommunicationServerPlatform() {} GDBRemoteCommunicationServerPlatform::~GDBRemoteCommunicationServerPlatform() =
default;
Status GDBRemoteCommunicationServerPlatform::LaunchGDBServer( Status GDBRemoteCommunicationServerPlatform::LaunchGDBServer(
const lldb_private::Args &args, std::string hostname, lldb::pid_t &pid, const lldb_private::Args &args, std::string hostname, lldb::pid_t &pid,
llvm::Optional<uint16_t> &port, std::string &socket_name) { llvm::Optional<uint16_t> &port, std::string &socket_name) {
if (!port) { if (!port) {
llvm::Expected<uint16_t> available_port = m_port_map.GetNextAvailablePort(); llvm::Expected<uint16_t> available_port = m_port_map.GetNextAvailablePort();
if (available_port) if (available_port)
port = *available_port; port = *available_port;
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 44 Lines • ▼ Show 20 LinesGDBRemoteRegisterContext::GDBRemoteRegisterContext(
// Make a heap based buffer that is big enough to store all registers // Make a heap based buffer that is big enough to store all registers
DataBufferSP reg_data_sp( DataBufferSP reg_data_sp(
new DataBufferHeap(m_reg_info_sp->GetRegisterDataByteSize(), 0)); new DataBufferHeap(m_reg_info_sp->GetRegisterDataByteSize(), 0));
m_reg_data.SetData(reg_data_sp); m_reg_data.SetData(reg_data_sp);
m_reg_data.SetByteOrder(thread.GetProcess()->GetByteOrder()); m_reg_data.SetByteOrder(thread.GetProcess()->GetByteOrder());
} }
// Destructor // Destructor
GDBRemoteRegisterContext::~GDBRemoteRegisterContext() {} GDBRemoteRegisterContext::~GDBRemoteRegisterContext() = default;
void GDBRemoteRegisterContext::InvalidateAllRegisters() { void GDBRemoteRegisterContext::InvalidateAllRegisters() {
SetAllRegisterValid(false); SetAllRegisterValid(false);
} }
void GDBRemoteRegisterContext::SetAllRegisterValid(bool b) { void GDBRemoteRegisterContext::SetAllRegisterValid(bool b) {
m_gpacket_cached = b; m_gpacket_cached = b;
std::vector<bool>::iterator pos, end = m_reg_valid.end(); std::vector<bool>::iterator pos, end = m_reg_valid.end();
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
return ProcessGDBRemote::GetPluginNameStatic(); return ProcessGDBRemote::GetPluginNameStatic();
} }
PluginProperties() : Properties() { PluginProperties() : Properties() {
m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName()); m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
m_collection_sp->Initialize(g_processgdbremote_properties); m_collection_sp->Initialize(g_processgdbremote_properties);
} }
~PluginProperties() override {} ~PluginProperties() override = default;
uint64_t GetPacketTimeout() { uint64_t GetPacketTimeout() {
const uint32_t idx = ePropertyPacketTimeout; const uint32_t idx = ePropertyPacketTimeout;
return m_collection_sp->GetPropertyAtIndexAsUInt64( return m_collection_sp->GetPropertyAtIndexAsUInt64(
nullptr, idx, g_processgdbremote_properties[idx].default_uint_value); nullptr, idx, g_processgdbremote_properties[idx].default_uint_value);
} }
bool SetPacketTimeout(uint64_t timeout) { bool SetPacketTimeout(uint64_t timeout) {
▲ Show 20 Lines • Show All 182 Lines • ▼ Show 20 Lines
"Print the output as JSON data for easy parsing.", false, true) { "Print the output as JSON data for easy parsing.", false, true) {
m_option_group.Append(&m_num_packets, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1); m_option_group.Append(&m_num_packets, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
m_option_group.Append(&m_max_send, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1); m_option_group.Append(&m_max_send, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
m_option_group.Append(&m_max_recv, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1); m_option_group.Append(&m_max_recv, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
m_option_group.Append(&m_json, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1); m_option_group.Append(&m_json, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
m_option_group.Finalize(); m_option_group.Finalize();
} }
~CommandObjectProcessGDBRemoteSpeedTest() override {} ~CommandObjectProcessGDBRemoteSpeedTest() override = default;
Options *GetOptions() override { return &m_option_group; } Options *GetOptions() override { return &m_option_group; }
bool DoExecute(Args &command, CommandReturnObject &result) override { bool DoExecute(Args &command, CommandReturnObject &result) override {
const size_t argc = command.GetArgumentCount(); const size_t argc = command.GetArgumentCount();
if (argc == 0) { if (argc == 0) {
ProcessGDBRemote *process = ProcessGDBRemote *process =
(ProcessGDBRemote *)m_interpreter.GetExecutionContext() (ProcessGDBRemote *)m_interpreter.GetExecutionContext()
Show All 34 Lines
class CommandObjectProcessGDBRemotePacketHistory : public CommandObjectParsed { class CommandObjectProcessGDBRemotePacketHistory : public CommandObjectParsed {
private: private:
public: public:
CommandObjectProcessGDBRemotePacketHistory(CommandInterpreter &interpreter) CommandObjectProcessGDBRemotePacketHistory(CommandInterpreter &interpreter)
: CommandObjectParsed(interpreter, "process plugin packet history", : CommandObjectParsed(interpreter, "process plugin packet history",
"Dumps the packet history buffer. ", nullptr) {} "Dumps the packet history buffer. ", nullptr) {}
~CommandObjectProcessGDBRemotePacketHistory() override {} ~CommandObjectProcessGDBRemotePacketHistory() override = default;
bool DoExecute(Args &command, CommandReturnObject &result) override { bool DoExecute(Args &command, CommandReturnObject &result) override {
const size_t argc = command.GetArgumentCount(); const size_t argc = command.GetArgumentCount();
if (argc == 0) { if (argc == 0) {
ProcessGDBRemote *process = ProcessGDBRemote *process =
(ProcessGDBRemote *)m_interpreter.GetExecutionContext() (ProcessGDBRemote *)m_interpreter.GetExecutionContext()
.GetProcessPtr(); .GetProcessPtr();
if (process) { if (process) {
Show All 14 Lines
private: private:
public: public:
CommandObjectProcessGDBRemotePacketXferSize(CommandInterpreter &interpreter) CommandObjectProcessGDBRemotePacketXferSize(CommandInterpreter &interpreter)
: CommandObjectParsed( : CommandObjectParsed(
interpreter, "process plugin packet xfer-size", interpreter, "process plugin packet xfer-size",
"Maximum size that lldb will try to read/write one one chunk.", "Maximum size that lldb will try to read/write one one chunk.",
nullptr) {} nullptr) {}
~CommandObjectProcessGDBRemotePacketXferSize() override {} ~CommandObjectProcessGDBRemotePacketXferSize() override = default;
bool DoExecute(Args &command, CommandReturnObject &result) override { bool DoExecute(Args &command, CommandReturnObject &result) override {
const size_t argc = command.GetArgumentCount(); const size_t argc = command.GetArgumentCount();
if (argc == 0) { if (argc == 0) {
result.AppendErrorWithFormat("'%s' takes an argument to specify the max " result.AppendErrorWithFormat("'%s' takes an argument to specify the max "
"amount to be transferred when " "amount to be transferred when "
"reading/writing", "reading/writing",
m_cmd_name.c_str()); m_cmd_name.c_str());
Show All 25 Lines
: CommandObjectParsed(interpreter, "process plugin packet send", : CommandObjectParsed(interpreter, "process plugin packet send",
"Send a custom packet through the GDB remote " "Send a custom packet through the GDB remote "
"protocol and print the answer. " "protocol and print the answer. "
"The packet header and footer will automatically " "The packet header and footer will automatically "
"be added to the packet prior to sending and " "be added to the packet prior to sending and "
"stripped from the result.", "stripped from the result.",
nullptr) {} nullptr) {}
~CommandObjectProcessGDBRemotePacketSend() override {} ~CommandObjectProcessGDBRemotePacketSend() override = default;
bool DoExecute(Args &command, CommandReturnObject &result) override { bool DoExecute(Args &command, CommandReturnObject &result) override {
const size_t argc = command.GetArgumentCount(); const size_t argc = command.GetArgumentCount();
if (argc == 0) { if (argc == 0) {
result.AppendErrorWithFormat( result.AppendErrorWithFormat(
"'%s' takes a one or more packet content arguments", "'%s' takes a one or more packet content arguments",
m_cmd_name.c_str()); m_cmd_name.c_str());
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
Show All 34 Lines
CommandObjectProcessGDBRemotePacketMonitor(CommandInterpreter &interpreter) CommandObjectProcessGDBRemotePacketMonitor(CommandInterpreter &interpreter)
: CommandObjectRaw(interpreter, "process plugin packet monitor", : CommandObjectRaw(interpreter, "process plugin packet monitor",
"Send a qRcmd packet through the GDB remote protocol " "Send a qRcmd packet through the GDB remote protocol "
"and print the response." "and print the response."
"The argument passed to this command will be hex " "The argument passed to this command will be hex "
"encoded into a valid 'qRcmd' packet, sent and the " "encoded into a valid 'qRcmd' packet, sent and the "
"response will be printed.") {} "response will be printed.") {}
~CommandObjectProcessGDBRemotePacketMonitor() override {} ~CommandObjectProcessGDBRemotePacketMonitor() override = default;
bool DoExecute(llvm::StringRef command, bool DoExecute(llvm::StringRef command,
CommandReturnObject &result) override { CommandReturnObject &result) override {
if (command.empty()) { if (command.empty()) {
result.AppendErrorWithFormat("'%s' takes a command string argument", result.AppendErrorWithFormat("'%s' takes a command string argument",
m_cmd_name.c_str()); m_cmd_name.c_str());
result.SetStatus(eReturnStatusFailed); result.SetStatus(eReturnStatusFailed);
return false; return false;
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 Lines
"xfer-size", "xfer-size",
CommandObjectSP( CommandObjectSP(
new CommandObjectProcessGDBRemotePacketXferSize(interpreter))); new CommandObjectProcessGDBRemotePacketXferSize(interpreter)));
LoadSubCommand("speed-test", LoadSubCommand("speed-test",
CommandObjectSP(new CommandObjectProcessGDBRemoteSpeedTest( CommandObjectSP(new CommandObjectProcessGDBRemoteSpeedTest(
interpreter))); interpreter)));
} }
~CommandObjectProcessGDBRemotePacket() override {} ~CommandObjectProcessGDBRemotePacket() override = default;
}; };
class CommandObjectMultiwordProcessGDBRemote : public CommandObjectMultiword { class CommandObjectMultiwordProcessGDBRemote : public CommandObjectMultiword {
public: public:
CommandObjectMultiwordProcessGDBRemote(CommandInterpreter &interpreter) CommandObjectMultiwordProcessGDBRemote(CommandInterpreter &interpreter)
: CommandObjectMultiword( : CommandObjectMultiword(
interpreter, "process plugin", interpreter, "process plugin",
"Commands for operating on a ProcessGDBRemote process.", "Commands for operating on a ProcessGDBRemote process.",
"process plugin <subcommand> [<subcommand-options>]") { "process plugin <subcommand> [<subcommand-options>]") {
LoadSubCommand( LoadSubCommand(
"packet", "packet",
CommandObjectSP(new CommandObjectProcessGDBRemotePacket(interpreter))); CommandObjectSP(new CommandObjectProcessGDBRemotePacket(interpreter)));
} }
~CommandObjectMultiwordProcessGDBRemote() override {} ~CommandObjectMultiwordProcessGDBRemote() override = default;
}; };
CommandObject *ProcessGDBRemote::GetPluginCommandObject() { CommandObject *ProcessGDBRemote::GetPluginCommandObject() {
if (!m_command_sp) if (!m_command_sp)
m_command_sp = std::make_shared<CommandObjectMultiwordProcessGDBRemote>( m_command_sp = std::make_shared<CommandObjectMultiwordProcessGDBRemote>(
GetTarget().GetDebugger().GetCommandInterpreter()); GetTarget().GetDebugger().GetCommandInterpreter());
return m_command_sp.get(); return m_command_sp.get();
} }
Context not available.

lldb/source/Plugins/Process/minidump/ProcessMinidump.cpp

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
APPEND_OPT(m_fb_app_state); APPEND_OPT(m_fb_app_state);
APPEND_OPT(m_fb_abort); APPEND_OPT(m_fb_abort);
APPEND_OPT(m_fb_thread); APPEND_OPT(m_fb_thread);
APPEND_OPT(m_fb_logcat); APPEND_OPT(m_fb_logcat);
APPEND_OPT(m_fb_all); APPEND_OPT(m_fb_all);
m_option_group.Finalize(); m_option_group.Finalize();
} }
~CommandObjectProcessMinidumpDump() override {} ~CommandObjectProcessMinidumpDump() override = default;
Options *GetOptions() override { return &m_option_group; } Options *GetOptions() override { return &m_option_group; }
bool DoExecute(Args &command, CommandReturnObject &result) override { bool DoExecute(Args &command, CommandReturnObject &result) override {
const size_t argc = command.GetArgumentCount(); const size_t argc = command.GetArgumentCount();
if (argc > 0) { if (argc > 0) {
result.AppendErrorWithFormat("'%s' take no arguments, only options", result.AppendErrorWithFormat("'%s' take no arguments, only options",
m_cmd_name.c_str()); m_cmd_name.c_str());
▲ Show 20 Lines • Show All 113 Lines • ▼ Show 20 Lines
CommandObjectMultiwordProcessMinidump(CommandInterpreter &interpreter) CommandObjectMultiwordProcessMinidump(CommandInterpreter &interpreter)
: CommandObjectMultiword(interpreter, "process plugin", : CommandObjectMultiword(interpreter, "process plugin",
"Commands for operating on a ProcessMinidump process.", "Commands for operating on a ProcessMinidump process.",
"process plugin <subcommand> [<subcommand-options>]") { "process plugin <subcommand> [<subcommand-options>]") {
LoadSubCommand("dump", LoadSubCommand("dump",
CommandObjectSP(new CommandObjectProcessMinidumpDump(interpreter))); CommandObjectSP(new CommandObjectProcessMinidumpDump(interpreter)));
} }
~CommandObjectMultiwordProcessMinidump() override {} ~CommandObjectMultiwordProcessMinidump() override = default;
}; };
CommandObject *ProcessMinidump::GetPluginCommandObject() { CommandObject *ProcessMinidump::GetPluginCommandObject() {
if (!m_command_sp) if (!m_command_sp)
m_command_sp = std::make_shared<CommandObjectMultiwordProcessMinidump>( m_command_sp = std::make_shared<CommandObjectMultiwordProcessMinidump>(
GetTarget().GetDebugger().GetCommandInterpreter()); GetTarget().GetDebugger().GetCommandInterpreter());
return m_command_sp.get(); return m_command_sp.get();
} }
Context not available.

lldb/source/Plugins/Process/minidump/ThreadMinidump.cpp

Show All 32 Lines
using namespace lldb_private; using namespace lldb_private;
using namespace minidump; using namespace minidump;
ThreadMinidump::ThreadMinidump(Process &process, const minidump::Thread &td, ThreadMinidump::ThreadMinidump(Process &process, const minidump::Thread &td,
llvm::ArrayRef<uint8_t> gpregset_data) llvm::ArrayRef<uint8_t> gpregset_data)
: Thread(process, td.ThreadId), m_thread_reg_ctx_sp(), : Thread(process, td.ThreadId), m_thread_reg_ctx_sp(),
m_gpregset_data(gpregset_data) {} m_gpregset_data(gpregset_data) {}
ThreadMinidump::~ThreadMinidump() {} ThreadMinidump::~ThreadMinidump() = default;
void ThreadMinidump::RefreshStateAfterStop() {} void ThreadMinidump::RefreshStateAfterStop() {}
RegisterContextSP ThreadMinidump::GetRegisterContext() { RegisterContextSP ThreadMinidump::GetRegisterContext() {
if (!m_reg_context_sp) { if (!m_reg_context_sp) {
m_reg_context_sp = CreateRegisterContextForFrame(nullptr); m_reg_context_sp = CreateRegisterContextForFrame(nullptr);
} }
return m_reg_context_sp; return m_reg_context_sp;
▲ Show 20 Lines • Show All 69 Lines • Show Last 20 Lines

lldb/source/Plugins/ScriptInterpreter/Lua/ScriptInterpreterLua.cpp

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
bool IsQuitCommand(llvm::StringRef cmd) { return cmd.rtrim() == "quit"; } bool IsQuitCommand(llvm::StringRef cmd) { return cmd.rtrim() == "quit"; }
}; };
ScriptInterpreterLua::ScriptInterpreterLua(Debugger &debugger) ScriptInterpreterLua::ScriptInterpreterLua(Debugger &debugger)
: ScriptInterpreter(debugger, eScriptLanguageLua), : ScriptInterpreter(debugger, eScriptLanguageLua),
m_lua(std::make_unique<Lua>()) {} m_lua(std::make_unique<Lua>()) {}
ScriptInterpreterLua::~ScriptInterpreterLua() {} ScriptInterpreterLua::~ScriptInterpreterLua() = default;
bool ScriptInterpreterLua::ExecuteOneLine(llvm::StringRef command, bool ScriptInterpreterLua::ExecuteOneLine(llvm::StringRef command,
CommandReturnObject *result, CommandReturnObject *result,
const ExecuteScriptOptions &options) { const ExecuteScriptOptions &options) {
if (command.empty()) { if (command.empty()) {
if (result) if (result)
result->AppendError("empty command passed to lua\n"); result->AppendError("empty command passed to lua\n");
return false; return false;
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Plugins/ScriptInterpreter/None/ScriptInterpreterNone.cpp

Show All 19 Lines
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
LLDB_PLUGIN_DEFINE(ScriptInterpreterNone) LLDB_PLUGIN_DEFINE(ScriptInterpreterNone)
ScriptInterpreterNone::ScriptInterpreterNone(Debugger &debugger) ScriptInterpreterNone::ScriptInterpreterNone(Debugger &debugger)
: ScriptInterpreter(debugger, eScriptLanguageNone) {} : ScriptInterpreter(debugger, eScriptLanguageNone) {}
ScriptInterpreterNone::~ScriptInterpreterNone() {} ScriptInterpreterNone::~ScriptInterpreterNone() = default;
bool ScriptInterpreterNone::ExecuteOneLine(llvm::StringRef command, bool ScriptInterpreterNone::ExecuteOneLine(llvm::StringRef command,
CommandReturnObject *, CommandReturnObject *,
const ExecuteScriptOptions &) { const ExecuteScriptOptions &) {
m_debugger.GetErrorStream().PutCString( m_debugger.GetErrorStream().PutCString(
"error: there is no embedded script interpreter in this mode.\n"); "error: there is no embedded script interpreter in this mode.\n");
return false; return false;
} }
Show All 37 Lines

lldb/source/Plugins/ScriptInterpreter/Python/PythonDataObjects.h

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
struct PythonFormat< struct PythonFormat<
T, typename std::enable_if<std::is_base_of<PythonObject, T>::value>::type> { T, typename std::enable_if<std::is_base_of<PythonObject, T>::value>::type> {
static constexpr char format = 'O'; static constexpr char format = 'O';
static auto get(const T &value) { return value.get(); } static auto get(const T &value) { return value.get(); }
}; };
class PythonObject { class PythonObject {
public: public:
PythonObject() {} PythonObject() = default;
PythonObject(PyRefType type, PyObject *py_obj) { PythonObject(PyRefType type, PyObject *py_obj) {
m_py_obj = py_obj; m_py_obj = py_obj;
// If this is a borrowed reference, we need to convert it to // If this is a borrowed reference, we need to convert it to
// an owned reference by incrementing it. If it is an owned // an owned reference by incrementing it. If it is an owned
// reference (for example the caller allocated it with PyDict_New() // reference (for example the caller allocated it with PyDict_New()
// then we must *not* increment it. // then we must *not* increment it.
if (m_py_obj && Py_IsInitialized() && type == PyRefType::Borrowed) if (m_py_obj && Py_IsInitialized() && type == PyRefType::Borrowed)
▲ Show 20 Lines • Show All 175 Lines • ▼ Show 20 Lines
return; return;
T::Convert(type, py_obj); T::Convert(type, py_obj);
if (T::Check(py_obj)) if (T::Check(py_obj))
PythonObject::operator=(PythonObject(type, py_obj)); PythonObject::operator=(PythonObject(type, py_obj));
else if (type == PyRefType::Owned) else if (type == PyRefType::Owned)
Py_DECREF(py_obj); Py_DECREF(py_obj);
} }
TypedPythonObject() {} TypedPythonObject() = default;
}; };
class PythonBytes : public TypedPythonObject<PythonBytes> { class PythonBytes : public TypedPythonObject<PythonBytes> {
public: public:
using TypedPythonObject::TypedPythonObject; using TypedPythonObject::TypedPythonObject;
explicit PythonBytes(llvm::ArrayRef<uint8_t> bytes); explicit PythonBytes(llvm::ArrayRef<uint8_t> bytes);
PythonBytes(const uint8_t *bytes, size_t length); PythonBytes(const uint8_t *bytes, size_t length);
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPythonImpl.h

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
class IOHandlerPythonInterpreter : public IOHandler { class IOHandlerPythonInterpreter : public IOHandler {
public: public:
IOHandlerPythonInterpreter(Debugger &debugger, IOHandlerPythonInterpreter(Debugger &debugger,
ScriptInterpreterPythonImpl *python) ScriptInterpreterPythonImpl *python)
: IOHandler(debugger, IOHandler::Type::PythonInterpreter), : IOHandler(debugger, IOHandler::Type::PythonInterpreter),
m_python(python) {} m_python(python) {}
~IOHandlerPythonInterpreter() override {} ~IOHandlerPythonInterpreter() override = default;
ConstString GetControlSequence(char ch) override { ConstString GetControlSequence(char ch) override {
if (ch == 'd') if (ch == 'd')
return ConstString("quit()\n"); return ConstString("quit()\n");
return ConstString(); return ConstString();
} }
void Run() override { void Run() override {
▲ Show 20 Lines • Show All 60 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
return g_setting_name; return g_setting_name;
} }
StructuredDataDarwinLogProperties() : Properties() { StructuredDataDarwinLogProperties() : Properties() {
m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName()); m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
m_collection_sp->Initialize(g_darwinlog_properties); m_collection_sp->Initialize(g_darwinlog_properties);
} }
~StructuredDataDarwinLogProperties() override {} ~StructuredDataDarwinLogProperties() override = default;
bool GetEnableOnStartup() const { bool GetEnableOnStartup() const {
const uint32_t idx = ePropertyEnableOnStartup; const uint32_t idx = ePropertyEnableOnStartup;
return m_collection_sp->GetPropertyAtIndexAsBoolean( return m_collection_sp->GetPropertyAtIndexAsBoolean(
nullptr, idx, g_darwinlog_properties[idx].default_uint_value != 0); nullptr, idx, g_darwinlog_properties[idx].default_uint_value != 0);
} }
llvm::StringRef GetAutoEnableOptions() const { llvm::StringRef GetAutoEnableOptions() const {
Show All 38 Lines
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() = default;
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(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));
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Linespublic:
static SymbolFile *CreateInstance(lldb::ObjectFileSP objfile_sp) { static SymbolFile *CreateInstance(lldb::ObjectFileSP objfile_sp) {
return new SymbolFileBreakpad(std::move(objfile_sp)); return new SymbolFileBreakpad(std::move(objfile_sp));
} }
// Constructors and Destructors // Constructors and Destructors
SymbolFileBreakpad(lldb::ObjectFileSP objfile_sp) SymbolFileBreakpad(lldb::ObjectFileSP objfile_sp)
: SymbolFile(std::move(objfile_sp)) {} : SymbolFile(std::move(objfile_sp)) {}
~SymbolFileBreakpad() override {} ~SymbolFileBreakpad() override = default;
uint32_t CalculateAbilities() override; uint32_t CalculateAbilities() override;
void InitializeObject() override {} void InitializeObject() override {}
// Compile Unit function calls // Compile Unit function calls
lldb::LanguageType ParseLanguage(CompileUnit &comp_unit) override { lldb::LanguageType ParseLanguage(CompileUnit &comp_unit) override {
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

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

Show All 18 Lines
namespace lldb_private { namespace lldb_private {
class CompileUnit; class CompileUnit;
class ExecutionContext; class ExecutionContext;
} }
class SymbolFileDWARF; class SymbolFileDWARF;
class DWARFASTParser { class DWARFASTParser {
public: public:
virtual ~DWARFASTParser() {} virtual ~DWARFASTParser() = default;
virtual lldb::TypeSP ParseTypeFromDWARF(const lldb_private::SymbolContext &sc, virtual lldb::TypeSP ParseTypeFromDWARF(const lldb_private::SymbolContext &sc,
const DWARFDIE &die, const DWARFDIE &die,
bool *type_is_new_ptr) = 0; bool *type_is_new_ptr) = 0;
virtual lldb_private::Function * virtual lldb_private::Function *
ParseFunctionFromDWARF(lldb_private::CompileUnit &comp_unit, ParseFunctionFromDWARF(lldb_private::CompileUnit &comp_unit,
const DWARFDIE &die) = 0; const DWARFDIE &die) = 0;
Show All 23 Lines

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

Show First 20 Lines • Show All 54 Lines • ▼ Show 20 Lines
#define DEBUG_PRINTF(fmt, ...) #define DEBUG_PRINTF(fmt, ...)
#endif #endif
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
DWARFASTParserClang::DWARFASTParserClang(TypeSystemClang &ast) DWARFASTParserClang::DWARFASTParserClang(TypeSystemClang &ast)
: m_ast(ast), m_die_to_decl_ctx(), m_decl_ctx_to_die() {} : m_ast(ast), m_die_to_decl_ctx(), m_decl_ctx_to_die() {}
DWARFASTParserClang::~DWARFASTParserClang() {} DWARFASTParserClang::~DWARFASTParserClang() = default;
static AccessType DW_ACCESS_to_AccessType(uint32_t dwarf_accessibility) { static AccessType DW_ACCESS_to_AccessType(uint32_t dwarf_accessibility) {
switch (dwarf_accessibility) { switch (dwarf_accessibility) {
case DW_ACCESS_public: case DW_ACCESS_public:
return eAccessPublic; return eAccessPublic;
case DW_ACCESS_private: case DW_ACCESS_private:
return eAccessPrivate; return eAccessPrivate;
case DW_ACCESS_protected: case DW_ACCESS_protected:
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

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

//===-- DWARFAttribute.cpp ------------------------------------------------===// //===-- DWARFAttribute.cpp ------------------------------------------------===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "DWARFAttribute.h" #include "DWARFAttribute.h"
#include "DWARFUnit.h" #include "DWARFUnit.h"
#include "DWARFDebugInfo.h" #include "DWARFDebugInfo.h"
DWARFAttributes::DWARFAttributes() : m_infos() {} DWARFAttributes::DWARFAttributes() : m_infos() {}
DWARFAttributes::~DWARFAttributes() {} DWARFAttributes::~DWARFAttributes() = default;
uint32_t DWARFAttributes::FindAttributeIndex(dw_attr_t attr) const { uint32_t DWARFAttributes::FindAttributeIndex(dw_attr_t attr) const {
collection::const_iterator end = m_infos.end(); collection::const_iterator end = m_infos.end();
collection::const_iterator beg = m_infos.begin(); collection::const_iterator beg = m_infos.begin();
collection::const_iterator pos; collection::const_iterator pos;
for (pos = beg; pos != end; ++pos) { for (pos = beg; pos != end; ++pos) {
if (pos->attr.get_attr() == attr) if (pos->attr.get_attr() == attr)
return std::distance(beg, pos); return std::distance(beg, pos);
Show All 40 Lines

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

Show All 18 Lines
class DWARFAttributes; class DWARFAttributes;
class DWARFUnit; class DWARFUnit;
class DWARFDebugInfoEntry; class DWARFDebugInfoEntry;
class DWARFDeclContext; class DWARFDeclContext;
class SymbolFileDWARF; class SymbolFileDWARF;
class DWARFBaseDIE { class DWARFBaseDIE {
public: public:
DWARFBaseDIE() {} DWARFBaseDIE() = default;
DWARFBaseDIE(DWARFUnit *cu, DWARFDebugInfoEntry *die) DWARFBaseDIE(DWARFUnit *cu, DWARFDebugInfoEntry *die)
: m_cu(cu), m_die(die) {} : m_cu(cu), m_die(die) {}
DWARFBaseDIE(const DWARFUnit *cu, DWARFDebugInfoEntry *die) DWARFBaseDIE(const DWARFUnit *cu, DWARFDebugInfoEntry *die)
: m_cu(const_cast<DWARFUnit *>(cu)), m_die(die) {} : m_cu(const_cast<DWARFUnit *>(cu)), m_die(die) {}
DWARFBaseDIE(DWARFUnit *cu, const DWARFDebugInfoEntry *die) DWARFBaseDIE(DWARFUnit *cu, const DWARFDebugInfoEntry *die)
▲ Show 20 Lines • Show All 90 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 48 Lines • ▼ Show 20 Lines void Next() {
} }
} }
public: public:
/// An iterator starting at die d. /// An iterator starting at die d.
explicit ElaboratingDIEIterator(DWARFDIE d) : m_worklist(1, d) {} explicit ElaboratingDIEIterator(DWARFDIE d) : m_worklist(1, d) {}
/// End marker /// End marker
ElaboratingDIEIterator() {} ElaboratingDIEIterator() = default;
const DWARFDIE &operator*() const { return m_worklist.back(); } const DWARFDIE &operator*() const { return m_worklist.back(); }
ElaboratingDIEIterator &operator++() { ElaboratingDIEIterator &operator++() {
Next(); Next();
return *this; return *this;
} }
ElaboratingDIEIterator operator++(int) { ElaboratingDIEIterator operator++(int) {
ElaboratingDIEIterator I = *this; ElaboratingDIEIterator I = *this;
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

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

Show All 17 Lines
// //
// A class that represents a declaration context all the way down to a // A class that represents a declaration context all the way down to a
// DIE. This is useful when trying to find a DIE in one DWARF to a DIE // DIE. This is useful when trying to find a DIE in one DWARF to a DIE
// in another DWARF file. // in another DWARF file.
class DWARFDeclContext { class DWARFDeclContext {
public: public:
struct Entry { struct Entry {
Entry() {} Entry() = default;
Entry(dw_tag_t t, const char *n) : tag(t), name(n) {} Entry(dw_tag_t t, const char *n) : tag(t), name(n) {}
bool NameMatches(const Entry &rhs) const { bool NameMatches(const Entry &rhs) const {
if (name == rhs.name) if (name == rhs.name)
return true; return true;
else if (name && rhs.name) else if (name && rhs.name)
return strcmp(name, rhs.name) == 0; return strcmp(name, rhs.name) == 0;
return false; return false;
▲ Show 20 Lines • Show All 55 Lines • Show Last 20 Lines

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

Show All 16 Lines
#include "lldb/lldb-defines.h" #include "lldb/lldb-defines.h"
class DWARFUnit; class DWARFUnit;
class NameToDIE { class NameToDIE {
public: public:
NameToDIE() : m_map() {} NameToDIE() : m_map() {}
~NameToDIE() {} ~NameToDIE() = default;
void Dump(lldb_private::Stream *s); void Dump(lldb_private::Stream *s);
void Insert(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();
Show All 21 Lines

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

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
UserID(0x7fffffff00000000), // Used by SymbolFileDWARFDebugMap to UserID(0x7fffffff00000000), // Used by SymbolFileDWARFDebugMap to
// when this class parses .o files to // when this class parses .o files to
// contain the .o file index/ID // contain the .o file index/ID
m_debug_map_module_wp(), m_debug_map_symfile(nullptr), m_debug_map_module_wp(), m_debug_map_symfile(nullptr),
m_context(m_objfile_sp->GetModule()->GetSectionList(), dwo_section_list), m_context(m_objfile_sp->GetModule()->GetSectionList(), dwo_section_list),
m_fetched_external_modules(false), m_fetched_external_modules(false),
m_supports_DW_AT_APPLE_objc_complete_type(eLazyBoolCalculate) {} m_supports_DW_AT_APPLE_objc_complete_type(eLazyBoolCalculate) {}
SymbolFileDWARF::~SymbolFileDWARF() {} SymbolFileDWARF::~SymbolFileDWARF() = default;
static 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();
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
UniqueDWARFASTTypeMap &GetUniqueDWARFASTTypeMap() { UniqueDWARFASTTypeMap &GetUniqueDWARFASTTypeMap() {
return m_unique_ast_type_map; return m_unique_ast_type_map;
} }
// OSOEntry // OSOEntry
class OSOEntry { class OSOEntry {
public: public:
OSOEntry() {} OSOEntry() = default;
OSOEntry(uint32_t exe_sym_idx, lldb::addr_t oso_file_addr) OSOEntry(uint32_t exe_sym_idx, lldb::addr_t oso_file_addr)
: m_exe_sym_idx(exe_sym_idx), m_oso_file_addr(oso_file_addr) {} : m_exe_sym_idx(exe_sym_idx), m_oso_file_addr(oso_file_addr) {}
uint32_t GetExeSymbolIndex() const { return m_exe_sym_idx; } uint32_t GetExeSymbolIndex() const { return m_exe_sym_idx; }
bool operator<(const OSOEntry &rhs) const { bool operator<(const OSOEntry &rhs) const {
return m_exe_sym_idx < rhs.m_exe_sym_idx; return m_exe_sym_idx < rhs.m_exe_sym_idx;
▲ Show 20 Lines • Show All 89 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
return new SymbolFileDWARFDebugMap(std::move(objfile_sp)); return new SymbolFileDWARFDebugMap(std::move(objfile_sp));
} }
SymbolFileDWARFDebugMap::SymbolFileDWARFDebugMap(ObjectFileSP objfile_sp) SymbolFileDWARFDebugMap::SymbolFileDWARFDebugMap(ObjectFileSP objfile_sp)
: SymbolFile(std::move(objfile_sp)), m_flags(), m_compile_unit_infos(), : SymbolFile(std::move(objfile_sp)), m_flags(), m_compile_unit_infos(),
m_func_indexes(), m_glob_indexes(), m_func_indexes(), m_glob_indexes(),
m_supports_DW_AT_APPLE_objc_complete_type(eLazyBoolCalculate) {} m_supports_DW_AT_APPLE_objc_complete_type(eLazyBoolCalculate) {}
SymbolFileDWARFDebugMap::~SymbolFileDWARFDebugMap() {} SymbolFileDWARFDebugMap::~SymbolFileDWARFDebugMap() = default;
void SymbolFileDWARFDebugMap::InitializeObject() {} void SymbolFileDWARFDebugMap::InitializeObject() {}
void SymbolFileDWARFDebugMap::InitOSO() { void SymbolFileDWARFDebugMap::InitOSO() {
if (m_flags.test(kHaveInitializedOSOs)) if (m_flags.test(kHaveInitializedOSOs))
return; return;
m_flags.set(kHaveInitializedOSOs); m_flags.set(kHaveInitializedOSOs);
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

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

Show All 24 Lines UniqueDWARFASTType(lldb::TypeSP &type_sp, const DWARFDIE &die,
const lldb_private::Declaration &decl, int32_t byte_size) const lldb_private::Declaration &decl, int32_t byte_size)
: m_type_sp(type_sp), m_die(die), m_declaration(decl), : m_type_sp(type_sp), m_die(die), m_declaration(decl),
m_byte_size(byte_size) {} m_byte_size(byte_size) {}
UniqueDWARFASTType(const UniqueDWARFASTType &rhs) UniqueDWARFASTType(const UniqueDWARFASTType &rhs)
: m_type_sp(rhs.m_type_sp), m_die(rhs.m_die), : m_type_sp(rhs.m_type_sp), m_die(rhs.m_die),
m_declaration(rhs.m_declaration), m_byte_size(rhs.m_byte_size) {} m_declaration(rhs.m_declaration), m_byte_size(rhs.m_byte_size) {}
~UniqueDWARFASTType() {} ~UniqueDWARFASTType() = default;
UniqueDWARFASTType &operator=(const UniqueDWARFASTType &rhs) { UniqueDWARFASTType &operator=(const UniqueDWARFASTType &rhs) {
if (this != &rhs) { if (this != &rhs) {
m_type_sp = rhs.m_type_sp; m_type_sp = rhs.m_type_sp;
m_die = rhs.m_die; m_die = rhs.m_die;
m_declaration = rhs.m_declaration; m_declaration = rhs.m_declaration;
m_byte_size = rhs.m_byte_size; m_byte_size = rhs.m_byte_size;
} }
return *this; return *this;
} }
lldb::TypeSP m_type_sp; lldb::TypeSP m_type_sp;
DWARFDIE m_die; DWARFDIE m_die;
lldb_private::Declaration m_declaration; lldb_private::Declaration m_declaration;
int32_t m_byte_size = -1; int32_t m_byte_size = -1;
}; };
class UniqueDWARFASTTypeList { class UniqueDWARFASTTypeList {
public: public:
UniqueDWARFASTTypeList() : m_collection() {} UniqueDWARFASTTypeList() : m_collection() {}
~UniqueDWARFASTTypeList() {} ~UniqueDWARFASTTypeList() = default;
uint32_t GetSize() { return (uint32_t)m_collection.size(); } uint32_t GetSize() { return (uint32_t)m_collection.size(); }
void Append(const UniqueDWARFASTType &entry) { void Append(const UniqueDWARFASTType &entry) {
m_collection.push_back(entry); m_collection.push_back(entry);
} }
bool Find(const DWARFDIE &die, const lldb_private::Declaration &decl, bool Find(const DWARFDIE &die, const lldb_private::Declaration &decl,
const int32_t byte_size, UniqueDWARFASTType &entry) const; const int32_t byte_size, UniqueDWARFASTType &entry) const;
protected: protected:
typedef std::vector<UniqueDWARFASTType> collection; typedef std::vector<UniqueDWARFASTType> collection;
collection m_collection; collection m_collection;
}; };
class UniqueDWARFASTTypeMap { class UniqueDWARFASTTypeMap {
public: public:
UniqueDWARFASTTypeMap() : m_collection() {} UniqueDWARFASTTypeMap() : m_collection() {}
~UniqueDWARFASTTypeMap() {} ~UniqueDWARFASTTypeMap() = default;
void Insert(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(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,
Show All 16 Lines

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

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
SymbolFile *SymbolFileNativePDB::CreateInstance(ObjectFileSP objfile_sp) { SymbolFile *SymbolFileNativePDB::CreateInstance(ObjectFileSP objfile_sp) {
return new SymbolFileNativePDB(std::move(objfile_sp)); return new SymbolFileNativePDB(std::move(objfile_sp));
} }
SymbolFileNativePDB::SymbolFileNativePDB(ObjectFileSP objfile_sp) SymbolFileNativePDB::SymbolFileNativePDB(ObjectFileSP objfile_sp)
: SymbolFile(std::move(objfile_sp)) {} : SymbolFile(std::move(objfile_sp)) {}
SymbolFileNativePDB::~SymbolFileNativePDB() {} SymbolFileNativePDB::~SymbolFileNativePDB() = default;
uint32_t SymbolFileNativePDB::CalculateAbilities() { uint32_t SymbolFileNativePDB::CalculateAbilities() {
uint32_t abilities = 0; uint32_t abilities = 0;
if (!m_objfile_sp) if (!m_objfile_sp)
return 0; return 0;
if (!m_index) { if (!m_index) {
// Lazily load and match the PDB file, but only do this once. // Lazily load and match the PDB file, but only do this once.
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

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

Show All 35 Lines
class PdbAstBuilder; class PdbAstBuilder;
class PdbIndex; class PdbIndex;
class UdtRecordCompleter : public llvm::codeview::TypeVisitorCallbacks { class UdtRecordCompleter : public llvm::codeview::TypeVisitorCallbacks {
using IndexedBase = using IndexedBase =
std::pair<uint64_t, std::unique_ptr<clang::CXXBaseSpecifier>>; std::pair<uint64_t, std::unique_ptr<clang::CXXBaseSpecifier>>;
union UdtTagRecord { union UdtTagRecord {
UdtTagRecord() {} UdtTagRecord() = default;
llvm::codeview::UnionRecord ur; llvm::codeview::UnionRecord ur;
llvm::codeview::ClassRecord cr; llvm::codeview::ClassRecord cr;
llvm::codeview::EnumRecord er; llvm::codeview::EnumRecord er;
} m_cvr; } m_cvr;
PdbTypeSymId m_id; PdbTypeSymId m_id;
CompilerType &m_derived_ct; CompilerType &m_derived_ct;
clang::TagDecl &m_tag_decl; clang::TagDecl &m_tag_decl;
Show All 32 Lines

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

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
default: default:
assert(false && "Unknown calling convention"); assert(false && "Unknown calling convention");
return clang::CC_C; return clang::CC_C;
} }
} }
PDBASTParser::PDBASTParser(lldb_private::TypeSystemClang &ast) : m_ast(ast) {} PDBASTParser::PDBASTParser(lldb_private::TypeSystemClang &ast) : m_ast(ast) {}
PDBASTParser::~PDBASTParser() {} PDBASTParser::~PDBASTParser() = default;
// DebugInfoASTParser interface // DebugInfoASTParser interface
lldb::TypeSP PDBASTParser::CreateLLDBTypeFromPDBType(const PDBSymbol &type) { lldb::TypeSP PDBASTParser::CreateLLDBTypeFromPDBType(const PDBSymbol &type) {
Declaration decl; Declaration decl;
switch (type.getSymTag()) { switch (type.getSymTag()) {
case PDB_SymType::BaseClass: { case PDB_SymType::BaseClass: {
auto symbol_file = m_ast.GetSymbolFile(); auto symbol_file = m_ast.GetSymbolFile();
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

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

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
lldb_private::SymbolFile * lldb_private::SymbolFile *
SymbolFilePDB::CreateInstance(ObjectFileSP objfile_sp) { SymbolFilePDB::CreateInstance(ObjectFileSP objfile_sp) {
return new SymbolFilePDB(std::move(objfile_sp)); return new SymbolFilePDB(std::move(objfile_sp));
} }
SymbolFilePDB::SymbolFilePDB(lldb::ObjectFileSP objfile_sp) SymbolFilePDB::SymbolFilePDB(lldb::ObjectFileSP objfile_sp)
: SymbolFile(std::move(objfile_sp)), m_session_up(), m_global_scope_up() {} : SymbolFile(std::move(objfile_sp)), m_session_up(), m_global_scope_up() {}
SymbolFilePDB::~SymbolFilePDB() {} SymbolFilePDB::~SymbolFilePDB() = default;
uint32_t SymbolFilePDB::CalculateAbilities() { uint32_t SymbolFilePDB::CalculateAbilities() {
uint32_t abilities = 0; uint32_t abilities = 0;
if (!m_objfile_sp) if (!m_objfile_sp)
return 0; return 0;
if (!m_session_up) { if (!m_session_up) {
// Lazily load and match the PDB file, but only do this once. // Lazily load and match the PDB file, but only do this once.
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetItemInfoHandler.h

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Linespublic:
~AppleGetItemInfoHandler(); ~AppleGetItemInfoHandler();
struct GetItemInfoReturnInfo { struct GetItemInfoReturnInfo {
lldb::addr_t item_buffer_ptr = LLDB_INVALID_ADDRESS; /* the address of the lldb::addr_t item_buffer_ptr = LLDB_INVALID_ADDRESS; /* the address of the
item buffer from libBacktraceRecording */ item buffer from libBacktraceRecording */
lldb::addr_t item_buffer_size = 0; /* the size of the item buffer from lldb::addr_t item_buffer_size = 0; /* the size of the item buffer from
libBacktraceRecording */ libBacktraceRecording */
GetItemInfoReturnInfo() {} GetItemInfoReturnInfo() = default;
}; };
/// Get the information about a work item by calling /// Get the information about a work item by calling
/// __introspection_dispatch_queue_item_get_info. If there's a page of /// __introspection_dispatch_queue_item_get_info. If there's a page of
/// memory that needs to be freed, pass in the address and size and it will /// memory that needs to be freed, pass in the address and size and it will
/// be freed before getting the list of queues. /// be freed before getting the list of queues.
/// ///
/// \param [in] thread /// \param [in] thread
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetItemInfoHandler.cpp

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
"; ";
AppleGetItemInfoHandler::AppleGetItemInfoHandler(Process *process) AppleGetItemInfoHandler::AppleGetItemInfoHandler(Process *process)
: m_process(process), m_get_item_info_impl_code(), : m_process(process), m_get_item_info_impl_code(),
m_get_item_info_function_mutex(), m_get_item_info_function_mutex(),
m_get_item_info_return_buffer_addr(LLDB_INVALID_ADDRESS), m_get_item_info_return_buffer_addr(LLDB_INVALID_ADDRESS),
m_get_item_info_retbuffer_mutex() {} m_get_item_info_retbuffer_mutex() {}
AppleGetItemInfoHandler::~AppleGetItemInfoHandler() {} AppleGetItemInfoHandler::~AppleGetItemInfoHandler() = default;
void AppleGetItemInfoHandler::Detach() { void AppleGetItemInfoHandler::Detach() {
if (m_process && m_process->IsAlive() && if (m_process && m_process->IsAlive() &&
m_get_item_info_return_buffer_addr != LLDB_INVALID_ADDRESS) { m_get_item_info_return_buffer_addr != LLDB_INVALID_ADDRESS) {
std::unique_lock<std::mutex> lock(m_get_item_info_retbuffer_mutex, std::unique_lock<std::mutex> lock(m_get_item_info_retbuffer_mutex,
std::defer_lock); std::defer_lock);
(void)lock.try_lock(); // Even if we don't get the lock, deallocate the buffer (void)lock.try_lock(); // Even if we don't get the lock, deallocate the buffer
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetPendingItemsHandler.h

Show First 20 Lines • Show All 49 Lines • ▼ Show 20 Linespublic:
struct GetPendingItemsReturnInfo { struct GetPendingItemsReturnInfo {
lldb::addr_t items_buffer_ptr = lldb::addr_t items_buffer_ptr =
LLDB_INVALID_ADDRESS; /* the address of the pending items buffer LLDB_INVALID_ADDRESS; /* the address of the pending items buffer
from libBacktraceRecording */ from libBacktraceRecording */
lldb::addr_t items_buffer_size = 0; /* the size of the pending items buffer lldb::addr_t items_buffer_size = 0; /* the size of the pending items buffer
from libBacktraceRecording */ from libBacktraceRecording */
uint64_t count = 0; /* the number of pending items included in the buffer */ uint64_t count = 0; /* the number of pending items included in the buffer */
GetPendingItemsReturnInfo() GetPendingItemsReturnInfo() = default;
teemperorUnsubmitted
Done
ReplyInline Actions

フォーマット

teemperor: フォーマット
JDevlieghereAuthorUnsubmitted
Done
ReplyInline Actions

完了

JDevlieghere: 完了
{}
}; };
/// Get the list of pending items for a given queue via a call to /// Get the list of pending items for a given queue via a call to
/// __introspection_dispatch_queue_get_pending_items. If there's a page of /// __introspection_dispatch_queue_get_pending_items. If there's a page of
/// memory that needs to be freed, pass in the address and size and it will /// memory that needs to be freed, pass in the address and size and it will
/// be freed before getting the list of queues. /// be freed before getting the list of queues.
/// ///
/// \param [in] thread /// \param [in] thread
▲ Show 20 Lines • Show All 49 Lines • Show Last 20 Lines

lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetPendingItemsHandler.cpp

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
"; ";
AppleGetPendingItemsHandler::AppleGetPendingItemsHandler(Process *process) AppleGetPendingItemsHandler::AppleGetPendingItemsHandler(Process *process)
: m_process(process), m_get_pending_items_impl_code(), : m_process(process), m_get_pending_items_impl_code(),
m_get_pending_items_function_mutex(), m_get_pending_items_function_mutex(),
m_get_pending_items_return_buffer_addr(LLDB_INVALID_ADDRESS), m_get_pending_items_return_buffer_addr(LLDB_INVALID_ADDRESS),
m_get_pending_items_retbuffer_mutex() {} m_get_pending_items_retbuffer_mutex() {}
AppleGetPendingItemsHandler::~AppleGetPendingItemsHandler() {} AppleGetPendingItemsHandler::~AppleGetPendingItemsHandler() = default;
void AppleGetPendingItemsHandler::Detach() { void AppleGetPendingItemsHandler::Detach() {
if (m_process && m_process->IsAlive() && if (m_process && m_process->IsAlive() &&
m_get_pending_items_return_buffer_addr != LLDB_INVALID_ADDRESS) { m_get_pending_items_return_buffer_addr != LLDB_INVALID_ADDRESS) {
std::unique_lock<std::mutex> lock(m_get_pending_items_retbuffer_mutex, std::unique_lock<std::mutex> lock(m_get_pending_items_retbuffer_mutex,
std::defer_lock); std::defer_lock);
(void)lock.try_lock(); // Even if we don't get the lock, deallocate the buffer (void)lock.try_lock(); // Even if we don't get the lock, deallocate the buffer
m_process->DeallocateMemory(m_get_pending_items_return_buffer_addr); m_process->DeallocateMemory(m_get_pending_items_return_buffer_addr);
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetQueuesHandler.h

Show First 20 Lines • Show All 46 Lines • ▼ Show 20 Linespublic:
struct GetQueuesReturnInfo { struct GetQueuesReturnInfo {
lldb::addr_t queues_buffer_ptr = lldb::addr_t queues_buffer_ptr =
LLDB_INVALID_ADDRESS; /* the address of the queues buffer from LLDB_INVALID_ADDRESS; /* the address of the queues buffer from
libBacktraceRecording */ libBacktraceRecording */
lldb::addr_t queues_buffer_size = 0; /* the size of the queues buffer from lldb::addr_t queues_buffer_size = 0; /* the size of the queues buffer from
libBacktraceRecording */ libBacktraceRecording */
uint64_t count = 0; /* the number of queues included in the queues buffer */ uint64_t count = 0; /* the number of queues included in the queues buffer */
GetQueuesReturnInfo() GetQueuesReturnInfo() = default;
teemperorUnsubmitted
Done
ReplyInline Actions

хэлбэр хэмжээ

teemperor: хэлбэр хэмжээ
JDevlieghereAuthorUnsubmitted
Done
ReplyInline Actions

хэлбэртэй, хэмжээтэй

JDevlieghere: хэлбэртэй, хэмжээтэй
{}
}; };
/// Get the list of queues that exist (with any active or pending items) via /// Get the list of queues that exist (with any active or pending items) via
/// a call to introspection_get_dispatch_queues(). If there's a page of /// a call to introspection_get_dispatch_queues(). If there's a page of
/// memory that needs to be freed, pass in the address and size and it will /// memory that needs to be freed, pass in the address and size and it will
/// be freed before getting the list of queues. /// be freed before getting the list of queues.
/// ///
/// \param [in] thread /// \param [in] thread
▲ Show 20 Lines • Show All 45 Lines • Show Last 20 Lines

lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetQueuesHandler.cpp

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
"; ";
AppleGetQueuesHandler::AppleGetQueuesHandler(Process *process) AppleGetQueuesHandler::AppleGetQueuesHandler(Process *process)
: m_process(process), m_get_queues_impl_code_up(), : m_process(process), m_get_queues_impl_code_up(),
m_get_queues_function_mutex(), m_get_queues_function_mutex(),
m_get_queues_return_buffer_addr(LLDB_INVALID_ADDRESS), m_get_queues_return_buffer_addr(LLDB_INVALID_ADDRESS),
m_get_queues_retbuffer_mutex() {} m_get_queues_retbuffer_mutex() {}
AppleGetQueuesHandler::~AppleGetQueuesHandler() {} AppleGetQueuesHandler::~AppleGetQueuesHandler() = default;
void AppleGetQueuesHandler::Detach() { void AppleGetQueuesHandler::Detach() {
if (m_process && m_process->IsAlive() && if (m_process && m_process->IsAlive() &&
m_get_queues_return_buffer_addr != LLDB_INVALID_ADDRESS) { m_get_queues_return_buffer_addr != LLDB_INVALID_ADDRESS) {
std::unique_lock<std::mutex> lock(m_get_queues_retbuffer_mutex, std::unique_lock<std::mutex> lock(m_get_queues_retbuffer_mutex,
std::defer_lock); std::defer_lock);
(void)lock.try_lock(); // Even if we don't get the lock, deallocate the buffer (void)lock.try_lock(); // Even if we don't get the lock, deallocate the buffer
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetThreadItemInfoHandler.h

Show First 20 Lines • Show All 46 Lines • ▼ Show 20 Linespublic:
~AppleGetThreadItemInfoHandler(); ~AppleGetThreadItemInfoHandler();
struct GetThreadItemInfoReturnInfo { struct GetThreadItemInfoReturnInfo {
lldb::addr_t item_buffer_ptr = LLDB_INVALID_ADDRESS; /* the address of the lldb::addr_t item_buffer_ptr = LLDB_INVALID_ADDRESS; /* the address of the
item buffer from libBacktraceRecording */ item buffer from libBacktraceRecording */
lldb::addr_t item_buffer_size = 0; /* the size of the item buffer from lldb::addr_t item_buffer_size = 0; /* the size of the item buffer from
libBacktraceRecording */ libBacktraceRecording */
GetThreadItemInfoReturnInfo() {} GetThreadItemInfoReturnInfo() = default;
}; };
/// Get the information about a work item by calling /// Get the information about a work item by calling
/// __introspection_dispatch_thread_get_item_info. If there's a page of /// __introspection_dispatch_thread_get_item_info. If there's a page of
/// memory that needs to be freed, pass in the address and size and it will /// memory that needs to be freed, pass in the address and size and it will
/// be freed before getting the list of queues. /// be freed before getting the list of queues.
/// ///
/// \param [in] thread_id /// \param [in] thread_id
▲ Show 20 Lines • Show All 47 Lines • Show Last 20 Lines

lldb/source/Plugins/SystemRuntime/MacOSX/AppleGetThreadItemInfoHandler.cpp

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
"; ";
AppleGetThreadItemInfoHandler::AppleGetThreadItemInfoHandler(Process *process) AppleGetThreadItemInfoHandler::AppleGetThreadItemInfoHandler(Process *process)
: m_process(process), m_get_thread_item_info_impl_code(), : m_process(process), m_get_thread_item_info_impl_code(),
m_get_thread_item_info_function_mutex(), m_get_thread_item_info_function_mutex(),
m_get_thread_item_info_return_buffer_addr(LLDB_INVALID_ADDRESS), m_get_thread_item_info_return_buffer_addr(LLDB_INVALID_ADDRESS),
m_get_thread_item_info_retbuffer_mutex() {} m_get_thread_item_info_retbuffer_mutex() {}
AppleGetThreadItemInfoHandler::~AppleGetThreadItemInfoHandler() {} AppleGetThreadItemInfoHandler::~AppleGetThreadItemInfoHandler() = default;
void AppleGetThreadItemInfoHandler::Detach() { void AppleGetThreadItemInfoHandler::Detach() {
if (m_process && m_process->IsAlive() && if (m_process && m_process->IsAlive() &&
m_get_thread_item_info_return_buffer_addr != LLDB_INVALID_ADDRESS) { m_get_thread_item_info_return_buffer_addr != LLDB_INVALID_ADDRESS) {
std::unique_lock<std::mutex> lock(m_get_thread_item_info_retbuffer_mutex, std::unique_lock<std::mutex> lock(m_get_thread_item_info_retbuffer_mutex,
std::defer_lock); std::defer_lock);
(void)lock.try_lock(); // Even if we don't get the lock, deallocate the buffer (void)lock.try_lock(); // Even if we don't get the lock, deallocate the buffer
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Plugins/SystemRuntime/MacOSX/SystemRuntimeMacOSX.h

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
private: private:
struct libBacktraceRecording_info { struct libBacktraceRecording_info {
uint16_t queue_info_version = 0; uint16_t queue_info_version = 0;
uint16_t queue_info_data_offset = 0; uint16_t queue_info_data_offset = 0;
uint16_t item_info_version = 0; uint16_t item_info_version = 0;
uint16_t item_info_data_offset = 0; uint16_t item_info_data_offset = 0;
libBacktraceRecording_info() {} libBacktraceRecording_info() = default;
}; };
// A structure which reflects the data recorded in the // A structure which reflects the data recorded in the
// libBacktraceRecording introspection_dispatch_item_info_s. // libBacktraceRecording introspection_dispatch_item_info_s.
struct ItemInfo { struct ItemInfo {
lldb::addr_t item_that_enqueued_this; lldb::addr_t item_that_enqueued_this;
lldb::addr_t function_or_block; lldb::addr_t function_or_block;
uint64_t enqueuing_thread_id; uint64_t enqueuing_thread_id;
▲ Show 20 Lines • Show All 60 Lines • ▼ Show 20 Lines
struct LibdispatchVoucherOffsets { struct LibdispatchVoucherOffsets {
uint16_t vo_version = UINT16_MAX; uint16_t vo_version = UINT16_MAX;
uint16_t vo_activity_ids_count = UINT16_MAX; uint16_t vo_activity_ids_count = UINT16_MAX;
uint16_t vo_activity_ids_count_size = UINT16_MAX; uint16_t vo_activity_ids_count_size = UINT16_MAX;
uint16_t vo_activity_ids_array = UINT16_MAX; uint16_t vo_activity_ids_array = UINT16_MAX;
uint16_t vo_activity_ids_array_entry_size = UINT16_MAX; uint16_t vo_activity_ids_array_entry_size = UINT16_MAX;
LibdispatchVoucherOffsets() LibdispatchVoucherOffsets() = default;
teemperorUnsubmitted
Done
ReplyInline Actions

formoup

teemperor: formoup
JDevlieghereAuthorUnsubmitted
Done
ReplyInline Actions

doune

JDevlieghere: doune
{}
bool IsValid() { return vo_version != UINT16_MAX; } bool IsValid() { return vo_version != UINT16_MAX; }
}; };
struct LibdispatchTSDIndexes { struct LibdispatchTSDIndexes {
uint16_t dti_version = UINT16_MAX; uint16_t dti_version = UINT16_MAX;
uint64_t dti_queue_index = UINT64_MAX; uint64_t dti_queue_index = UINT64_MAX;
uint64_t dti_voucher_index = UINT64_MAX; uint64_t dti_voucher_index = UINT64_MAX;
uint64_t dti_qos_class_index = UINT64_MAX; uint64_t dti_qos_class_index = UINT64_MAX;
LibdispatchTSDIndexes() {} LibdispatchTSDIndexes() = default;
bool IsValid() { return dti_version != UINT16_MAX; } bool IsValid() { return dti_version != UINT16_MAX; }
}; };
struct LibpthreadOffsets { struct LibpthreadOffsets {
uint16_t plo_version = UINT16_MAX; uint16_t plo_version = UINT16_MAX;
uint16_t plo_pthread_tsd_base_offset = UINT16_MAX; uint16_t plo_pthread_tsd_base_offset = UINT16_MAX;
uint16_t plo_pthread_tsd_base_address_offset = UINT16_MAX; uint16_t plo_pthread_tsd_base_address_offset = UINT16_MAX;
uint16_t plo_pthread_tsd_entry_size = UINT16_MAX; uint16_t plo_pthread_tsd_entry_size = UINT16_MAX;
LibpthreadOffsets() LibpthreadOffsets() = default;
teemperorUnsubmitted
Done
ReplyInline Actions

isimo

teemperor: isimo
JDevlieghereAuthorUnsubmitted
Done
ReplyInline Actions

isimo sixazululiwe

JDevlieghere: isimo sixazululiwe
{}
bool IsValid() { return plo_version != UINT16_MAX; } bool IsValid() { return plo_version != UINT16_MAX; }
}; };
// The libBacktraceRecording function // The libBacktraceRecording function
// __introspection_dispatch_queue_get_pending_items has // __introspection_dispatch_queue_get_pending_items has
// two forms. It can either return a simple array of item_refs (void *) size // two forms. It can either return a simple array of item_refs (void *) size
// or it can return // or it can return
▲ Show 20 Lines • Show All 59 Lines • Show Last 20 Lines

lldb/source/Plugins/UnwindAssembly/x86/x86AssemblyInspectionEngine.h

Show First 20 Lines • Show All 41 Lines • ▼ Show 20 Linespublic:
/// One of the two initialize methods that can be called on this object; /// One of the two initialize methods that can be called on this object;
/// they must be called before any of the assembly inspection methods /// they must be called before any of the assembly inspection methods
/// are called. This one takes a vector of register name and lldb /// are called. This one takes a vector of register name and lldb
/// register numbers. /// register numbers.
struct lldb_reg_info { struct lldb_reg_info {
const char *name = nullptr; const char *name = nullptr;
uint32_t lldb_regnum = LLDB_INVALID_REGNUM; uint32_t lldb_regnum = LLDB_INVALID_REGNUM;
lldb_reg_info() {} lldb_reg_info() = default;
}; };
void Initialize(std::vector<lldb_reg_info> &reg_info); void Initialize(std::vector<lldb_reg_info> &reg_info);
/// Create an UnwindPlan for a "non-call site" stack frame situation. /// Create an UnwindPlan for a "non-call site" stack frame situation.
/// This is usually when this function/method is currently executing, and may /// This is usually when this function/method is currently executing, and may
/// be at /// be at
/// a location where exception-handling style unwind information (eh_frame, /// a location where exception-handling style unwind information (eh_frame,
/// compact unwind info, arm unwind info) /// compact unwind info, arm unwind info)
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Symbol/ArmUnwindInfo.cpp

Show First 20 Lines • Show All 62 Lines • ▼ Show 20 Lines while (m_arm_exidx_data.ValidOffset(offset)) {
m_exidx_entries.emplace_back(file_addr, addr, data); m_exidx_entries.emplace_back(file_addr, addr, data);
} }
// Sort the entries in the exidx section. The entries should be sorted inside // Sort the entries in the exidx section. The entries should be sorted inside
// the section but some old compiler isn't sorted them. // the section but some old compiler isn't sorted them.
llvm::sort(m_exidx_entries.begin(), m_exidx_entries.end()); llvm::sort(m_exidx_entries.begin(), m_exidx_entries.end());
} }
ArmUnwindInfo::~ArmUnwindInfo() {} ArmUnwindInfo::~ArmUnwindInfo() = default;
// Read a byte from the unwind instruction stream with the given offset. Custom // Read a byte from the unwind instruction stream with the given offset. Custom
// function is required because have to red in order of significance within // function is required because have to red in order of significance within
// their containing word (most significant byte first) and in increasing word // their containing word (most significant byte first) and in increasing word
// address order. // address order.
uint8_t ArmUnwindInfo::GetByteAtOffset(const uint32_t *data, uint8_t ArmUnwindInfo::GetByteAtOffset(const uint32_t *data,
uint16_t offset) const { uint16_t offset) const {
uint32_t value = data[offset / 4]; uint32_t value = data[offset / 4];
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Symbol/Block.cpp

Show All 19 Lines
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
Block::Block(lldb::user_id_t uid) Block::Block(lldb::user_id_t uid)
: UserID(uid), m_parent_scope(nullptr), m_children(), m_ranges(), : UserID(uid), m_parent_scope(nullptr), m_children(), m_ranges(),
m_inlineInfoSP(), m_variable_list_sp(), m_parsed_block_info(false), m_inlineInfoSP(), m_variable_list_sp(), m_parsed_block_info(false),
m_parsed_block_variables(false), m_parsed_child_blocks(false) {} m_parsed_block_variables(false), m_parsed_child_blocks(false) {}
Block::~Block() {} Block::~Block() = default;
void Block::GetDescription(Stream *s, Function *function, void Block::GetDescription(Stream *s, Function *function,
lldb::DescriptionLevel level, Target *target) const { lldb::DescriptionLevel level, Target *target) const {
*s << "id = " << ((const UserID &)*this); *s << "id = " << ((const UserID &)*this);
size_t num_ranges = m_ranges.GetSize(); size_t num_ranges = m_ranges.GetSize();
if (num_ranges > 0) { if (num_ranges > 0) {
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Symbol/CompactUnwindInfo.cpp

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
CompactUnwindInfo::CompactUnwindInfo(ObjectFile &objfile, SectionSP &section_sp) CompactUnwindInfo::CompactUnwindInfo(ObjectFile &objfile, SectionSP &section_sp)
: m_objfile(objfile), m_section_sp(section_sp), : m_objfile(objfile), m_section_sp(section_sp),
m_section_contents_if_encrypted(), m_mutex(), m_indexes(), m_section_contents_if_encrypted(), m_mutex(), m_indexes(),
m_indexes_computed(eLazyBoolCalculate), m_unwindinfo_data(), m_indexes_computed(eLazyBoolCalculate), m_unwindinfo_data(),
m_unwindinfo_data_computed(false), m_unwind_header() {} m_unwindinfo_data_computed(false), m_unwind_header() {}
// destructor // destructor
CompactUnwindInfo::~CompactUnwindInfo() {} CompactUnwindInfo::~CompactUnwindInfo() = default;
bool CompactUnwindInfo::GetUnwindPlan(Target &target, Address addr, bool CompactUnwindInfo::GetUnwindPlan(Target &target, Address addr,
UnwindPlan &unwind_plan) { UnwindPlan &unwind_plan) {
if (!IsValid(target.GetProcessSP())) { if (!IsValid(target.GetProcessSP())) {
return false; return false;
} }
FunctionInfo function_info; FunctionInfo function_info;
if (GetCompactUnwindInfoForFunction(target, addr, function_info)) { if (GetCompactUnwindInfoForFunction(target, addr, function_info)) {
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Symbol/FuncUnwinders.cpp

Show First 20 Lines • Show All 49 Lines • ▼ Show 20 Lines : m_unwind_table(unwind_table), m_range(range), m_mutex(),
m_tried_unwind_plan_arm_unwind(false), m_tried_unwind_plan_arm_unwind(false),
m_tried_unwind_plan_symbol_file(false), m_tried_unwind_fast(false), m_tried_unwind_plan_symbol_file(false), m_tried_unwind_fast(false),
m_tried_unwind_arch_default(false), m_tried_unwind_arch_default(false),
m_tried_unwind_arch_default_at_func_entry(false), m_tried_unwind_arch_default_at_func_entry(false),
m_first_non_prologue_insn() {} m_first_non_prologue_insn() {}
/// destructor /// destructor
FuncUnwinders::~FuncUnwinders() {} FuncUnwinders::~FuncUnwinders() = default;
UnwindPlanSP FuncUnwinders::GetUnwindPlanAtCallSite(Target &target, UnwindPlanSP FuncUnwinders::GetUnwindPlanAtCallSite(Target &target,
Thread &thread) { Thread &thread) {
std::lock_guard<std::recursive_mutex> guard(m_mutex); std::lock_guard<std::recursive_mutex> guard(m_mutex);
if (UnwindPlanSP plan_sp = GetObjectFileUnwindPlan(target)) if (UnwindPlanSP plan_sp = GetObjectFileUnwindPlan(target))
return plan_sp; return plan_sp;
if (UnwindPlanSP plan_sp = GetSymbolFileUnwindPlan(thread)) if (UnwindPlanSP plan_sp = GetSymbolFileUnwindPlan(thread))
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Symbol/Function.cpp

Show All 26 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(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() = default;
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);
} }
int FunctionInfo::Compare(const FunctionInfo &a, const FunctionInfo &b) { int FunctionInfo::Compare(const FunctionInfo &a, const FunctionInfo &b) {
Show All 25 Lines
InlineFunctionInfo::InlineFunctionInfo(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() = default;
void InlineFunctionInfo::Dump(Stream *s, bool show_fullpaths) const { void InlineFunctionInfo::Dump(Stream *s, bool show_fullpaths) const {
FunctionInfo::Dump(s, show_fullpaths); FunctionInfo::Dump(s, show_fullpaths);
if (m_mangled) if (m_mangled)
m_mangled.Dump(s); m_mangled.Dump(s);
} }
void InlineFunctionInfo::DumpStopContext(Stream *s) const { void InlineFunctionInfo::DumpStopContext(Stream *s) const {
▲ Show 20 Lines • Show All 147 Lines • ▼ Show 20 LinesFunction::Function(CompileUnit *comp_unit, lldb::user_id_t func_uid,
const AddressRange &range) const AddressRange &range)
: UserID(func_uid), m_comp_unit(comp_unit), m_type_uid(type_uid), : UserID(func_uid), m_comp_unit(comp_unit), m_type_uid(type_uid),
m_type(type), m_mangled(mangled), m_block(func_uid), m_range(range), m_type(type), m_mangled(mangled), m_block(func_uid), m_range(range),
m_frame_base(), m_flags(), m_prologue_byte_size(0) { m_frame_base(), m_flags(), m_prologue_byte_size(0) {
m_block.SetParentScope(this); m_block.SetParentScope(this);
assert(comp_unit != nullptr); assert(comp_unit != nullptr);
} }
Function::~Function() {} Function::~Function() = default;
void Function::GetStartLineSourceInfo(FileSpec &source_file, void Function::GetStartLineSourceInfo(FileSpec &source_file,
uint32_t &line_no) { uint32_t &line_no) {
line_no = 0; line_no = 0;
source_file.Clear(); source_file.Clear();
if (m_comp_unit == nullptr) if (m_comp_unit == nullptr)
return; return;
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Symbol/LineTable.cpp

Show All 28 LinesLineTable::LineTable(CompileUnit *comp_unit,
for (const auto &sequence : sequences) { for (const auto &sequence : sequences) {
LineSequenceImpl *seq = static_cast<LineSequenceImpl *>(sequence.get()); LineSequenceImpl *seq = static_cast<LineSequenceImpl *>(sequence.get());
m_entries.insert(m_entries.end(), seq->m_entries.begin(), m_entries.insert(m_entries.end(), seq->m_entries.begin(),
seq->m_entries.end()); seq->m_entries.end());
} }
} }
// Destructor // Destructor
LineTable::~LineTable() {} LineTable::~LineTable() = default;
void LineTable::InsertLineEntry(lldb::addr_t file_addr, uint32_t line, void LineTable::InsertLineEntry(lldb::addr_t file_addr, uint32_t line,
uint16_t column, uint16_t file_idx, uint16_t column, uint16_t file_idx,
bool is_start_of_statement, bool is_start_of_statement,
bool is_start_of_basic_block, bool is_start_of_basic_block,
bool is_prologue_end, bool is_epilogue_begin, bool is_prologue_end, bool is_epilogue_begin,
bool is_terminal_entry) { bool is_terminal_entry) {
Entry entry(file_addr, line, column, file_idx, is_start_of_statement, Entry entry(file_addr, line, column, file_idx, is_start_of_statement,
is_start_of_basic_block, is_prologue_end, is_epilogue_begin, is_start_of_basic_block, is_prologue_end, is_epilogue_begin,
is_terminal_entry); is_terminal_entry);
LineTable::Entry::LessThanBinaryPredicate less_than_bp(this); LineTable::Entry::LessThanBinaryPredicate less_than_bp(this);
entry_collection::iterator pos = entry_collection::iterator pos =
llvm::upper_bound(m_entries, entry, less_than_bp); llvm::upper_bound(m_entries, entry, less_than_bp);
// Stream s(stdout); // Stream s(stdout);
// s << "\n\nBefore:\n"; // s << "\n\nBefore:\n";
// Dump (&s, Address::DumpStyleFileAddress); // Dump (&s, Address::DumpStyleFileAddress);
m_entries.insert(pos, entry); m_entries.insert(pos, entry);
// s << "After:\n"; // s << "After:\n";
// Dump (&s, Address::DumpStyleFileAddress); // Dump (&s, Address::DumpStyleFileAddress);
} }
LineSequence::LineSequence() {} LineSequence::LineSequence() = default;
void LineTable::LineSequenceImpl::Clear() { m_entries.clear(); } void LineTable::LineSequenceImpl::Clear() { m_entries.clear(); }
std::unique_ptr<LineSequence> LineTable::CreateLineSequenceContainer() { std::unique_ptr<LineSequence> LineTable::CreateLineSequenceContainer() {
return std::make_unique<LineTable::LineSequenceImpl>(); return std::make_unique<LineTable::LineSequenceImpl>();
} }
void LineTable::AppendLineEntryToSequence( void LineTable::AppendLineEntryToSequence(
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Symbol/SymbolContext.cpp

Show First 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
} }
SymbolContext::SymbolContext(SymbolContextScope *sc_scope) SymbolContext::SymbolContext(SymbolContextScope *sc_scope)
: target_sp(), module_sp(), comp_unit(nullptr), function(nullptr), : target_sp(), module_sp(), comp_unit(nullptr), function(nullptr),
block(nullptr), line_entry(), symbol(nullptr), variable(nullptr) { block(nullptr), line_entry(), symbol(nullptr), variable(nullptr) {
sc_scope->CalculateSymbolContext(this); sc_scope->CalculateSymbolContext(this);
} }
SymbolContext::~SymbolContext() {} SymbolContext::~SymbolContext() = default;
void SymbolContext::Clear(bool clear_target) { void SymbolContext::Clear(bool clear_target) {
if (clear_target) if (clear_target)
target_sp.reset(); target_sp.reset();
module_sp.reset(); module_sp.reset();
comp_unit = nullptr; comp_unit = nullptr;
function = nullptr; function = nullptr;
block = nullptr; block = nullptr;
▲ Show 20 Lines • Show All 182 Lines • ▼ Show 20 Lines
// SymbolContextSpecifier // SymbolContextSpecifier
// //
SymbolContextSpecifier::SymbolContextSpecifier(const TargetSP &target_sp) SymbolContextSpecifier::SymbolContextSpecifier(const TargetSP &target_sp)
: m_target_sp(target_sp), m_module_spec(), m_module_sp(), m_file_spec_up(), : m_target_sp(target_sp), m_module_spec(), m_module_sp(), m_file_spec_up(),
m_start_line(0), m_end_line(0), m_function_spec(), m_class_name(), m_start_line(0), m_end_line(0), m_function_spec(), m_class_name(),
m_address_range_up(), m_type(eNothingSpecified) {} m_address_range_up(), m_type(eNothingSpecified) {}
SymbolContextSpecifier::~SymbolContextSpecifier() {} SymbolContextSpecifier::~SymbolContextSpecifier() = default;
bool SymbolContextSpecifier::AddLineSpecification(uint32_t line_no, bool SymbolContextSpecifier::AddLineSpecification(uint32_t line_no,
SpecificationType type) { SpecificationType type) {
bool return_value = true; bool return_value = true;
switch (type) { switch (type) {
case eNothingSpecified: case eNothingSpecified:
Clear(); Clear();
break; break;
▲ Show 20 Lines • Show All 182 Lines • ▼ Show 20 Lines
} }
// //
// SymbolContextList // SymbolContextList
// //
SymbolContextList::SymbolContextList() : m_symbol_contexts() {} SymbolContextList::SymbolContextList() : m_symbol_contexts() {}
SymbolContextList::~SymbolContextList() {} SymbolContextList::~SymbolContextList() = default;
void SymbolContextList::Append(const SymbolContext &sc) { void SymbolContextList::Append(const SymbolContext &sc) {
m_symbol_contexts.push_back(sc); m_symbol_contexts.push_back(sc);
} }
void SymbolContextList::Append(const SymbolContextList &sc_list) { void SymbolContextList::Append(const SymbolContextList &sc_list) {
collection::const_iterator pos, end = sc_list.m_symbol_contexts.end(); collection::const_iterator pos, end = sc_list.m_symbol_contexts.end();
for (pos = sc_list.m_symbol_contexts.begin(); pos != end; ++pos) for (pos = sc_list.m_symbol_contexts.begin(); pos != end; ++pos)
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Symbol/Symtab.cpp

Show All 35 LinesSymtab::Symtab(ObjectFile *objfile)
m_name_to_symbol_indices.emplace(std::make_pair( m_name_to_symbol_indices.emplace(std::make_pair(
lldb::eFunctionNameTypeBase, UniqueCStringMap<uint32_t>())); lldb::eFunctionNameTypeBase, UniqueCStringMap<uint32_t>()));
m_name_to_symbol_indices.emplace(std::make_pair( m_name_to_symbol_indices.emplace(std::make_pair(
lldb::eFunctionNameTypeMethod, UniqueCStringMap<uint32_t>())); lldb::eFunctionNameTypeMethod, UniqueCStringMap<uint32_t>()));
m_name_to_symbol_indices.emplace(std::make_pair( m_name_to_symbol_indices.emplace(std::make_pair(
lldb::eFunctionNameTypeSelector, UniqueCStringMap<uint32_t>())); lldb::eFunctionNameTypeSelector, UniqueCStringMap<uint32_t>()));
} }
Symtab::~Symtab() {} Symtab::~Symtab() = default;
void Symtab::Reserve(size_t count) { void Symtab::Reserve(size_t count) {
// Clients should grab the mutex from this symbol table and lock it manually // Clients should grab the mutex from this symbol table and lock it manually
// when calling this function to avoid performance issues. // when calling this function to avoid performance issues.
m_symbols.reserve(count); m_symbols.reserve(count);
} }
Symbol *Symtab::Resize(size_t count) { Symbol *Symtab::Resize(size_t count) {
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Symbol/TypeList.cpp

Show All 16 Lines
#include "lldb/Symbol/TypeList.h" #include "lldb/Symbol/TypeList.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
TypeList::TypeList() : m_types() {} TypeList::TypeList() : m_types() {}
// Destructor // Destructor
TypeList::~TypeList() {} TypeList::~TypeList() = default;
void TypeList::Insert(const TypeSP &type_sp) { void TypeList::Insert(const TypeSP &type_sp) {
// Just push each type on the back for now. We will worry about uniquing // Just push each type on the back for now. We will worry about uniquing
// later // later
if (type_sp) if (type_sp)
m_types.push_back(type_sp); m_types.push_back(type_sp);
} }
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Symbol/TypeMap.cpp

Show All 16 Lines
#include "lldb/Symbol/TypeMap.h" #include "lldb/Symbol/TypeMap.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
TypeMap::TypeMap() : m_types() {} TypeMap::TypeMap() : m_types() {}
// Destructor // Destructor
TypeMap::~TypeMap() {} TypeMap::~TypeMap() = default;
void TypeMap::Insert(const TypeSP &type_sp) { void TypeMap::Insert(const TypeSP &type_sp) {
// Just push each type on the back for now. We will worry about uniquing // Just push each type on the back for now. We will worry about uniquing
// later // later
if (type_sp) if (type_sp)
m_types.insert(std::make_pair(type_sp->GetID(), type_sp)); m_types.insert(std::make_pair(type_sp->GetID(), type_sp));
} }
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Symbol/TypeSystem.cpp

Show All 29 Linesllvm::Optional<LanguageType> LanguageSet::GetSingularLanguage() {
return {}; return {};
} }
void LanguageSet::Insert(LanguageType language) { bitvector.set(language); } void LanguageSet::Insert(LanguageType language) { bitvector.set(language); }
size_t LanguageSet::Size() const { return bitvector.count(); } size_t LanguageSet::Size() const { return bitvector.count(); }
bool LanguageSet::Empty() const { return bitvector.none(); } bool LanguageSet::Empty() const { return bitvector.none(); }
bool LanguageSet::operator[](unsigned i) const { return bitvector[i]; } bool LanguageSet::operator[](unsigned i) const { return bitvector[i]; }
TypeSystem::~TypeSystem() {} TypeSystem::~TypeSystem() = default;
static lldb::TypeSystemSP CreateInstanceHelper(lldb::LanguageType language, static lldb::TypeSystemSP CreateInstanceHelper(lldb::LanguageType language,
Module *module, Target *target) { Module *module, Target *target) {
uint32_t i = 0; uint32_t i = 0;
TypeSystemCreateInstance create_callback; TypeSystemCreateInstance create_callback;
while ((create_callback = PluginManager::GetTypeSystemCreateCallbackAtIndex( while ((create_callback = PluginManager::GetTypeSystemCreateCallbackAtIndex(
i++)) != nullptr) { i++)) != nullptr) {
lldb::TypeSystemSP type_system_sp = lldb::TypeSystemSP type_system_sp =
▲ Show 20 Lines • Show All 128 Lines • ▼ Show 20 Lines
TypeSystem::CreateUtilityFunction(std::string text, std::string name) { TypeSystem::CreateUtilityFunction(std::string text, std::string name) {
return {}; return {};
} }
#pragma mark TypeSystemMap #pragma mark TypeSystemMap
TypeSystemMap::TypeSystemMap() : m_mutex(), m_map() {} TypeSystemMap::TypeSystemMap() : m_mutex(), m_map() {}
TypeSystemMap::~TypeSystemMap() {} TypeSystemMap::~TypeSystemMap() = default;
void TypeSystemMap::Clear() { void TypeSystemMap::Clear() {
collection map; collection map;
{ {
std::lock_guard<std::mutex> guard(m_mutex); std::lock_guard<std::mutex> guard(m_mutex);
map = m_map; map = m_map;
m_clear_in_progress = true; m_clear_in_progress = true;
} }
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Symbol/UnwindTable.cpp

Show First 20 Lines • Show All 77 Lines • ▼ Show 20 Lines if (sect) {
SectionSP sect_extab = sl->FindSectionByType(eSectionTypeARMextab, true); SectionSP sect_extab = sl->FindSectionByType(eSectionTypeARMextab, true);
if (sect_extab.get()) { if (sect_extab.get()) {
m_arm_unwind_up = m_arm_unwind_up =
std::make_unique<ArmUnwindInfo>(*object_file, sect, sect_extab); std::make_unique<ArmUnwindInfo>(*object_file, sect, sect_extab);
} }
} }
} }
UnwindTable::~UnwindTable() {} UnwindTable::~UnwindTable() = default;
llvm::Optional<AddressRange> UnwindTable::GetAddressRange(const Address &addr, llvm::Optional<AddressRange> UnwindTable::GetAddressRange(const Address &addr,
SymbolContext &sc) { SymbolContext &sc) {
AddressRange range; AddressRange range;
// First check the unwind info from the object file plugin // First check the unwind info from the object file plugin
if (m_object_file_unwind_up && if (m_object_file_unwind_up &&
m_object_file_unwind_up->GetAddressRange(addr, range)) m_object_file_unwind_up->GetAddressRange(addr, range))
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Symbol/Variable.cpp

Show First 20 Lines • Show All 43 Lines • ▼ Show 20 LinesVariable::Variable(lldb::user_id_t uid, const char *name, const char *mangled,
bool static_member) bool static_member)
: UserID(uid), m_name(name), m_mangled(ConstString(mangled)), : UserID(uid), m_name(name), m_mangled(ConstString(mangled)),
m_symfile_type_sp(symfile_type_sp), m_scope(scope), m_symfile_type_sp(symfile_type_sp), m_scope(scope),
m_owner_scope(context), m_scope_range(scope_range), m_owner_scope(context), m_scope_range(scope_range),
m_declaration(decl_ptr), m_location(location), m_external(external), m_declaration(decl_ptr), m_location(location), m_external(external),
m_artificial(artificial), m_loc_is_const_data(location_is_constant_data), m_artificial(artificial), m_loc_is_const_data(location_is_constant_data),
m_static_member(static_member) {} m_static_member(static_member) {}
Variable::~Variable() {} Variable::~Variable() = default;
lldb::LanguageType Variable::GetLanguage() const { lldb::LanguageType Variable::GetLanguage() const {
lldb::LanguageType lang = m_mangled.GuessLanguage(); lldb::LanguageType lang = m_mangled.GuessLanguage();
if (lang != lldb::eLanguageTypeUnknown) if (lang != lldb::eLanguageTypeUnknown)
return lang; return lang;
if (auto *func = m_owner_scope->CalculateSymbolContextFunction()) { if (auto *func = m_owner_scope->CalculateSymbolContextFunction()) {
if ((lang = func->GetLanguage()) != lldb::eLanguageTypeUnknown) if ((lang = func->GetLanguage()) != lldb::eLanguageTypeUnknown)
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Symbol/VariableList.cpp

Show All 14 Lines
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
// VariableList constructor // VariableList constructor
VariableList::VariableList() : m_variables() {} VariableList::VariableList() : m_variables() {}
// Destructor // Destructor
VariableList::~VariableList() {} VariableList::~VariableList() = default;
void VariableList::AddVariable(const VariableSP &var_sp) { void VariableList::AddVariable(const VariableSP &var_sp) {
m_variables.push_back(var_sp); m_variables.push_back(var_sp);
} }
bool VariableList::AddVariableIfUnique(const lldb::VariableSP &var_sp) { bool VariableList::AddVariableIfUnique(const lldb::VariableSP &var_sp) {
if (FindVariableIndex(var_sp) == UINT32_MAX) { if (FindVariableIndex(var_sp) == UINT32_MAX) {
m_variables.push_back(var_sp); m_variables.push_back(var_sp);
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Target/JITLoaderList.cpp

Show All 9 Lines
#include "lldb/Target/JITLoaderList.h" #include "lldb/Target/JITLoaderList.h"
#include "lldb/lldb-private.h" #include "lldb/lldb-private.h"
using namespace lldb; using namespace lldb;
using namespace lldb_private; using namespace lldb_private;
JITLoaderList::JITLoaderList() : m_jit_loaders_vec(), m_jit_loaders_mutex() {} JITLoaderList::JITLoaderList() : m_jit_loaders_vec(), m_jit_loaders_mutex() {}
JITLoaderList::~JITLoaderList() {} JITLoaderList::~JITLoaderList() = default;
void JITLoaderList::Append(const JITLoaderSP &jit_loader_sp) { void JITLoaderList::Append(const JITLoaderSP &jit_loader_sp) {
std::lock_guard<std::recursive_mutex> guard(m_jit_loaders_mutex); std::lock_guard<std::recursive_mutex> guard(m_jit_loaders_mutex);
m_jit_loaders_vec.push_back(jit_loader_sp); m_jit_loaders_vec.push_back(jit_loader_sp);
} }
void JITLoaderList::Remove(const JITLoaderSP &jit_loader_sp) { void JITLoaderList::Remove(const JITLoaderSP &jit_loader_sp) {
std::lock_guard<std::recursive_mutex> guard(m_jit_loaders_mutex); std::lock_guard<std::recursive_mutex> guard(m_jit_loaders_mutex);
Show All 29 Lines

lldb/source/Target/Language.cpp

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
void Language::GetDefaultExceptionResolverDescription(bool catch_on, void Language::GetDefaultExceptionResolverDescription(bool catch_on,
bool throw_on, bool throw_on,
Stream &s) { Stream &s) {
s.Printf("Exception breakpoint (catch: %s throw: %s)", s.Printf("Exception breakpoint (catch: %s throw: %s)",
catch_on ? "on" : "off", throw_on ? "on" : "off"); catch_on ? "on" : "off", throw_on ? "on" : "off");
} }
// Constructor // Constructor
Language::Language() {} Language::Language() = default;
// Destructor // Destructor
Language::~Language() {} Language::~Language() = default;
Context not available.

lldb/source/Target/Memory.cpp

Show All 20 Lines
// MemoryCache constructor // MemoryCache constructor
MemoryCache::MemoryCache(Process &process) MemoryCache::MemoryCache(Process &process)
: m_mutex(), m_L1_cache(), m_L2_cache(), m_invalid_ranges(), : m_mutex(), m_L1_cache(), m_L2_cache(), m_invalid_ranges(),
m_process(process), m_process(process),
m_L2_cache_line_byte_size(process.GetMemoryCacheLineSize()) {} m_L2_cache_line_byte_size(process.GetMemoryCacheLineSize()) {}
// Destructor // Destructor
MemoryCache::~MemoryCache() {} MemoryCache::~MemoryCache() = default;
void MemoryCache::Clear(bool clear_invalid_ranges) { void MemoryCache::Clear(bool clear_invalid_ranges) {
std::lock_guard<std::recursive_mutex> guard(m_mutex); std::lock_guard<std::recursive_mutex> guard(m_mutex);
m_L1_cache.clear(); m_L1_cache.clear();
m_L2_cache.clear(); m_L2_cache.clear();
if (clear_invalid_ranges) if (clear_invalid_ranges)
m_invalid_ranges.Clear(); m_invalid_ranges.Clear();
m_L2_cache_line_byte_size = m_process.GetMemoryCacheLineSize(); m_L2_cache_line_byte_size = m_process.GetMemoryCacheLineSize();
▲ Show 20 Lines • Show All 182 Lines • ▼ Show 20 Lines
: m_range(addr, byte_size), m_permissions(permissions), : m_range(addr, byte_size), m_permissions(permissions),
m_chunk_size(chunk_size) m_chunk_size(chunk_size)
{ {
// The entire address range is free to start with. // The entire address range is free to start with.
m_free_blocks.Append(m_range); m_free_blocks.Append(m_range);
assert(byte_size > chunk_size); assert(byte_size > chunk_size);
} }
AllocatedBlock::~AllocatedBlock() {} AllocatedBlock::~AllocatedBlock() = default;
lldb::addr_t AllocatedBlock::ReserveBlock(uint32_t size) { lldb::addr_t AllocatedBlock::ReserveBlock(uint32_t size) {
// We must return something valid for zero bytes. // We must return something valid for zero bytes.
if (size == 0) if (size == 0)
size = 1; size = 1;
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS)); Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
const size_t free_count = m_free_blocks.GetSize(); const size_t free_count = m_free_blocks.GetSize();
▲ Show 20 Lines • Show All 53 Lines • ▼ Show 20 Lines
Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS)); Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
LLDB_LOGV(log, "({0}) (addr = {1:x}) => {2}", this, addr, success); LLDB_LOGV(log, "({0}) (addr = {1:x}) => {2}", this, addr, success);
return success; return success;
} }
AllocatedMemoryCache::AllocatedMemoryCache(Process &process) AllocatedMemoryCache::AllocatedMemoryCache(Process &process)
: m_process(process), m_mutex(), m_memory_map() {} : m_process(process), m_mutex(), m_memory_map() {}
AllocatedMemoryCache::~AllocatedMemoryCache() {} AllocatedMemoryCache::~AllocatedMemoryCache() = default;
void AllocatedMemoryCache::Clear() { void AllocatedMemoryCache::Clear() {
std::lock_guard<std::recursive_mutex> guard(m_mutex); std::lock_guard<std::recursive_mutex> guard(m_mutex);
if (m_process.IsAlive()) { if (m_process.IsAlive()) {
PermissionsToBlockMap::iterator pos, end = m_memory_map.end(); PermissionsToBlockMap::iterator pos, end = m_memory_map.end();
for (pos = m_memory_map.begin(); pos != end; ++pos) for (pos = m_memory_map.begin(); pos != end; ++pos)
m_process.DoDeallocateMemory(pos->second->GetBaseAddress()); m_process.DoDeallocateMemory(pos->second->GetBaseAddress());
} }
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

lldb/source/Target/QueueItem.cpp

Show All 21 Lines : m_queue_wp(), m_process_wp(), m_item_ref(item_ref), m_address(address),
m_enqueueing_thread_id(LLDB_INVALID_THREAD_ID), m_enqueueing_thread_id(LLDB_INVALID_THREAD_ID),
m_enqueueing_queue_id(LLDB_INVALID_QUEUE_ID), m_enqueueing_queue_id(LLDB_INVALID_QUEUE_ID),
m_target_queue_id(LLDB_INVALID_QUEUE_ID), m_stop_id(0), m_backtrace(), m_target_queue_id(LLDB_INVALID_QUEUE_ID), m_stop_id(0), m_backtrace(),
m_thread_label(), m_queue_label(), m_target_queue_label() { m_thread_label(), m_queue_label(), m_target_queue_label() {
m_queue_wp = queue_sp; m_queue_wp = queue_sp;
m_process_wp = process_sp; m_process_wp = process_sp;
} }
QueueItem::~QueueItem() {} QueueItem::~QueueItem() = default;
QueueItemKind QueueItem::GetKind() { QueueItemKind QueueItem::GetKind() {
FetchEntireItem(); FetchEntireItem();
return m_kind; return m_kind;
} }
void QueueItem::SetKind(QueueItemKind item_kind) { m_kind = item_kind; } void QueueItem::SetKind(QueueItemKind item_kind) { m_kind = item_kind; }
▲ Show 20 Lines • Show All 68 Lines • Show Last 20 Lines

lldb/source/Target/StructuredDataPlugin.cpp

Show All 17 Lines
namespace { namespace {
class CommandStructuredData : public CommandObjectMultiword { class CommandStructuredData : public CommandObjectMultiword {
public: public:
CommandStructuredData(CommandInterpreter &interpreter) CommandStructuredData(CommandInterpreter &interpreter)
: CommandObjectMultiword(interpreter, "structured-data", : CommandObjectMultiword(interpreter, "structured-data",
"Parent for per-plugin structured data commands", "Parent for per-plugin structured data commands",
"plugin structured-data <plugin>") {} "plugin structured-data <plugin>") {}
~CommandStructuredData() override {} ~CommandStructuredData() override = default;
}; };
} }
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() = default;
bool StructuredDataPlugin::GetEnabled(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 {
Show All 26 Lines

lldb/source/Target/ThreadPlanBase.cpp

Show All 37 Lines
#else #else
ThreadPlanTracerSP new_tracer_sp(new ThreadPlanTracer(m_thread)); ThreadPlanTracerSP new_tracer_sp(new ThreadPlanTracer(m_thread));
#endif #endif
new_tracer_sp->EnableTracing(thread.GetTraceEnabledState()); new_tracer_sp->EnableTracing(thread.GetTraceEnabledState());
SetThreadPlanTracer(new_tracer_sp); SetThreadPlanTracer(new_tracer_sp);
SetIsMasterPlan(true); SetIsMasterPlan(true);
} }
ThreadPlanBase::~ThreadPlanBase() {} ThreadPlanBase::~ThreadPlanBase() = default;
void ThreadPlanBase::GetDescription(Stream *s, lldb::DescriptionLevel level) { void ThreadPlanBase::GetDescription(Stream *s, lldb::DescriptionLevel level) {
s->Printf("Base thread plan."); s->Printf("Base thread plan.");
} }
bool ThreadPlanBase::ValidatePlan(Stream *error) { return true; } bool ThreadPlanBase::ValidatePlan(Stream *error) { return true; }
bool ThreadPlanBase::DoPlanExplainsStop(Event *event_ptr) { bool ThreadPlanBase::DoPlanExplainsStop(Event *event_ptr) {
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Target/ThreadPlanCallUserExpression.cpp

Show All 37 LinesThreadPlanCallUserExpression::ThreadPlanCallUserExpression(
: ThreadPlanCallFunction(thread, function, CompilerType(), args, options), : ThreadPlanCallFunction(thread, function, CompilerType(), args, options),
m_user_expression_sp(user_expression_sp) { m_user_expression_sp(user_expression_sp) {
// User expressions are generally "User generated" so we should set them up // User expressions are generally "User generated" so we should set them up
// to stop when done. // to stop when done.
SetIsMasterPlan(true); SetIsMasterPlan(true);
SetOkayToDiscard(false); SetOkayToDiscard(false);
} }
ThreadPlanCallUserExpression::~ThreadPlanCallUserExpression() {} ThreadPlanCallUserExpression::~ThreadPlanCallUserExpression() = default;
void ThreadPlanCallUserExpression::GetDescription( void ThreadPlanCallUserExpression::GetDescription(
Stream *s, lldb::DescriptionLevel level) { Stream *s, lldb::DescriptionLevel level) {
if (level == eDescriptionLevelBrief) if (level == eDescriptionLevelBrief)
s->Printf("User Expression thread plan"); s->Printf("User Expression thread plan");
else else
ThreadPlanCallFunction::GetDescription(s, level); ThreadPlanCallFunction::GetDescription(s, level);
} }
▲ Show 20 Lines • Show All 63 Lines • Show Last 20 Lines

lldb/source/Target/ThreadPlanStepOverBreakpoint.cpp

Show All 30 Lines
{ {
m_breakpoint_addr = thread.GetRegisterContext()->GetPC(); m_breakpoint_addr = thread.GetRegisterContext()->GetPC();
m_breakpoint_site_id = m_breakpoint_site_id =
thread.GetProcess()->GetBreakpointSiteList().FindIDByAddress( thread.GetProcess()->GetBreakpointSiteList().FindIDByAddress(
m_breakpoint_addr); m_breakpoint_addr);
} }
ThreadPlanStepOverBreakpoint::~ThreadPlanStepOverBreakpoint() {} ThreadPlanStepOverBreakpoint::~ThreadPlanStepOverBreakpoint() = default;
void ThreadPlanStepOverBreakpoint::GetDescription( void ThreadPlanStepOverBreakpoint::GetDescription(
Stream *s, lldb::DescriptionLevel level) { Stream *s, lldb::DescriptionLevel level) {
s->Printf("Single stepping past breakpoint site %" PRIu64 " at 0x%" PRIx64, s->Printf("Single stepping past breakpoint site %" PRIu64 " at 0x%" PRIx64,
m_breakpoint_site_id, (uint64_t)m_breakpoint_addr); m_breakpoint_site_id, (uint64_t)m_breakpoint_addr);
} }
bool ThreadPlanStepOverBreakpoint::ValidatePlan(Stream *error) { return true; } bool ThreadPlanStepOverBreakpoint::ValidatePlan(Stream *error) { return true; }
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Utility/ArchSpec.cpp

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
return &entries[i]; return &entries[i];
} }
return nullptr; return nullptr;
} }
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// Constructors and destructors. // Constructors and destructors.
ArchSpec::ArchSpec() {} ArchSpec::ArchSpec() = default;
ArchSpec::ArchSpec(const char *triple_cstr) { ArchSpec::ArchSpec(const char *triple_cstr) {
if (triple_cstr) if (triple_cstr)
SetTriple(triple_cstr); SetTriple(triple_cstr);
} }
ArchSpec::ArchSpec(llvm::StringRef triple_str) { SetTriple(triple_str); } ArchSpec::ArchSpec(llvm::StringRef triple_str) { SetTriple(triple_str); }
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Utility/Args.cpp

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
m_entries.emplace_back(entry.ref(), entry.quote); m_entries.emplace_back(entry.ref(), entry.quote);
m_argv.push_back(m_entries.back().data()); m_argv.push_back(m_entries.back().data());
} }
m_argv.push_back(nullptr); m_argv.push_back(nullptr);
return *this; return *this;
} }
// Destructor // Destructor
Args::~Args() {} Args::~Args() = default;
void Args::Dump(Stream &s, const char *label_name) const { void Args::Dump(Stream &s, const char *label_name) const {
if (!label_name) if (!label_name)
return; return;
int i = 0; int i = 0;
for (auto &entry : m_entries) { for (auto &entry : m_entries) {
s.Indent(); s.Indent();
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Utility/DataBufferLLVM.cpp

Show All 15 Lines
DataBufferLLVM::DataBufferLLVM( DataBufferLLVM::DataBufferLLVM(
std::unique_ptr<llvm::WritableMemoryBuffer> MemBuffer) std::unique_ptr<llvm::WritableMemoryBuffer> MemBuffer)
: Buffer(std::move(MemBuffer)) { : Buffer(std::move(MemBuffer)) {
assert(Buffer != nullptr && assert(Buffer != nullptr &&
"Cannot construct a DataBufferLLVM with a null buffer"); "Cannot construct a DataBufferLLVM with a null buffer");
} }
DataBufferLLVM::~DataBufferLLVM() {} DataBufferLLVM::~DataBufferLLVM() = default;
uint8_t *DataBufferLLVM::GetBytes() { uint8_t *DataBufferLLVM::GetBytes() {
return reinterpret_cast<uint8_t *>(Buffer->getBufferStart()); return reinterpret_cast<uint8_t *>(Buffer->getBufferStart());
} }
const uint8_t *DataBufferLLVM::GetBytes() const { const uint8_t *DataBufferLLVM::GetBytes() const {
return reinterpret_cast<const uint8_t *>(Buffer->getBufferStart()); return reinterpret_cast<const uint8_t *>(Buffer->getBufferStart());
} }
lldb::offset_t DataBufferLLVM::GetByteSize() const { lldb::offset_t DataBufferLLVM::GetByteSize() const {
return Buffer->getBufferSize(); return Buffer->getBufferSize();
} }

lldb/source/Utility/Event.cpp

Show First 20 Lines • Show All 91 Lines • ▼ Show 20 Lines
: EventData(), m_process_sp(), m_object_sp(), m_plugin_sp() {} : EventData(), m_process_sp(), m_object_sp(), m_plugin_sp() {}
EventDataStructuredData::EventDataStructuredData( EventDataStructuredData::EventDataStructuredData(
const ProcessSP &process_sp, const StructuredData::ObjectSP &object_sp, const ProcessSP &process_sp, const StructuredData::ObjectSP &object_sp,
const lldb::StructuredDataPluginSP &plugin_sp) const lldb::StructuredDataPluginSP &plugin_sp)
: EventData(), m_process_sp(process_sp), m_object_sp(object_sp), : 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() = default;
// EventDataStructuredData member functions // EventDataStructuredData member functions
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 {
▲ Show 20 Lines • Show All 79 Lines • Show Last 20 Lines

lldb/source/Utility/GDBRemote.cpp

Show All 18 Lines
using namespace llvm; using namespace llvm;
StreamGDBRemote::StreamGDBRemote() : StreamString() {} StreamGDBRemote::StreamGDBRemote() : StreamString() {}
StreamGDBRemote::StreamGDBRemote(uint32_t flags, uint32_t addr_size, StreamGDBRemote::StreamGDBRemote(uint32_t flags, uint32_t addr_size,
ByteOrder byte_order) ByteOrder byte_order)
: StreamString(flags, addr_size, byte_order) {} : StreamString(flags, addr_size, byte_order) {}
StreamGDBRemote::~StreamGDBRemote() {} StreamGDBRemote::~StreamGDBRemote() = default;
int StreamGDBRemote::PutEscapedBytes(const void *s, size_t src_len) { int StreamGDBRemote::PutEscapedBytes(const void *s, size_t src_len) {
int bytes_written = 0; int bytes_written = 0;
const uint8_t *src = static_cast<const uint8_t *>(s); const uint8_t *src = static_cast<const uint8_t *>(s);
bool binary_is_set = m_flags.Test(eBinary); bool binary_is_set = m_flags.Test(eBinary);
m_flags.Clear(eBinary); m_flags.Clear(eBinary);
while (src_len) { while (src_len) {
uint8_t byte = *src; uint8_t byte = *src;
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Utility/Stream.cpp

Show All 26 LinesStream::Stream(uint32_t flags, uint32_t addr_size, ByteOrder byte_order,
: m_flags(flags), m_addr_size(addr_size), m_byte_order(byte_order), : m_flags(flags), m_addr_size(addr_size), m_byte_order(byte_order),
m_indent_level(0), m_forwarder(*this, colors) {} m_indent_level(0), m_forwarder(*this, colors) {}
Stream::Stream(bool colors) Stream::Stream(bool colors)
: m_flags(0), m_byte_order(endian::InlHostByteOrder()), : m_flags(0), m_byte_order(endian::InlHostByteOrder()),
m_forwarder(*this, colors) {} m_forwarder(*this, colors) {}
// Destructor // Destructor
Stream::~Stream() {} Stream::~Stream() = default;
ByteOrder Stream::SetByteOrder(ByteOrder byte_order) { ByteOrder Stream::SetByteOrder(ByteOrder byte_order) {
ByteOrder old_byte_order = m_byte_order; ByteOrder old_byte_order = m_byte_order;
m_byte_order = byte_order; m_byte_order = byte_order;
return old_byte_order; return old_byte_order;
} }
// Put an offset "uval" out to the stream using the printf format in "format". // Put an offset "uval" out to the stream using the printf format in "format".
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Utility/StreamString.cpp

Show All 11 Lines
using namespace lldb_private; using namespace lldb_private;
StreamString::StreamString() : Stream(0, 4, eByteOrderBig) {} StreamString::StreamString() : Stream(0, 4, eByteOrderBig) {}
StreamString::StreamString(uint32_t flags, uint32_t addr_size, StreamString::StreamString(uint32_t flags, uint32_t addr_size,
ByteOrder byte_order) ByteOrder byte_order)
: Stream(flags, addr_size, byte_order), m_packet() {} : Stream(flags, addr_size, byte_order), m_packet() {}
StreamString::~StreamString() {} StreamString::~StreamString() = default;
void StreamString::Flush() { void StreamString::Flush() {
// Nothing to do when flushing a buffer based stream... // Nothing to do when flushing a buffer based stream...
} }
size_t StreamString::WriteImpl(const void *s, size_t length) { size_t StreamString::WriteImpl(const void *s, size_t length) {
m_packet.append(static_cast<const char *>(s), length); m_packet.append(static_cast<const char *>(s), length);
return length; return length;
Show All 38 Lines

lldb/source/Utility/StringExtractor.cpp

Show All 34 Lines
StringExtractor::StringExtractor(const char *packet_cstr) StringExtractor::StringExtractor(const char *packet_cstr)
: m_packet(), m_index(0) { : m_packet(), m_index(0) {
if (packet_cstr) if (packet_cstr)
m_packet.assign(packet_cstr); m_packet.assign(packet_cstr);
} }
// Destructor // Destructor
StringExtractor::~StringExtractor() {} StringExtractor::~StringExtractor() = default;
char StringExtractor::GetChar(char fail_value) { char StringExtractor::GetChar(char fail_value) {
if (m_index < m_packet.size()) { if (m_index < m_packet.size()) {
char ch = m_packet[m_index]; char ch = m_packet[m_index];
++m_index; ++m_index;
return ch; return ch;
} }
m_index = UINT64_MAX; m_index = UINT64_MAX;
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Utility/StringList.cpp

Show All 27 Lines
StringList::StringList(const char **strv, int strc) : m_strings() { StringList::StringList(const char **strv, int strc) : m_strings() {
for (int i = 0; i < strc; ++i) { for (int i = 0; i < strc; ++i) {
if (strv[i]) if (strv[i])
m_strings.push_back(strv[i]); m_strings.push_back(strv[i]);
} }
} }
StringList::~StringList() {} StringList::~StringList() = default;
void StringList::AppendString(const char *str) { void StringList::AppendString(const char *str) {
if (str) if (str)
m_strings.push_back(str); m_strings.push_back(str);
} }
void StringList::AppendString(const std::string &s) { m_strings.push_back(s); } void StringList::AppendString(const std::string &s) { m_strings.push_back(s); }
▲ Show 20 Lines • Show All 91 Lines • Show Last 20 Lines

lldb/source/Utility/TildeExpressionResolver.cpp

Show All 21 Lines
#endif #endif
using namespace lldb_private; using namespace lldb_private;
using namespace llvm; using namespace llvm;
namespace fs = llvm::sys::fs; namespace fs = llvm::sys::fs;
namespace path = llvm::sys::path; namespace path = llvm::sys::path;
TildeExpressionResolver::~TildeExpressionResolver() {} TildeExpressionResolver::~TildeExpressionResolver() = default;
bool StandardTildeExpressionResolver::ResolveExact( bool StandardTildeExpressionResolver::ResolveExact(
StringRef Expr, SmallVectorImpl<char> &Output) { StringRef Expr, SmallVectorImpl<char> &Output) {
// We expect the tilde expression to be ONLY the expression itself, and // We expect the tilde expression to be ONLY the expression itself, and
// contain no separators. // contain no separators.
assert(!llvm::any_of(Expr, [](char c) { return path::is_separator(c); })); assert(!llvm::any_of(Expr, [](char c) { return path::is_separator(c); }));
assert(Expr.empty() || Expr[0] == '~'); assert(Expr.empty() || Expr[0] == '~');
▲ Show 20 Lines • Show All 56 Lines • Show Last 20 Lines