diff options
Diffstat (limited to 'include/lldb')
35 files changed, 849 insertions, 163 deletions
diff --git a/include/lldb/API/SBFrame.h b/include/lldb/API/SBFrame.h index 2ca9e062490d..3177b0cc5a69 100644 --- a/include/lldb/API/SBFrame.h +++ b/include/lldb/API/SBFrame.h @@ -90,6 +90,10 @@ public: /// See also IsInlined(). const char * GetFunctionName(); + + // Get an appropriate function name for this frame that is suitable for display to a user + const char * + GetDisplayFunctionName (); const char * GetFunctionName() const; diff --git a/include/lldb/API/SBFunction.h b/include/lldb/API/SBFunction.h index 7d578393eb2c..86cfeb49bb58 100644 --- a/include/lldb/API/SBFunction.h +++ b/include/lldb/API/SBFunction.h @@ -36,6 +36,9 @@ public: GetName() const; const char * + GetDisplayName() const; + + const char * GetMangledName () const; lldb::SBInstructionList diff --git a/include/lldb/API/SBPlatform.h b/include/lldb/API/SBPlatform.h index db4a754103ca..80ad1c06e868 100644 --- a/include/lldb/API/SBPlatform.h +++ b/include/lldb/API/SBPlatform.h @@ -189,6 +189,9 @@ namespace lldb { SBError SetFilePermissions (const char *path, uint32_t file_permissions); + SBUnixSignals + GetUnixSignals() const; + protected: friend class SBDebugger; diff --git a/include/lldb/API/SBSymbol.h b/include/lldb/API/SBSymbol.h index 3d259a2c20c6..5acebe975261 100644 --- a/include/lldb/API/SBSymbol.h +++ b/include/lldb/API/SBSymbol.h @@ -38,6 +38,9 @@ public: GetName() const; const char * + GetDisplayName() const; + + const char * GetMangledName () const; lldb::SBInstructionList diff --git a/include/lldb/API/SBTarget.h b/include/lldb/API/SBTarget.h index dcca4e7b3a19..2ca0b124ce0a 100644 --- a/include/lldb/API/SBTarget.h +++ b/include/lldb/API/SBTarget.h @@ -769,6 +769,9 @@ public: GetDescription (lldb::SBStream &description, lldb::DescriptionLevel description_level); lldb::SBValue + EvaluateExpression (const char *expr); + + lldb::SBValue EvaluateExpression (const char *expr, const SBExpressionOptions &options); lldb::addr_t diff --git a/include/lldb/API/SBUnixSignals.h b/include/lldb/API/SBUnixSignals.h index 9eae30739bb8..ae48b63e1a2f 100644 --- a/include/lldb/API/SBUnixSignals.h +++ b/include/lldb/API/SBUnixSignals.h @@ -65,17 +65,20 @@ public: protected: friend class SBProcess; + friend class SBPlatform; - SBUnixSignals (lldb::ProcessSP &process_sp); + SBUnixSignals(lldb::ProcessSP &process_sp); - lldb::ProcessSP + SBUnixSignals(lldb::PlatformSP &platform_sp); + + lldb::UnixSignalsSP GetSP() const; void - SetSP (const lldb::ProcessSP &process_sp); + SetSP(const lldb::UnixSignalsSP &signals_sp); private: - lldb::ProcessWP m_opaque_wp; + lldb::UnixSignalsWP m_opaque_wp; }; diff --git a/include/lldb/Core/Connection.h b/include/lldb/Core/Connection.h index c354519a222e..121395c0b23c 100644 --- a/include/lldb/Core/Connection.h +++ b/include/lldb/Core/Connection.h @@ -187,6 +187,20 @@ public: virtual bool InterruptRead() = 0; + //------------------------------------------------------------------ + /// Returns the underlying IOObject used by the Connection. + /// + /// The IOObject can be used to wait for data to become available + /// on the connection. If the Connection does not use IOObjects (and + /// hence does not support waiting) this function should return a + /// null pointer. + /// + /// @return + /// The underlying IOObject used for reading. + //------------------------------------------------------------------ + virtual lldb::IOObjectSP + GetReadObject() { return lldb::IOObjectSP(); } + private: //------------------------------------------------------------------ // For Connection only diff --git a/include/lldb/Core/Mangled.h b/include/lldb/Core/Mangled.h index a2a2b5591d0f..6d8d8c4a0da7 100644 --- a/include/lldb/Core/Mangled.h +++ b/include/lldb/Core/Mangled.h @@ -182,8 +182,17 @@ public: /// A const reference to the demangled name string object. //---------------------------------------------------------------------- const ConstString& - GetDemangledName () const; + GetDemangledName (lldb::LanguageType language) const; + //---------------------------------------------------------------------- + /// Display demangled name get accessor. + /// + /// @return + /// A const reference to the display demangled name string object. + //---------------------------------------------------------------------- + ConstString + GetDisplayDemangledName (lldb::LanguageType language) const; + void SetDemangledName (const ConstString &name) { @@ -231,8 +240,8 @@ public: /// object has a valid name of that kind, else a const reference to the /// other name is returned. //---------------------------------------------------------------------- - const ConstString& - GetName (NamePreference preference = ePreferDemangled) const; + ConstString + GetName (lldb::LanguageType language, NamePreference preference = ePreferDemangled) const; //---------------------------------------------------------------------- /// Check if "name" matches either the mangled or demangled name. @@ -244,15 +253,15 @@ public: /// \b True if \a name matches either name, \b false otherwise. //---------------------------------------------------------------------- bool - NameMatches (const ConstString &name) const + NameMatches (const ConstString &name, lldb::LanguageType language) const { if (m_mangled == name) return true; - return GetDemangledName () == name; + return GetDemangledName (language) == name; } bool - NameMatches (const RegularExpression& regex) const; + NameMatches (const RegularExpression& regex, lldb::LanguageType language) const; //---------------------------------------------------------------------- /// Get the memory cost of this object. diff --git a/include/lldb/Core/StructuredData.h b/include/lldb/Core/StructuredData.h index 8acfa310deac..7da29e48299d 100644 --- a/include/lldb/Core/StructuredData.h +++ b/include/lldb/Core/StructuredData.h @@ -238,14 +238,15 @@ public: { } - void + bool ForEach (std::function <bool(Object* object)> const &foreach_callback) const { for (const auto &object_sp : m_items) { if (foreach_callback(object_sp.get()) == false) - break; + return false; } + return true; } diff --git a/include/lldb/DataFormatters/CXXFormatterFunctions.h b/include/lldb/DataFormatters/CXXFormatterFunctions.h index 9b1a02ca0a5c..a175e1a4d164 100644 --- a/include/lldb/DataFormatters/CXXFormatterFunctions.h +++ b/include/lldb/DataFormatters/CXXFormatterFunctions.h @@ -18,6 +18,7 @@ #include "lldb/Core/ConstString.h" #include "lldb/DataFormatters/FormatClasses.h" #include "lldb/DataFormatters/TypeSynthetic.h" +#include "lldb/DataFormatters/VectorType.h" #include "lldb/Target/ExecutionContext.h" #include "lldb/Target/ObjCLanguageRuntime.h" #include "lldb/Target/Target.h" diff --git a/include/lldb/DataFormatters/VectorType.h b/include/lldb/DataFormatters/VectorType.h index e69de29bb2d1..56d0c6d90ecd 100644 --- a/include/lldb/DataFormatters/VectorType.h +++ b/include/lldb/DataFormatters/VectorType.h @@ -0,0 +1,28 @@ +//===-- VectorType.h ------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef liblldb_VectorType_h_ +#define liblldb_VectorType_h_ + +#include "lldb/lldb-forward.h" + +namespace lldb_private { + namespace formatters + { + bool + VectorTypeSummaryProvider (ValueObject&, + Stream&, + const TypeSummaryOptions&); + + SyntheticChildrenFrontEnd* + VectorTypeSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP); + } // namespace formatters +} // namespace lldb_private + +#endif // liblldb_VectorType_h_ diff --git a/include/lldb/Expression/ClangUserExpression.h b/include/lldb/Expression/ClangUserExpression.h index dbea48148e14..a549f5e8a547 100644 --- a/include/lldb/Expression/ClangUserExpression.h +++ b/include/lldb/Expression/ClangUserExpression.h @@ -30,7 +30,7 @@ #include "lldb/Symbol/TaggedASTType.h" #include "lldb/Target/ExecutionContext.h" -namespace lldb_private +namespace lldb_private { //---------------------------------------------------------------------- @@ -45,7 +45,7 @@ namespace lldb_private class ClangUserExpression : public ClangExpression { public: - + enum { kDefaultTimeout = 500000u }; //------------------------------------------------------------------ /// Constructor @@ -59,7 +59,7 @@ public: /// /// @param[in] language /// If not eLanguageTypeUnknown, a language to use when parsing - /// the expression. Currently restricted to those languages + /// the expression. Currently restricted to those languages /// supported by Clang. /// /// @param[in] desired_type @@ -70,13 +70,13 @@ public: const char *expr_prefix, lldb::LanguageType language, ResultType desired_type); - + //------------------------------------------------------------------ /// Destructor //------------------------------------------------------------------ - virtual + virtual ~ClangUserExpression (); - + //------------------------------------------------------------------ /// Parse the expression /// @@ -92,28 +92,28 @@ public: /// Determines whether interpretation is possible or mandatory. /// /// @param[in] keep_result_in_memory - /// True if the resulting persistent variable should reside in + /// True if the resulting persistent variable should reside in /// target memory, if applicable. /// /// @return /// True on success (no errors); false otherwise. //------------------------------------------------------------------ bool - Parse (Stream &error_stream, + Parse (Stream &error_stream, ExecutionContext &exe_ctx, lldb_private::ExecutionPolicy execution_policy, bool keep_result_in_memory, bool generate_debug_info); - + bool CanInterpret () { return m_can_interpret; } - + bool MatchesContext (ExecutionContext &exe_ctx); - + //------------------------------------------------------------------ /// Execute the parsed expression /// @@ -131,9 +131,9 @@ public: /// This is a shared pointer to this ClangUserExpression. This is /// needed because Execute can push a thread plan that will hold onto /// the ClangUserExpression for an unbounded period of time. So you - /// need to give the thread plan a reference to this object that can + /// need to give the thread plan a reference to this object that can /// keep it alive. - /// + /// /// @param[in] result /// A pointer to direct at the persistent variable in which the /// expression's result is stored. @@ -147,7 +147,7 @@ public: const EvaluateExpressionOptions& options, lldb::ClangUserExpressionSP &shared_ptr_to_me, lldb::ClangExpressionVariableSP &result); - + //------------------------------------------------------------------ /// Apply the side effects of the function to program state. /// @@ -157,7 +157,7 @@ public: /// @param[in] exe_ctx /// The execution context to use when looking up entities that /// are needed for parsing (locations of variables, etc.) - /// + /// /// @param[in] result /// A pointer to direct at the persistent variable in which the /// expression's result is stored. @@ -177,7 +177,7 @@ public: lldb::ClangExpressionVariableSP &result, lldb::addr_t function_stack_bottom = LLDB_INVALID_ADDRESS, lldb::addr_t function_stack_top = LLDB_INVALID_ADDRESS); - + //------------------------------------------------------------------ /// Return the string that the parser should parse. Must be a full /// translation unit. @@ -187,7 +187,7 @@ public: { return m_transformed_text.c_str(); } - + //------------------------------------------------------------------ /// Return the string that the user typed. //------------------------------------------------------------------ @@ -196,7 +196,7 @@ public: { return m_expr_text.c_str(); } - + //------------------------------------------------------------------ /// Return the function name that should be used for executing the /// expression. Text() should contain the definition of this @@ -207,7 +207,7 @@ public: { return "$__lldb_expr"; } - + //------------------------------------------------------------------ /// Return the language that should be used when parsing. To use /// the default, return eLanguageTypeUnknown. @@ -217,7 +217,7 @@ public: { return m_language; } - + //------------------------------------------------------------------ /// Return the object that the parser should use when resolving external /// values. May be NULL if everything should be self-contained. @@ -227,7 +227,7 @@ public: { return m_expr_decl_map.get(); } - + //------------------------------------------------------------------ /// Return the object that the parser should allow to access ASTs. /// May be NULL if the ASTs do not need to be transformed. @@ -238,9 +238,9 @@ public: //------------------------------------------------------------------ clang::ASTConsumer * ASTTransformer (clang::ASTConsumer *passthrough); - + //------------------------------------------------------------------ - /// Return the desired result type of the function, or + /// Return the desired result type of the function, or /// eResultTypeAny if indifferent. //------------------------------------------------------------------ virtual ResultType @@ -248,7 +248,7 @@ public: { return m_desired_type; } - + //------------------------------------------------------------------ /// Return true if validation code should be inserted into the /// expression. @@ -258,7 +258,7 @@ public: { return true; } - + //------------------------------------------------------------------ /// Return true if external variables in the expression should be /// resolved. @@ -302,15 +302,15 @@ public: const char *expr_prefix, lldb::ValueObjectSP &result_valobj_sp, Error &error); - + static const Error::ValueType kNoResult = 0x1001; ///< ValueObject::GetError() returns this if there is no result from the expression. private: //------------------------------------------------------------------ /// Populate m_in_cplusplus_method and m_in_objectivec_method based on the environment. //------------------------------------------------------------------ - + void - ScanContext (ExecutionContext &exe_ctx, + ScanContext (ExecutionContext &exe_ctx, lldb_private::Error &err); bool @@ -319,21 +319,21 @@ private: lldb::addr_t &struct_address, lldb::addr_t &object_ptr, lldb::addr_t &cmd_ptr); - + void InstallContext (ExecutionContext &exe_ctx); - + bool LockAndCheckContext (ExecutionContext &exe_ctx, lldb::TargetSP &target_sp, lldb::ProcessSP &process_sp, lldb::StackFrameSP &frame_sp); - + lldb::ProcessWP m_process_wp; ///< The process used as the context for the expression. Address m_address; ///< The address the process is stopped in. lldb::addr_t m_stack_frame_bottom; ///< The bottom of the allocated stack frame. lldb::addr_t m_stack_frame_top; ///< The top of the allocated stack frame. - + std::string m_expr_text; ///< The text of the expression, as typed by the user std::string m_expr_prefix; ///< The text of the translation-level definitions, as provided by the user lldb::LanguageType m_language; ///< The language to use when parsing (eLanguageTypeUnknown means use defaults) @@ -341,7 +341,7 @@ private: bool m_allow_objc; ///< True if the language allows Objective-C. std::string m_transformed_text; ///< The text of the expression, as send to the parser ResultType m_desired_type; ///< The type to coerce the expression's result to. If eResultTypeAny, inferred from the expression. - + std::unique_ptr<ClangExpressionDeclMap> m_expr_decl_map; ///< The map to use when parsing the expression. std::shared_ptr<IRExecutionUnit> m_execution_unit_sp; ///< The execution unit the expression is stored in. std::unique_ptr<Materializer> m_materializer_ap; ///< The materializer to use when running the expression. @@ -354,12 +354,12 @@ private: bool m_needs_object_ptr; ///< True if "this" or "self" must be looked up and passed in. False if the expression doesn't really use them and they can be NULL. bool m_const_object; ///< True if "this" is const. Target *m_target; ///< The target for storing persistent data like types and variables. - + bool m_can_interpret; ///< True if the expression could be evaluated statically; false otherwise. lldb::addr_t m_materialized_address; ///< The address at which the arguments to the expression have been materialized. Materializer::DematerializerSP m_dematerializer_sp; ///< The dematerializer. }; - + } // namespace lldb_private #endif // liblldb_ClangUserExpression_h_ diff --git a/include/lldb/Expression/IRInterpreter.h b/include/lldb/Expression/IRInterpreter.h index 5defa8dd2026..c314bf1099ea 100644 --- a/include/lldb/Expression/IRInterpreter.h +++ b/include/lldb/Expression/IRInterpreter.h @@ -44,7 +44,8 @@ public: static bool CanInterpret (llvm::Module &module, llvm::Function &function, - lldb_private::Error &error); + lldb_private::Error &error, + const bool support_function_calls); static bool Interpret (llvm::Module &module, @@ -53,7 +54,8 @@ public: lldb_private::IRMemoryMap &memory_map, lldb_private::Error &error, lldb::addr_t stack_frame_bottom, - lldb::addr_t stack_frame_top); + lldb::addr_t stack_frame_top, + lldb_private::ExecutionContext &exe_ctx); private: static bool diff --git a/include/lldb/Expression/IRMemoryMap.h b/include/lldb/Expression/IRMemoryMap.h index 0da8384c8e63..80add46ef0da 100644 --- a/include/lldb/Expression/IRMemoryMap.h +++ b/include/lldb/Expression/IRMemoryMap.h @@ -60,7 +60,7 @@ public: void ReadMemory (uint8_t *bytes, lldb::addr_t process_address, size_t size, Error &error); void ReadScalarFromMemory (Scalar &scalar, lldb::addr_t process_address, size_t size, Error &error); void ReadPointerFromMemory (lldb::addr_t *address, lldb::addr_t process_address, Error &error); - + bool GetAllocSize(lldb::addr_t address, size_t &size); void GetMemoryData (DataExtractor &extractor, lldb::addr_t process_address, size_t size, Error &error); lldb::ByteOrder GetByteOrder(); diff --git a/include/lldb/Host/Host.h b/include/lldb/Host/Host.h index caf33634057d..235367a7cc5c 100644 --- a/include/lldb/Host/Host.h +++ b/include/lldb/Host/Host.h @@ -244,8 +244,8 @@ public: #endif // !defined(__ANDROID__) && !defined(__ANDROID_NDK__) #endif // defined (__APPLE__) || defined (__linux__) || defined (__FreeBSD__) || defined (__GLIBC__) || defined(__NetBSD__) - static const lldb_private::UnixSignalsSP& - GetUnixSignals (); + static const lldb::UnixSignalsSP & + GetUnixSignals(); static Error LaunchProcess (ProcessLaunchInfo &launch_info); diff --git a/include/lldb/Host/MainLoop.h b/include/lldb/Host/MainLoop.h new file mode 100644 index 000000000000..276538a336b6 --- /dev/null +++ b/include/lldb/Host/MainLoop.h @@ -0,0 +1,27 @@ +//===-- MainLoop.h ----------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef lldb_Host_MainLoop_h_ +#define lldb_Host_MainLoop_h_ + +#ifdef _WIN32 +#include "lldb/Host/MainLoopBase.h" +namespace lldb_private +{ +typedef MainLoopBase MainLoop; +} +#else +#include "lldb/Host/posix/MainLoopPosix.h" +namespace lldb_private +{ +typedef MainLoopPosix MainLoop; +} +#endif + +#endif // lldb_Host_MainLoop_h_ diff --git a/include/lldb/Host/MainLoopBase.h b/include/lldb/Host/MainLoopBase.h new file mode 100644 index 000000000000..bff2ce78110d --- /dev/null +++ b/include/lldb/Host/MainLoopBase.h @@ -0,0 +1,94 @@ +//===-- MainLoopBase.h ------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef lldb_Host_posix_MainLoopBase_h_ +#define lldb_Host_posix_MainLoopBase_h_ + +#include <functional> + +#include "llvm/Support/ErrorHandling.h" + +#include "lldb/Core/Error.h" +#include "lldb/Host/IOObject.h" + +namespace lldb_private { + +// The purpose of this class is to enable multiplexed processing of data from different sources +// without resorting to multi-threading. Clients can register IOObjects, which will be monitored +// for readability, and when they become ready, the specified callback will be invoked. +// Monitoring for writability is not supported, but can be easily added if needed. +// +// The RegisterReadObject function return a handle, which controls the duration of the monitoring. When +// this handle is destroyed, the callback is deregistered. +// +// This class simply defines the interface common for all platforms, actual implementations are +// platform-specific. +class MainLoopBase +{ +private: + class ReadHandle; + +public: + MainLoopBase() { } + virtual ~MainLoopBase() { } + + typedef std::unique_ptr<ReadHandle> ReadHandleUP; + + typedef std::function<void(MainLoopBase &)> Callback; + + virtual ReadHandleUP + RegisterReadObject(const lldb::IOObjectSP &object_sp, const Callback &callback, Error &error) + { llvm_unreachable("Not implemented"); } + + // Waits for registered events and invoke the proper callbacks. Returns when all callbacks + // deregister themselves or when someone requests termination. + virtual Error + Run() + { llvm_unreachable("Not implemented"); } + + // Requests the exit of the Run() function. + virtual void + RequestTermination() + { llvm_unreachable("Not implemented"); } + +protected: + ReadHandleUP + CreateReadHandle(const lldb::IOObjectSP &object_sp) + { return ReadHandleUP(new ReadHandle(*this, object_sp)); } + + virtual void + UnregisterReadObject(const lldb::IOObjectSP &object_sp) + { llvm_unreachable("Not implemented"); } + +private: + class ReadHandle + { + public: + ~ReadHandle() { m_mainloop.UnregisterReadObject(m_object_sp); } + + private: + ReadHandle(MainLoopBase &mainloop, const lldb::IOObjectSP &object_sp) + : m_mainloop(mainloop), m_object_sp(object_sp) + { } + + MainLoopBase &m_mainloop; + lldb::IOObjectSP m_object_sp; + + friend class MainLoopBase; + DISALLOW_COPY_AND_ASSIGN(ReadHandle); + }; + +private: + DISALLOW_COPY_AND_ASSIGN(MainLoopBase); +}; + +} // namespace lldb_private + + +#endif // lldb_Host_posix_MainLoopBase_h_ diff --git a/include/lldb/Host/StringConvert.h b/include/lldb/Host/StringConvert.h index 3cc260cf2be1..af5c2a08db87 100644 --- a/include/lldb/Host/StringConvert.h +++ b/include/lldb/Host/StringConvert.h @@ -39,6 +39,8 @@ ToSInt64 (const char *s, int64_t fail_value = 0, int base = 0, bool *success_ptr uint64_t ToUInt64 (const char *s, uint64_t fail_value = 0, int base = 0, bool *success_ptr = nullptr); +double +ToDouble (const char *s, double fail_value = 0.0, bool *success_ptr = nullptr); } // namespace StringConvert } // namespace lldb_private diff --git a/include/lldb/Host/common/NativeProcessProtocol.h b/include/lldb/Host/common/NativeProcessProtocol.h index f6a685aae147..4f0f3a962d32 100644 --- a/include/lldb/Host/common/NativeProcessProtocol.h +++ b/include/lldb/Host/common/NativeProcessProtocol.h @@ -35,8 +35,6 @@ namespace lldb_private friend class SoftwareBreakpoint; public: - static NativeProcessProtocol * - CreateInstance (lldb::pid_t pid); // lldb_private::Host calls should be used to launch a process for debugging, and // then the process should be attached to. When attaching to a process @@ -44,7 +42,6 @@ namespace lldb_private // and then this function should be called. NativeProcessProtocol (lldb::pid_t pid); - public: virtual ~NativeProcessProtocol () { } @@ -297,6 +294,62 @@ namespace lldb_private virtual Error GetFileLoadAddress(const llvm::StringRef& file_name, lldb::addr_t& load_addr) = 0; + //------------------------------------------------------------------ + /// Launch a process for debugging. This method will create an concrete + /// instance of NativeProcessProtocol, based on the host platform. + /// (e.g. NativeProcessLinux on linux, etc.) + /// + /// @param[in] launch_info + /// Information required to launch the process. + /// + /// @param[in] native_delegate + /// The delegate that will receive messages regarding the + /// inferior. Must outlive the NativeProcessProtocol + /// instance. + /// + /// @param[out] process_sp + /// On successful return from the method, this parameter + /// contains the shared pointer to the + /// NativeProcessProtocol that can be used to manipulate + /// the native process. + /// + /// @return + /// An error object indicating if the operation succeeded, + /// and if not, what error occurred. + //------------------------------------------------------------------ + static Error + Launch (ProcessLaunchInfo &launch_info, + NativeDelegate &native_delegate, + NativeProcessProtocolSP &process_sp); + + //------------------------------------------------------------------ + /// Attach to an existing process. This method will create an concrete + /// instance of NativeProcessProtocol, based on the host platform. + /// (e.g. NativeProcessLinux on linux, etc.) + /// + /// @param[in] pid + /// pid of the process locatable + /// + /// @param[in] native_delegate + /// The delegate that will receive messages regarding the + /// inferior. Must outlive the NativeProcessProtocol + /// instance. + /// + /// @param[out] process_sp + /// On successful return from the method, this parameter + /// contains the shared pointer to the + /// NativeProcessProtocol that can be used to manipulate + /// the native process. + /// + /// @return + /// An error object indicating if the operation succeeded, + /// and if not, what error occurred. + //------------------------------------------------------------------ + static Error + Attach (lldb::pid_t pid, + NativeDelegate &native_delegate, + NativeProcessProtocolSP &process_sp); + protected: lldb::pid_t m_pid; diff --git a/include/lldb/Host/posix/ConnectionFileDescriptorPosix.h b/include/lldb/Host/posix/ConnectionFileDescriptorPosix.h index bcbb6014b116..2e0fd705b2a8 100644 --- a/include/lldb/Host/posix/ConnectionFileDescriptorPosix.h +++ b/include/lldb/Host/posix/ConnectionFileDescriptorPosix.h @@ -59,12 +59,7 @@ class ConnectionFileDescriptor : public Connection bool InterruptRead() override; lldb::IOObjectSP - GetReadObject() - { - return m_read_sp; - } - const lldb::IOObjectSP - GetReadObject() const + GetReadObject() override { return m_read_sp; } diff --git a/include/lldb/Host/posix/MainLoopPosix.h b/include/lldb/Host/posix/MainLoopPosix.h new file mode 100644 index 000000000000..9a665ded295e --- /dev/null +++ b/include/lldb/Host/posix/MainLoopPosix.h @@ -0,0 +1,100 @@ +//===-- MainLoopPosix.h -----------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef lldb_Host_posix_MainLoopPosix_h_ +#define lldb_Host_posix_MainLoopPosix_h_ + +#include "lldb/Host/MainLoopBase.h" + +#include "llvm/ADT/DenseMap.h" + +namespace lldb_private { + +// Posix implementation of the MainLoopBase class. It can monitor file descriptors for +// readability using pselect. In addition to the common base, this class provides the ability to +// invoke a given handler when a signal is received. +// +// Since this class is primarily intended to be used for single-threaded processing, it does not +// attempt to perform any internal synchronisation and any concurrent accesses must be protected +// externally. However, it is perfectly legitimate to have more than one instance of this class +// running on separate threads, or even a single thread (with some limitations on signal +// monitoring). +// TODO: Add locking if this class is to be used in a multi-threaded context. +class MainLoopPosix: public MainLoopBase +{ +private: + class SignalHandle; + +public: + typedef std::unique_ptr<SignalHandle> SignalHandleUP; + + ~MainLoopPosix() override; + + ReadHandleUP + RegisterReadObject(const lldb::IOObjectSP &object_sp, const Callback &callback, Error &error) override; + + // Listening for signals from multiple MainLoopPosix instances is perfectly safe as long as they + // don't try to listen for the same signal. The callback function is invoked when the control + // returns to the Run() function, not when the hander is executed. This means that you can + // treat the callback as a normal function and perform things which would not be safe in a + // signal handler. However, since the callback is not invoked synchronously, you cannot use + // this mechanism to handle SIGSEGV and the like. + SignalHandleUP + RegisterSignal(int signo, const Callback &callback, Error &error); + + Error + Run() override; + + // This should only be performed from a callback. Do not attempt to terminate the processing + // from another thread. + // TODO: Add synchronization if we want to be terminated from another thread. + void + RequestTermination() override + { m_terminate_request = true; } + +protected: + void + UnregisterReadObject(const lldb::IOObjectSP &object_sp) override; + + void + UnregisterSignal(int signo); + +private: + class SignalHandle + { + public: + ~SignalHandle() { m_mainloop.UnregisterSignal(m_signo); } + + private: + SignalHandle(MainLoopPosix &mainloop, int signo) : m_mainloop(mainloop), m_signo(signo) { } + + MainLoopPosix &m_mainloop; + int m_signo; + + friend class MainLoopPosix; + DISALLOW_COPY_AND_ASSIGN(SignalHandle); + }; + + struct SignalInfo + { + Callback callback; + struct sigaction old_action; + bool was_blocked : 1; + }; + + llvm::DenseMap<IOObject::WaitableHandle, Callback> m_read_fds; + llvm::DenseMap<int, SignalInfo> m_signals; + bool m_terminate_request : 1; +}; + +} // namespace lldb_private + + +#endif // lldb_Host_posix_MainLoopPosix_h_ + diff --git a/include/lldb/Interpreter/CommandObject.h b/include/lldb/Interpreter/CommandObject.h index c0901d5e3032..023de29c7b6c 100644 --- a/include/lldb/Interpreter/CommandObject.h +++ b/include/lldb/Interpreter/CommandObject.h @@ -161,6 +161,9 @@ public: } void + FormatLongHelpText (Stream &output_strm, const char *long_help); + + void GenerateHelpText (CommandReturnObject &result); virtual void diff --git a/include/lldb/Symbol/Function.h b/include/lldb/Symbol/Function.h index 5954cf520d70..30c8f168e5f1 100644 --- a/include/lldb/Symbol/Function.h +++ b/include/lldb/Symbol/Function.h @@ -123,7 +123,7 @@ public: /// @return /// A const reference to the method name object. //------------------------------------------------------------------ - const ConstString& + ConstString GetName () const; //------------------------------------------------------------------ @@ -240,11 +240,14 @@ public: Dump(Stream *s, bool show_fullpaths) const; void - DumpStopContext (Stream *s) const; + DumpStopContext (Stream *s, lldb::LanguageType language) const; - const ConstString & - GetName () const; + ConstString + GetName (lldb::LanguageType language) const; + ConstString + GetDisplayName (lldb::LanguageType language) const; + //------------------------------------------------------------------ /// Get accessor for the call site declaration information. /// @@ -437,6 +440,8 @@ public: return m_range; } + lldb::LanguageType + GetLanguage() const; //------------------------------------------------------------------ /// Find the file and line number of the source location of the start /// of the function. This will use the declaration if present and fall @@ -524,11 +529,14 @@ public: return m_frame_base; } - const ConstString & - GetName() const - { - return m_mangled.GetName(); - } + ConstString + GetName() const; + + ConstString + GetNameNoArguments () const; + + ConstString + GetDisplayName () const; const Mangled & GetMangled() const diff --git a/include/lldb/Symbol/Symbol.h b/include/lldb/Symbol/Symbol.h index ad11563634ea..f9438b006c4e 100644 --- a/include/lldb/Symbol/Symbol.h +++ b/include/lldb/Symbol/Symbol.h @@ -152,18 +152,28 @@ public: lldb::addr_t ResolveCallableAddress(Target &target) const; - const ConstString & - GetName () const - { - return m_mangled.GetName(); - } + ConstString + GetName () const; + + ConstString + GetNameNoArguments () const; + ConstString + GetDisplayName () const; + uint32_t GetID() const { return m_uid; } + lldb::LanguageType + GetLanguage() const + { + // TODO: See if there is a way to determine the language for a symbol somehow, for now just return our best guess + return m_mangled.GuessLanguage(); + } + void SetID(uint32_t uid) { diff --git a/include/lldb/Symbol/Variable.h b/include/lldb/Symbol/Variable.h index a345bcb8c23a..8d413cac3d7d 100644 --- a/include/lldb/Symbol/Variable.h +++ b/include/lldb/Symbol/Variable.h @@ -55,7 +55,7 @@ public: return m_declaration; } - const ConstString& + ConstString GetName() const; SymbolContextScope * @@ -70,12 +70,7 @@ public: // function that can be called by commands and expression parsers to make // sure we match anything we come across. bool - NameMatches (const ConstString &name) const - { - if (m_name == name) - return true; - return m_mangled.NameMatches (name); - } + NameMatches (const ConstString &name) const; bool NameMatches (const RegularExpression& regex) const; @@ -83,6 +78,9 @@ public: Type * GetType(); + lldb::LanguageType + GetLanguage () const; + lldb::ValueType GetScope() const { diff --git a/include/lldb/Target/ABI.h b/include/lldb/Target/ABI.h index cfd214d28874..89d4f6bdba6c 100644 --- a/include/lldb/Target/ABI.h +++ b/include/lldb/Target/ABI.h @@ -39,10 +39,9 @@ public: }; eType type; /* value of eType */ size_t size; /* size in bytes of this argument */ - union { - lldb::addr_t value; /* literal value */ - uint8_t *data; /* host data pointer */ - }; + + lldb::addr_t value; /* literal value */ + std::unique_ptr<uint8_t[]> data_ap; /* host data pointer */ }; virtual @@ -58,7 +57,7 @@ public: lldb::addr_t returnAddress, llvm::ArrayRef<lldb::addr_t> args) const = 0; - // Prepare trivial call used from ThreadPlanFunctionCallGDB + // Prepare trivial call used from ThreadPlanFunctionCallUsingABI // AD: // . Because i don't want to change other ABI's this is not declared pure virtual. // The dummy implementation will simply fail. Only HexagonABI will currently diff --git a/include/lldb/Target/Platform.h b/include/lldb/Target/Platform.h index 8f89e9b3cf5f..feaac57b128a 100644 --- a/include/lldb/Target/Platform.h +++ b/include/lldb/Target/Platform.h @@ -863,6 +863,12 @@ class ModuleCache; return 1; } + virtual const lldb::UnixSignalsSP & + GetRemoteUnixSignals(); + + const lldb::UnixSignalsSP & + GetUnixSignals(); + //------------------------------------------------------------------ /// Locate a queue name given a thread's qaddr /// @@ -939,65 +945,6 @@ class ModuleCache; virtual const std::vector<ConstString> & GetTrapHandlerSymbolNames (); - //------------------------------------------------------------------ - /// Launch a process for debugging. - /// - /// This differs from Launch in that it returns a NativeProcessProtocol. - /// Currently used by lldb-gdbserver. - /// - /// @param[in] launch_info - /// Information required to launch the process. - /// - /// @param[in] native_delegate - /// The delegate that will receive messages regarding the - /// inferior. Must outlive the NativeProcessProtocol - /// instance. - /// - /// @param[out] process_sp - /// On successful return from the method, this parameter - /// contains the shared pointer to the - /// NativeProcessProtocol that can be used to manipulate - /// the native process. - /// - /// @return - /// An error object indicating if the operation succeeded, - /// and if not, what error occurred. - //------------------------------------------------------------------ - virtual Error - LaunchNativeProcess ( - ProcessLaunchInfo &launch_info, - lldb_private::NativeProcessProtocol::NativeDelegate &native_delegate, - NativeProcessProtocolSP &process_sp); - - //------------------------------------------------------------------ - /// Attach to an existing process on the given platform. - /// - /// This method differs from Attach() in that it returns a - /// NativeProcessProtocol. Currently this is used by lldb-gdbserver. - /// - /// @param[in] pid - /// pid of the process locatable by the platform. - /// - /// @param[in] native_delegate - /// The delegate that will receive messages regarding the - /// inferior. Must outlive the NativeProcessProtocol - /// instance. - /// - /// @param[out] process_sp - /// On successful return from the method, this parameter - /// contains the shared pointer to the - /// NativeProcessProtocol that can be used to manipulate - /// the native process. - /// - /// @return - /// An error object indicating if the operation succeeded, - /// and if not, what error occurred. - //------------------------------------------------------------------ - virtual Error - AttachNativeProcess (lldb::pid_t pid, - lldb_private::NativeProcessProtocol::NativeDelegate &native_delegate, - NativeProcessProtocolSP &process_sp); - protected: bool m_is_host; // Set to true when we are able to actually set the OS version while diff --git a/include/lldb/Target/Process.h b/include/lldb/Target/Process.h index db0f0cfa028b..f75b3cd5683d 100644 --- a/include/lldb/Target/Process.h +++ b/include/lldb/Target/Process.h @@ -30,6 +30,7 @@ #include "lldb/Core/Event.h" #include "lldb/Core/ThreadSafeValue.h" #include "lldb/Core/PluginInterface.h" +#include "lldb/Core/StructuredData.h" #include "lldb/Core/UserSettingsController.h" #include "lldb/Breakpoint/BreakpointSiteList.h" #include "lldb/Host/HostThread.h" @@ -949,7 +950,7 @@ public: /// Construct with a shared pointer to a target, the Process listener, /// and the appropriate UnixSignalsSP for the process. //------------------------------------------------------------------ - Process(Target &target, Listener &listener, const UnixSignalsSP &unix_signals_sp); + Process(Target &target, Listener &listener, const lldb::UnixSignalsSP &unix_signals_sp); //------------------------------------------------------------------ /// Destructor. @@ -1401,10 +1402,10 @@ public: Signal (int signal); void - SetUnixSignals (const UnixSignalsSP &signals_sp); + SetUnixSignals(const lldb::UnixSignalsSP &signals_sp); - UnixSignals & - GetUnixSignals (); + const lldb::UnixSignalsSP & + GetUnixSignals(); //================================================================== // Plug-in Process Control Overrides @@ -1887,6 +1888,37 @@ public: virtual void ModulesDidLoad (ModuleList &module_list); + + //------------------------------------------------------------------ + /// Retrieve the list of shared libraries that are loaded for this process + /// + /// For certain platforms, the time it takes for the DynamicLoader plugin to + /// read all of the shared libraries out of memory over a slow communication + /// channel may be too long. In that instance, the gdb-remote stub may be + /// able to retrieve the necessary information about the solibs out of memory + /// and return a concise summary sufficient for the DynamicLoader plugin. + /// + /// @param [in] image_list_address + /// The address where the table of shared libraries is stored in memory, + /// if that is appropriate for this platform. Else this may be + /// passed as LLDB_INVALID_ADDRESS. + /// + /// @param [in] image_count + /// The number of shared libraries that are present in this process, if + /// that is appropriate for this platofrm Else this may be passed as + /// LLDB_INVALID_ADDRESS. + /// + /// @return + /// A StructureDataSP object which, if non-empty, will contain the + /// information the DynamicLoader needs to get the initial scan of + /// solibs resolved. + //------------------------------------------------------------------ + virtual lldb_private::StructuredData::ObjectSP + GetLoadedDynamicLibrariesInfos (lldb::addr_t image_list_address, lldb::addr_t image_count) + { + return StructuredData::ObjectSP(); + } + protected: void @@ -2439,8 +2471,41 @@ public: /// True if execution of JIT code is possible; false otherwise. //------------------------------------------------------------------ void SetCanJIT (bool can_jit); + + //------------------------------------------------------------------ + /// Determines whether executing function calls using the interpreter + /// is possible for this process. + /// + /// @return + /// True if possible; false otherwise. + //------------------------------------------------------------------ + bool CanInterpretFunctionCalls () + { + return m_can_interpret_function_calls; + } //------------------------------------------------------------------ + /// Sets whether executing function calls using the interpreter + /// is possible for this process. + /// + /// @param[in] can_interpret_function_calls + /// True if possible; false otherwise. + //------------------------------------------------------------------ + void SetCanInterpretFunctionCalls (bool can_interpret_function_calls) + { + m_can_interpret_function_calls = can_interpret_function_calls; + } + + //------------------------------------------------------------------ + /// Sets whether executing code in this process is possible. + /// This could be either through JIT or interpreting. + /// + /// @param[in] can_run_code + /// True if execution of code is possible; false otherwise. + //------------------------------------------------------------------ + void SetCanRunCode (bool can_run_code); + + //------------------------------------------------------------------ /// Actually deallocate memory in the process. /// /// This function will deallocate memory in the process's address @@ -3205,7 +3270,7 @@ protected: lldb::DynamicCheckerFunctionsUP m_dynamic_checkers_ap; ///< The functions used by the expression parser to validate data that expressions use. lldb::OperatingSystemUP m_os_ap; lldb::SystemRuntimeUP m_system_runtime_ap; - UnixSignalsSP m_unix_signals_sp; /// This is the current signal set for this process. + lldb::UnixSignalsSP m_unix_signals_sp; /// This is the current signal set for this process. lldb::ABISP m_abi_sp; lldb::IOHandlerSP m_process_input_reader; Communication m_stdio_communication; @@ -3236,6 +3301,7 @@ protected: lldb::StateType m_last_broadcast_state; /// This helps with the Public event coalescing in ShouldBroadcastEvent. std::map<lldb::addr_t,lldb::addr_t> m_resolved_indirect_addresses; bool m_destroy_in_process; + bool m_can_interpret_function_calls; // Some targets, e.g the OSX kernel, don't support the ability to modify the stack. enum { eCanJITDontKnow= 0, diff --git a/include/lldb/Target/ThreadPlanCallFunction.h b/include/lldb/Target/ThreadPlanCallFunction.h index 12200ab76553..36e4d6e71c79 100644 --- a/include/lldb/Target/ThreadPlanCallFunction.h +++ b/include/lldb/Target/ThreadPlanCallFunction.h @@ -34,6 +34,10 @@ public: llvm::ArrayRef<lldb::addr_t> args, const EvaluateExpressionOptions &options); + ThreadPlanCallFunction(Thread &thread, + const Address &function, + const EvaluateExpressionOptions &options); + virtual ~ThreadPlanCallFunction (); @@ -134,7 +138,8 @@ protected: virtual bool DoPlanExplainsStop (Event *event_ptr); -private: + virtual void + SetReturnValue(); bool ConstructorSetup (Thread &thread, @@ -153,7 +158,7 @@ private: bool BreakpointsExplainStop (); - + bool m_valid; bool m_stop_other_threads; bool m_unwind_on_error; @@ -172,13 +177,14 @@ private: // it's nice to know the real stop reason. // This gets set in DoTakedown. StreamString m_constructor_errors; - ClangASTType m_return_type; lldb::ValueObjectSP m_return_valobj_sp; // If this contains a valid pointer, use the ABI to extract values when complete bool m_takedown_done; // We want to ensure we only do the takedown once. This ensures that. bool m_should_clear_objc_exception_bp; bool m_should_clear_cxx_exception_bp; lldb::addr_t m_stop_address; // This is the address we stopped at. Also set in DoTakedown; +private: + ClangASTType m_return_type; DISALLOW_COPY_AND_ASSIGN (ThreadPlanCallFunction); }; diff --git a/include/lldb/Target/ThreadPlanCallFunctionUsingABI.h b/include/lldb/Target/ThreadPlanCallFunctionUsingABI.h new file mode 100644 index 000000000000..83d78a5dca08 --- /dev/null +++ b/include/lldb/Target/ThreadPlanCallFunctionUsingABI.h @@ -0,0 +1,58 @@ +//===-- ThreadPlanCallFunctionUsingABI.h --------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef liblldb_ThreadPlanCallFunctionUsingABI_h_ +#define liblldb_ThreadPlanCallFunctionUsingABI_h_ + +// C Includes +// C++ Includes +// Other libraries and framework includes +// Project includes +#include "lldb/lldb-private.h" +#include "lldb/Target/ABI.h" +#include "lldb/Target/Thread.h" +#include "lldb/Target/ThreadPlanCallFunction.h" + +#include "llvm/ADT/ArrayRef.h" +#include "llvm/IR/Type.h" + +namespace lldb_private { + +class ThreadPlanCallFunctionUsingABI : public ThreadPlanCallFunction +{ + // Create a thread plan to call a function at the address passed in the "function" + // argument, this function is executed using register manipulation instead of JIT. + // Class derives from ThreadPlanCallFunction and differs by calling a alternative + // ABI interface ABI::PrepareTrivialCall() which provides more detailed information. +public: + ThreadPlanCallFunctionUsingABI (Thread &thread, + const Address &function_address, + llvm::Type &function_prototype, + llvm::Type &return_type, + llvm::ArrayRef<ABI::CallArgument> args, + const EvaluateExpressionOptions &options); + + ~ThreadPlanCallFunctionUsingABI (); + + void + GetDescription (Stream *s, lldb::DescriptionLevel level) override; + +protected: + void + SetReturnValue () override; + + +private: + llvm::Type &m_return_type; + DISALLOW_COPY_AND_ASSIGN (ThreadPlanCallFunctionUsingABI); +}; + +} // namespace lldb_private + +#endif // liblldb_ThreadPlanCallFunctionUsingABI_h_ diff --git a/include/lldb/Target/UnixSignals.h b/include/lldb/Target/UnixSignals.h index f47a90bbf545..76955deabc78 100644 --- a/include/lldb/Target/UnixSignals.h +++ b/include/lldb/Target/UnixSignals.h @@ -26,6 +26,9 @@ namespace lldb_private class UnixSignals { public: + static lldb::UnixSignalsSP + Create(const ArchSpec &arch); + //------------------------------------------------------------------ // Constructors and Destructors //------------------------------------------------------------------ @@ -89,6 +92,12 @@ public: int32_t GetNextSignalNumber (int32_t current_signal) const; + int32_t + GetNumSignals() const; + + int32_t + GetSignalAtIndex(int32_t index) const; + // We assume that the elements of this object are constant once it is constructed, // since a process should never need to add or remove symbols as it runs. So don't // call these functions anywhere but the constructor of your subclass of UnixSignals or in @@ -130,14 +139,18 @@ protected: ~Signal () {} }; - void + virtual void Reset (); typedef std::map <int32_t, Signal> collection; collection m_signals; - DISALLOW_COPY_AND_ASSIGN (UnixSignals); + // GDBRemote signals need to be copyable. + UnixSignals(const UnixSignals &rhs); + + const UnixSignals & + operator=(const UnixSignals &rhs) = delete; }; } // Namespace lldb diff --git a/include/lldb/Utility/JSON.h b/include/lldb/Utility/JSON.h index 45ddb71b5e03..da5e26dbda28 100644 --- a/include/lldb/Utility/JSON.h +++ b/include/lldb/Utility/JSON.h @@ -11,6 +11,7 @@ #define utility_JSON_h_ #include "lldb/Core/Stream.h" +#include "lldb/Utility/StringExtractor.h" #include <inttypes.h> #include <map> @@ -22,6 +23,7 @@ #include "llvm/Support/Casting.h" namespace lldb_private { + class JSONValue { public: @@ -97,8 +99,9 @@ namespace lldb_private { { public: JSONNumber (); - JSONNumber (int64_t i); - + explicit JSONNumber (uint64_t i); + explicit JSONNumber (double d); + JSONNumber (const JSONNumber& s) = delete; JSONNumber& operator = (const JSONNumber& s) = delete; @@ -107,10 +110,19 @@ namespace lldb_private { Write (Stream& s); typedef std::shared_ptr<JSONNumber> SP; - - int64_t + + uint64_t GetData () { return m_data; } - + + double + GetAsDouble() + { + if (m_is_integer) + return (double)m_data; + else + return m_double; + } + static bool classof(const JSONValue *V) { return V->GetKind() == JSONValue::Kind::Number; @@ -120,7 +132,9 @@ namespace lldb_private { ~JSONNumber () = default; private: - int64_t m_data; + bool m_is_integer; + uint64_t m_data; + double m_double; }; class JSONTrue : public JSONValue @@ -271,6 +285,48 @@ namespace lldb_private { Vector m_elements; }; + + + class JSONParser : public StringExtractor + { + public: + enum Token + { + Invalid, + Error, + ObjectStart, + ObjectEnd, + ArrayStart, + ArrayEnd, + Comma, + Colon, + String, + Integer, + Float, + True, + False, + Null, + EndOfFile + }; + + JSONParser (const char *cstr); + + int + GetEscapedChar (bool &was_escaped); + + Token + GetToken (std::string &value); + + JSONValue::SP + ParseJSONValue (); + + protected: + JSONValue::SP + ParseJSONObject (); + + JSONValue::SP + ParseJSONArray (); + }; } #endif // utility_ProcessStructReader_h_ diff --git a/include/lldb/Utility/StringExtractor.h b/include/lldb/Utility/StringExtractor.h new file mode 100644 index 000000000000..0f2dbb166be1 --- /dev/null +++ b/include/lldb/Utility/StringExtractor.h @@ -0,0 +1,176 @@ +//===-- StringExtractor.h ---------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef utility_StringExtractor_h_ +#define utility_StringExtractor_h_ + +// C Includes +// C++ Includes +#include <string> +#include <stdint.h> + +// Other libraries and framework includes +// Project includes + +class StringExtractor +{ +public: + + enum { + BigEndian = 0, + LittleEndian = 1 + }; + //------------------------------------------------------------------ + // Constructors and Destructors + //------------------------------------------------------------------ + StringExtractor(); + StringExtractor(const char *packet_cstr); + StringExtractor(const StringExtractor& rhs); + virtual ~StringExtractor(); + + //------------------------------------------------------------------ + // Operators + //------------------------------------------------------------------ + const StringExtractor& + operator=(const StringExtractor& rhs); + + // Returns true if the file position is still valid for the data + // contained in this string extractor object. + bool + IsGood() const + { + return m_index != UINT64_MAX; + } + + uint64_t + GetFilePos () const + { + return m_index; + } + + void + SetFilePos (uint32_t idx) + { + m_index = idx; + } + + void + Clear () + { + m_packet.clear(); + m_index = 0; + } + + void + SkipSpaces (); + + std::string & + GetStringRef () + { + return m_packet; + } + + const std::string & + GetStringRef () const + { + return m_packet; + } + + bool + Empty() + { + return m_packet.empty(); + } + + size_t + GetBytesLeft () + { + if (m_index < m_packet.size()) + return m_packet.size() - m_index; + return 0; + } + + char + GetChar (char fail_value = '\0'); + + char + PeekChar (char fail_value = '\0') + { + const char *cstr = Peek(); + if (cstr) + return cstr[0]; + return fail_value; + } + + int + DecodeHexU8(); + + uint8_t + GetHexU8 (uint8_t fail_value = 0, bool set_eof_on_fail = true); + + bool + GetNameColonValue (std::string &name, std::string &value); + + int32_t + GetS32 (int32_t fail_value, int base = 0); + + uint32_t + GetU32 (uint32_t fail_value, int base = 0); + + int64_t + GetS64 (int64_t fail_value, int base = 0); + + uint64_t + GetU64 (uint64_t fail_value, int base = 0); + + uint32_t + GetHexMaxU32 (bool little_endian, uint32_t fail_value); + + uint64_t + GetHexMaxU64 (bool little_endian, uint64_t fail_value); + + size_t + GetHexBytes (void *dst, size_t dst_len, uint8_t fail_fill_value); + + size_t + GetHexBytesAvail (void *dst, size_t dst_len); + + uint64_t + GetHexWithFixedSize (uint32_t byte_size, bool little_endian, uint64_t fail_value); + + size_t + GetHexByteString (std::string &str); + + size_t + GetHexByteStringFixedLength (std::string &str, uint32_t nibble_length); + + size_t + GetHexByteStringTerminatedBy (std::string &str, + char terminator); + + const char * + Peek () + { + if (m_index < m_packet.size()) + return m_packet.c_str() + m_index; + return nullptr; + } + +protected: + //------------------------------------------------------------------ + // For StringExtractor only + //------------------------------------------------------------------ + std::string m_packet; // The string in which to extract data. + uint64_t m_index; // When extracting data from a packet, this index + // will march along as things get extracted. If set + // to UINT64_MAX the end of the packet data was + // reached when decoding information +}; + +#endif // utility_StringExtractor_h_ diff --git a/include/lldb/lldb-forward.h b/include/lldb/lldb-forward.h index e0c2ae4b8b8d..da90ac4775ee 100644 --- a/include/lldb/lldb-forward.h +++ b/include/lldb/lldb-forward.h @@ -423,6 +423,8 @@ namespace lldb { #ifndef LLDB_DISABLE_PYTHON typedef std::shared_ptr<lldb_private::ScriptedSyntheticChildren> ScriptedSyntheticChildrenSP; #endif + typedef std::shared_ptr<lldb_private::UnixSignals> UnixSignalsSP; + typedef std::weak_ptr<lldb_private::UnixSignals> UnixSignalsWP; typedef std::shared_ptr<lldb_private::UnwindAssembly> UnwindAssemblySP; typedef std::shared_ptr<lldb_private::UnwindPlan> UnwindPlanSP; typedef lldb_private::SharingPtr<lldb_private::ValueObject> ValueObjectSP; diff --git a/include/lldb/lldb-private-forward.h b/include/lldb/lldb-private-forward.h index 424aa4cc53f4..bcfeb68b0b25 100644 --- a/include/lldb/lldb-private-forward.h +++ b/include/lldb/lldb-private-forward.h @@ -34,7 +34,6 @@ namespace lldb_private typedef std::weak_ptr<lldb_private::NativeProcessProtocol> NativeProcessProtocolWP; typedef std::shared_ptr<lldb_private::NativeRegisterContext> NativeRegisterContextSP; typedef std::shared_ptr<lldb_private::NativeThreadProtocol> NativeThreadProtocolSP; - typedef std::shared_ptr<lldb_private::UnixSignals> UnixSignalsSP; } #endif // #if defined(__cplusplus) |