Clean up NativeRegisterContext

[labath]

Summary

This commit removes the concrete_frame_idx member from
NativeRegisterContext and related functions, which was always set to
zero and never used.

I also change the native thread class to store a NativeRegisterContext
as a unique_ptr (documenting the ownership) and make sure it is always
initialized (most of the code was already blindly dereferencing the
register context pointer, assuming it would always be present -- this
makes its treatment consistent).

(I've checked that x86-linux, arm-linux, mips-linux, and x86-netbsd
build after this, the PPC and SystemZ changes are eyeballed.)

[krytarowski]

The NetBSD part looks fine.

lldb/trunk/include/lldb/Host/common/NativeRegisterContext.h

 class NativeThreadProtocol;
 
 class NativeRegisterContext
     : public std::enable_shared_from_this<NativeRegisterContext> {
 public:
   //------------------------------------------------------------------
   // Constructors and Destructors
   //------------------------------------------------------------------
-  NativeRegisterContext(NativeThreadProtocol &thread,
-                        uint32_t concrete_frame_idx);
+  NativeRegisterContext(NativeThreadProtocol &thread);
 
   virtual ~NativeRegisterContext();
 
   // void
   // InvalidateIfNeeded (bool force);
 
   //------------------------------------------------------------------
   // Subclasses must override these functions
public:
   // }
 
 protected:
   //------------------------------------------------------------------
   // Classes that inherit from RegisterContext can see and modify these
   //------------------------------------------------------------------
   NativeThreadProtocol
       &m_thread; // The thread that this register context belongs to.
-  uint32_t m_concrete_frame_idx; // The concrete frame index for this register
-                                 // context
   // uint32_t m_stop_id;             // The stop ID that any data in this
   // context is valid for
 
 private:
   //------------------------------------------------------------------
   // For RegisterContext only
   //------------------------------------------------------------------
   DISALLOW_COPY_AND_ASSIGN(NativeRegisterContext);
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_NativeRegisterContext_h_

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

public:
   NativeThreadProtocol(NativeProcessProtocol &process, lldb::tid_t tid);
 
   virtual ~NativeThreadProtocol() {}
 
   virtual std::string GetName() = 0;
 
   virtual lldb::StateType GetState() = 0;
 
-  virtual NativeRegisterContextSP GetRegisterContext() = 0;
+  virtual NativeRegisterContext &GetRegisterContext() = 0;
 
   virtual Status ReadRegister(uint32_t reg, RegisterValue &reg_value);
 
   virtual Status WriteRegister(uint32_t reg, const RegisterValue &reg_value);
 
   virtual Status SaveAllRegisters(lldb::DataBufferSP &data_sp);
 
   virtual Status RestoreAllRegisters(lldb::DataBufferSP &data_sp);

lldb/trunk/include/lldb/lldb-private-forward.h

 class NativeThreadProtocol;
 class ResumeActionList;
 class UnixSignals;
 
 // ---------------------------------------------------------------
 // SP/WP decls.
 // ---------------------------------------------------------------
 typedef std::shared_ptr<NativeBreakpoint> NativeBreakpointSP;
-typedef std::shared_ptr<lldb_private::NativeRegisterContext>
-    NativeRegisterContextSP;
 }
 
 #endif // #if defined(__cplusplus)
 #endif // #ifndef LLDB_lldb_private_forward_h_

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

