<rdar://problem/13700260>

<rdar://problem/13723772>

Modified the lldb_private::Thread to work much better with the OperatingSystem plug-ins. Operating system plug-ins can now return have a "core" key/value pair in each thread dictionary for the OperatingSystemPython plug-ins which allows the core threads to be contained with memory threads. It also allows these memory threads to be stepped, resumed, and controlled just as if they were the actual backing threads themselves.

A few things are introduced:
- lldb_private::Thread now has a GetProtocolID() method which returns the thread protocol ID for a given thread. The protocol ID (Thread::GetProtocolID()) is usually the same as the thread id (Thread::GetID()), but it can differ when a memory thread has its own id, but is backed by an actual API thread.
- Cleaned up the Thread::WillResume() code to do the mandatory parts in Thread::ShouldResume(), and let the thread subclasses override the Thread::WillResume() which is now just a notification.
- Cleaned up ClearStackFrames() implementations so that fewer thread subclasses needed to override them
- Changed the POSIXThread class a bit since it overrode Thread::WillResume(). It is doing the wrong thing by calling "Thread::SetResumeState()" on its own, this shouldn't be done by thread subclasses, but the current code might rely on it so I left it in with a TODO comment with an explanation.

llvm-svn: 180886

1 files changed, 114 insertions, 0 deletions

diff --git a/lldb/source/Plugins/Process/Utility/RegisterContextThreadMemory.h b/lldb/source/Plugins/Process/Utility/RegisterContextThreadMemory.h
new file mode 100644
index 00000000000..8d7a4b622fe
--- /dev/null
+++ b/lldb/source/Plugins/Process/Utility/RegisterContextThreadMemory.h
@@ -0,0 +1,114 @@
+//===-- RegisterContextThreadMemory.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_RegisterContextThreadMemory_h_
+#define lldb_RegisterContextThreadMemory_h_
+
+#include <vector>
+
+#include "lldb/lldb-private.h"
+#include "lldb/Target/RegisterContext.h"
+#include "lldb/Symbol/SymbolContext.h"
+
+namespace lldb_private {
+    
+class RegisterContextThreadMemory : public lldb_private::RegisterContext
+{
+public:
+    RegisterContextThreadMemory (Thread &thread,
+                                 lldb::addr_t register_data_addr);
+    
+    virtual ~RegisterContextThreadMemory();
+    //------------------------------------------------------------------
+    // Subclasses must override these functions
+    //------------------------------------------------------------------
+    virtual void
+    InvalidateAllRegisters ();
+    
+    virtual size_t
+    GetRegisterCount ();
+    
+    virtual const RegisterInfo *
+    GetRegisterInfoAtIndex (size_t reg);
+    
+    virtual size_t
+    GetRegisterSetCount ();
+    
+    virtual const RegisterSet *
+    GetRegisterSet (size_t reg_set);
+    
+    virtual bool
+    ReadRegister (const RegisterInfo *reg_info, RegisterValue &reg_value);
+    
+    virtual bool
+    WriteRegister (const RegisterInfo *reg_info, const RegisterValue &reg_value);
+    
+    // These two functions are used to implement "push" and "pop" of register states.  They are used primarily
+    // for expression evaluation, where we need to push a new state (storing the old one in data_sp) and then
+    // restoring the original state by passing the data_sp we got from ReadAllRegisters to WriteAllRegisterValues.
+    // ReadAllRegisters will do what is necessary to return a coherent set of register values for this thread, which
+    // may mean e.g. interrupting a thread that is sitting in a kernel trap.  That is a somewhat disruptive operation,
+    // so these API's should only be used when this behavior is needed.
+    
+    virtual bool
+    ReadAllRegisterValues (lldb::DataBufferSP &data_sp);
+    
+    virtual bool
+    WriteAllRegisterValues (const lldb::DataBufferSP &data_sp);
+    
+    bool
+    CopyFromRegisterContext (lldb::RegisterContextSP context);
+    
+    virtual uint32_t
+    ConvertRegisterKindToRegisterNumber (uint32_t kind, uint32_t num);
+    
+    //------------------------------------------------------------------
+    // Subclasses can override these functions if desired
+    //------------------------------------------------------------------
+    virtual uint32_t
+    NumSupportedHardwareBreakpoints ();
+    
+    virtual uint32_t
+    SetHardwareBreakpoint (lldb::addr_t addr, size_t size);
+    
+    virtual bool
+    ClearHardwareBreakpoint (uint32_t hw_idx);
+    
+    virtual uint32_t
+    NumSupportedHardwareWatchpoints ();
+    
+    virtual uint32_t
+    SetHardwareWatchpoint (lldb::addr_t addr, size_t size, bool read, bool write);
+    
+    virtual bool
+    ClearHardwareWatchpoint (uint32_t hw_index);
+    
+    virtual bool
+    HardwareSingleStep (bool enable);
+    
+    virtual Error
+    ReadRegisterValueFromMemory (const lldb_private::RegisterInfo *reg_info, lldb::addr_t src_addr, uint32_t src_len, RegisterValue &reg_value);
+    
+    virtual Error
+    WriteRegisterValueToMemory (const lldb_private::RegisterInfo *reg_info, lldb::addr_t dst_addr, uint32_t dst_len, const RegisterValue &reg_value);
+    
+protected:
+    void
+    UpdateRegisterContext ();
+    
+    lldb::ThreadWP m_thread_wp;
+    lldb::RegisterContextSP m_reg_ctx_sp;
+    lldb::addr_t m_register_data_addr;
+    uint32_t m_stop_id;
+private:
+    DISALLOW_COPY_AND_ASSIGN (RegisterContextThreadMemory);
+};
+} // namespace lldb_private
+
+#endif  // lldb_RegisterContextThreadMemory_h_