NativeProcessProtocol::GetHardwareDebugSupportInfo() const {
   // get any thread
   NativeThreadProtocol *thread(
       const_cast<NativeProcessProtocol *>(this)->GetThreadAtIndex(0));
   if (!thread) {
     LLDB_LOG(log, "failed to find a thread to grab a NativeRegisterContext!");
     return llvm::None;
   }
 
-  NativeRegisterContextSP reg_ctx_sp(thread->GetRegisterContext());
-  if (!reg_ctx_sp) {
-    LLDB_LOG(
-        log,
-        "failed to get a RegisterContextNativeProcess from the first thread!");
-    return llvm::None;
-  }
-
-  return std::make_pair(reg_ctx_sp->NumSupportedHardwareBreakpoints(),
-                        reg_ctx_sp->NumSupportedHardwareWatchpoints());
+  NativeRegisterContext &reg_ctx = thread->GetRegisterContext();
+  return std::make_pair(reg_ctx.NumSupportedHardwareBreakpoints(),
+                        reg_ctx.NumSupportedHardwareWatchpoints());
 }
 
 Status NativeProcessProtocol::SetWatchpoint(lldb::addr_t addr, size_t size,
                                             uint32_t watch_flags,
                                             bool hardware) {
   // This default implementation assumes setting the watchpoint for
   // the process will require setting the watchpoint for each of the
   // threads.  Furthermore, it will track watchpoints set for the

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

 
 #include "lldb/Host/PosixApi.h"
 #include "lldb/Host/common/NativeProcessProtocol.h"
 #include "lldb/Host/common/NativeThreadProtocol.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
-NativeRegisterContext::NativeRegisterContext(NativeThreadProtocol &thread,
-                                             uint32_t concrete_frame_idx)
-    : m_thread(thread), m_concrete_frame_idx(concrete_frame_idx) {}
+NativeRegisterContext::NativeRegisterContext(NativeThreadProtocol &thread)
+    : m_thread(thread) {}
 
 //----------------------------------------------------------------------
 // Destructor
 //----------------------------------------------------------------------
 NativeRegisterContext::~NativeRegisterContext() {}
 
 // FIXME revisit invalidation, process stop ids, etc.  Right now we don't
 // support caching in NativeRegisterContext.  We can do this later by

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

 using namespace lldb_private;
 
 NativeThreadProtocol::NativeThreadProtocol(NativeProcessProtocol &process,
                                            lldb::tid_t tid)
     : m_process(process), m_tid(tid) {}
 
 Status NativeThreadProtocol::ReadRegister(uint32_t reg,
                                           RegisterValue &reg_value) {
-  NativeRegisterContextSP register_context_sp = GetRegisterContext();
-  if (!register_context_sp)
-    return Status("no register context");
+  NativeRegisterContext &register_context = GetRegisterContext();
 
   const RegisterInfo *const reg_info =
-      register_context_sp->GetRegisterInfoAtIndex(reg);
+      register_context.GetRegisterInfoAtIndex(reg);
   if (!reg_info)
     return Status("no register info for reg num %" PRIu32, reg);
 
-  return register_context_sp->ReadRegister(reg_info, reg_value);
+  return register_context.ReadRegister(reg_info, reg_value);
   ;
 }
 
 Status NativeThreadProtocol::WriteRegister(uint32_t reg,
                                            const RegisterValue &reg_value) {
-  NativeRegisterContextSP register_context_sp = GetRegisterContext();
-  if (!register_context_sp)
-    return Status("no register context");
+  NativeRegisterContext& register_context = GetRegisterContext();
 
   const RegisterInfo *const reg_info =
-      register_context_sp->GetRegisterInfoAtIndex(reg);
+      register_context.GetRegisterInfoAtIndex(reg);
   if (!reg_info)
     return Status("no register info for reg num %" PRIu32, reg);
 
-  return register_context_sp->WriteRegister(reg_info, reg_value);
+  return register_context.WriteRegister(reg_info, reg_value);
 }
 
 Status NativeThreadProtocol::SaveAllRegisters(lldb::DataBufferSP &data_sp) {
-  NativeRegisterContextSP register_context_sp = GetRegisterContext();
-  if (!register_context_sp)
-    return Status("no register context");
-  return register_context_sp->WriteAllRegisterValues(data_sp);
+  return GetRegisterContext().WriteAllRegisterValues(data_sp);
 }
 
 Status NativeThreadProtocol::RestoreAllRegisters(lldb::DataBufferSP &data_sp) {
-  NativeRegisterContextSP register_context_sp = GetRegisterContext();
-  if (!register_context_sp)
-    return Status("no register context");
-  return register_context_sp->ReadAllRegisterValues(data_sp);
+  return GetRegisterContext().ReadAllRegisterValues(data_sp);
 }

lldb/trunk/source/Plugins/Process/Linux/NativeProcessLinux.cpp

void NativeProcessLinux::MonitorSIGTRAP(const siginfo_t &info,
   }
 
   case 0:
   case TRAP_TRACE:  // We receive this on single stepping.
   case TRAP_HWBKPT: // We receive this on watchpoint hit
   {
     // If a watchpoint was hit, report it
     uint32_t wp_index;
-    Status error = thread.GetRegisterContext()->GetWatchpointHitIndex(
+    Status error = thread.GetRegisterContext().GetWatchpointHitIndex(
         wp_index, (uintptr_t)info.si_addr);
     if (error.Fail())
       LLDB_LOG(log,
                "received error while checking for watchpoint hits, pid = "
                "{0}, error = {1}",
                thread.GetID(), error);
     if (wp_index != LLDB_INVALID_INDEX32) {
       MonitorWatchpoint(thread, wp_index);
       break;
     }
 
     // If a breakpoint was hit, report it
     uint32_t bp_index;
-    error = thread.GetRegisterContext()->GetHardwareBreakHitIndex(
+    error = thread.GetRegisterContext().GetHardwareBreakHitIndex(
         bp_index, (uintptr_t)info.si_addr);
     if (error.Fail())
       LLDB_LOG(log, "received error while checking for hardware "
                     "breakpoint hits, pid = {0}, error = {1}",
                thread.GetID(), error);
     if (bp_index != LLDB_INVALID_INDEX32) {
       MonitorBreakpoint(thread);
       break;
     }
 
     // Otherwise, report step over
     MonitorTrace(thread);
     break;
   }
 
   case SI_KERNEL:
 #if defined __mips__
     // For mips there is no special signal for watchpoint
     // So we check for watchpoint in kernel trap
     {
       // If a watchpoint was hit, report it
       uint32_t wp_index;
-      Status error = thread.GetRegisterContext()->GetWatchpointHitIndex(
+      Status error = thread.GetRegisterContext().GetWatchpointHitIndex(
           wp_index, LLDB_INVALID_ADDRESS);
       if (error.Fail())
         LLDB_LOG(log,
                  "received error while checking for watchpoint hits, pid = "
                  "{0}, error = {1}",
                  thread.GetID(), error);
       if (wp_index != LLDB_INVALID_INDEX32) {
         MonitorWatchpoint(thread, wp_index);
void NativeProcessLinux::MonitorSignal(const siginfo_t &info,
 
   // Send a stop to the debugger after we get all other threads to stop.
   StopRunningThreads(thread.GetID());
 }
 
 namespace {
 
 struct EmulatorBaton {
-  NativeProcessLinux *m_process;
-  NativeRegisterContext *m_reg_context;
+  NativeProcessLinux &m_process;
+  NativeRegisterContext &m_reg_context;
 
   // eRegisterKindDWARF -> RegsiterValue
   std::unordered_map<uint32_t, RegisterValue> m_register_values;
 
-  EmulatorBaton(NativeProcessLinux *process, NativeRegisterContext *reg_context)
+  EmulatorBaton(NativeProcessLinux &process, NativeRegisterContext &reg_context)
       : m_process(process), m_reg_context(reg_context) {}
 };
 
 } // anonymous namespace
 
 static size_t ReadMemoryCallback(EmulateInstruction *instruction, void *baton,
                                  const EmulateInstruction::Context &context,
                                  lldb::addr_t addr, void *dst, size_t length) {
   EmulatorBaton *emulator_baton = static_cast<EmulatorBaton *>(baton);
 
   size_t bytes_read;
-  emulator_baton->m_process->ReadMemory(addr, dst, length, bytes_read);
+  emulator_baton->m_process.ReadMemory(addr, dst, length, bytes_read);
   return bytes_read;
 }
 
 static bool ReadRegisterCallback(EmulateInstruction *instruction, void *baton,
                                  const RegisterInfo *reg_info,
                                  RegisterValue &reg_value) {
   EmulatorBaton *emulator_baton = static_cast<EmulatorBaton *>(baton);
 
   auto it = emulator_baton->m_register_values.find(
       reg_info->kinds[eRegisterKindDWARF]);
   if (it != emulator_baton->m_register_values.end()) {
     reg_value = it->second;
     return true;
   }
 
   // The emulator only fill in the dwarf regsiter numbers (and in some case
   // the generic register numbers). Get the full register info from the
   // register context based on the dwarf register numbers.
   const RegisterInfo *full_reg_info =
-      emulator_baton->m_reg_context->GetRegisterInfo(
+      emulator_baton->m_reg_context.GetRegisterInfo(
           eRegisterKindDWARF, reg_info->kinds[eRegisterKindDWARF]);
 
   Status error =
-      emulator_baton->m_reg_context->ReadRegister(full_reg_info, reg_value);
+      emulator_baton->m_reg_context.ReadRegister(full_reg_info, reg_value);
   if (error.Success())
     return true;
 
   return false;
 }
 
 static bool WriteRegisterCallback(EmulateInstruction *instruction, void *baton,
                                   const EmulateInstruction::Context &context,
                                   const RegisterInfo *reg_info,
                                   const RegisterValue &reg_value) {
   EmulatorBaton *emulator_baton = static_cast<EmulatorBaton *>(baton);
   emulator_baton->m_register_values[reg_info->kinds[eRegisterKindDWARF]] =
       reg_value;
   return true;
 }
 
 static size_t WriteMemoryCallback(EmulateInstruction *instruction, void *baton,
                                   const EmulateInstruction::Context &context,
                                   lldb::addr_t addr, const void *dst,
                                   size_t length) {
   return length;
 }
 
-static lldb::addr_t ReadFlags(NativeRegisterContext *regsiter_context) {
-  const RegisterInfo *flags_info = regsiter_context->GetRegisterInfo(
+static lldb::addr_t ReadFlags(NativeRegisterContext &regsiter_context) {
+  const RegisterInfo *flags_info = regsiter_context.GetRegisterInfo(
       eRegisterKindGeneric, LLDB_REGNUM_GENERIC_FLAGS);
-  return regsiter_context->ReadRegisterAsUnsigned(flags_info,
-                                                  LLDB_INVALID_ADDRESS);
+  return regsiter_context.ReadRegisterAsUnsigned(flags_info,
 }
 
 Status
 NativeProcessLinux::SetupSoftwareSingleStepping(NativeThreadLinux &thread) {
   Status error;
-  NativeRegisterContextSP register_context_sp = thread.GetRegisterContext();
+  NativeRegisterContext& register_context = thread.GetRegisterContext();
 
   std::unique_ptr<EmulateInstruction> emulator_ap(
       EmulateInstruction::FindPlugin(m_arch, eInstructionTypePCModifying,
                                      nullptr));
 
   if (emulator_ap == nullptr)
     return Status("Instruction emulator not found!");
 
-  EmulatorBaton baton(this, register_context_sp.get());
+  EmulatorBaton baton(*this, register_context);
   emulator_ap->SetBaton(&baton);
   emulator_ap->SetReadMemCallback(&ReadMemoryCallback);
   emulator_ap->SetReadRegCallback(&ReadRegisterCallback);
   emulator_ap->SetWriteMemCallback(&WriteMemoryCallback);
   emulator_ap->SetWriteRegCallback(&WriteRegisterCallback);
 
   if (!emulator_ap->ReadInstruction())
     return Status("Read instruction failed!");
 
   bool emulation_result =
       emulator_ap->EvaluateInstruction(eEmulateInstructionOptionAutoAdvancePC);
 
-  const RegisterInfo *reg_info_pc = register_context_sp->GetRegisterInfo(
+  const RegisterInfo *reg_info_pc = register_context.GetRegisterInfo(
       eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC);
-  const RegisterInfo *reg_info_flags = register_context_sp->GetRegisterInfo(
+  const RegisterInfo *reg_info_flags = register_context.GetRegisterInfo(
       eRegisterKindGeneric, LLDB_REGNUM_GENERIC_FLAGS);
 
   auto pc_it =
       baton.m_register_values.find(reg_info_pc->kinds[eRegisterKindDWARF]);
   auto flags_it =
       baton.m_register_values.find(reg_info_flags->kinds[eRegisterKindDWARF]);
 
   lldb::addr_t next_pc;
   lldb::addr_t next_flags;
   if (emulation_result) {
     assert(pc_it != baton.m_register_values.end() &&
            "Emulation was successfull but PC wasn't updated");
     next_pc = pc_it->second.GetAsUInt64();
 
     if (flags_it != baton.m_register_values.end())
       next_flags = flags_it->second.GetAsUInt64();
     else
-      next_flags = ReadFlags(register_context_sp.get());
+      next_flags = ReadFlags(register_context);
   } else if (pc_it == baton.m_register_values.end()) {
     // Emulate instruction failed and it haven't changed PC. Advance PC
     // with the size of the current opcode because the emulation of all
     // PC modifying instruction should be successful. The failure most
     // likely caused by a not supported instruction which don't modify PC.
-    next_pc =
-        register_context_sp->GetPC() + emulator_ap->GetOpcode().GetByteSize();
-    next_flags = ReadFlags(register_context_sp.get());
+    next_pc = register_context.GetPC() + emulator_ap->GetOpcode().GetByteSize();
+    next_flags = ReadFlags(register_context);
   } else {
     // The instruction emulation failed after it modified the PC. It is an
     // unknown error where we can't continue because the next instruction is
     // modifying the PC but we don't  know how.
     return Status("Instruction emulation failed unexpectedly.");
   }
 
   if (m_arch.GetMachine() == llvm::Triple::arm) {

 Status
 NativeProcessLinux::FixupBreakpointPCAsNeeded(NativeThreadLinux &thread) {
   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_BREAKPOINTS));
 
   Status error;
 
   // Find out the size of a breakpoint (might depend on where we are in the
   // code).
-  NativeRegisterContextSP context_sp = thread.GetRegisterContext();
-  if (!context_sp) {
-    error.SetErrorString("cannot get a NativeRegisterContext for the thread");
-    LLDB_LOG(log, "failed: {0}", error);
-    return error;
-  }
+  NativeRegisterContext &context = thread.GetRegisterContext();
 
   uint32_t breakpoint_size = 0;
   error = GetSoftwareBreakpointPCOffset(breakpoint_size);
   if (error.Fail()) {
     LLDB_LOG(log, "GetBreakpointSize() failed: {0}", error);
     return error;
   } else
     LLDB_LOG(log, "breakpoint size: {0}", breakpoint_size);
 
   // First try probing for a breakpoint at a software breakpoint location: PC -
   // breakpoint size.
-  const lldb::addr_t initial_pc_addr =
-      context_sp->GetPCfromBreakpointLocation();
+  const lldb::addr_t initial_pc_addr = context.GetPCfromBreakpointLocation();
   lldb::addr_t breakpoint_addr = initial_pc_addr;
   if (breakpoint_size > 0) {
     // Do not allow breakpoint probe to wrap around.
     if (breakpoint_addr >= breakpoint_size)
       breakpoint_addr -= breakpoint_size;
   }
 
   // Check if we stopped because of a breakpoint.
LLDB_LOG(log,
              GetID(), breakpoint_addr);
     return Status();
   }
 
   // Change the program counter.
   LLDB_LOG(log, "pid {0} tid {1}: changing PC from {2:x} to {3:x}", GetID(),
            thread.GetID(), initial_pc_addr, breakpoint_addr);
 
-  error = context_sp->SetPC(breakpoint_addr);
+  error = context.SetPC(breakpoint_addr);
   if (error.Fail()) {
     LLDB_LOG(log, "pid {0} tid {1}: failed to set PC: {2}", GetID(),
              thread.GetID(), error);
     return error;
   }
 
   return error;
 }

lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux.h

 //===-- NativeRegisterContextLinux.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_NativeRegisterContextLinux_h
 #define lldb_NativeRegisterContextLinux_h
 
-#include "lldb/Host/common/NativeThreadProtocol.h"
-
-#include "Plugins/Process/Linux/NativeProcessLinux.h"
 #include "Plugins/Process/Utility/NativeRegisterContextRegisterInfo.h"
+#include "lldb/Host/common/NativeThreadProtocol.h"
 
 namespace lldb_private {
 namespace process_linux {
 
 class NativeRegisterContextLinux : public NativeRegisterContextRegisterInfo {
 public:
   NativeRegisterContextLinux(NativeThreadProtocol &native_thread,
-                             uint32_t concrete_frame_idx,
                              RegisterInfoInterface *reg_info_interface_p);
 
   // This function is implemented in the NativeRegisterContextLinux_* subclasses
-  // to create a new
-  // instance of the host specific NativeRegisterContextLinux. The
-  // implementations can't collide
-  // as only one NativeRegisterContextLinux_* variant should be compiled into
-  // the final
-  // executable.
-  static NativeRegisterContextLinux *
+  // to create a new instance of the host specific NativeRegisterContextLinux.
+  // The implementations can't collide as only one NativeRegisterContextLinux_*
+  // variant should be compiled into the final executable.
+  static std::unique_ptr<NativeRegisterContextLinux>
   CreateHostNativeRegisterContextLinux(const ArchSpec &target_arch,
-                                       NativeThreadProtocol &native_thread,
-                                       uint32_t concrete_frame_idx);
+                                       NativeThreadProtocol &native_thread);
 
 protected:
   lldb::ByteOrder GetByteOrder() const;
 
   virtual Status ReadRegisterRaw(uint32_t reg_index, RegisterValue &reg_value);
 
   virtual Status WriteRegisterRaw(uint32_t reg_index,
                                   const RegisterValue &reg_value);

lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux.cpp

 //===-- NativeRegisterContextLinux.cpp --------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "NativeRegisterContextLinux.h"
 
 #include "lldb/Core/RegisterValue.h"
 #include "lldb/Host/common/NativeProcessProtocol.h"
 #include "lldb/Host/common/NativeThreadProtocol.h"
 #include "lldb/Host/linux/Ptrace.h"
 
+#include "Plugins/Process/Linux/NativeProcessLinux.h"
 #include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
 
 using namespace lldb_private;
 using namespace lldb_private::process_linux;
 
 NativeRegisterContextLinux::NativeRegisterContextLinux(
-    NativeThreadProtocol &native_thread, uint32_t concrete_frame_idx,
+    NativeThreadProtocol &native_thread,
     RegisterInfoInterface *reg_info_interface_p)
-    : NativeRegisterContextRegisterInfo(native_thread, concrete_frame_idx,
-                                        reg_info_interface_p) {}
+    : NativeRegisterContextRegisterInfo(native_thread, reg_info_interface_p) {}
 
 lldb::ByteOrder NativeRegisterContextLinux::GetByteOrder() const {
   return m_thread.GetProcess().GetByteOrder();
 }
 
 Status NativeRegisterContextLinux::ReadRegisterRaw(uint32_t reg_index,
                                                    RegisterValue &reg_value) {
   const RegisterInfo *const reg_info = GetRegisterInfoAtIndex(reg_index);

lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_arm.h

 namespace lldb_private {
 namespace process_linux {
 
 class NativeProcessLinux;
 
 class NativeRegisterContextLinux_arm : public NativeRegisterContextLinux {
 public:
   NativeRegisterContextLinux_arm(const ArchSpec &target_arch,
-                                 NativeThreadProtocol &native_thread,
-                                 uint32_t concrete_frame_idx);
+                                 NativeThreadProtocol &native_thread);
 
   uint32_t GetRegisterSetCount() const override;
 
   const RegisterSet *GetRegisterSet(uint32_t set_index) const override;
 
   uint32_t GetUserRegisterCount() const override;
 
   Status ReadRegister(const RegisterInfo *reg_info,

lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_arm.cpp

 //===-- NativeRegisterContextLinux_arm.cpp --------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #if defined(__arm__) || defined(__arm64__) || defined(__aarch64__)
 
 #include "NativeRegisterContextLinux_arm.h"
 
+#include "Plugins/Process/Linux/NativeProcessLinux.h"
+#include "Plugins/Process/Linux/Procfs.h"
+#include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
+#include "Plugins/Process/Utility/RegisterInfoPOSIX_arm.h"
 #include "lldb/Core/RegisterValue.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Status.h"
 
-#include "Plugins/Process/Linux/Procfs.h"
-#include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
-#include "Plugins/Process/Utility/RegisterInfoPOSIX_arm.h"
-
 #include <elf.h>
 #include <sys/socket.h>
 
 #define REG_CONTEXT_SIZE (GetGPRSize() + sizeof(m_fpr))
 
 #ifndef PTRACE_GETVFPREGS
 #define PTRACE_GETVFPREGS 27
 #define PTRACE_SETVFPREGS 28

 static const RegisterSet g_reg_sets_arm[k_num_register_sets] = {
     {"General Purpose Registers", "gpr", k_num_gpr_registers_arm,
      g_gpr_regnums_arm},
     {"Floating Point Registers", "fpu", k_num_fpr_registers_arm,
      g_fpu_regnums_arm}};
 
 #if defined(__arm__)
 
-NativeRegisterContextLinux *
+std::unique_ptr<NativeRegisterContextLinux>
 NativeRegisterContextLinux::CreateHostNativeRegisterContextLinux(
-    const ArchSpec &target_arch, NativeThreadProtocol &native_thread,
-    uint32_t concrete_frame_idx) {
-  return new NativeRegisterContextLinux_arm(target_arch, native_thread,
-                                            concrete_frame_idx);
+    const ArchSpec &target_arch, NativeThreadProtocol &native_thread) {
+  return llvm::make_unique<NativeRegisterContextLinux_arm>(target_arch,
+                                                           native_thread);
 }
 
 #endif // defined(__arm__)
 
 NativeRegisterContextLinux_arm::NativeRegisterContextLinux_arm(
-    const ArchSpec &target_arch, NativeThreadProtocol &native_thread,
-    uint32_t concrete_frame_idx)
-    : NativeRegisterContextLinux(native_thread, concrete_frame_idx,
+    const ArchSpec &target_arch, NativeThreadProtocol &native_thread)
+    : NativeRegisterContextLinux(native_thread,
                                  new RegisterInfoPOSIX_arm(target_arch)) {
   switch (target_arch.GetMachine()) {
   case llvm::Triple::arm:
     m_reg_info.num_registers = k_num_registers_arm;
     m_reg_info.num_gpr_registers = k_num_gpr_registers_arm;
     m_reg_info.num_fpr_registers = k_num_fpr_registers_arm;
     m_reg_info.last_gpr = k_last_gpr_arm;
     m_reg_info.first_fpr = k_first_fpr_arm;

lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_arm64.h

 namespace lldb_private {
 namespace process_linux {
 
 class NativeProcessLinux;
 
 class NativeRegisterContextLinux_arm64 : public NativeRegisterContextLinux {
 public:
   NativeRegisterContextLinux_arm64(const ArchSpec &target_arch,
-                                   NativeThreadProtocol &native_thread,
-                                   uint32_t concrete_frame_idx);
+                                   NativeThreadProtocol &native_thread);
 
   uint32_t GetRegisterSetCount() const override;
 
   uint32_t GetUserRegisterCount() const override;
 
   const RegisterSet *GetRegisterSet(uint32_t set_index) const override;
 
   Status ReadRegister(const RegisterInfo *reg_info,

lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_arm64.cpp

 
 // Register sets for ARM64.
 static const RegisterSet g_reg_sets_arm64[k_num_register_sets] = {
     {"General Purpose Registers", "gpr", k_num_gpr_registers_arm64,
      g_gpr_regnums_arm64},
     {"Floating Point Registers", "fpu", k_num_fpr_registers_arm64,
      g_fpu_regnums_arm64}};
 
-NativeRegisterContextLinux *
+std::unique_ptr<NativeRegisterContextLinux>
 NativeRegisterContextLinux::CreateHostNativeRegisterContextLinux(
-    const ArchSpec &target_arch, NativeThreadProtocol &native_thread,
-    uint32_t concrete_frame_idx) {
+    const ArchSpec &target_arch, NativeThreadProtocol &native_thread) {
   switch (target_arch.GetMachine()) {
   case llvm::Triple::arm:
-    return new NativeRegisterContextLinux_arm(target_arch, native_thread,
-                                              concrete_frame_idx);
+    return llvm::make_unique<NativeRegisterContextLinux_arm>(target_arch,
+                                                             native_thread);
   case llvm::Triple::aarch64:
-    return new NativeRegisterContextLinux_arm64(target_arch, native_thread,
-                                                concrete_frame_idx);
+    return llvm::make_unique<NativeRegisterContextLinux_arm64>(target_arch,
+                                                               native_thread);
   default:
     llvm_unreachable("have no register context for architecture");
   }
 }
 
 NativeRegisterContextLinux_arm64::NativeRegisterContextLinux_arm64(
-    const ArchSpec &target_arch, NativeThreadProtocol &native_thread,
-    uint32_t concrete_frame_idx)
-    : NativeRegisterContextLinux(native_thread, concrete_frame_idx,
+    const ArchSpec &target_arch, NativeThreadProtocol &native_thread)
+    : NativeRegisterContextLinux(native_thread,
                                  new RegisterInfoPOSIX_arm64(target_arch)) {
   switch (target_arch.GetMachine()) {
   case llvm::Triple::aarch64:
     m_reg_info.num_registers = k_num_registers_arm64;
     m_reg_info.num_gpr_registers = k_num_gpr_registers_arm64;
     m_reg_info.num_fpr_registers = k_num_fpr_registers_arm64;
     m_reg_info.last_gpr = k_last_gpr_arm64;
     m_reg_info.first_fpr = k_first_fpr_arm64;

lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.h

 namespace lldb_private {
 namespace process_linux {
 
 class NativeProcessLinux;
 
 class NativeRegisterContextLinux_mips64 : public NativeRegisterContextLinux {
 public:
   NativeRegisterContextLinux_mips64(const ArchSpec &target_arch,
-                                    NativeThreadProtocol &native_thread,
-                                    uint32_t concrete_frame_idx);
+                                    NativeThreadProtocol &native_thread);
 
   uint32_t GetRegisterSetCount() const override;
 
   lldb::addr_t GetPCfromBreakpointLocation(
       lldb::addr_t fail_value = LLDB_INVALID_ADDRESS) override;
 
   lldb::addr_t GetWatchpointHitAddress(uint32_t wp_index) override;
 

lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.cpp

 #ifndef PTRACE_GETREGSET
 #define PTRACE_GETREGSET 0x4204
 #endif
 struct pt_watch_regs default_watch_regs;
 
 using namespace lldb_private;
 using namespace lldb_private::process_linux;
 
-NativeRegisterContextLinux *
+std::unique_ptr<NativeRegisterContextLinux>
 NativeRegisterContextLinux::CreateHostNativeRegisterContextLinux(
-    const ArchSpec &target_arch, NativeThreadProtocol &native_thread,
-    uint32_t concrete_frame_idx) {
-  return new NativeRegisterContextLinux_mips64(target_arch, native_thread,
-                                               concrete_frame_idx);
+    const ArchSpec &target_arch, NativeThreadProtocol &native_thread) {
+  return llvm::make_unique<NativeRegisterContextLinux_mips64>(target_arch,
+                                                              native_thread);
 }
 
 #define REG_CONTEXT_SIZE                                                       \
   (GetRegisterInfoInterface().GetGPRSize() + sizeof(FPR_linux_mips) +          \
    sizeof(MSA_linux_mips))
 
 // ----------------------------------------------------------------------------
 // NativeRegisterContextLinux_mips64 members.
 // ----------------------------------------------------------------------------
 
 static RegisterInfoInterface *
 CreateRegisterInfoInterface(const ArchSpec &target_arch) {
   if ((target_arch.GetMachine() == llvm::Triple::mips) ||
        (target_arch.GetMachine() == llvm::Triple::mipsel)) {
     // 32-bit hosts run with a RegisterContextLinux_mips context.
     return new RegisterContextLinux_mips(
         target_arch, NativeRegisterContextLinux_mips64::IsMSAAvailable());
   } else {
     return new RegisterContextLinux_mips64(
         target_arch, NativeRegisterContextLinux_mips64::IsMSAAvailable());
   }
 }
 
 NativeRegisterContextLinux_mips64::NativeRegisterContextLinux_mips64(
-    const ArchSpec &target_arch, NativeThreadProtocol &native_thread,
-    uint32_t concrete_frame_idx)
-    : NativeRegisterContextLinux(native_thread, concrete_frame_idx,
+    const ArchSpec &target_arch, NativeThreadProtocol &native_thread)
+    : NativeRegisterContextLinux(native_thread,
                                  CreateRegisterInfoInterface(target_arch)) {
   switch (target_arch.GetMachine()) {
   case llvm::Triple::mips:
   case llvm::Triple::mipsel:
     m_reg_info.num_registers = k_num_registers_mips;
     m_reg_info.num_gpr_registers = k_num_gpr_registers_mips;
     m_reg_info.num_fpr_registers = k_num_fpr_registers_mips;
     m_reg_info.last_gpr = k_last_gpr_mips;

lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_ppc64le.h

 namespace lldb_private {
 namespace process_linux {
 
 class NativeProcessLinux;
 
 class NativeRegisterContextLinux_ppc64le : public NativeRegisterContextLinux {
 public:
   NativeRegisterContextLinux_ppc64le(const ArchSpec &target_arch,
-                                   NativeThreadProtocol &native_thread,
-                                   uint32_t concrete_frame_idx);
+                                     NativeThreadProtocol &native_thread);
 
   uint32_t GetRegisterSetCount() const override;
 
   uint32_t GetUserRegisterCount() const override;
 
   const RegisterSet *GetRegisterSet(uint32_t set_index) const override;
 
   Status ReadRegister(const RegisterInfo *reg_info,

lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_ppc64le.cpp

static const RegisterSet g_reg_sets_ppc64le[k_num_register_sets] = {
     {"Floating Point Registers", "fpr", k_num_fpr_registers_ppc64le,
      g_fpr_regnums_ppc64le},
     {"AltiVec/VMX Registers", "vmx", k_num_vmx_registers_ppc64le,
      g_vmx_regnums_ppc64le},
     {"VSX Registers", "vsx", k_num_vsx_registers_ppc64le,
      g_vsx_regnums_ppc64le},
 };
 
-NativeRegisterContextLinux *
+std::unique_ptr<NativeRegisterContextLinux>
 NativeRegisterContextLinux::CreateHostNativeRegisterContextLinux(
-    const ArchSpec &target_arch, NativeThreadProtocol &native_thread,
-    uint32_t concrete_frame_idx) {
+    const ArchSpec &target_arch, NativeThreadProtocol &native_thread) {
   switch (target_arch.GetMachine()) {
   case llvm::Triple::ppc64le:
-    return new NativeRegisterContextLinux_ppc64le(target_arch, native_thread,
-                                              concrete_frame_idx);
+    return llvm::make_unique<NativeRegisterContextLinux_ppc64le>(target_arch,
+                                                                 native_thread);
   default:
     llvm_unreachable("have no register context for architecture");
   }
 }
 
 NativeRegisterContextLinux_ppc64le::NativeRegisterContextLinux_ppc64le(
-    const ArchSpec &target_arch, NativeThreadProtocol &native_thread,
-    uint32_t concrete_frame_idx)
-    : NativeRegisterContextLinux(native_thread, concrete_frame_idx,
+    const ArchSpec &target_arch, NativeThreadProtocol &native_thread)
+    : NativeRegisterContextLinux(native_thread,
                                  new RegisterInfoPOSIX_ppc64le(target_arch)) {
   if (target_arch.GetMachine() != llvm::Triple::ppc64le) {
     llvm_unreachable("Unhandled target architecture.");
   }
 
   ::memset(&m_gpr_ppc64le, 0, sizeof(m_gpr_ppc64le));
   ::memset(&m_fpr_ppc64le, 0, sizeof(m_fpr_ppc64le));
   ::memset(&m_vmx_ppc64le, 0, sizeof(m_vmx_ppc64le));

lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_s390x.h

 namespace lldb_private {
 namespace process_linux {
 
 class NativeProcessLinux;
 
 class NativeRegisterContextLinux_s390x : public NativeRegisterContextLinux {
 public:
   NativeRegisterContextLinux_s390x(const ArchSpec &target_arch,
-                                   NativeThreadProtocol &native_thread,
-                                   uint32_t concrete_frame_idx);
+                                   NativeThreadProtocol &native_thread);
 
   uint32_t GetRegisterSetCount() const override;
 
   const RegisterSet *GetRegisterSet(uint32_t set_index) const override;
 
   uint32_t GetUserRegisterCount() const override;
 
   Status ReadRegister(const RegisterInfo *reg_info,

lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_s390x.cpp

 
 // ----------------------------------------------------------------------------
 // Required ptrace defines.
 // ----------------------------------------------------------------------------
 
 #define NT_S390_LAST_BREAK 0x306  /* s390 breaking event address */
 #define NT_S390_SYSTEM_CALL 0x307 /* s390 system call restart data */
 
-NativeRegisterContextLinux *
+std::unique_ptr<NativeRegisterContextLinux>
 NativeRegisterContextLinux::CreateHostNativeRegisterContextLinux(
-    const ArchSpec &target_arch, NativeThreadProtocol &native_thread,
-    uint32_t concrete_frame_idx) {
-  return new NativeRegisterContextLinux_s390x(target_arch, native_thread,
-                                              concrete_frame_idx);
+    const ArchSpec &target_arch, NativeThreadProtocol &native_thread) {
+  return llvm::make_unique<NativeRegisterContextLinux_s390x>(target_arch,
+                                                             native_thread);
 }
 
 // ----------------------------------------------------------------------------
 // NativeRegisterContextLinux_s390x members.
 // ----------------------------------------------------------------------------
 
 static RegisterInfoInterface *
 CreateRegisterInfoInterface(const ArchSpec &target_arch) {
   assert((HostInfo::GetArchitecture().GetAddressByteSize() == 8) &&
          "Register setting path assumes this is a 64-bit host");
   return new RegisterContextLinux_s390x(target_arch);
 }
 
 NativeRegisterContextLinux_s390x::NativeRegisterContextLinux_s390x(
-    const ArchSpec &target_arch, NativeThreadProtocol &native_thread,
-    uint32_t concrete_frame_idx)
-    : NativeRegisterContextLinux(native_thread, concrete_frame_idx,
+    const ArchSpec &target_arch, NativeThreadProtocol &native_thread)
+    : NativeRegisterContextLinux(native_thread,
                                  CreateRegisterInfoInterface(target_arch)) {
   // Set up data about ranges of valid registers.
   switch (target_arch.GetMachine()) {
   case llvm::Triple::systemz:
     m_reg_info.num_registers = k_num_registers_s390x;
     m_reg_info.num_gpr_registers = k_num_gpr_registers_s390x;
     m_reg_info.num_fpr_registers = k_num_fpr_registers_s390x;
     m_reg_info.last_gpr = k_last_gpr_s390x;

lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_x86_64.h

 namespace lldb_private {
 namespace process_linux {
 
 class NativeProcessLinux;
 
 class NativeRegisterContextLinux_x86_64 : public NativeRegisterContextLinux {
 public:
   NativeRegisterContextLinux_x86_64(const ArchSpec &target_arch,
-                                    NativeThreadProtocol &native_thread,
-                                    uint32_t concrete_frame_idx);
+                                    NativeThreadProtocol &native_thread);
 
   uint32_t GetRegisterSetCount() const override;
 
   const RegisterSet *GetRegisterSet(uint32_t set_index) const override;
 
   uint32_t GetUserRegisterCount() const override;
 
   Status ReadRegister(const RegisterInfo *reg_info,

lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_x86_64.cpp

 // ----------------------------------------------------------------------------
 // XCR0 extended register sets masks.
 // ----------------------------------------------------------------------------
 #define mask_XSTATE_AVX (1ULL << 2)
 #define mask_XSTATE_BNDREGS (1ULL << 3)
 #define mask_XSTATE_BNDCFG (1ULL << 4)
 #define mask_XSTATE_MPX (mask_XSTATE_BNDREGS | mask_XSTATE_BNDCFG)
 
-NativeRegisterContextLinux *
+std::unique_ptr<NativeRegisterContextLinux>
 NativeRegisterContextLinux::CreateHostNativeRegisterContextLinux(
-    const ArchSpec &target_arch, NativeThreadProtocol &native_thread,
-    uint32_t concrete_frame_idx) {
-  return new NativeRegisterContextLinux_x86_64(target_arch, native_thread,
-                                               concrete_frame_idx);
+    const ArchSpec &target_arch, NativeThreadProtocol &native_thread) {
+  return std::unique_ptr<NativeRegisterContextLinux>(
+      new NativeRegisterContextLinux_x86_64(target_arch, native_thread));
 }
 
 // ----------------------------------------------------------------------------
 // NativeRegisterContextLinux_x86_64 members.
 // ----------------------------------------------------------------------------
 
 static RegisterInfoInterface *
 CreateRegisterInfoInterface(const ArchSpec &target_arch) {
   if (HostInfo::GetArchitecture().GetAddressByteSize() == 4) {
     // 32-bit hosts run with a RegisterContextLinux_i386 context.
     return new RegisterContextLinux_i386(target_arch);
   } else {
     assert((HostInfo::GetArchitecture().GetAddressByteSize() == 8) &&
            "Register setting path assumes this is a 64-bit host");
     // X86_64 hosts know how to work with 64-bit and 32-bit EXEs using the
     // x86_64 register context.
     return new RegisterContextLinux_x86_64(target_arch);
   }
 }
 
 NativeRegisterContextLinux_x86_64::NativeRegisterContextLinux_x86_64(
-    const ArchSpec &target_arch, NativeThreadProtocol &native_thread,
-    uint32_t concrete_frame_idx)
-    : NativeRegisterContextLinux(native_thread, concrete_frame_idx,
+    const ArchSpec &target_arch, NativeThreadProtocol &native_thread)
+    : NativeRegisterContextLinux(native_thread,
                                  CreateRegisterInfoInterface(target_arch)),
       m_xstate_type(XStateType::Invalid), m_fpr(), m_iovec(), m_ymm_set(),
       m_mpx_set(), m_reg_info(), m_gpr_x86_64() {
   // Set up data about ranges of valid registers.
   switch (target_arch.GetMachine()) {
   case llvm::Triple::x86:
     m_reg_info.num_registers = k_num_registers_i386;
     m_reg_info.num_gpr_registers = k_num_gpr_registers_i386;

lldb/trunk/source/Plugins/Process/Linux/NativeThreadLinux.h

 //===-- NativeThreadLinux.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_NativeThreadLinux_H_
 #define liblldb_NativeThreadLinux_H_
 
-#include "SingleStepCheck.h"
+#include "Plugins/Process/Linux/NativeRegisterContextLinux.h"
+#include "Plugins/Process/Linux/SingleStepCheck.h"
 #include "lldb/Host/common/NativeThreadProtocol.h"
 #include "lldb/lldb-private-forward.h"
 
 #include <csignal>
 #include <map>
 #include <memory>
 #include <string>
 
public:
   // ---------------------------------------------------------------------
   std::string GetName() override;
 
   lldb::StateType GetState() override;
 
   bool GetStopReason(ThreadStopInfo &stop_info,
                      std::string &description) override;
 
-  NativeRegisterContextSP GetRegisterContext() override;
+  NativeRegisterContextLinux &GetRegisterContext() override {
+    return *m_reg_context_up;
+  }
 
   Status SetWatchpoint(lldb::addr_t addr, size_t size, uint32_t watch_flags,
                        bool hardware) override;
 
   Status RemoveWatchpoint(lldb::addr_t addr) override;
 
   Status SetHardwareBreakpoint(lldb::addr_t addr, size_t size) override;
 
private:
 
   void SetStopped();
 
   // ---------------------------------------------------------------------
   // Member Variables
   // ---------------------------------------------------------------------
   lldb::StateType m_state;
   ThreadStopInfo m_stop_info;
-  NativeRegisterContextSP m_reg_context_sp;
+  std::unique_ptr<NativeRegisterContextLinux> m_reg_context_up;
   std::string m_stop_description;
   using WatchpointIndexMap = std::map<lldb::addr_t, uint32_t>;
   WatchpointIndexMap m_watchpoint_index_map;
   WatchpointIndexMap m_hw_break_index_map;
   std::unique_ptr<SingleStepWorkaround> m_step_workaround;
 };
 } // namespace process_linux
 } // namespace lldb_private
 
 #endif // #ifndef liblldb_NativeThreadLinux_H_

lldb/trunk/source/Plugins/Process/Linux/NativeThreadLinux.cpp

log.Printf("%s: %s invalid stop reason %" PRIu32, __FUNCTION__, header,
                static_cast<uint32_t>(stop_info.reason));
   }
 }
 }
 
 NativeThreadLinux::NativeThreadLinux(NativeProcessLinux &process,
                                      lldb::tid_t tid)
     : NativeThreadProtocol(process, tid), m_state(StateType::eStateInvalid),
-      m_stop_info(), m_reg_context_sp(), m_stop_description() {}
+      m_stop_info(),
+      m_reg_context_up(
+          NativeRegisterContextLinux::CreateHostNativeRegisterContextLinux(
+              process.GetArchitecture(), *this)),
+      m_stop_description() {}
 
 std::string NativeThreadLinux::GetName() {
   NativeProcessLinux &process = GetProcess();
 
   auto BufferOrError = getProcFile(process.GetID(), GetID(), "comm");
   if (!BufferOrError)
     return "";
   return BufferOrError.get()->getBuffer().rtrim('\n');
if (log) {
                   " in state %s cannot answer stop reason",
                   __FUNCTION__, GetID(), StateAsCString(m_state));
     }
     return false;
   }
   llvm_unreachable("unhandled StateType!");
 }
 
-NativeRegisterContextSP NativeThreadLinux::GetRegisterContext() {
-  // Return the register context if we already created it.
-  if (m_reg_context_sp)
-    return m_reg_context_sp;
-
-  const uint32_t concrete_frame_idx = 0;
-  m_reg_context_sp.reset(
-      NativeRegisterContextLinux::CreateHostNativeRegisterContextLinux(
-          m_process.GetArchitecture(), *this, concrete_frame_idx));
-
-  return m_reg_context_sp;
-}
-
 Status NativeThreadLinux::SetWatchpoint(lldb::addr_t addr, size_t size,
                                         uint32_t watch_flags, bool hardware) {
   if (!hardware)
     return Status("not implemented");
   if (m_state == eStateLaunching)
     return Status();
   Status error = RemoveWatchpoint(addr);
   if (error.Fail())
     return error;
-  NativeRegisterContextSP reg_ctx = GetRegisterContext();
-  uint32_t wp_index = reg_ctx->SetHardwareWatchpoint(addr, size, watch_flags);
+  uint32_t wp_index =
+      m_reg_context_up->SetHardwareWatchpoint(addr, size, watch_flags);
   if (wp_index == LLDB_INVALID_INDEX32)
     return Status("Setting hardware watchpoint failed.");
   m_watchpoint_index_map.insert({addr, wp_index});
   return Status();
 }
 
 Status NativeThreadLinux::RemoveWatchpoint(lldb::addr_t addr) {
   auto wp = m_watchpoint_index_map.find(addr);
   if (wp == m_watchpoint_index_map.end())
     return Status();
   uint32_t wp_index = wp->second;
   m_watchpoint_index_map.erase(wp);
-  if (GetRegisterContext()->ClearHardwareWatchpoint(wp_index))
+  if (m_reg_context_up->ClearHardwareWatchpoint(wp_index))
     return Status();
   return Status("Clearing hardware watchpoint failed.");
 }
 
 Status NativeThreadLinux::SetHardwareBreakpoint(lldb::addr_t addr,
                                                 size_t size) {
   if (m_state == eStateLaunching)
     return Status();
 
   Status error = RemoveHardwareBreakpoint(addr);
   if (error.Fail())
     return error;
 
-  NativeRegisterContextSP reg_ctx = GetRegisterContext();
-  uint32_t bp_index = reg_ctx->SetHardwareBreakpoint(addr, size);
+  uint32_t bp_index = m_reg_context_up->SetHardwareBreakpoint(addr, size);
 
   if (bp_index == LLDB_INVALID_INDEX32)
     return Status("Setting hardware breakpoint failed.");
 
   m_hw_break_index_map.insert({addr, bp_index});
   return Status();
 }
 
 Status NativeThreadLinux::RemoveHardwareBreakpoint(lldb::addr_t addr) {
   auto bp = m_hw_break_index_map.find(addr);
   if (bp == m_hw_break_index_map.end())
     return Status();
 
   uint32_t bp_index = bp->second;
-  if (GetRegisterContext()->ClearHardwareBreakpoint(bp_index)) {
+  if (m_reg_context_up->ClearHardwareBreakpoint(bp_index)) {
     m_hw_break_index_map.erase(bp);
     return Status();
   }
 
   return Status("Clearing hardware breakpoint failed.");
 }
 
 Status NativeThreadLinux::Resume(uint32_t signo) {
   const StateType new_state = StateType::eStateRunning;
   MaybeLogStateChange(new_state);
   m_state = new_state;
 
   m_stop_info.reason = StopReason::eStopReasonNone;
   m_stop_description.clear();
 
   // If watchpoints have been set, but none on this thread,
   // then this is a new thread. So set all existing watchpoints.
   if (m_watchpoint_index_map.empty()) {
     NativeProcessLinux &process = GetProcess();
 
     const auto &watchpoint_map = process.GetWatchpointMap();
-    GetRegisterContext()->ClearAllHardwareWatchpoints();
+    m_reg_context_up->ClearAllHardwareWatchpoints();
     for (const auto &pair : watchpoint_map) {
       const auto &wp = pair.second;
       SetWatchpoint(wp.m_addr, wp.m_size, wp.m_watch_flags, wp.m_hardware);
     }
   }
 
   // Set all active hardware breakpoint on all threads.
   if (m_hw_break_index_map.empty()) {
     NativeProcessLinux &process = GetProcess();
 
     const auto &hw_breakpoint_map = process.GetHardwareBreakpointMap();
-    GetRegisterContext()->ClearAllHardwareBreakpoints();
+    m_reg_context_up->ClearAllHardwareBreakpoints();
     for (const auto &pair : hw_breakpoint_map) {
       const auto &bp = pair.second;
       SetHardwareBreakpoint(bp.m_addr, bp.m_size);
     }
   }
 
   intptr_t data = 0;
 

 }
 
 void NativeThreadLinux::SetStoppedByWatchpoint(uint32_t wp_index) {
   SetStopped();
 
   lldbassert(wp_index != LLDB_INVALID_INDEX32 && "wp_index cannot be invalid");
 
   std::ostringstream ostr;
-  ostr << GetRegisterContext()->GetWatchpointAddress(wp_index) << " ";
+  ostr << m_reg_context_up->GetWatchpointAddress(wp_index) << " ";
   ostr << wp_index;
 
   /*
    * MIPS: Last 3bits of the watchpoint address are masked by the kernel. For
    * example:
    * 'n' is at 0x120010d00 and 'm' is 0x120010d04. When a watchpoint is set at
    * 'm', then
    * watch exception is generated even when 'n' is read/written. To handle this
    * case,
    * find the base address of the load/store instruction and append it in the
    * stop-info
    * packet.
   */
-  ostr << " " << GetRegisterContext()->GetWatchpointHitAddress(wp_index);
+  ostr << " " << m_reg_context_up->GetWatchpointHitAddress(wp_index);
 
   m_stop_description = ostr.str();
 
   m_stop_info.reason = StopReason::eStopReasonWatchpoint;
   m_stop_info.details.signal.signo = SIGTRAP;
 }
 
 bool NativeThreadLinux::IsStoppedAtBreakpoint() {

lldb/trunk/source/Plugins/Process/NetBSD/NativeProcessNetBSD.cpp

for (const auto &thread : m_threads)
       static_cast<NativeThreadNetBSD &>(*thread).SetStoppedByExec();
     SetState(StateType::eStateStopped, true);
   } break;
   case TRAP_DBREG: {
     // If a watchpoint was hit, report it
     uint32_t wp_index;
     Status error = static_cast<NativeThreadNetBSD &>(*m_threads[info.psi_lwpid])
                        .GetRegisterContext()
-                       ->GetWatchpointHitIndex(
+                       .GetWatchpointHitIndex(
                            wp_index, (uintptr_t)info.psi_siginfo.si_addr);
     if (error.Fail())
       LLDB_LOG(log,
                "received error while checking for watchpoint hits, pid = "
                "{0}, LWP = {1}, error = {2}",
                GetID(), info.psi_lwpid, error);
     if (wp_index != LLDB_INVALID_INDEX32) {
       for (const auto &thread : m_threads)
         static_cast<NativeThreadNetBSD &>(*thread).SetStoppedByWatchpoint(
             wp_index);
       SetState(StateType::eStateStopped, true);
       break;
     }
 
     // If a breakpoint was hit, report it
     uint32_t bp_index;
     error = static_cast<NativeThreadNetBSD &>(*m_threads[info.psi_lwpid])
                 .GetRegisterContext()
-                ->GetHardwareBreakHitIndex(bp_index,
+                .GetHardwareBreakHitIndex(bp_index,
                                            (uintptr_t)info.psi_siginfo.si_addr);
     if (error.Fail())
       LLDB_LOG(log,
                "received error while checking for hardware "
                "breakpoint hits, pid = {0}, LWP = {1}, error = {2}",
                GetID(), info.psi_lwpid, error);
     if (bp_index != LLDB_INVALID_INDEX32) {
       for (const auto &thread : m_threads)

 }
 
 Status
 NativeProcessNetBSD::FixupBreakpointPCAsNeeded(NativeThreadNetBSD &thread) {
   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_BREAKPOINTS));
   Status error;
   // Find out the size of a breakpoint (might depend on where we are in the
   // code).
-  NativeRegisterContextSP context_sp = thread.GetRegisterContext();
-  if (!context_sp) {
-    error.SetErrorString("cannot get a NativeRegisterContext for the thread");
-    LLDB_LOG(log, "failed: {0}", error);
-    return error;
-  }
+  NativeRegisterContext& context = thread.GetRegisterContext();
   uint32_t breakpoint_size = 0;
   error = GetSoftwareBreakpointPCOffset(breakpoint_size);
   if (error.Fail()) {
     LLDB_LOG(log, "GetBreakpointSize() failed: {0}", error);
     return error;
   } else
     LLDB_LOG(log, "breakpoint size: {0}", breakpoint_size);
   // First try probing for a breakpoint at a software breakpoint location: PC
   // - breakpoint size.
   const lldb::addr_t initial_pc_addr =
-      context_sp->GetPCfromBreakpointLocation();
+      context.GetPCfromBreakpointLocation();
   lldb::addr_t breakpoint_addr = initial_pc_addr;
   if (breakpoint_size > 0) {
     // Do not allow breakpoint probe to wrap around.
     if (breakpoint_addr >= breakpoint_size)
       breakpoint_addr -= breakpoint_size;
   }
   // Check if we stopped because of a breakpoint.
   NativeBreakpointSP breakpoint_sp;
LLDB_LOG(log,
              "pid {0} breakpoint found at {1:x}, it is software, but the "
              "size is zero, nothing to do (unexpected)",
              GetID(), breakpoint_addr);
     return Status();
   }
   // Change the program counter.
   LLDB_LOG(log, "pid {0} tid {1}: changing PC from {2:x} to {3:x}", GetID(),
            thread.GetID(), initial_pc_addr, breakpoint_addr);
-  error = context_sp->SetPC(breakpoint_addr);
+  error = context.SetPC(breakpoint_addr);
   if (error.Fail()) {
     LLDB_LOG(log, "pid {0} tid {1}: failed to set PC: {2}", GetID(),
              thread.GetID(), error);
     return error;
   }
   return error;
 }
 

lldb/trunk/source/Plugins/Process/NetBSD/NativeRegisterContextNetBSD.h

 #include "Plugins/Process/Utility/NativeRegisterContextRegisterInfo.h"
 
 namespace lldb_private {
 namespace process_netbsd {
 
 class NativeRegisterContextNetBSD : public NativeRegisterContextRegisterInfo {
 public:
   NativeRegisterContextNetBSD(NativeThreadProtocol &native_thread,
-                              uint32_t concrete_frame_idx,
                               RegisterInfoInterface *reg_info_interface_p);
 
   // This function is implemented in the NativeRegisterContextNetBSD_*
   // subclasses to create a new instance of the host specific
   // NativeRegisterContextNetBSD. The implementations can't collide as only one
   // NativeRegisterContextNetBSD_* variant should be compiled into the final
   // executable.
   static NativeRegisterContextNetBSD *
   CreateHostNativeRegisterContextNetBSD(const ArchSpec &target_arch,
-                                        NativeThreadProtocol &native_thread,
-                                        uint32_t concrete_frame_idx);
+                                        NativeThreadProtocol &native_thread);
 
 protected:
   virtual Status ReadGPR();
   virtual Status WriteGPR();
 
   virtual Status ReadFPR();
   virtual Status WriteFPR();
 

lldb/trunk/source/Plugins/Process/NetBSD/NativeRegisterContextNetBSD.cpp

 using namespace lldb_private::process_netbsd;
 
 // clang-format off
 #include <sys/types.h>
 #include <sys/ptrace.h>
 // clang-format on
 
 NativeRegisterContextNetBSD::NativeRegisterContextNetBSD(
-    NativeThreadProtocol &native_thread, uint32_t concrete_frame_idx,
+    NativeThreadProtocol &native_thread,
     RegisterInfoInterface *reg_info_interface_p)
-    : NativeRegisterContextRegisterInfo(native_thread, concrete_frame_idx,
+    : NativeRegisterContextRegisterInfo(native_thread,
                                         reg_info_interface_p) {}
 
 Status NativeRegisterContextNetBSD::ReadGPR() {
   void *buf = GetGPRBuffer();
   if (!buf)
     return Status("GPR buffer is NULL");
 
   return DoReadGPR(buf);

lldb/trunk/source/Plugins/Process/NetBSD/NativeRegisterContextNetBSD_x86_64.h

 namespace lldb_private {
 namespace process_netbsd {
 
 class NativeProcessNetBSD;
 
 class NativeRegisterContextNetBSD_x86_64 : public NativeRegisterContextNetBSD {
 public:
   NativeRegisterContextNetBSD_x86_64(const ArchSpec &target_arch,
-                                     NativeThreadProtocol &native_thread,
-                                     uint32_t concrete_frame_idx);
+                                     NativeThreadProtocol &native_thread);
   uint32_t GetRegisterSetCount() const override;
 
   const RegisterSet *GetRegisterSet(uint32_t set_index) const override;
 
   Status ReadRegister(const RegisterInfo *reg_info,
                       RegisterValue &reg_value) override;
 
   Status WriteRegister(const RegisterInfo *reg_info,

lldb/trunk/source/Plugins/Process/NetBSD/NativeRegisterContextNetBSD_x86_64.cpp

const int fpu_save = []() -> int {
 
   return val;
 }();
 
 } // namespace
 
 NativeRegisterContextNetBSD *
 NativeRegisterContextNetBSD::CreateHostNativeRegisterContextNetBSD(
-    const ArchSpec &target_arch, NativeThreadProtocol &native_thread,
-    uint32_t concrete_frame_idx) {
-  return new NativeRegisterContextNetBSD_x86_64(target_arch, native_thread,
-                                                concrete_frame_idx);
+    const ArchSpec &target_arch, NativeThreadProtocol &native_thread) {
+  return new NativeRegisterContextNetBSD_x86_64(target_arch, native_thread);
 }
 
 // ----------------------------------------------------------------------------
 // NativeRegisterContextNetBSD_x86_64 members.
 // ----------------------------------------------------------------------------
 
 static RegisterInfoInterface *
 CreateRegisterInfoInterface(const ArchSpec &target_arch) {
   assert((HostInfo::GetArchitecture().GetAddressByteSize() == 8) &&
          "Register setting path assumes this is a 64-bit host");
   // X86_64 hosts know how to work with 64-bit and 32-bit EXEs using the
   // x86_64 register context.
   return new RegisterContextNetBSD_x86_64(target_arch);
 }
 
 NativeRegisterContextNetBSD_x86_64::NativeRegisterContextNetBSD_x86_64(
-    const ArchSpec &target_arch, NativeThreadProtocol &native_thread,
-    uint32_t concrete_frame_idx)
-    : NativeRegisterContextNetBSD(native_thread, concrete_frame_idx,
+    const ArchSpec &target_arch, NativeThreadProtocol &native_thread)
+    : NativeRegisterContextNetBSD(native_thread,
                                   CreateRegisterInfoInterface(target_arch)),
       m_gpr_x86_64(), m_fpr_x86_64(), m_dbr_x86_64() {}
 
 // CONSIDER after local and llgs debugging are merged, register set support can
 // be moved into a base x86-64 class with IsRegisterSetAvailable made virtual.
 uint32_t NativeRegisterContextNetBSD_x86_64::GetRegisterSetCount() const {
   uint32_t sets = 0;
   for (uint32_t set_index = 0; set_index < k_num_register_sets; ++set_index) {

lldb/trunk/source/Plugins/Process/NetBSD/NativeThreadNetBSD.h

public:
   // ---------------------------------------------------------------------
   std::string GetName() override;
 
   lldb::StateType GetState() override;
 
   bool GetStopReason(ThreadStopInfo &stop_info,
                      std::string &description) override;
 
-  NativeRegisterContextSP GetRegisterContext() override;
+  NativeRegisterContext& GetRegisterContext() override;
 
   Status SetWatchpoint(lldb::addr_t addr, size_t size, uint32_t watch_flags,
                        bool hardware) override;
 
   Status RemoveWatchpoint(lldb::addr_t addr) override;
 
   Status SetHardwareBreakpoint(lldb::addr_t addr, size_t size) override;
 
private:
   void SetRunning();
   void SetStepping();
 
   // ---------------------------------------------------------------------
   // Member Variables
   // ---------------------------------------------------------------------
   lldb::StateType m_state;
   ThreadStopInfo m_stop_info;
-  NativeRegisterContextSP m_reg_context_sp;
+  std::unique_ptr<NativeRegisterContext> m_reg_context_up;
   std::string m_stop_description;
   using WatchpointIndexMap = std::map<lldb::addr_t, uint32_t>;
   WatchpointIndexMap m_watchpoint_index_map;
   WatchpointIndexMap m_hw_break_index_map;
 };
 
 typedef std::shared_ptr<NativeThreadNetBSD> NativeThreadNetBSDSP;
 } // namespace process_netbsd
 } // namespace lldb_private
 
 #endif // #ifndef liblldb_NativeThreadNetBSD_H_

lldb/trunk/source/Plugins/Process/NetBSD/NativeThreadNetBSD.cpp

 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::process_netbsd;
 
 NativeThreadNetBSD::NativeThreadNetBSD(NativeProcessNetBSD &process,
                                        lldb::tid_t tid)
     : NativeThreadProtocol(process, tid), m_state(StateType::eStateInvalid),
-      m_stop_info(), m_reg_context_sp(), m_stop_description() {}
+      m_stop_info(), m_reg_context_up(
+NativeRegisterContextNetBSD::CreateHostNativeRegisterContextNetBSD(process.GetArchitecture(), *this)
+), m_stop_description() {}
 
 void NativeThreadNetBSD::SetStoppedBySignal(uint32_t signo,
                                             const siginfo_t *info) {
   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_THREAD));
   LLDB_LOG(log, "tid = {0} in called with signal {1}", GetID(), signo);
 
   SetStopped();
 

 }
 
 void NativeThreadNetBSD::SetStoppedByWatchpoint(uint32_t wp_index) {
   SetStopped();
 
   lldbassert(wp_index != LLDB_INVALID_INDEX32 && "wp_index cannot be invalid");
 
   std::ostringstream ostr;
-  ostr << GetRegisterContext()->GetWatchpointAddress(wp_index) << " ";
+  ostr << GetRegisterContext().GetWatchpointAddress(wp_index) << " ";
   ostr << wp_index;
 
-  ostr << " " << GetRegisterContext()->GetWatchpointHitAddress(wp_index);
+  ostr << " " << GetRegisterContext().GetWatchpointHitAddress(wp_index);
 
   m_stop_description = ostr.str();
 
   m_stop_info.reason = StopReason::eStopReasonWatchpoint;
   m_stop_info.details.signal.signo = SIGTRAP;
 }
 
 void NativeThreadNetBSD::SetStopped() {
bool NativeThreadNetBSD::GetStopReason(ThreadStopInfo &stop_info,
   case eStateDetached:
     LLDB_LOG(log, "tid = {0} in state {1} cannot answer stop reason", GetID(),
              StateAsCString(m_state));
     return false;
   }
   llvm_unreachable("unhandled StateType!");
 }
 
-NativeRegisterContextSP NativeThreadNetBSD::GetRegisterContext() {
-  // Return the register context if we already created it.
-  if (m_reg_context_sp)
-    return m_reg_context_sp;
-
-  const uint32_t concrete_frame_idx = 0;
-  m_reg_context_sp.reset(
-      NativeRegisterContextNetBSD::CreateHostNativeRegisterContextNetBSD(
-          m_process.GetArchitecture(), *this, concrete_frame_idx));
-
-  return m_reg_context_sp;
+NativeRegisterContext& NativeThreadNetBSD::GetRegisterContext() {
+  assert(m_reg_context_up);
+return  *m_reg_context_up;
 }
 
 Status NativeThreadNetBSD::SetWatchpoint(lldb::addr_t addr, size_t size,
                                          uint32_t watch_flags, bool hardware) {
   if (!hardware)
     return Status("not implemented");
   if (m_state == eStateLaunching)
     return Status();
   Status error = RemoveWatchpoint(addr);
   if (error.Fail())
     return error;
-  NativeRegisterContextSP reg_ctx = GetRegisterContext();
-  uint32_t wp_index = reg_ctx->SetHardwareWatchpoint(addr, size, watch_flags);
+  uint32_t wp_index = GetRegisterContext().SetHardwareWatchpoint(addr, size, watch_flags);
   if (wp_index == LLDB_INVALID_INDEX32)
     return Status("Setting hardware watchpoint failed.");
   m_watchpoint_index_map.insert({addr, wp_index});
   return Status();
 }
 
 Status NativeThreadNetBSD::RemoveWatchpoint(lldb::addr_t addr) {
   auto wp = m_watchpoint_index_map.find(addr);
   if (wp == m_watchpoint_index_map.end())
     return Status();
   uint32_t wp_index = wp->second;
   m_watchpoint_index_map.erase(wp);
-  if (GetRegisterContext()->ClearHardwareWatchpoint(wp_index))
+  if (GetRegisterContext().ClearHardwareWatchpoint(wp_index))
     return Status();
   return Status("Clearing hardware watchpoint failed.");
 }
 
 Status NativeThreadNetBSD::SetHardwareBreakpoint(lldb::addr_t addr,
                                                  size_t size) {
   if (m_state == eStateLaunching)
     return Status();
 
   Status error = RemoveHardwareBreakpoint(addr);
   if (error.Fail())
     return error;
 
-  NativeRegisterContextSP reg_ctx = GetRegisterContext();
-  uint32_t bp_index = reg_ctx->SetHardwareBreakpoint(addr, size);
+  uint32_t bp_index = GetRegisterContext().SetHardwareBreakpoint(addr, size);
 
   if (bp_index == LLDB_INVALID_INDEX32)
     return Status("Setting hardware breakpoint failed.");
 
   m_hw_break_index_map.insert({addr, bp_index});
   return Status();
 }
 
 Status NativeThreadNetBSD::RemoveHardwareBreakpoint(lldb::addr_t addr) {
   auto bp = m_hw_break_index_map.find(addr);
   if (bp == m_hw_break_index_map.end())
     return Status();
 
   uint32_t bp_index = bp->second;
-  if (GetRegisterContext()->ClearHardwareBreakpoint(bp_index)) {
+  if (GetRegisterContext().ClearHardwareBreakpoint(bp_index)) {
     m_hw_break_index_map.erase(bp);
     return Status();
   }
 
   return Status("Clearing hardware breakpoint failed.");
 }

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

 namespace lldb_private {
 class NativeRegisterContextRegisterInfo : public NativeRegisterContext {
 public:
   ///
   /// Construct a NativeRegisterContextRegisterInfo, taking ownership
   /// of the register_info_interface pointer.
   ///
   NativeRegisterContextRegisterInfo(
-      NativeThreadProtocol &thread, uint32_t concrete_frame_idx,
+      NativeThreadProtocol &thread,
       RegisterInfoInterface *register_info_interface);
 
   uint32_t GetRegisterCount() const override;
 
   uint32_t GetUserRegisterCount() const override;
 
   const RegisterInfo *GetRegisterInfoAtIndex(uint32_t reg_index) const override;
 
   const RegisterInfoInterface &GetRegisterInfoInterface() const;
 
 private:
   std::unique_ptr<RegisterInfoInterface> m_register_info_interface_up;
 };
 }
 #endif

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

 //===-- NativeRegisterContextRegisterInfo.cpp -------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "NativeRegisterContextRegisterInfo.h"
 #include "lldb/lldb-private-forward.h"
 #include "lldb/lldb-types.h"
 
 using namespace lldb_private;
 
 NativeRegisterContextRegisterInfo::NativeRegisterContextRegisterInfo(
-    NativeThreadProtocol &thread, uint32_t concrete_frame_idx,
+    NativeThreadProtocol &thread,
     RegisterInfoInterface *register_info_interface)
-    : NativeRegisterContext(thread, concrete_frame_idx),
+    : NativeRegisterContext(thread),
       m_register_info_interface_up(register_info_interface) {
   assert(register_info_interface && "null register_info_interface");
 }
 
 uint32_t NativeRegisterContextRegisterInfo::GetRegisterCount() const {
   return m_register_info_interface_up->GetRegisterCount();
 }
 

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

for (i = buf_size - 1; i >= 0; i--)
       response.PutHex8(buf[i]);
   } else {
     for (i = 0; i < buf_size; i++)
       response.PutHex8(buf[i]);
   }
 }
 
 static void WriteRegisterValueInHexFixedWidth(
-    StreamString &response, NativeRegisterContextSP &reg_ctx_sp,
+    StreamString &response, NativeRegisterContext &reg_ctx,
     const RegisterInfo &reg_info, const RegisterValue *reg_value_p,
     lldb::ByteOrder byte_order) {
   RegisterValue reg_value;
   if (!reg_value_p) {
-    Status error = reg_ctx_sp->ReadRegister(&reg_info, reg_value);
+    Status error = reg_ctx.ReadRegister(&reg_info, reg_value);
     if (error.Success())
       reg_value_p = &reg_value;
     // else log.
   }
 
   if (reg_value_p) {
     AppendHexValue(response, (const uint8_t *)reg_value_p->GetBytes(),
                    reg_value_p->GetByteSize(),
                    byte_order == lldb::eByteOrderLittle);
   } else {
     // Zero-out any unreadable values.
     if (reg_info.byte_size > 0) {
       std::basic_string<uint8_t> zeros(reg_info.byte_size, '\0');
       AppendHexValue(response, zeros.data(), zeros.size(), false);
     }
   }
 }
 
 static JSONObject::SP GetRegistersAsJSON(NativeThreadProtocol &thread) {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
 
-  NativeRegisterContextSP reg_ctx_sp = thread.GetRegisterContext();
-  if (!reg_ctx_sp)
-    return nullptr;
+  NativeRegisterContext& reg_ctx = thread.GetRegisterContext();
 
   JSONObject::SP register_object_sp = std::make_shared<JSONObject>();
 
 #ifdef LLDB_JTHREADSINFO_FULL_REGISTER_SET
   // Expedite all registers in the first register set (i.e. should be GPRs) that
   // are not contained in other registers.
   const RegisterSet *reg_set_p = reg_ctx_sp->GetRegisterSet(0);
   if (!reg_set_p)
     return nullptr;
   for (const uint32_t *reg_num_p = reg_set_p->registers;
        *reg_num_p != LLDB_INVALID_REGNUM; ++reg_num_p) {
     uint32_t reg_num = *reg_num_p;
 #else
   // Expedite only a couple of registers until we figure out why sending
   // registers is
   // expensive.
   static const uint32_t k_expedited_registers[] = {
       LLDB_REGNUM_GENERIC_PC, LLDB_REGNUM_GENERIC_SP, LLDB_REGNUM_GENERIC_FP,
       LLDB_REGNUM_GENERIC_RA, LLDB_INVALID_REGNUM};
 
   for (const uint32_t *generic_reg_p = k_expedited_registers;
        *generic_reg_p != LLDB_INVALID_REGNUM; ++generic_reg_p) {
-    uint32_t reg_num = reg_ctx_sp->ConvertRegisterKindToRegisterNumber(
+    uint32_t reg_num = reg_ctx.ConvertRegisterKindToRegisterNumber(
         eRegisterKindGeneric, *generic_reg_p);
     if (reg_num == LLDB_INVALID_REGNUM)
       continue; // Target does not support the given register.
 #endif
 
     const RegisterInfo *const reg_info_p =
-        reg_ctx_sp->GetRegisterInfoAtIndex(reg_num);
+        reg_ctx.GetRegisterInfoAtIndex(reg_num);
     if (reg_info_p == nullptr) {
       if (log)
         log->Printf(
             "%s failed to get register info for register index %" PRIu32,
             __FUNCTION__, reg_num);
       continue;
     }
 
     if (reg_info_p->value_regs != nullptr)
       continue; // Only expedite registers that are not contained in other
                 // registers.
 
     RegisterValue reg_value;
-    Status error = reg_ctx_sp->ReadRegister(reg_info_p, reg_value);
+    Status error = reg_ctx.ReadRegister(reg_info_p, reg_value);
     if (error.Fail()) {
       if (log)
         log->Printf("%s failed to read register '%s' index %" PRIu32 ": %s",
                     __FUNCTION__,
                     reg_info_p->name ? reg_info_p->name : "<unnamed-register>",
                     reg_num, error.AsCString());
       continue;
     }
 
     StreamString stream;
-    WriteRegisterValueInHexFixedWidth(stream, reg_ctx_sp, *reg_info_p,
+    WriteRegisterValueInHexFixedWidth(stream, reg_ctx, *reg_info_p,
                                       &reg_value, lldb::eByteOrderBig);
 
     register_object_sp->SetObject(
         llvm::to_string(reg_num),
         std::make_shared<JSONString>(stream.GetString()));
   }
 
   return register_object_sp;
if (m_list_threads_in_stop_reply) {
     }
 
     uint32_t i = 0;
     response.PutCString("thread-pcs");
     char delimiter = ':';
     for (NativeThreadProtocol *thread;
          (thread = m_debugged_process_up->GetThreadAtIndex(i)) != nullptr;
          ++i) {
-      NativeRegisterContextSP reg_ctx_sp = thread->GetRegisterContext();
-      if (!reg_ctx_sp)
-        continue;
+      NativeRegisterContext& reg_ctx = thread->GetRegisterContext();
 
-      uint32_t reg_to_read = reg_ctx_sp->ConvertRegisterKindToRegisterNumber(
+      uint32_t reg_to_read = reg_ctx.ConvertRegisterKindToRegisterNumber(
           eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC);
       const RegisterInfo *const reg_info_p =
-          reg_ctx_sp->GetRegisterInfoAtIndex(reg_to_read);
+          reg_ctx.GetRegisterInfoAtIndex(reg_to_read);
 
       RegisterValue reg_value;
-      Status error = reg_ctx_sp->ReadRegister(reg_info_p, reg_value);
+      Status error = reg_ctx.ReadRegister(reg_info_p, reg_value);
       if (error.Fail()) {
         if (log)
           log->Printf("%s failed to read register '%s' index %" PRIu32 ": %s",
                       __FUNCTION__,
                       reg_info_p->name ? reg_info_p->name
                                        : "<unnamed-register>",
                       reg_to_read, error.AsCString());
         continue;
       }
 
       response.PutChar(delimiter);
       delimiter = ',';
-      WriteRegisterValueInHexFixedWidth(response, reg_ctx_sp, *reg_info_p,
+      WriteRegisterValueInHexFixedWidth(response, reg_ctx, *reg_info_p,
                                         &reg_value, endian::InlHostByteOrder());
     }
 
     response.PutChar(';');
   }
 
   //
   // Expedite registers.
   //
 
   // Grab the register context.
-  NativeRegisterContextSP reg_ctx_sp = thread->GetRegisterContext();
-  if (reg_ctx_sp) {
-    // Expedite all registers in the first register set (i.e. should be GPRs)
-    // that are not contained in other registers.
-    const RegisterSet *reg_set_p;
-    if (reg_ctx_sp->GetRegisterSetCount() > 0 &&
-        ((reg_set_p = reg_ctx_sp->GetRegisterSet(0)) != nullptr)) {
-      if (log)
-        log->Printf("GDBRemoteCommunicationServerLLGS::%s expediting registers "
-                    "from set '%s' (registers set count: %zu)",
-                    __FUNCTION__,
-                    reg_set_p->name ? reg_set_p->name : "<unnamed-set>",
-                    reg_set_p->num_registers);
+  NativeRegisterContext& reg_ctx = thread->GetRegisterContext();
+  if (reg_ctx.GetRegisterSetCount() > 0 &&
+      ((reg_set_p = reg_ctx.GetRegisterSet(0)) != nullptr)) {
 
-      for (const uint32_t *reg_num_p = reg_set_p->registers;
-           *reg_num_p != LLDB_INVALID_REGNUM; ++reg_num_p) {
-        const RegisterInfo *const reg_info_p =
-            reg_ctx_sp->GetRegisterInfoAtIndex(*reg_num_p);
-        if (reg_info_p == nullptr) {
-          if (log)
-            log->Printf("GDBRemoteCommunicationServerLLGS::%s failed to get "
-                        "register info for register set '%s', register index "
-                        "%" PRIu32,
-                        __FUNCTION__,
-                        reg_set_p->name ? reg_set_p->name : "<unnamed-set>",
-                        *reg_num_p);
-        } else if (reg_info_p->value_regs == nullptr) {
-          // Only expediate registers that are not contained in other registers.
-          RegisterValue reg_value;
-          Status error = reg_ctx_sp->ReadRegister(reg_info_p, reg_value);
-          if (error.Success()) {
-            response.Printf("%.02x:", *reg_num_p);
-            WriteRegisterValueInHexFixedWidth(response, reg_ctx_sp, *reg_info_p,
-                                              &reg_value, lldb::eByteOrderBig);
-            response.PutChar(';');
-          } else {
-            if (log)
-              log->Printf("GDBRemoteCommunicationServerLLGS::%s failed to read "
-                          "register '%s' index %" PRIu32 ": %s",
-                          __FUNCTION__, reg_info_p->name ? reg_info_p->name
-                                                         : "<unnamed-register>",
-                          *reg_num_p, error.AsCString());
-          }
-        }
-      }
-    }
-  }
+          reg_ctx.GetRegisterInfoAtIndex(*reg_num_p);
+        Status error = reg_ctx.ReadRegister(reg_info_p, reg_value);
+          WriteRegisterValueInHexFixedWidth(response, reg_ctx, *reg_info_p,
+                        __FUNCTION__,
+                        reg_info_p->name ? reg_info_p->name
 
   const char *reason_str = GetStopReasonString(tid_stop_info.reason);
   if (reason_str != nullptr) {
     response.Printf("reason:%s;", reason_str);
   }
 
   if (!description.empty()) {
     // Description may contains special chars, send as hex bytes.
if (!m_debugged_process_up ||
     return SendErrorResponse(68);
 
   // Ensure we have a thread.
   NativeThreadProtocol *thread = m_debugged_process_up->GetThreadAtIndex(0);
   if (!thread)
     return SendErrorResponse(69);
 
   // Get the register context for the first thread.
-  NativeRegisterContextSP reg_context_sp(thread->GetRegisterContext());
-  if (!reg_context_sp)
-    return SendErrorResponse(69);
+  NativeRegisterContext &reg_context = thread->GetRegisterContext();
 
   // Parse out the register number from the request.
   packet.SetFilePos(strlen("qRegisterInfo"));
   const uint32_t reg_index =
       packet.GetHexMaxU32(false, std::numeric_limits<uint32_t>::max());
   if (reg_index == std::numeric_limits<uint32_t>::max())
     return SendErrorResponse(69);
 
   // Return the end of registers response if we've iterated one past the end of
   // the register set.
-  if (reg_index >= reg_context_sp->GetUserRegisterCount())
+  if (reg_index >= reg_context.GetUserRegisterCount())
     return SendErrorResponse(69);
 
-  const RegisterInfo *reg_info =
-      reg_context_sp->GetRegisterInfoAtIndex(reg_index);
+  const RegisterInfo *reg_info = reg_context.GetRegisterInfoAtIndex(reg_index);
   if (!reg_info)
     return SendErrorResponse(69);
 
   // Build the reginfos response.
   StreamGDBRemote response;
 
   response.PutCString("name:");
   response.PutCString(reg_info->name);
GDBRemoteCommunicationServerLLGS::Handle_qRegisterInfo(
   case eFormatVectorOfUInt128:
     response.PutCString("format:vector-uint128;");
     break;
   default:
     break;
   };
 
   const char *const register_set_name =
-      reg_context_sp->GetRegisterSetNameForRegisterAtIndex(reg_index);
+      reg_context.GetRegisterSetNameForRegisterAtIndex(reg_index);
   if (register_set_name) {
     response.PutCString("set:");
     response.PutCString(register_set_name);
     response.PutChar(';');
   }
 
   if (reg_info->kinds[RegisterKind::eRegisterKindEHFrame] !=
       LLDB_INVALID_REGNUM)
GDBRemoteCommunicationServerLLGS::Handle_p(StringExtractorGDBRemote &packet) {
   // Get the thread to use.
   NativeThreadProtocol *thread = GetThreadFromSuffix(packet);
   if (!thread) {
     LLDB_LOG(log, "failed, no thread available");
     return SendErrorResponse(0x15);
   }
 
   // Get the thread's register context.
-  NativeRegisterContextSP reg_context_sp(thread->GetRegisterContext());
-  if (!reg_context_sp) {
-    LLDB_LOG(
-        log,
-        "pid {0} tid {1} failed, no register context available for the thread",
-        m_debugged_process_up->GetID(), thread->GetID());
-    return SendErrorResponse(0x15);
-  }
+  NativeRegisterContext &reg_context = thread->GetRegisterContext();
 
   // Return the end of registers response if we've iterated one past the end of
   // the register set.
-  if (reg_index >= reg_context_sp->GetUserRegisterCount()) {
+  if (reg_index >= reg_context.GetUserRegisterCount()) {
     if (log)
       log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, requested "
                   "register %" PRIu32 " beyond register count %" PRIu32,
                   __FUNCTION__, reg_index,
-                  reg_context_sp->GetUserRegisterCount());
+                  reg_context.GetUserRegisterCount());
     return SendErrorResponse(0x15);
   }
 
-  const RegisterInfo *reg_info =
-      reg_context_sp->GetRegisterInfoAtIndex(reg_index);
+  const RegisterInfo *reg_info = reg_context.GetRegisterInfoAtIndex(reg_index);
   if (!reg_info) {
     if (log)
       log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, requested "
                   "register %" PRIu32 " returned NULL",
                   __FUNCTION__, reg_index);
     return SendErrorResponse(0x15);
   }
 
   // Build the reginfos response.
   StreamGDBRemote response;
 
   // Retrieve the value
   RegisterValue reg_value;
-  Status error = reg_context_sp->ReadRegister(reg_info, reg_value);
+  Status error = reg_context.ReadRegister(reg_info, reg_value);
   if (error.Fail()) {
     if (log)
       log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, read of "
                   "requested register %" PRIu32 " (%s) failed: %s",
                   __FUNCTION__, reg_index, reg_info->name, error.AsCString());
     return SendErrorResponse(0x15);
   }
 
if (!thread) {
     if (log)
       log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, no thread "
                   "available (thread index 0)",
                   __FUNCTION__);
     return SendErrorResponse(0x28);
   }
 
   // Get the thread's register context.
-  NativeRegisterContextSP reg_context_sp(thread->GetRegisterContext());
-  if (!reg_context_sp) {
-    if (log)
-      log->Printf(
-          "GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " tid %" PRIu64
-          " failed, no register context available for the thread",
-          __FUNCTION__, m_debugged_process_up->GetID(), thread->GetID());
-    return SendErrorResponse(0x15);
-  }
-
-  const RegisterInfo *reg_info =
-      reg_context_sp->GetRegisterInfoAtIndex(reg_index);
+  NativeRegisterContext &reg_context = thread->GetRegisterContext();
+  const RegisterInfo *reg_info = reg_context.GetRegisterInfoAtIndex(reg_index);
   if (!reg_info) {
     if (log)
       log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, requested "
                   "register %" PRIu32 " returned NULL",
                   __FUNCTION__, reg_index);
     return SendErrorResponse(0x48);
   }
 
   // Return the end of registers response if we've iterated one past the end of
   // the register set.
-  if (reg_index >= reg_context_sp->GetUserRegisterCount()) {
+  if (reg_index >= reg_context.GetUserRegisterCount()) {
     if (log)
       log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, requested "
                   "register %" PRIu32 " beyond register count %" PRIu32,
-                  __FUNCTION__, reg_index,
-                  reg_context_sp->GetUserRegisterCount());
+                  __FUNCTION__, reg_index, reg_context.GetUserRegisterCount());
     return SendErrorResponse(0x47);
   }
 
   // The dwarf expression are evaluate on host site
   // which may cause register size to change
   // Hence the reg_size may not be same as reg_info->bytes_size
   if ((reg_size != reg_info->byte_size) &&
       !(reg_info->dynamic_size_dwarf_expr_bytes)) {
     return SendIllFormedResponse(packet, "P packet register size is incorrect");
   }
 
   // Build the reginfos response.
   StreamGDBRemote response;
 
   RegisterValue reg_value(
       reg_bytes, reg_size,
       m_debugged_process_up->GetArchitecture().GetByteOrder());
-  Status error = reg_context_sp->WriteRegister(reg_info, reg_value);
+  Status error = reg_context.WriteRegister(reg_info, reg_value);
   if (error.Fail()) {
     if (log)
       log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, write of "
                   "requested register %" PRIu32 " (%s) failed: %s",
                   __FUNCTION__, reg_index, reg_info->name, error.AsCString());
     return SendErrorResponse(0x32);
   }
 
if (m_thread_suffix_supported)
       return SendIllFormedResponse(
           packet, "No thread specified in QSaveRegisterState packet");
     else
       return SendIllFormedResponse(packet,
                                    "No thread was is set with the Hg packet");
   }
 
   // Grab the register context for the thread.
-  NativeRegisterContextSP reg_context_sp(thread->GetRegisterContext());
-  if (!reg_context_sp) {
-    LLDB_LOG(
-        log,
-        "pid {0} tid {1} failed, no register context available for the thread",
-        m_debugged_process_up->GetID(), thread->GetID());
-    return SendErrorResponse(0x15);
-  }
+  NativeRegisterContext& reg_context = thread->GetRegisterContext();
 
   // Save registers to a buffer.
   DataBufferSP register_data_sp;
-  Status error = reg_context_sp->ReadAllRegisterValues(register_data_sp);
+  Status error = reg_context.ReadAllRegisterValues(register_data_sp);
   if (error.Fail()) {
     LLDB_LOG(log, "pid {0} failed to save all register values: {1}",
              m_debugged_process_up->GetID(), error);
     return SendErrorResponse(0x75);
   }
 
   // Allocate a new save id.
   const uint32_t save_id = GetNextSavedRegistersID();
if (m_thread_suffix_supported)
       return SendIllFormedResponse(
           packet, "No thread specified in QRestoreRegisterState packet");
     else
       return SendIllFormedResponse(packet,
                                    "No thread was is set with the Hg packet");
   }
 
   // Grab the register context for the thread.
-  NativeRegisterContextSP reg_context_sp(thread->GetRegisterContext());
-  if (!reg_context_sp) {
-    LLDB_LOG(
-        log,
-        "pid {0} tid {1} failed, no register context available for the thread",
-        m_debugged_process_up->GetID(), thread->GetID());
-    return SendErrorResponse(0x15);
-  }
+  NativeRegisterContext &reg_context = thread->GetRegisterContext();
 
   // Retrieve register state buffer, then remove from the list.
   DataBufferSP register_data_sp;
   {
     std::lock_guard<std::mutex> guard(m_saved_registers_mutex);
 
     // Find the register set buffer for the given save id.
     auto it = m_saved_registers_map.find(save_id);
     if (it == m_saved_registers_map.end()) {
       LLDB_LOG(log,
                "pid {0} does not have a register set save buffer for id {1}",
                m_debugged_process_up->GetID(), save_id);
       return SendErrorResponse(0x77);
     }
     register_data_sp = it->second;
 
     // Remove it from the map.
     m_saved_registers_map.erase(it);
   }
 
-  Status error = reg_context_sp->WriteAllRegisterValues(register_data_sp);
+  Status error = reg_context.WriteAllRegisterValues(register_data_sp);
   if (error.Fail()) {
     LLDB_LOG(log, "pid {0} failed to restore all register values: {1}",
              m_debugged_process_up->GetID(), error);
     return SendErrorResponse(0x77);
   }
 
   return SendOKResponse();
 }