Update LLDB snapshot to upstream r225923 (git 2b588ecd)

Sponsored by:	DARPA, AFRL

27 files changed, 2263 insertions, 1038 deletions

diff --git a/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/ARMDefines.h b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/ARMDefines.h
index 2c8ad35..cfb33be 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/ARMDefines.h
+++ b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/ARMDefines.h
@@ -45,7 +45,8 @@ typedef enum
 #define COND_AL     0xE    // Always (unconditional)    Always (unconditional)        Any
 #define COND_UNCOND 0xF
 
-static inline const char *ARMCondCodeToString(uint32_t CC)
+static inline const char *
+ARMCondCodeToString(uint32_t CC)
 {
     switch (CC) {
     default: assert(0 && "Unknown condition code");
@@ -67,6 +68,37 @@ static inline const char *ARMCondCodeToString(uint32_t CC)
     }
 }
 
+static inline bool
+ARMConditionPassed(const uint32_t condition, const uint32_t cpsr)
+{
+    const uint32_t cpsr_n = (cpsr >> 31) & 1u; // Negative condition code flag
+    const uint32_t cpsr_z = (cpsr >> 30) & 1u; // Zero condition code flag
+    const uint32_t cpsr_c = (cpsr >> 29) & 1u; // Carry condition code flag
+    const uint32_t cpsr_v = (cpsr >> 28) & 1u; // Overflow condition code flag
+
+    switch (condition) {
+        case COND_EQ: return (cpsr_z == 1);
+        case COND_NE: return (cpsr_z == 0);
+        case COND_CS: return (cpsr_c == 1);
+        case COND_CC: return (cpsr_c == 0);
+        case COND_MI: return (cpsr_n == 1);
+        case COND_PL: return (cpsr_n == 0);
+        case COND_VS: return (cpsr_v == 1);
+        case COND_VC: return (cpsr_v == 0);
+        case COND_HI: return ((cpsr_c == 1) && (cpsr_z == 0));
+        case COND_LS: return ((cpsr_c == 0) || (cpsr_z == 1));
+        case COND_GE: return (cpsr_n == cpsr_v);
+        case COND_LT: return (cpsr_n != cpsr_v);
+        case COND_GT: return ((cpsr_z == 0) && (cpsr_n == cpsr_v));
+        case COND_LE: return ((cpsr_z == 1) || (cpsr_n != cpsr_v));
+        case COND_AL:
+        case COND_UNCOND:
+        default:
+            return true;
+    }
+    return false;
+}
+
 // Bit positions for CPSR
 #define CPSR_T_POS  5
 #define CPSR_F_POS  6
diff --git a/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/DynamicRegisterInfo.cpp b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/DynamicRegisterInfo.cpp
index 3507ccf..1088924 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/DynamicRegisterInfo.cpp
+++ b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/DynamicRegisterInfo.cpp
@@ -81,6 +81,7 @@ DynamicRegisterInfo::SetRegisterInfo (const lldb_private::PythonDictionary &dict
             else
             {
                 Clear();
+                printf("error: register sets must have valid names\n");
                 return 0;
             }
         }
@@ -121,6 +122,8 @@ DynamicRegisterInfo::SetRegisterInfo (const lldb_private::PythonDictionary &dict
                 if (reg_info.name == NULL)
                 {
                     Clear();
+                    printf("error: registers must have valid names\n");
+                    reg_info_dict.Dump();
                     return 0;
                 }
                     
@@ -290,6 +293,7 @@ DynamicRegisterInfo::SetRegisterInfo (const lldb_private::PythonDictionary &dict
                     if (!success)
                     {
                         Clear();
+                        reg_info_dict.Dump();
                         return 0;
                     }
                 }
@@ -297,6 +301,8 @@ DynamicRegisterInfo::SetRegisterInfo (const lldb_private::PythonDictionary &dict
                 if (bitsize == 0)
                 {
                     Clear();
+                    printf("error: invalid or missing 'bitsize' key/value pair in register dictionary\n");
+                    reg_info_dict.Dump();
                     return 0;
                 }
 
@@ -308,6 +314,8 @@ DynamicRegisterInfo::SetRegisterInfo (const lldb_private::PythonDictionary &dict
                     if (Args::StringToFormat(format_cstr, reg_info.format, NULL).Fail())
                     {
                         Clear();
+                        printf("error: invalid 'format' value in register dictionary\n");
+                        reg_info_dict.Dump();
                         return 0;
                     }
                 }
@@ -326,6 +334,8 @@ DynamicRegisterInfo::SetRegisterInfo (const lldb_private::PythonDictionary &dict
                 if (static_cast<size_t>(set) >= m_sets.size())
                 {
                     Clear();
+                    printf("error: invalid 'set' value in register dictionary, valid values are 0 - %i\n", (int)set);
+                    reg_info_dict.Dump();
                     return 0;
                 }
 
@@ -409,6 +419,8 @@ DynamicRegisterInfo::SetRegisterInfo (const lldb_private::PythonDictionary &dict
             else
             {
                 Clear();
+                printf("error: items in the 'registers' array must be dictionaries\n");
+                regs.Dump();
                 return 0;
             }
         }
diff --git a/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/HistoryThread.cpp b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/HistoryThread.cpp
index 590bb01..206b829 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/HistoryThread.cpp
+++ b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/HistoryThread.cpp
@@ -39,7 +39,7 @@ HistoryThread::HistoryThread (lldb_private::Process &process,
         m_originating_unique_thread_id (tid),
         m_queue_id (LLDB_INVALID_QUEUE_ID)
 {
-    m_unwinder_ap.reset (new HistoryUnwind (*this, pcs, stop_id, stop_id_is_valid));
+    m_unwinder_ap.reset (new HistoryUnwind (*this, pcs, stop_id_is_valid));
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
     if (log)
         log->Printf ("%p HistoryThread::HistoryThread",
diff --git a/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/HistoryThread.h b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/HistoryThread.h
index f9a431d..51173c6 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/HistoryThread.h
+++ b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/HistoryThread.h
@@ -101,6 +101,18 @@ public:
     {
         m_thread_name = name;
     }
+    
+    virtual const char *
+    GetName ()
+    {
+        return m_thread_name.c_str();
+    }
+    
+    virtual void
+    SetName(const char *name)
+    {
+        m_thread_name = name;
+    }
 
 protected:
     virtual lldb::StackFrameListSP
diff --git a/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/HistoryUnwind.cpp b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/HistoryUnwind.cpp
index f809ebe..14afcbe 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/HistoryUnwind.cpp
+++ b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/HistoryUnwind.cpp
@@ -24,11 +24,9 @@ using namespace lldb_private;
 
 HistoryUnwind::HistoryUnwind (Thread &thread,
                               std::vector<lldb::addr_t> pcs,
-                              uint32_t stop_id,
                               bool stop_id_is_valid) :
         Unwind (thread),
         m_pcs (pcs),
-        m_stop_id (stop_id),
         m_stop_id_is_valid (stop_id_is_valid)
 {
 }
diff --git a/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/HistoryUnwind.h b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/HistoryUnwind.h
index 0661b80..733f93e 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/HistoryUnwind.h
+++ b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/HistoryUnwind.h
@@ -21,7 +21,7 @@ namespace lldb_private {
 class HistoryUnwind : public lldb_private::Unwind
 {
 public:
-    HistoryUnwind (Thread &thread, std::vector<lldb::addr_t> pcs, uint32_t stop_id, bool stop_id_is_valid);
+    HistoryUnwind (Thread &thread, std::vector<lldb::addr_t> pcs, bool stop_id_is_valid);
 
     virtual ~HistoryUnwind ();
 
@@ -42,7 +42,6 @@ protected:
 private:
 
     std::vector<lldb::addr_t>   m_pcs;
-    uint32_t                    m_stop_id;
     bool                        m_stop_id_is_valid;
 };
 
diff --git a/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/InferiorCallPOSIX.cpp b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/InferiorCallPOSIX.cpp
index 4a94457..7db83ae 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/InferiorCallPOSIX.cpp
+++ b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/InferiorCallPOSIX.cpp
@@ -98,13 +98,11 @@ lldb_private::InferiorCallMmap (Process *process,
                 ClangASTContext *clang_ast_context = process->GetTarget().GetScratchClangASTContext();
                 ClangASTType clang_void_ptr_type = clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
                 lldb::addr_t args[] = { addr, length, prot_arg, flags_arg, fd, offset };
-                ThreadPlanCallFunction *call_function_thread_plan
-                  = new ThreadPlanCallFunction (*thread,
-                                                mmap_range.GetBaseAddress(),
-                                                clang_void_ptr_type,
-                                                args,
-                                                options);
-                lldb::ThreadPlanSP call_plan_sp (call_function_thread_plan);
+                lldb::ThreadPlanSP call_plan_sp (new ThreadPlanCallFunction (*thread,
+                                                                             mmap_range.GetBaseAddress(),
+                                                                             clang_void_ptr_type,
+                                                                             args,
+                                                                             options));
                 if (call_plan_sp)
                 {
                     StreamFile error_strm;
@@ -241,13 +239,11 @@ lldb_private::InferiorCall (Process *process,
 
     ClangASTContext *clang_ast_context = process->GetTarget().GetScratchClangASTContext();
     ClangASTType clang_void_ptr_type = clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
-    ThreadPlanCallFunction *call_function_thread_plan
-        = new ThreadPlanCallFunction (*thread,
-                                      *address,
-                                      clang_void_ptr_type,
-                                      llvm::ArrayRef<addr_t>(),
-                                      options);
-    lldb::ThreadPlanSP call_plan_sp (call_function_thread_plan);
+    lldb::ThreadPlanSP call_plan_sp (new ThreadPlanCallFunction (*thread,
+                                                                 *address,
+                                                                 clang_void_ptr_type,
+                                                                 llvm::ArrayRef<addr_t>(),
+                                                                 options));
     if (call_plan_sp)
     {
         StreamString error_strm;
diff --git a/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/InstructionUtils.h b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/InstructionUtils.h
index 8139900..6226fbc 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/InstructionUtils.h
+++ b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/InstructionUtils.h
@@ -20,7 +20,7 @@ static inline uint64_t
 Bits64 (const uint64_t bits, const uint32_t msbit, const uint32_t lsbit)
 {
     assert(msbit < 64 && lsbit <= msbit);
-    return (bits >> lsbit) & ((1u << (msbit - lsbit + 1)) - 1);
+    return (bits >> lsbit) & ((1ull << (msbit - lsbit + 1)) - 1);
 }
 
 // Return the bit field(s) from the most significant bit (msbit) to the
diff --git a/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/LinuxSignals.cpp b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/LinuxSignals.cpp
index fb49df6..11a3eef 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/LinuxSignals.cpp
+++ b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/LinuxSignals.cpp
@@ -53,7 +53,7 @@ LinuxSignals::Reset()
     AddSignal (24,   "SIGXCPU",   "XCPU",    false,   true , true , "CPU resource exceeded");
     AddSignal (25,   "SIGXFSZ",   "XFSZ",    false,   true , true , "file size limit exceeded");
     AddSignal (26,   "SIGVTALRM", "VTALRM",  false,   true , true , "virtual time alarm");
-    AddSignal (27,   "SIGPROF",   "PROF",    false,   true , true , "profiling time alarm");
+    AddSignal (27,   "SIGPROF",   "PROF",    false,   false, false, "profiling time alarm");
     AddSignal (28,   "SIGWINCH",  "WINCH",   false,   true , true , "window size changes");
     AddSignal (29,   "SIGPOLL",   "POLL",    false,   true , true , "pollable event");
     AddSignal (29,   "SIGIO",     "IO",      false,   true , true , "input/output ready");
diff --git a/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterContextFreeBSD_powerpc.cpp b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterContextFreeBSD_powerpc.cpp
new file mode 100644
index 0000000..5170e6d
--- /dev/null
+++ b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterContextFreeBSD_powerpc.cpp
@@ -0,0 +1,230 @@
+//===-- RegisterContextFreeBSD_powerpc.cpp ----------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===---------------------------------------------------------------------===//
+
+#include <vector>
+#include "RegisterContextPOSIX_powerpc.h"
+#include "RegisterContextFreeBSD_powerpc.h"
+
+using namespace lldb_private;
+using namespace lldb;
+
+// http://svnweb.freebsd.org/base/head/sys/powerpc/include/reg.h
+typedef struct _GPR64
+{
+    uint64_t r0;
+    uint64_t r1;
+    uint64_t r2;
+    uint64_t r3;
+    uint64_t r4;
+    uint64_t r5;
+    uint64_t r6;
+    uint64_t r7;
+    uint64_t r8;
+    uint64_t r9;
+    uint64_t r10;
+    uint64_t r11;
+    uint64_t r12;
+    uint64_t r13;
+    uint64_t r14;
+    uint64_t r15;
+    uint64_t r16;
+    uint64_t r17;
+    uint64_t r18;
+    uint64_t r19;
+    uint64_t r20;
+    uint64_t r21;
+    uint64_t r22;
+    uint64_t r23;
+    uint64_t r24;
+    uint64_t r25;
+    uint64_t r26;
+    uint64_t r27;
+    uint64_t r28;
+    uint64_t r29;
+    uint64_t r30;
+    uint64_t r31;
+    uint64_t lr;
+    uint64_t cr;
+    uint64_t xer;
+    uint64_t ctr;
+    uint64_t pc;
+} GPR64;
+
+typedef struct _GPR32
+{
+    uint32_t r0;
+    uint32_t r1;
+    uint32_t r2;
+    uint32_t r3;
+    uint32_t r4;
+    uint32_t r5;
+    uint32_t r6;
+    uint32_t r7;
+    uint32_t r8;
+    uint32_t r9;
+    uint32_t r10;
+    uint32_t r11;
+    uint32_t r12;
+    uint32_t r13;
+    uint32_t r14;
+    uint32_t r15;
+    uint32_t r16;
+    uint32_t r17;
+    uint32_t r18;
+    uint32_t r19;
+    uint32_t r20;
+    uint32_t r21;
+    uint32_t r22;
+    uint32_t r23;
+    uint32_t r24;
+    uint32_t r25;
+    uint32_t r26;
+    uint32_t r27;
+    uint32_t r28;
+    uint32_t r29;
+    uint32_t r30;
+    uint32_t r31;
+    uint32_t lr;
+    uint32_t cr;
+    uint32_t xer;
+    uint32_t ctr;
+    uint32_t pc;
+} GPR32;
+
+typedef struct _FPR
+{
+    uint64_t f0;
+    uint64_t f1;
+    uint64_t f2;
+    uint64_t f3;
+    uint64_t f4;
+    uint64_t f5;
+    uint64_t f6;
+    uint64_t f7;
+    uint64_t f8;
+    uint64_t f9;
+    uint64_t f10;
+    uint64_t f11;
+    uint64_t f12;
+    uint64_t f13;
+    uint64_t f14;
+    uint64_t f15;
+    uint64_t f16;
+    uint64_t f17;
+    uint64_t f18;
+    uint64_t f19;
+    uint64_t f20;
+    uint64_t f21;
+    uint64_t f22;
+    uint64_t f23;
+    uint64_t f24;
+    uint64_t f25;
+    uint64_t f26;
+    uint64_t f27;
+    uint64_t f28;
+    uint64_t f29;
+    uint64_t f30;
+    uint64_t f31;
+    uint64_t fpscr;
+} FPR;
+
+//---------------------------------------------------------------------------
+// Include RegisterInfos_powerpc to declare our g_register_infos_powerpc structure.
+//---------------------------------------------------------------------------
+#define DECLARE_REGISTER_INFOS_POWERPC_STRUCT
+#include "RegisterInfos_powerpc.h"
+#undef DECLARE_REGISTER_INFOS_POWERPC_STRUCT
+
+RegisterContextFreeBSD_powerpc::RegisterContextFreeBSD_powerpc(const ArchSpec &target_arch) :
+    RegisterInfoInterface(target_arch)
+{
+}
+
+RegisterContextFreeBSD_powerpc::~RegisterContextFreeBSD_powerpc()
+{
+}
+
+size_t
+RegisterContextFreeBSD_powerpc::GetGPRSize() const
+{
+    // This is an 'abstract' base, so no GPR struct.
+    return 0;
+}
+
+const RegisterInfo *
+RegisterContextFreeBSD_powerpc::GetRegisterInfo() const
+{
+    //assert (m_target_arch.GetCore() == ArchSpec::eCore_powerpc);
+    llvm_unreachable("Abstract class!");
+    return NULL;
+}
+
+uint32_t
+RegisterContextFreeBSD_powerpc::GetRegisterCount () const
+{
+    return 0;
+}
+
+RegisterContextFreeBSD_powerpc32::RegisterContextFreeBSD_powerpc32(const ArchSpec &target_arch) :
+    RegisterContextFreeBSD_powerpc(target_arch)
+{
+}
+
+RegisterContextFreeBSD_powerpc32::~RegisterContextFreeBSD_powerpc32()
+{
+}
+
+size_t
+RegisterContextFreeBSD_powerpc32::GetGPRSize() const
+{
+    return sizeof(GPR32);
+}
+
+const RegisterInfo *
+RegisterContextFreeBSD_powerpc32::GetRegisterInfo() const
+{
+    //assert (m_target_arch.GetCore() == ArchSpec::eCore_powerpc);
+    return g_register_infos_powerpc32;
+}
+
+uint32_t
+RegisterContextFreeBSD_powerpc32::GetRegisterCount () const
+{
+    return static_cast<uint32_t> (sizeof (g_register_infos_powerpc32) / sizeof (g_register_infos_powerpc32 [0]));
+}
+
+RegisterContextFreeBSD_powerpc64::RegisterContextFreeBSD_powerpc64(const ArchSpec &target_arch) :
+    RegisterContextFreeBSD_powerpc(target_arch)
+{
+}
+
+RegisterContextFreeBSD_powerpc64::~RegisterContextFreeBSD_powerpc64()
+{
+}
+
+size_t
+RegisterContextFreeBSD_powerpc64::GetGPRSize() const
+{
+    return sizeof(GPR64);
+}
+
+const RegisterInfo *
+RegisterContextFreeBSD_powerpc64::GetRegisterInfo() const
+{
+    //assert (m_target_arch.GetCore() == ArchSpec::eCore_powerpc);
+    if (m_target_arch.GetMachine() == llvm::Triple::ppc)
+        return g_register_infos_powerpc64_32;
+    return g_register_infos_powerpc64;
+}
+
+uint32_t
+RegisterContextFreeBSD_powerpc64::GetRegisterCount () const
+{
+    return static_cast<uint32_t> (sizeof (g_register_infos_powerpc64) / sizeof (g_register_infos_powerpc64 [0]));
+}
diff --git a/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterContextFreeBSD_powerpc.h b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterContextFreeBSD_powerpc.h
new file mode 100644
index 0000000..b907fe9
--- /dev/null
+++ b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterContextFreeBSD_powerpc.h
@@ -0,0 +1,66 @@
+//===-- RegisterContextFreeBSD_powerpc.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_RegisterContextFreeBSD_powerpc_H_
+#define liblldb_RegisterContextFreeBSD_powerpc_H_
+
+#include "RegisterContextPOSIX.h"
+
+class RegisterContextFreeBSD_powerpc:
+    public lldb_private::RegisterInfoInterface
+{
+public:
+    RegisterContextFreeBSD_powerpc(const lldb_private::ArchSpec &target_arch);
+    virtual ~RegisterContextFreeBSD_powerpc();
+
+    size_t
+    GetGPRSize() const override;
+
+    const lldb_private::RegisterInfo *
+    GetRegisterInfo() const override;
+
+    uint32_t
+    GetRegisterCount() const override;
+};
+
+class RegisterContextFreeBSD_powerpc32:
+    public RegisterContextFreeBSD_powerpc
+{
+public:
+    RegisterContextFreeBSD_powerpc32(const lldb_private::ArchSpec &target_arch);
+    virtual ~RegisterContextFreeBSD_powerpc32();
+
+    size_t
+    GetGPRSize() const override;
+
+    const lldb_private::RegisterInfo *
+    GetRegisterInfo() const override;
+
+    uint32_t
+    GetRegisterCount() const override;
+};
+
+class RegisterContextFreeBSD_powerpc64:
+    public RegisterContextFreeBSD_powerpc
+{
+public:
+    RegisterContextFreeBSD_powerpc64(const lldb_private::ArchSpec &target_arch);
+    virtual ~RegisterContextFreeBSD_powerpc64();
+
+    size_t
+    GetGPRSize() const override;
+
+    const lldb_private::RegisterInfo *
+    GetRegisterInfo() const override;
+
+    uint32_t
+    GetRegisterCount() const override;
+};
+
+#endif
diff --git a/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterContextLLDB.cpp b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterContextLLDB.cpp
index b58e6bb..f47d687 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterContextLLDB.cpp
+++ b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterContextLLDB.cpp
@@ -172,6 +172,21 @@ RegisterContextLLDB::InitializeZerothFrame()
         m_sym_ctx_valid = true;
     }
 
+    if (m_sym_ctx.symbol)
+    {
+        UnwindLogMsg ("with pc value of 0x%" PRIx64 ", symbol name is '%s'",
+                      current_pc, m_sym_ctx.symbol == NULL ? "" : m_sym_ctx.symbol->GetName().AsCString());
+    }
+    else if (m_sym_ctx.function)
+    {
+        UnwindLogMsg ("with pc value of 0x%" PRIx64 ", function name is '%s'",
+                      current_pc, m_sym_ctx.symbol == NULL ? "" : m_sym_ctx.function->GetName().AsCString());
+    }
+    else
+    {
+        UnwindLogMsg ("with pc value of 0x%" PRIx64 ", no symbol/function name is known.", current_pc);
+    }
+
     AddressRange addr_range;
     m_sym_ctx.GetAddressRange (resolve_scope, 0, false, addr_range);
 
@@ -217,7 +232,6 @@ RegisterContextLLDB::InitializeZerothFrame()
     m_full_unwind_plan_sp = GetFullUnwindPlanForFrame ();
 
     UnwindPlan::RowSP active_row;
-    int cfa_offset = 0;
     lldb::RegisterKind row_register_kind = eRegisterKindGeneric;
     if (m_full_unwind_plan_sp && m_full_unwind_plan_sp->PlanValidAtAddress (m_current_pc))
     {
@@ -239,18 +253,13 @@ RegisterContextLLDB::InitializeZerothFrame()
     }
 
 
-    addr_t cfa_regval = LLDB_INVALID_ADDRESS;
-    if (!ReadGPRValue (row_register_kind, active_row->GetCFARegister(), cfa_regval))
+    if (!ReadCFAValueForRow (row_register_kind, active_row, m_cfa))
     {
         UnwindLogMsg ("could not read CFA register for this frame.");
         m_frame_type = eNotAValidFrame;
         return;
     }
 
-    cfa_offset = active_row->GetCFAOffset ();
-    m_cfa = cfa_regval + cfa_offset;
-
-    UnwindLogMsg ("cfa_regval = 0x%16.16" PRIx64 " (cfa_regval = 0x%16.16" PRIx64 ", cfa_offset = %i)", m_cfa, cfa_regval, cfa_offset);
     UnwindLogMsg ("initialized frame current pc is 0x%" PRIx64 " cfa is 0x%" PRIx64 " using %s UnwindPlan",
             (uint64_t) m_current_pc.GetLoadAddress (exe_ctx.GetTargetPtr()),
             (uint64_t) m_cfa,
@@ -294,20 +303,27 @@ RegisterContextLLDB::InitializeNonZerothFrame()
 
     if (log)
     {
-        UnwindLogMsg ("pc = 0x%16.16" PRIx64, pc);
+        UnwindLogMsg ("pc = 0x%" PRIx64, pc);
         addr_t reg_val;
         if (ReadGPRValue (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_FP, reg_val))
-            UnwindLogMsg ("fp = 0x%16.16" PRIx64, reg_val);
+            UnwindLogMsg ("fp = 0x%" PRIx64, reg_val);
         if (ReadGPRValue (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_SP, reg_val))
-            UnwindLogMsg ("sp = 0x%16.16" PRIx64, reg_val);
+            UnwindLogMsg ("sp = 0x%" PRIx64, reg_val);
     }
 
-    // A pc of 0x0 means it's the end of the stack crawl
-    if (pc == 0)
+    // A pc of 0x0 means it's the end of the stack crawl unless we're above a trap handler function
+    bool above_trap_handler = false;
+    if (GetNextFrame().get() && GetNextFrame()->IsValid() && GetNextFrame()->IsTrapHandlerFrame())
+        above_trap_handler = true;
+
+    if (pc == 0 || pc == 0x1)
     {
-        m_frame_type = eNotAValidFrame;
-        UnwindLogMsg ("this frame has a pc of 0x0");
-        return;
+        if (above_trap_handler == false)
+        {
+            m_frame_type = eNotAValidFrame;
+            UnwindLogMsg ("this frame has a pc of 0x0");
+            return;
+        }
     }
 
     ExecutionContext exe_ctx(m_thread.shared_from_this());
@@ -363,35 +379,31 @@ RegisterContextLLDB::InitializeNonZerothFrame()
             m_all_registers_available = false;
             m_current_offset = -1;
             m_current_offset_backed_up_one = -1;
-            addr_t cfa_regval = LLDB_INVALID_ADDRESS;
             RegisterKind row_register_kind = m_full_unwind_plan_sp->GetRegisterKind ();
             UnwindPlan::RowSP row = m_full_unwind_plan_sp->GetRowForFunctionOffset(0);
             if (row.get())
             {
-                uint32_t cfa_regnum = row->GetCFARegister();
-                int cfa_offset = row->GetCFAOffset();
-                if (!ReadGPRValue (row_register_kind, cfa_regnum, cfa_regval))
+                if (!ReadCFAValueForRow (row_register_kind, row, m_cfa))
                 {
                     UnwindLogMsg ("failed to get cfa value");
                     if (m_frame_type != eSkipFrame)   // don't override eSkipFrame
                     {
-                        m_frame_type = eNormalFrame;
+                        m_frame_type = eNotAValidFrame;
                     }
                     return;
                 }
-                m_cfa = cfa_regval + cfa_offset;
 
                 // A couple of sanity checks..
-                if (cfa_regval == LLDB_INVALID_ADDRESS || cfa_regval == 0 || cfa_regval == 1)
+                if (m_cfa == LLDB_INVALID_ADDRESS || m_cfa == 0 || m_cfa == 1)
                 {
                     UnwindLogMsg ("could not find a valid cfa address");
                     m_frame_type = eNotAValidFrame;
                     return;
                 }
 
-                // cfa_regval should point into the stack memory; if we can query memory region permissions,
+                // m_cfa should point into the stack memory; if we can query memory region permissions,
                 // see if the memory is allocated & readable.
-                if (process->GetLoadAddressPermissions(cfa_regval, permissions)
+                if (process->GetLoadAddressPermissions(m_cfa, permissions)
                     && (permissions & ePermissionsReadable) == 0)
                 {
                     m_frame_type = eNotAValidFrame;
@@ -406,6 +418,17 @@ RegisterContextLLDB::InitializeNonZerothFrame()
                 return;
             }
 
+            if (CheckIfLoopingStack ())
+            {
+                TryFallbackUnwindPlan();
+                if (CheckIfLoopingStack ())
+                {
+                    UnwindLogMsg ("same CFA address as next frame, assuming the unwind is looping - stopping");
+                    m_frame_type = eNotAValidFrame;
+                    return;
+                }
+            }
+
             UnwindLogMsg ("initialized frame cfa is 0x%" PRIx64, (uint64_t) m_cfa);
             return;
         }
@@ -431,6 +454,21 @@ RegisterContextLLDB::InitializeNonZerothFrame()
         m_sym_ctx_valid = true;
     }
 
+    if (m_sym_ctx.symbol)
+    {
+        UnwindLogMsg ("with pc value of 0x%" PRIx64 ", symbol name is '%s'",
+                      pc, m_sym_ctx.symbol == NULL ? "" : m_sym_ctx.symbol->GetName().AsCString());
+    }
+    else if (m_sym_ctx.function)
+    {
+        UnwindLogMsg ("with pc value of 0x%" PRIx64 ", function name is '%s'",
+                      pc, m_sym_ctx.symbol == NULL ? "" : m_sym_ctx.function->GetName().AsCString());
+    }
+    else
+    {
+        UnwindLogMsg ("with pc value of 0x%" PRIx64 ", no symbol/function name is known.", pc);
+    }
+
     AddressRange addr_range;
     if (!m_sym_ctx.GetAddressRange (resolve_scope, 0, false, addr_range))
     {
@@ -461,17 +499,22 @@ RegisterContextLLDB::InitializeNonZerothFrame()
     // to the ABI plugin and consult that.
     if (decr_pc_and_recompute_addr_range)
     {
-        Address temporary_pc(m_current_pc);
-        temporary_pc.SetOffset(m_current_pc.GetOffset() - 1);
-        m_sym_ctx.Clear(false);
+        UnwindLogMsg ("Backing up the pc value of 0x%" PRIx64 " by 1 and re-doing symbol lookup; old symbol was %s",
+                      pc, m_sym_ctx.symbol == NULL ? "" : m_sym_ctx.symbol->GetName().AsCString());
+        Address temporary_pc;
+        temporary_pc.SetLoadAddress (pc - 1, &process->GetTarget());
+        m_sym_ctx.Clear (false);
         m_sym_ctx_valid = false;
         uint32_t resolve_scope = eSymbolContextFunction | eSymbolContextSymbol;
         
-        if (pc_module_sp->ResolveSymbolContextForAddress (temporary_pc, resolve_scope, m_sym_ctx) & resolve_scope)
+        ModuleSP temporary_module_sp = temporary_pc.GetModule();
+        if (temporary_module_sp &&
+            temporary_module_sp->ResolveSymbolContextForAddress (temporary_pc, resolve_scope, m_sym_ctx) & resolve_scope)
         {
             if (m_sym_ctx.GetAddressRange (resolve_scope, 0, false,  addr_range))
                 m_sym_ctx_valid = true;
         }
+        UnwindLogMsg ("Symbol is now %s", m_sym_ctx.symbol == NULL ? "" : m_sym_ctx.symbol->GetName().AsCString());
     }
 
     // If we were able to find a symbol/function, set addr_range_ptr to the bounds of that symbol/function.
@@ -479,13 +522,15 @@ RegisterContextLLDB::InitializeNonZerothFrame()
     if (addr_range.GetBaseAddress().IsValid())
     {
         m_start_pc = addr_range.GetBaseAddress();
-        m_current_offset = m_current_pc.GetOffset() - m_start_pc.GetOffset();
+        m_current_offset = pc - m_start_pc.GetLoadAddress (&process->GetTarget());
         m_current_offset_backed_up_one = m_current_offset;
         if (decr_pc_and_recompute_addr_range && m_current_offset_backed_up_one > 0)
         {
             m_current_offset_backed_up_one--;
             if (m_sym_ctx_valid)
-                m_current_pc.SetOffset(m_current_pc.GetOffset() - 1);
+            {
+                m_current_pc.SetLoadAddress (pc - 1, &process->GetTarget());
+            }
         }
     }
     else
@@ -512,7 +557,6 @@ RegisterContextLLDB::InitializeNonZerothFrame()
     m_fast_unwind_plan_sp = GetFastUnwindPlanForFrame ();
 
     UnwindPlan::RowSP active_row;
-    int cfa_offset = 0;
     RegisterKind row_register_kind = eRegisterKindGeneric;
 
     // Try to get by with just the fast UnwindPlan if possible - the full UnwindPlan may be expensive to get
@@ -553,27 +597,33 @@ RegisterContextLLDB::InitializeNonZerothFrame()
         return;
     }
 
-    addr_t cfa_regval = LLDB_INVALID_ADDRESS;
-    if (!ReadGPRValue (row_register_kind, active_row->GetCFARegister(), cfa_regval))
+    if (!ReadCFAValueForRow (row_register_kind, active_row, m_cfa))
     {
         UnwindLogMsg ("failed to get cfa reg %d/%d", row_register_kind, active_row->GetCFARegister());
         m_frame_type = eNotAValidFrame;
         return;
     }
 
-    cfa_offset = active_row->GetCFAOffset ();
-    m_cfa = cfa_regval + cfa_offset;
+    UnwindLogMsg ("m_cfa = 0x%" PRIx64, m_cfa);
 
-    UnwindLogMsg ("cfa_regval = 0x%16.16" PRIx64 " (cfa_regval = 0x%16.16" PRIx64 ", cfa_offset = %i)", m_cfa, cfa_regval, cfa_offset);
-
-    // A couple of sanity checks..
-    if (cfa_regval == LLDB_INVALID_ADDRESS || cfa_regval == 0 || cfa_regval == 1)
+    if (CheckIfLoopingStack ())
     {
-        UnwindLogMsg ("could not find a valid cfa address");
-        m_frame_type = eNotAValidFrame;
-        return;
+        TryFallbackUnwindPlan();
+        if (CheckIfLoopingStack ())
+        {
+            UnwindLogMsg ("same CFA address as next frame, assuming the unwind is looping - stopping");
+            m_frame_type = eNotAValidFrame;
+            return;
+        }
     }
 
+    UnwindLogMsg ("initialized frame current pc is 0x%" PRIx64 " cfa is 0x%" PRIx64,
+            (uint64_t) m_current_pc.GetLoadAddress (exe_ctx.GetTargetPtr()), (uint64_t) m_cfa);
+}
+
+bool
+RegisterContextLLDB::CheckIfLoopingStack ()
+{
     // If we have a bad stack setup, we can get the same CFA value multiple times -- or even
     // more devious, we can actually oscillate between two CFA values.  Detect that here and
     // break out to avoid a possible infinite loop in lldb trying to unwind the stack.
@@ -581,29 +631,19 @@ RegisterContextLLDB::InitializeNonZerothFrame()
     addr_t next_next_frame_cfa = LLDB_INVALID_ADDRESS;
     if (GetNextFrame().get() && GetNextFrame()->GetCFA(next_frame_cfa))
     {
-        bool repeating_frames = false;
         if (next_frame_cfa == m_cfa)
         {
-            repeating_frames = true;
-        }
-        else
-        {
-            if (GetNextFrame()->GetNextFrame() && GetNextFrame()->GetNextFrame()->GetCFA(next_next_frame_cfa)
-                && next_next_frame_cfa == m_cfa)
-            {
-                repeating_frames = true;
-            }
+            // We have a loop in the stack unwind
+            return true;
         }
-        if (repeating_frames && abi && abi->FunctionCallsChangeCFA())
+        if (GetNextFrame()->GetNextFrame().get() && GetNextFrame()->GetNextFrame()->GetCFA(next_next_frame_cfa)
+            && next_next_frame_cfa == m_cfa)
         {
-            UnwindLogMsg ("same CFA address as next frame, assuming the unwind is looping - stopping");
-            m_frame_type = eNotAValidFrame;
-            return;
+            // We have a loop in the stack unwind
+            return true; 
         }
     }
-
-    UnwindLogMsg ("initialized frame current pc is 0x%" PRIx64 " cfa is 0x%" PRIx64,
-            (uint64_t) m_current_pc.GetLoadAddress (exe_ctx.GetTargetPtr()), (uint64_t) m_cfa);
+    return false;
 }
 
 
@@ -715,13 +755,17 @@ RegisterContextLLDB::GetFullUnwindPlanForFrame ()
         uint32_t permissions;
         addr_t current_pc_addr = m_current_pc.GetLoadAddress (exe_ctx.GetTargetPtr());
         if (current_pc_addr == 0
-            || (process->GetLoadAddressPermissions (current_pc_addr, permissions)
+            || (process &&
+                process->GetLoadAddressPermissions (current_pc_addr, permissions)
                 && (permissions & ePermissionsExecutable) == 0))
         {
-            unwind_plan_sp.reset (new UnwindPlan (lldb::eRegisterKindGeneric));
-            abi->CreateFunctionEntryUnwindPlan(*unwind_plan_sp);
-            m_frame_type = eNormalFrame;
-            return unwind_plan_sp;
+            if (abi)
+            {
+                unwind_plan_sp.reset (new UnwindPlan (lldb::eRegisterKindGeneric));
+                abi->CreateFunctionEntryUnwindPlan(*unwind_plan_sp);
+                m_frame_type = eNormalFrame;
+                return unwind_plan_sp;
+            }
         }
     }
 
@@ -764,10 +808,10 @@ RegisterContextLLDB::GetFullUnwindPlanForFrame ()
     // is properly encoded in the eh_frame section, so prefer that if available.
     // On other platforms we may need to provide a platform-specific UnwindPlan which encodes the details of
     // how to unwind out of sigtramp.
-    if (m_frame_type == eTrapHandlerFrame)
+    if (m_frame_type == eTrapHandlerFrame && process)
     {
         m_fast_unwind_plan_sp.reset();
-        unwind_plan_sp = func_unwinders_sp->GetUnwindPlanAtCallSite (m_current_offset_backed_up_one);
+        unwind_plan_sp = func_unwinders_sp->GetUnwindPlanAtCallSite (process->GetTarget(), m_current_offset_backed_up_one);
         if (unwind_plan_sp && unwind_plan_sp->PlanValidAtAddress (m_current_pc) && unwind_plan_sp->GetSourcedFromCompiler() == eLazyBoolYes)
         {
             return unwind_plan_sp;
@@ -782,7 +826,7 @@ RegisterContextLLDB::GetFullUnwindPlanForFrame ()
     // But there is not.
     if (process && process->GetDynamicLoader() && process->GetDynamicLoader()->AlwaysRelyOnEHUnwindInfo (m_sym_ctx))
     {
-        unwind_plan_sp = func_unwinders_sp->GetUnwindPlanAtCallSite (m_current_offset_backed_up_one);
+        unwind_plan_sp = func_unwinders_sp->GetUnwindPlanAtCallSite (process->GetTarget(), m_current_offset_backed_up_one);
         if (unwind_plan_sp && unwind_plan_sp->PlanValidAtAddress (m_current_pc))
         {
             UnwindLogMsgVerbose ("frame uses %s for full UnwindPlan because the DynamicLoader suggested we prefer it",
@@ -792,7 +836,7 @@ RegisterContextLLDB::GetFullUnwindPlanForFrame ()
     }
 
     // Typically the NonCallSite UnwindPlan is the unwind created by inspecting the assembly language instructions
-    if (behaves_like_zeroth_frame)
+    if (behaves_like_zeroth_frame && process)
     {
         unwind_plan_sp = func_unwinders_sp->GetUnwindPlanAtNonCallSite (process->GetTarget(), m_thread, m_current_offset_backed_up_one);
         if (unwind_plan_sp && unwind_plan_sp->PlanValidAtAddress (m_current_pc))
@@ -812,7 +856,10 @@ RegisterContextLLDB::GetFullUnwindPlanForFrame ()
     }
 
     // Typically this is unwind info from an eh_frame section intended for exception handling; only valid at call sites
-    unwind_plan_sp = func_unwinders_sp->GetUnwindPlanAtCallSite (m_current_offset_backed_up_one);
+    if (process)
+    {
+        unwind_plan_sp = func_unwinders_sp->GetUnwindPlanAtCallSite (process->GetTarget(), m_current_offset_backed_up_one);
+    }
     int valid_offset = -1;
     if (IsUnwindPlanValidForCurrentPC(unwind_plan_sp, valid_offset))
     {
@@ -822,7 +869,10 @@ RegisterContextLLDB::GetFullUnwindPlanForFrame ()
 
     // We'd prefer to use an UnwindPlan intended for call sites when we're at a call site but if we've
     // struck out on that, fall back to using the non-call-site assembly inspection UnwindPlan if possible.
-    unwind_plan_sp = func_unwinders_sp->GetUnwindPlanAtNonCallSite (process->GetTarget(), m_thread, m_current_offset_backed_up_one);
+    if (process)
+    {
+        unwind_plan_sp = func_unwinders_sp->GetUnwindPlanAtNonCallSite (process->GetTarget(), m_thread, m_current_offset_backed_up_one);
+    }
     if (unwind_plan_sp && unwind_plan_sp->GetSourcedFromCompiler() == eLazyBoolNo)
     {
         // We probably have an UnwindPlan created by inspecting assembly instructions, and we probably
@@ -908,6 +958,16 @@ RegisterContextLLDB::ReadRegisterValueFromRegisterLocation (lldb_private::Unwind
 
     switch (regloc.type)
     {
+    case UnwindLLDB::RegisterLocation::eRegisterInLiveRegisterContext:
+        {
+            const RegisterInfo *other_reg_info = GetRegisterInfoAtIndex(regloc.location.register_number);
+
+            if (!other_reg_info)
+                return false;
+
+            success = m_thread.GetRegisterContext()->ReadRegister (other_reg_info, value);
+        }
+        break;
     case UnwindLLDB::RegisterLocation::eRegisterInRegister:
         {
             const RegisterInfo *other_reg_info = GetRegisterInfoAtIndex(regloc.location.register_number);
@@ -962,6 +1022,12 @@ RegisterContextLLDB::WriteRegisterValueToRegisterLocation (lldb_private::UnwindL
 
     switch (regloc.type)
     {
+        case UnwindLLDB::RegisterLocation::eRegisterInLiveRegisterContext:
+            {
+                const RegisterInfo *other_reg_info = GetRegisterInfoAtIndex(regloc.location.register_number);
+                success = m_thread.GetRegisterContext()->WriteRegister (other_reg_info, value);
+            }
+            break;
         case UnwindLLDB::RegisterLocation::eRegisterInRegister:
             {
                 const RegisterInfo *other_reg_info = GetRegisterInfoAtIndex(regloc.location.register_number);
@@ -1004,6 +1070,11 @@ RegisterContextLLDB::IsValid () const
     return m_frame_type != eNotAValidFrame;
 }
 
+// After the final stack frame in a stack walk we'll get one invalid (eNotAValidFrame) stack frame --
+// one past the end of the stack walk.  But higher-level code will need to tell the differnece between
+// "the unwind plan below this frame failed" versus "we successfully completed the stack walk" so
+// this method helps to disambiguate that.
+
 bool
 RegisterContextLLDB::IsTrapHandlerFrame () const
 {
@@ -1056,57 +1127,42 @@ RegisterContextLLDB::IsTrapHandlerSymbol (lldb_private::Process *process, const
 enum UnwindLLDB::RegisterSearchResult
 RegisterContextLLDB::SavedLocationForRegister (uint32_t lldb_regnum, lldb_private::UnwindLLDB::RegisterLocation &regloc)
 {
+    RegisterNumber regnum (m_thread, eRegisterKindLLDB, lldb_regnum);
+
     // Have we already found this register location?
     if (!m_registers.empty())
     {
         std::map<uint32_t, lldb_private::UnwindLLDB::RegisterLocation>::const_iterator iterator;
-        iterator = m_registers.find (lldb_regnum);
+        iterator = m_registers.find (regnum.GetAsKind (eRegisterKindLLDB));
         if (iterator != m_registers.end())
         {
             regloc = iterator->second;
-            UnwindLogMsg ("supplying caller's saved reg %d's location, cached", lldb_regnum);
+            UnwindLogMsg ("supplying caller's saved %s (%d)'s location, cached", 
+                           regnum.GetName(), regnum.GetAsKind (eRegisterKindLLDB));
             return UnwindLLDB::RegisterSearchResult::eRegisterFound;
         }
     }
 
-    uint32_t sp_regnum = LLDB_INVALID_REGNUM;
-    uint32_t pc_regnum = LLDB_INVALID_REGNUM;
-    m_thread.GetRegisterContext()->ConvertBetweenRegisterKinds (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_SP, eRegisterKindLLDB, sp_regnum);
-    m_thread.GetRegisterContext()->ConvertBetweenRegisterKinds (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC, eRegisterKindLLDB, pc_regnum);
-
-    // Are we looking for the CALLER's stack pointer?  The stack pointer is defined to be the same as THIS frame's
-    // CFA so just return the CFA value.  This is true on x86-32/x86-64 at least.
-    if (sp_regnum != LLDB_INVALID_REGNUM && sp_regnum == lldb_regnum)
-    {
-        // make sure we won't lose precision copying an addr_t (m_cfa) into a uint64_t (.inferred_value)
-        assert (sizeof (addr_t) <= sizeof (uint64_t));
-        regloc.type = UnwindLLDB::RegisterLocation::eRegisterValueInferred;
-        regloc.location.inferred_value = m_cfa;
-        m_registers[lldb_regnum] = regloc;
-        UnwindLogMsg ("supplying caller's stack pointer (%d) value, computed from CFA", lldb_regnum);
-        return UnwindLLDB::RegisterSearchResult::eRegisterFound;
-    }
-
     // Look through the available UnwindPlans for the register location.
 
     UnwindPlan::Row::RegisterLocation unwindplan_regloc;
     bool have_unwindplan_regloc = false;
-    RegisterKind unwindplan_registerkind = (RegisterKind)-1;
+    RegisterKind unwindplan_registerkind = kNumRegisterKinds;
 
     if (m_fast_unwind_plan_sp)
     {
         UnwindPlan::RowSP active_row = m_fast_unwind_plan_sp->GetRowForFunctionOffset (m_current_offset);
         unwindplan_registerkind = m_fast_unwind_plan_sp->GetRegisterKind ();
-        uint32_t row_regnum;
-        if (!m_thread.GetRegisterContext()->ConvertBetweenRegisterKinds (eRegisterKindLLDB, lldb_regnum, unwindplan_registerkind, row_regnum))
+        if (regnum.GetAsKind (unwindplan_registerkind) == LLDB_INVALID_REGNUM)
         {
-            UnwindLogMsg ("could not convert lldb regnum %d into %d RegisterKind reg numbering scheme",
-                    lldb_regnum, (int) unwindplan_registerkind);
+            UnwindLogMsg ("could not convert lldb regnum %s (%d) into %d RegisterKind reg numbering scheme",
+                    regnum.GetName(), regnum.GetAsKind (eRegisterKindLLDB), (int) unwindplan_registerkind);
             return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
         }
-        if (active_row->GetRegisterInfo (row_regnum, unwindplan_regloc))
+        if (active_row->GetRegisterInfo (regnum.GetAsKind (unwindplan_registerkind), unwindplan_regloc))
         {
-            UnwindLogMsg ("supplying caller's saved reg %d's location using FastUnwindPlan", lldb_regnum);
+            UnwindLogMsg ("supplying caller's saved %s (%d)'s location using FastUnwindPlan", 
+                          regnum.GetName(), regnum.GetAsKind (eRegisterKindLLDB));
             have_unwindplan_regloc = true;
         }
     }
@@ -1119,37 +1175,49 @@ RegisterContextLLDB::SavedLocationForRegister (uint32_t lldb_regnum, lldb_privat
 
         if (m_full_unwind_plan_sp)
         {
+            RegisterNumber pc_regnum (m_thread, eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC);
+
             UnwindPlan::RowSP active_row = m_full_unwind_plan_sp->GetRowForFunctionOffset (m_current_offset);
             unwindplan_registerkind = m_full_unwind_plan_sp->GetRegisterKind ();
-            uint32_t row_regnum;
-            bool row_register_rewritten_to_return_address_reg = false;
+
+            RegisterNumber return_address_reg;
 
             // If we're fetching the saved pc and this UnwindPlan defines a ReturnAddress register (e.g. lr on arm),
             // look for the return address register number in the UnwindPlan's row.
-            if (lldb_regnum == pc_regnum && m_full_unwind_plan_sp->GetReturnAddressRegister() != LLDB_INVALID_REGNUM)
+            if (pc_regnum.IsValid()
+                && pc_regnum == regnum
+                && m_full_unwind_plan_sp->GetReturnAddressRegister() != LLDB_INVALID_REGNUM)
             {
-               row_regnum = m_full_unwind_plan_sp->GetReturnAddressRegister();
-               row_register_rewritten_to_return_address_reg = true;
-               UnwindLogMsg ("requested caller's saved PC but this UnwindPlan uses a RA reg; getting reg %d instead",
-                       row_regnum);
+                
+                return_address_reg.init (m_thread, m_full_unwind_plan_sp->GetRegisterKind(), m_full_unwind_plan_sp->GetReturnAddressRegister());
+                regnum = return_address_reg;
+                UnwindLogMsg ("requested caller's saved PC but this UnwindPlan uses a RA reg; getting %s (%d) instead",
+                              return_address_reg.GetName(), return_address_reg.GetAsKind (eRegisterKindLLDB));
             }
             else
             {
-                if (!m_thread.GetRegisterContext()->ConvertBetweenRegisterKinds (eRegisterKindLLDB, lldb_regnum, unwindplan_registerkind, row_regnum))
+                if (regnum.GetAsKind (unwindplan_registerkind) == LLDB_INVALID_REGNUM)
                 {
                     if (unwindplan_registerkind == eRegisterKindGeneric)
-                        UnwindLogMsg ("could not convert lldb regnum %d into eRegisterKindGeneric reg numbering scheme", lldb_regnum);
+                    {
+                        UnwindLogMsg ("could not convert lldb regnum %s (%d) into eRegisterKindGeneric reg numbering scheme", 
+                                      regnum.GetName(), regnum.GetAsKind (eRegisterKindLLDB));
+                    }
                     else
-                        UnwindLogMsg ("could not convert lldb regnum %d into %d RegisterKind reg numbering scheme",
-                                lldb_regnum, (int) unwindplan_registerkind);
+                    {
+                        UnwindLogMsg ("could not convert lldb regnum %s (%d) into %d RegisterKind reg numbering scheme",
+                                    regnum.GetName(), regnum.GetAsKind (eRegisterKindLLDB), (int) unwindplan_registerkind);
+                    }
                     return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
                 }
             }
 
-            if (active_row->GetRegisterInfo (row_regnum, unwindplan_regloc))
+            if (regnum.IsValid() 
+                && active_row->GetRegisterInfo (regnum.GetAsKind (unwindplan_registerkind), unwindplan_regloc))
             {
                 have_unwindplan_regloc = true;
-                UnwindLogMsg ("supplying caller's saved reg %d's location using %s UnwindPlan", lldb_regnum,
+                UnwindLogMsg ("supplying caller's saved %s (%d)'s location using %s UnwindPlan", 
+                              regnum.GetName(), regnum.GetAsKind (eRegisterKindLLDB),
                               m_full_unwind_plan_sp->GetSourceName().GetCString());
             }
 
@@ -1158,19 +1226,19 @@ RegisterContextLLDB::SavedLocationForRegister (uint32_t lldb_regnum, lldb_privat
             // Handle this specially.
 
             if (have_unwindplan_regloc == false 
-                && row_register_rewritten_to_return_address_reg == true 
-                && IsFrameZero()
-                && row_regnum != LLDB_INVALID_REGNUM)
+                && return_address_reg.IsValid()
+                && IsFrameZero())
             {
-                uint32_t ra_regnum_in_lldb_reg_numbering;
-                if (m_thread.GetRegisterContext()->ConvertBetweenRegisterKinds (unwindplan_registerkind, row_regnum, eRegisterKindLLDB, ra_regnum_in_lldb_reg_numbering))
+                if (return_address_reg.GetAsKind (eRegisterKindLLDB) != LLDB_INVALID_REGNUM)
                 {
                     lldb_private::UnwindLLDB::RegisterLocation new_regloc;
-                    new_regloc.type = UnwindLLDB::RegisterLocation::eRegisterInRegister;
-                    new_regloc.location.register_number = ra_regnum_in_lldb_reg_numbering;
-                    m_registers[lldb_regnum] = new_regloc;
+                    new_regloc.type = UnwindLLDB::RegisterLocation::eRegisterInLiveRegisterContext;
+                    new_regloc.location.register_number = return_address_reg.GetAsKind (eRegisterKindLLDB);
+                    m_registers[regnum.GetAsKind (eRegisterKindLLDB)] = new_regloc;
                     regloc = new_regloc;
-                    UnwindLogMsg ("supplying caller's register %d from the live RegisterContext at frame 0, saved in %d", lldb_regnum, ra_regnum_in_lldb_reg_numbering);
+                    UnwindLogMsg ("supplying caller's register %s (%d) from the live RegisterContext at frame 0, saved in %d", 
+                                  return_address_reg.GetName(), return_address_reg.GetAsKind (eRegisterKindLLDB), 
+                                  return_address_reg.GetAsKind (eRegisterKindLLDB));
                     return UnwindLLDB::RegisterSearchResult::eRegisterFound;
                 }
             }
@@ -1187,13 +1255,12 @@ RegisterContextLLDB::SavedLocationForRegister (uint32_t lldb_regnum, lldb_privat
             // when we're at a call site location.
 
             // arch_default_ra_regnum is the return address register # in the Full UnwindPlan register numbering
-            uint32_t arch_default_ra_regnum = LLDB_INVALID_REGNUM; 
-            if (m_thread.GetRegisterContext()->ConvertBetweenRegisterKinds (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_RA, unwindplan_registerkind, arch_default_ra_regnum)
-                && arch_default_ra_regnum != LLDB_INVALID_REGNUM
-                && pc_regnum != LLDB_INVALID_REGNUM
-                && pc_regnum == lldb_regnum
+            RegisterNumber arch_default_ra_regnum (m_thread, eRegisterKindGeneric, LLDB_REGNUM_GENERIC_RA);
+
+            if (arch_default_ra_regnum.GetAsKind (unwindplan_registerkind) != LLDB_INVALID_REGNUM
+                && pc_regnum == regnum
                 && unwindplan_regloc.IsInOtherRegister()
-                && unwindplan_regloc.GetRegisterNumber() == arch_default_ra_regnum
+                && unwindplan_regloc.GetRegisterNumber() == arch_default_ra_regnum.GetAsKind (unwindplan_registerkind)
                 && m_full_unwind_plan_sp->GetSourcedFromCompiler() != eLazyBoolYes
                 && !m_all_registers_available)
             {
@@ -1201,15 +1268,32 @@ RegisterContextLLDB::SavedLocationForRegister (uint32_t lldb_regnum, lldb_privat
                               m_full_unwind_plan_sp->GetSourceName().GetCString());
 
                 // Throw away the full unwindplan; install the arch default unwindplan
-                if (TryFallbackUnwindPlan())
+                if (ForceSwitchToFallbackUnwindPlan())
                 {
-                    // Now re-fetch the pc value we're searching for
-                    uint32_t arch_default_pc_reg = LLDB_INVALID_REGNUM;
+                    // Update for the possibly new unwind plan
+                    unwindplan_registerkind = m_full_unwind_plan_sp->GetRegisterKind ();
                     UnwindPlan::RowSP active_row = m_full_unwind_plan_sp->GetRowForFunctionOffset (m_current_offset);
-                    if (m_thread.GetRegisterContext()->ConvertBetweenRegisterKinds (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC, m_full_unwind_plan_sp->GetRegisterKind(), arch_default_pc_reg)
-                        && arch_default_pc_reg != LLDB_INVALID_REGNUM
-                        && active_row
-                        && active_row->GetRegisterInfo (arch_default_pc_reg, unwindplan_regloc))
+
+                    // Sanity check: Verify that we can fetch a pc value and CFA value with this unwind plan
+
+                    RegisterNumber arch_default_pc_reg (m_thread, eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC);
+                    bool can_fetch_pc_value = false;
+                    bool can_fetch_cfa = false;
+                    addr_t cfa_value;
+                    if (active_row)
+                    {
+                        if (arch_default_pc_reg.GetAsKind (unwindplan_registerkind) != LLDB_INVALID_REGNUM
+                            && active_row->GetRegisterInfo (arch_default_pc_reg.GetAsKind (unwindplan_registerkind), unwindplan_regloc))
+                        {
+                            can_fetch_pc_value = true;
+                        }
+                        if (ReadCFAValueForRow (unwindplan_registerkind, active_row, cfa_value))
+                        {
+                            can_fetch_cfa = true;
+                        }
+                    }
+
+                    if (can_fetch_pc_value && can_fetch_cfa)
                     {
                         have_unwindplan_regloc = true;
                     }
@@ -1218,10 +1302,35 @@ RegisterContextLLDB::SavedLocationForRegister (uint32_t lldb_regnum, lldb_privat
                         have_unwindplan_regloc = false;
                     }
                 }
+                else
+                {
+                    // We were unable to fall back to another unwind plan
+                    have_unwindplan_regloc = false;
+                }
             }
         }
     }
 
+    if (have_unwindplan_regloc == false)
+    {
+        // Did the UnwindPlan fail to give us the caller's stack pointer?  
+        // The stack pointer is defined to be the same as THIS frame's CFA, so return the CFA value as
+        // the caller's stack pointer.  This is true on x86-32/x86-64 at least.
+
+        RegisterNumber sp_regnum (m_thread, eRegisterKindGeneric, LLDB_REGNUM_GENERIC_SP);
+        if (sp_regnum.GetAsKind (eRegisterKindLLDB) != LLDB_INVALID_REGNUM 
+            && sp_regnum.GetAsKind (eRegisterKindLLDB) == regnum.GetAsKind (eRegisterKindLLDB))
+        {
+            // make sure we won't lose precision copying an addr_t (m_cfa) into a uint64_t (.inferred_value)
+            assert (sizeof (addr_t) <= sizeof (uint64_t));
+            regloc.type = UnwindLLDB::RegisterLocation::eRegisterValueInferred;
+            regloc.location.inferred_value = m_cfa;
+            m_registers[regnum.GetAsKind (eRegisterKindLLDB)] = regloc;
+            UnwindLogMsg ("supplying caller's stack pointer %s (%d) value, computed from CFA", 
+                        regnum.GetName(), regnum.GetAsKind (eRegisterKindLLDB));
+            return UnwindLLDB::RegisterSearchResult::eRegisterFound;
+        }
+    }
 
     ExecutionContext exe_ctx(m_thread.shared_from_this());
     Process *process = exe_ctx.GetProcessPtr();
@@ -1232,11 +1341,11 @@ RegisterContextLLDB::SavedLocationForRegister (uint32_t lldb_regnum, lldb_privat
         ABI *abi = process ? process->GetABI().get() : NULL;
         if (abi)
         {
-            const RegisterInfo *reg_info = GetRegisterInfoAtIndex(lldb_regnum);
+            const RegisterInfo *reg_info = GetRegisterInfoAtIndex(regnum.GetAsKind (eRegisterKindLLDB));
             if (reg_info && abi->RegisterIsVolatile (reg_info))
             {
-                UnwindLogMsg ("did not supply reg location for %d (%s) because it is volatile",
-                    lldb_regnum, reg_info->name ? reg_info->name : "??");
+                UnwindLogMsg ("did not supply reg location for %s (%d) because it is volatile",
+                              regnum.GetName(), regnum.GetAsKind (eRegisterKindLLDB));
                 return UnwindLLDB::RegisterSearchResult::eRegisterIsVolatile;
             }
         }
@@ -1245,15 +1354,27 @@ RegisterContextLLDB::SavedLocationForRegister (uint32_t lldb_regnum, lldb_privat
         {
             // This is frame 0 - we should return the actual live register context value
             lldb_private::UnwindLLDB::RegisterLocation new_regloc;
-            new_regloc.type = UnwindLLDB::RegisterLocation::eRegisterInRegister;
-            new_regloc.location.register_number = lldb_regnum;
-            m_registers[lldb_regnum] = new_regloc;
+            new_regloc.type = UnwindLLDB::RegisterLocation::eRegisterInLiveRegisterContext;
+            new_regloc.location.register_number = regnum.GetAsKind (eRegisterKindLLDB);
+            m_registers[regnum.GetAsKind (eRegisterKindLLDB)] = new_regloc;
             regloc = new_regloc;
-            UnwindLogMsg ("supplying caller's register %d from the live RegisterContext at frame 0", lldb_regnum);
+            UnwindLogMsg ("supplying caller's register %s (%d) from the live RegisterContext at frame 0", 
+                           regnum.GetName(), regnum.GetAsKind (eRegisterKindLLDB));
             return UnwindLLDB::RegisterSearchResult::eRegisterFound;
         }
         else
-        UnwindLogMsg ("could not supply caller's reg %d location", lldb_regnum);
+        {
+            std::string unwindplan_name ("");
+            if (m_full_unwind_plan_sp)
+            {
+                unwindplan_name += "via '";
+                unwindplan_name += m_full_unwind_plan_sp->GetSourceName().AsCString();
+                unwindplan_name += "'";
+            }
+            UnwindLogMsg ("no save location for %s (%d) %s", 
+                      regnum.GetName(), regnum.GetAsKind (eRegisterKindLLDB),
+                      unwindplan_name.c_str());
+        }
         return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
     }
 
@@ -1262,8 +1383,9 @@ RegisterContextLLDB::SavedLocationForRegister (uint32_t lldb_regnum, lldb_privat
     {
         lldb_private::UnwindLLDB::RegisterLocation new_regloc;
         new_regloc.type = UnwindLLDB::RegisterLocation::eRegisterNotSaved;
-        m_registers[lldb_regnum] = new_regloc;
-        UnwindLogMsg ("could not supply caller's reg %d location", lldb_regnum);
+        m_registers[regnum.GetAsKind (eRegisterKindLLDB)] = new_regloc;
+        UnwindLogMsg ("save location for %s (%d) is unspecified, continue searching", 
+                      regnum.GetName(), regnum.GetAsKind (eRegisterKindLLDB));
         return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
     }
 
@@ -1271,7 +1393,8 @@ RegisterContextLLDB::SavedLocationForRegister (uint32_t lldb_regnum, lldb_privat
     {
         if (IsFrameZero ())
         {
-            UnwindLogMsg ("could not supply caller's reg %d location", lldb_regnum);
+            UnwindLogMsg ("could not supply caller's %s (%d) location, IsSame", 
+                          regnum.GetName(), regnum.GetAsKind (eRegisterKindLLDB));
             return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
         }
         else
@@ -1285,8 +1408,10 @@ RegisterContextLLDB::SavedLocationForRegister (uint32_t lldb_regnum, lldb_privat
         int offset = unwindplan_regloc.GetOffset();
         regloc.type = UnwindLLDB::RegisterLocation::eRegisterValueInferred;
         regloc.location.inferred_value = m_cfa + offset;
-        m_registers[lldb_regnum] = regloc;
-        UnwindLogMsg ("supplying caller's register %d, value is CFA plus offset %d", lldb_regnum, offset);
+        m_registers[regnum.GetAsKind (eRegisterKindLLDB)] = regloc;
+        UnwindLogMsg ("supplying caller's register %s (%d), value is CFA plus offset %d [value is 0x%" PRIx64 "]", 
+                      regnum.GetName(), regnum.GetAsKind (eRegisterKindLLDB), 
+                      offset, regloc.location.inferred_value);
         return UnwindLLDB::RegisterSearchResult::eRegisterFound;
     }
 
@@ -1295,24 +1420,29 @@ RegisterContextLLDB::SavedLocationForRegister (uint32_t lldb_regnum, lldb_privat
         int offset = unwindplan_regloc.GetOffset();
         regloc.type = UnwindLLDB::RegisterLocation::eRegisterSavedAtMemoryLocation;
         regloc.location.target_memory_location = m_cfa + offset;
-        m_registers[lldb_regnum] = regloc;
-        UnwindLogMsg ("supplying caller's register %d from the stack, saved at CFA plus offset %d", lldb_regnum, offset);
+        m_registers[regnum.GetAsKind (eRegisterKindLLDB)] = regloc;
+        UnwindLogMsg ("supplying caller's register %s (%d) from the stack, saved at CFA plus offset %d [saved at 0x%" PRIx64 "]", 
+                      regnum.GetName(), regnum.GetAsKind (eRegisterKindLLDB), 
+                      offset, regloc.location.target_memory_location);
         return UnwindLLDB::RegisterSearchResult::eRegisterFound;
     }
 
     if (unwindplan_regloc.IsInOtherRegister())
     {
         uint32_t unwindplan_regnum = unwindplan_regloc.GetRegisterNumber();
-        uint32_t row_regnum_in_lldb;
-        if (!m_thread.GetRegisterContext()->ConvertBetweenRegisterKinds (unwindplan_registerkind, unwindplan_regnum, eRegisterKindLLDB, row_regnum_in_lldb))
+        RegisterNumber row_regnum (m_thread, unwindplan_registerkind, unwindplan_regnum);
+        if (row_regnum.GetAsKind (eRegisterKindLLDB) == LLDB_INVALID_REGNUM)
         {
-            UnwindLogMsg ("could not supply caller's reg %d location", lldb_regnum);
+            UnwindLogMsg ("could not supply caller's %s (%d) location - was saved in another reg but couldn't convert that regnum", 
+                          regnum.GetName(), regnum.GetAsKind (eRegisterKindLLDB));
             return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
         }
         regloc.type = UnwindLLDB::RegisterLocation::eRegisterInRegister;
-        regloc.location.register_number = row_regnum_in_lldb;
-        m_registers[lldb_regnum] = regloc;
-        UnwindLogMsg ("supplying caller's register %d, saved in register %d", lldb_regnum, row_regnum_in_lldb);
+        regloc.location.register_number = row_regnum.GetAsKind (eRegisterKindLLDB);
+        m_registers[regnum.GetAsKind (eRegisterKindLLDB)] = regloc;
+        UnwindLogMsg ("supplying caller's register %s (%d), saved in register %s (%d)", 
+                      regnum.GetName(), regnum.GetAsKind (eRegisterKindLLDB), 
+                      row_regnum.GetName(), row_regnum.GetAsKind (eRegisterKindLLDB));
         return UnwindLLDB::RegisterSearchResult::eRegisterFound;
     }
 
@@ -1334,75 +1464,277 @@ RegisterContextLLDB::SavedLocationForRegister (uint32_t lldb_regnum, lldb_privat
              {
                 regloc.type = UnwindLLDB::RegisterLocation::eRegisterValueInferred;
                 regloc.location.inferred_value = val;
-                m_registers[lldb_regnum] = regloc;
-                UnwindLogMsg ("supplying caller's register %d via DWARF expression (IsDWARFExpression)", lldb_regnum);
+                m_registers[regnum.GetAsKind (eRegisterKindLLDB)] = regloc;
+                UnwindLogMsg ("supplying caller's register %s (%d) via DWARF expression (IsDWARFExpression)", 
+                              regnum.GetName(), regnum.GetAsKind (eRegisterKindLLDB));
                 return UnwindLLDB::RegisterSearchResult::eRegisterFound;
             }
             else
             {
                 regloc.type = UnwindLLDB::RegisterLocation::eRegisterSavedAtMemoryLocation;
                 regloc.location.target_memory_location = val;
-                m_registers[lldb_regnum] = regloc;
-                UnwindLogMsg ("supplying caller's register %d via DWARF expression (IsAtDWARFExpression)", lldb_regnum);
+                m_registers[regnum.GetAsKind (eRegisterKindLLDB)] = regloc;
+                UnwindLogMsg ("supplying caller's register %s (%d) via DWARF expression (IsAtDWARFExpression)", 
+                              regnum.GetName(), regnum.GetAsKind (eRegisterKindLLDB));
                 return UnwindLLDB::RegisterSearchResult::eRegisterFound;
             }
         }
-        UnwindLogMsg ("tried to use IsDWARFExpression or IsAtDWARFExpression for reg %d but failed", lldb_regnum);
+        UnwindLogMsg ("tried to use IsDWARFExpression or IsAtDWARFExpression for %s (%d) but failed", 
+                      regnum.GetName(), regnum.GetAsKind (eRegisterKindLLDB));
         return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
     }
 
-    UnwindLogMsg ("could not supply caller's reg %d location", lldb_regnum);
+    UnwindLogMsg ("no save location for %s (%d) in this stack frame", 
+                   regnum.GetName(), regnum.GetAsKind (eRegisterKindLLDB));
 
     // FIXME UnwindPlan::Row types atDWARFExpression and isDWARFExpression are unsupported.
 
     return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
 }
 
-// If the Full unwindplan has been determined to be incorrect, this method will
-// replace it with the architecture's default unwindplan, if one is defined.
-// It will also find the FuncUnwinders object for this function and replace the
-// Full unwind method for the function there so we don't use the errant Full unwindplan
-// again in the future of this debug session.
-// We're most likely doing this because the Full unwindplan was generated by assembly
-// instruction profiling and the profiler got something wrong.
+// TryFallbackUnwindPlan() -- this method is a little tricky.
+// 
+// When this is called, the frame above -- the caller frame, the "previous" frame --
+// is invalid or bad. 
+//
+// Instead of stopping the stack walk here, we'll try a different UnwindPlan and see
+// if we can get a valid frame above us.  
+//
+// This most often happens when an unwind plan based on assembly instruction inspection
+// is not correct -- mostly with hand-written assembly functions or functions where the
+// stack frame is set up "out of band", e.g. the kernel saved the register context and
+// then called an asynchronous trap handler like _sigtramp.
+//
+// Often in these cases, if we just do a dumb stack walk we'll get past this tricky
+// frame and our usual techniques can continue to be used.
 
 bool
 RegisterContextLLDB::TryFallbackUnwindPlan ()
 {
-    UnwindPlan::Row::RegisterLocation unwindplan_regloc;
-    if (m_fallback_unwind_plan_sp.get() == NULL)
+    if (m_fallback_unwind_plan_sp.get() == nullptr)
+        return false;
+
+    if (m_full_unwind_plan_sp.get() == nullptr)
         return false;
 
+    if (m_full_unwind_plan_sp.get() == m_fallback_unwind_plan_sp.get()
+        || m_full_unwind_plan_sp->GetSourceName() == m_fallback_unwind_plan_sp->GetSourceName())
+    {
+        return false;
+    }
+
+    // If a compiler generated unwind plan failed, trying the arch default unwindplan
+    // isn't going to do any better.
+    if (m_full_unwind_plan_sp->GetSourcedFromCompiler() == eLazyBoolYes)
+        return false;
+
+
+    // Get the caller's pc value and our own CFA value.
+    // Swap in the fallback unwind plan, re-fetch the caller's pc value and CFA value.
+    // If they're the same, then the fallback unwind plan provides no benefit.
+
+    RegisterNumber pc_regnum (m_thread, eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC);
+
+    addr_t old_caller_pc_value = LLDB_INVALID_ADDRESS;
+    addr_t new_caller_pc_value = LLDB_INVALID_ADDRESS;
+    addr_t old_this_frame_cfa_value = m_cfa;
+    UnwindLLDB::RegisterLocation regloc;
+    if (SavedLocationForRegister (pc_regnum.GetAsKind (eRegisterKindLLDB), regloc) == UnwindLLDB::RegisterSearchResult::eRegisterFound)
+    {
+        const RegisterInfo *reg_info = GetRegisterInfoAtIndex(pc_regnum.GetAsKind (eRegisterKindLLDB));
+        if (reg_info)
+        {
+            RegisterValue reg_value;
+            if (ReadRegisterValueFromRegisterLocation (regloc, reg_info, reg_value))
+            {
+                old_caller_pc_value = reg_value.GetAsUInt64();
+            }
+        }
+    }
+
+    // This is a tricky wrinkle!  If SavedLocationForRegister() detects a really impossible 
+    // register location for the full unwind plan, it may call ForceSwitchToFallbackUnwindPlan()
+    // which in turn replaces the full unwindplan with the fallback... in short, we're done,
+    // we're using the fallback UnwindPlan.
+    // We checked if m_fallback_unwind_plan_sp was nullptr at the top -- the only way it 
+    // became nullptr since then is via SavedLocationForRegister().
+    if (m_fallback_unwind_plan_sp.get() == nullptr)
+        return true;
+
+
+    // Switch the full UnwindPlan to be the fallback UnwindPlan.  If we decide this isn't
+    // working, we need to restore.
+    // We'll also need to save & restore the value of the m_cfa ivar.  Save is down below a bit in 'old_cfa'.
     UnwindPlanSP original_full_unwind_plan_sp = m_full_unwind_plan_sp;
+    addr_t old_cfa = m_cfa;
+
+    m_registers.clear();
+
+    m_full_unwind_plan_sp = m_fallback_unwind_plan_sp;
+
     UnwindPlan::RowSP active_row = m_fallback_unwind_plan_sp->GetRowForFunctionOffset (m_current_offset);
     
     if (active_row && active_row->GetCFARegister() != LLDB_INVALID_REGNUM)
     {
-        FuncUnwindersSP func_unwinders_sp;
-        if (m_sym_ctx_valid && m_current_pc.IsValid() && m_current_pc.GetModule())
+        addr_t new_cfa;
+        if (!ReadCFAValueForRow (m_fallback_unwind_plan_sp->GetRegisterKind(), active_row, new_cfa)
+            || new_cfa == 0 || new_cfa == 1 || new_cfa == LLDB_INVALID_ADDRESS)
+        {
+            UnwindLogMsg ("failed to get cfa with fallback unwindplan");
+            m_fallback_unwind_plan_sp.reset();
+            m_full_unwind_plan_sp = original_full_unwind_plan_sp;
+            m_cfa = old_cfa;
+            return false;
+        }
+        m_cfa = new_cfa;
+
+        if (SavedLocationForRegister (pc_regnum.GetAsKind (eRegisterKindLLDB), regloc) == UnwindLLDB::RegisterSearchResult::eRegisterFound)
         {
-            func_unwinders_sp = m_current_pc.GetModule()->GetObjectFile()->GetUnwindTable().GetFuncUnwindersContainingAddress (m_current_pc, m_sym_ctx);
-            if (func_unwinders_sp)
+            const RegisterInfo *reg_info = GetRegisterInfoAtIndex(pc_regnum.GetAsKind (eRegisterKindLLDB));
+            if (reg_info)
             {
-                func_unwinders_sp->InvalidateNonCallSiteUnwindPlan (m_thread);
+                RegisterValue reg_value;
+                if (ReadRegisterValueFromRegisterLocation (regloc, reg_info, reg_value))
+                {
+                    new_caller_pc_value = reg_value.GetAsUInt64();
+                }
             }
         }
-        m_registers.clear();
-        m_full_unwind_plan_sp = m_fallback_unwind_plan_sp;
-        addr_t cfa_regval = LLDB_INVALID_ADDRESS;
-        if (ReadGPRValue (m_fallback_unwind_plan_sp->GetRegisterKind(), active_row->GetCFARegister(), cfa_regval))
+
+
+        if (new_caller_pc_value == LLDB_INVALID_ADDRESS)
         {
-            m_cfa = cfa_regval + active_row->GetCFAOffset ();
+            UnwindLogMsg ("failed to get a pc value for the caller frame with the fallback unwind plan");
+            m_fallback_unwind_plan_sp.reset();
+            m_full_unwind_plan_sp = original_full_unwind_plan_sp;
+            m_cfa = old_cfa;
+            return false;
+        }
+
+        if (old_caller_pc_value != LLDB_INVALID_ADDRESS)
+        {
+            if (old_caller_pc_value == new_caller_pc_value && new_cfa == old_this_frame_cfa_value)
+            {
+                UnwindLogMsg ("fallback unwind plan got the same values for this frame CFA and caller frame pc, not using");
+                m_fallback_unwind_plan_sp.reset();
+                m_full_unwind_plan_sp = original_full_unwind_plan_sp;
+                m_cfa = old_cfa;
+                return false;
+            }
         }
 
-        UnwindLogMsg ("full unwind plan '%s' has been replaced by architecture default unwind plan '%s' for this function from now on.",
-                      original_full_unwind_plan_sp->GetSourceName().GetCString(), m_fallback_unwind_plan_sp->GetSourceName().GetCString());
+        UnwindLogMsg ("trying to unwind from this function with the UnwindPlan '%s' because UnwindPlan '%s' failed.", 
+                      m_fallback_unwind_plan_sp->GetSourceName().GetCString(),
+                      original_full_unwind_plan_sp->GetSourceName().GetCString());
+
+        // We've copied the fallback unwind plan into the full - now clear the fallback.
         m_fallback_unwind_plan_sp.reset();
     }
 
     return true;
 }
 
+bool
+RegisterContextLLDB::ForceSwitchToFallbackUnwindPlan ()
+{
+    if (m_fallback_unwind_plan_sp.get() == NULL)
+        return false;
+
+    if (m_full_unwind_plan_sp.get() == NULL)
+        return false;
+
+    if (m_full_unwind_plan_sp.get() == m_fallback_unwind_plan_sp.get()
+        || m_full_unwind_plan_sp->GetSourceName() == m_fallback_unwind_plan_sp->GetSourceName())
+    {
+        return false;
+    }
+
+    UnwindPlan::RowSP active_row = m_fallback_unwind_plan_sp->GetRowForFunctionOffset (m_current_offset);
+    
+    if (active_row && active_row->GetCFARegister() != LLDB_INVALID_REGNUM)
+    {
+        addr_t new_cfa;
+        if (!ReadCFAValueForRow (m_fallback_unwind_plan_sp->GetRegisterKind(), active_row, new_cfa)
+            || new_cfa == 0 || new_cfa == 1 || new_cfa == LLDB_INVALID_ADDRESS)
+        {
+            UnwindLogMsg ("failed to get cfa with fallback unwindplan");
+            m_fallback_unwind_plan_sp.reset();
+            return false;
+        }
+
+        m_full_unwind_plan_sp = m_fallback_unwind_plan_sp;
+        m_fallback_unwind_plan_sp.reset();
+
+        m_registers.clear();
+
+        m_cfa = new_cfa;
+
+        UnwindLogMsg ("switched unconditionally to the fallback unwindplan %s", m_full_unwind_plan_sp->GetSourceName().GetCString());
+        return true;
+    }
+    return false;
+}
+
+bool
+RegisterContextLLDB::ReadCFAValueForRow (lldb::RegisterKind row_register_kind,
+                                         const UnwindPlan::RowSP &row,
+                                         addr_t &cfa_value)
+{
+    RegisterNumber cfa_reg (m_thread, row_register_kind, row->GetCFARegister());
+    RegisterValue reg_value;
+
+    cfa_value = LLDB_INVALID_ADDRESS;
+    addr_t cfa_reg_contents;
+
+    if (ReadGPRValue (cfa_reg, cfa_reg_contents))
+    {
+        if (row->GetCFAType() == UnwindPlan::Row::CFAIsRegisterDereferenced)
+        {
+            const RegisterInfo *reg_info = GetRegisterInfoAtIndex (cfa_reg.GetAsKind (eRegisterKindLLDB));
+            RegisterValue reg_value;
+            if (reg_info)
+            {
+                Error error = ReadRegisterValueFromMemory(reg_info,
+                                                          cfa_reg_contents,
+                                                          reg_info->byte_size,
+                                                          reg_value);
+                if (error.Success ())
+                {
+                    cfa_value = reg_value.GetAsUInt64();
+                    UnwindLogMsg ("CFA value via dereferencing reg %s (%d): reg has val 0x%" PRIx64 ", CFA value is 0x%" PRIx64,
+                                  cfa_reg.GetName(), cfa_reg.GetAsKind (eRegisterKindLLDB),
+                                  cfa_reg_contents, cfa_value);
+                    return true;
+                }
+                else
+                {
+                    UnwindLogMsg ("Tried to deref reg %s (%d) [0x%" PRIx64 "] but memory read failed.",
+                                  cfa_reg.GetName(), cfa_reg.GetAsKind (eRegisterKindLLDB),
+                                  cfa_reg_contents);
+                }
+            }
+        }
+        else
+        {
+            if (cfa_reg_contents == LLDB_INVALID_ADDRESS || cfa_reg_contents == 0 || cfa_reg_contents == 1)
+            {
+                UnwindLogMsg ("Got an invalid CFA register value - reg %s (%d), value 0x%" PRIx64,
+                              cfa_reg.GetName(), cfa_reg.GetAsKind (eRegisterKindLLDB),
+                              cfa_reg_contents);
+                cfa_reg_contents = LLDB_INVALID_ADDRESS;
+                return false;
+            }
+            cfa_value = cfa_reg_contents + row->GetCFAOffset ();
+            UnwindLogMsg ("CFA is 0x%" PRIx64 ": Register %s (%d) contents are 0x%" PRIx64 ", offset is %d",
+                          cfa_value, 
+                          cfa_reg.GetName(), cfa_reg.GetAsKind (eRegisterKindLLDB), 
+                          cfa_reg_contents, row->GetCFAOffset ());
+            return true;
+        }
+    }
+    return false;
+}
+
 // Retrieve a general purpose register value for THIS frame, as saved by the NEXT frame, i.e. the frame that
 // this frame called.  e.g.
 //
@@ -1471,6 +1803,12 @@ RegisterContextLLDB::ReadGPRValue (lldb::RegisterKind register_kind, uint32_t re
     return false;
 }
 
+bool
+RegisterContextLLDB::ReadGPRValue (const RegisterNumber &regnum, addr_t &value)
+{
+    return ReadGPRValue (regnum.GetRegisterKind(), regnum.GetRegisterNumber(), value);
+}
+
 // Find the value of a register in THIS frame
 
 bool
@@ -1593,6 +1931,10 @@ RegisterContextLLDB::ReadPC (addr_t& pc)
     if (!IsValid())
         return false;
 
+    bool above_trap_handler = false;
+    if (GetNextFrame().get() && GetNextFrame()->IsValid() && GetNextFrame()->IsTrapHandlerFrame())
+        above_trap_handler = true;
+
     if (ReadGPRValue (eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC, pc))
     {
         // A pc value of 0 or 1 is impossible in the middle of the stack -- it indicates the end of a stack walk.
@@ -1601,6 +1943,7 @@ RegisterContextLLDB::ReadPC (addr_t& pc)
         // find the bug.
 
         if (m_all_registers_available == false
+            && above_trap_handler == false
             && (pc == 0 || pc == 1))
         {
             return false;
diff --git a/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterContextLLDB.h b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterContextLLDB.h
index d6ecfeb..5f94a97 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterContextLLDB.h
+++ b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterContextLLDB.h
@@ -16,6 +16,7 @@
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Symbol/UnwindPlan.h"
 #include "lldb/Symbol/SymbolContext.h"
+#include "lldb/Utility/RegisterNumber.h"
 #include "UnwindLLDB.h"
 
 namespace lldb_private {
@@ -98,6 +99,12 @@ private:
     // UnwindLLDB needs to pass around references to RegisterLocations
     friend class UnwindLLDB;
 
+
+    // Returns true if we have an unwind loop -- the same stack frame unwinding 
+    // multiple times.
+    bool
+    CheckIfLoopingStack ();
+
     // Indicates whether this frame is frame zero -- the currently
     // executing frame -- or not.
     bool
@@ -175,11 +182,30 @@ private:
     bool
     TryFallbackUnwindPlan ();
 
+    //------------------------------------------------------------------
+    /// Switch to the fallback unwind plan unconditionally without any safety
+    /// checks that it is providing better results than the normal unwind plan.
+    ///
+    /// The only time it is valid to call this method is if the full unwindplan is
+    /// found to be fundamentally incorrect/impossible.
+    ///
+    /// Returns true if it was able to install the fallback unwind plan.
+    //------------------------------------------------------------------
+    bool
+    ForceSwitchToFallbackUnwindPlan ();
+
     // Get the contents of a general purpose (address-size) register for this frame
     // (usually retrieved from the next frame)
     bool
     ReadGPRValue (lldb::RegisterKind register_kind, uint32_t regnum, lldb::addr_t &value);
 
+    bool
+    ReadGPRValue (const RegisterNumber &reg_num, lldb::addr_t &value);
+
+    // Get the CFA register for a given frame.
+    bool
+    ReadCFAValueForRow (lldb::RegisterKind register_kind, const UnwindPlan::RowSP &row, lldb::addr_t &value);
+
     lldb::UnwindPlanSP
     GetFastUnwindPlanForFrame ();
 
diff --git a/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterContextMacOSXFrameBackchain.cpp b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterContextMacOSXFrameBackchain.cpp
index e246e71..a2ab674 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterContextMacOSXFrameBackchain.cpp
+++ b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterContextMacOSXFrameBackchain.cpp
@@ -149,7 +149,8 @@ RegisterContextMacOSXFrameBackchain::ReadRegister (const RegisterInfo *reg_info,
 
             // TOOD: need a better way to detect when "long double" types are
             // the same bytes size as "double"
-#if !defined(__arm__) && !defined(__arm64__) && !defined(__aarch64__) && !defined(_MSC_VER) && !defined(__mips__)
+#if !defined(__arm__) && !defined(__arm64__) && !defined(__aarch64__) && !defined(_MSC_VER) && \
+    !defined(__mips__) && !defined(__powerpc__) && !defined(__ANDROID_NDK__)
         case sizeof (long double):
             if (sizeof (long double) == sizeof(uint32_t))
             {
diff --git a/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterContextPOSIX_powerpc.cpp b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterContextPOSIX_powerpc.cpp
new file mode 100644
index 0000000..a9477d5
--- /dev/null
+++ b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterContextPOSIX_powerpc.cpp
@@ -0,0 +1,273 @@
+//===-- RegisterContextPOSIX_powerpc.cpp -------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include <cstring>
+#include <errno.h>
+#include <stdint.h>
+
+#include "lldb/Core/DataBufferHeap.h"
+#include "lldb/Core/DataExtractor.h"
+#include "lldb/Core/RegisterValue.h"
+#include "lldb/Core/Scalar.h"
+#include "lldb/Target/Target.h"
+#include "lldb/Target/Thread.h"
+#include "lldb/Host/Endian.h"
+#include "llvm/Support/Compiler.h"
+
+#include "RegisterContextPOSIX_powerpc.h"
+#include "Plugins/Process/elf-core/ProcessElfCore.h"
+
+using namespace lldb_private;
+using namespace lldb;
+
+static const
+uint32_t g_gpr_regnums[] =
+{
+    gpr_r0_powerpc,
+    gpr_r1_powerpc,
+    gpr_r2_powerpc,
+    gpr_r3_powerpc,
+    gpr_r4_powerpc,
+    gpr_r5_powerpc,
+    gpr_r6_powerpc,
+    gpr_r7_powerpc,
+    gpr_r8_powerpc,
+    gpr_r9_powerpc,
+    gpr_r10_powerpc,
+    gpr_r11_powerpc,
+    gpr_r12_powerpc,
+    gpr_r13_powerpc,
+    gpr_r14_powerpc,
+    gpr_r15_powerpc,
+    gpr_r16_powerpc,
+    gpr_r17_powerpc,
+    gpr_r18_powerpc,
+    gpr_r19_powerpc,
+    gpr_r20_powerpc,
+    gpr_r21_powerpc,
+    gpr_r22_powerpc,
+    gpr_r23_powerpc,
+    gpr_r24_powerpc,
+    gpr_r25_powerpc,
+    gpr_r26_powerpc,
+    gpr_r27_powerpc,
+    gpr_r28_powerpc,
+    gpr_r29_powerpc,
+    gpr_r30_powerpc,
+    gpr_r31_powerpc,
+    gpr_lr_powerpc,
+    gpr_cr_powerpc,
+    gpr_xer_powerpc,
+    gpr_ctr_powerpc,
+    gpr_pc_powerpc,
+};
+
+static const
+uint32_t g_fpr_regnums[] =
+{
+    fpr_f0_powerpc,
+    fpr_f1_powerpc,
+    fpr_f2_powerpc,
+    fpr_f3_powerpc,
+    fpr_f4_powerpc,
+    fpr_f5_powerpc,
+    fpr_f6_powerpc,
+    fpr_f7_powerpc,
+    fpr_f8_powerpc,
+    fpr_f9_powerpc,
+    fpr_f10_powerpc,
+    fpr_f11_powerpc,
+    fpr_f12_powerpc,
+    fpr_f13_powerpc,
+    fpr_f14_powerpc,
+    fpr_f15_powerpc,
+    fpr_f16_powerpc,
+    fpr_f17_powerpc,
+    fpr_f18_powerpc,
+    fpr_f19_powerpc,
+    fpr_f20_powerpc,
+    fpr_f21_powerpc,
+    fpr_f22_powerpc,
+    fpr_f23_powerpc,
+    fpr_f24_powerpc,
+    fpr_f25_powerpc,
+    fpr_f26_powerpc,
+    fpr_f27_powerpc,
+    fpr_f28_powerpc,
+    fpr_f29_powerpc,
+    fpr_f30_powerpc,
+    fpr_f31_powerpc,
+    fpr_fpscr_powerpc,
+};
+
+// Number of register sets provided by this context.
+enum
+{
+    k_num_register_sets = 2
+};
+
+static const RegisterSet
+g_reg_sets_powerpc[k_num_register_sets] =
+{
+    { "General Purpose Registers",  "gpr", k_num_gpr_registers_powerpc, g_gpr_regnums },
+    { "Floating Point Registers",  "fpr", k_num_fpr_registers_powerpc, g_fpr_regnums },
+};
+
+bool RegisterContextPOSIX_powerpc::IsGPR(unsigned reg)
+{
+    return reg <= k_num_gpr_registers_powerpc;   // GPR's come first.
+}
+
+bool
+RegisterContextPOSIX_powerpc::IsFPR(unsigned reg)
+{
+    // XXX
+    return (reg >= k_first_fpr) && (reg <= k_last_fpr);
+}
+
+RegisterContextPOSIX_powerpc::RegisterContextPOSIX_powerpc(Thread &thread,
+                                               uint32_t concrete_frame_idx,
+                                               RegisterInfoInterface *register_info)
+    : RegisterContext(thread, concrete_frame_idx)
+{
+    m_register_info_ap.reset(register_info);
+
+    // elf-core yet to support ReadFPR()
+    ProcessSP base = CalculateProcess();
+    if (base.get()->GetPluginName() ==  ProcessElfCore::GetPluginNameStatic())
+        return;
+}
+
+RegisterContextPOSIX_powerpc::~RegisterContextPOSIX_powerpc()
+{
+}
+
+void
+RegisterContextPOSIX_powerpc::Invalidate()
+{
+}
+
+void
+RegisterContextPOSIX_powerpc::InvalidateAllRegisters()
+{
+}
+
+unsigned
+RegisterContextPOSIX_powerpc::GetRegisterOffset(unsigned reg)
+{
+    assert(reg < k_num_registers_powerpc && "Invalid register number.");
+    return GetRegisterInfo()[reg].byte_offset;
+}
+
+unsigned
+RegisterContextPOSIX_powerpc::GetRegisterSize(unsigned reg)
+{
+    assert(reg < k_num_registers_powerpc && "Invalid register number.");
+    return GetRegisterInfo()[reg].byte_size;
+}
+
+size_t
+RegisterContextPOSIX_powerpc::GetRegisterCount()
+{
+    size_t num_registers = k_num_registers_powerpc;
+    return num_registers;
+}
+
+size_t
+RegisterContextPOSIX_powerpc::GetGPRSize()
+{
+    return m_register_info_ap->GetGPRSize();
+}
+
+const RegisterInfo *
+RegisterContextPOSIX_powerpc::GetRegisterInfo()
+{
+    // Commonly, this method is overridden and g_register_infos is copied and specialized.
+    // So, use GetRegisterInfo() rather than g_register_infos in this scope.
+    return m_register_info_ap->GetRegisterInfo ();
+}
+
+const RegisterInfo *
+RegisterContextPOSIX_powerpc::GetRegisterInfoAtIndex(size_t reg)
+{
+    if (reg < k_num_registers_powerpc)
+        return &GetRegisterInfo()[reg];
+    else
+        return NULL;
+}
+
+size_t
+RegisterContextPOSIX_powerpc::GetRegisterSetCount()
+{
+    size_t sets = 0;
+    for (size_t set = 0; set < k_num_register_sets; ++set)
+    {
+        if (IsRegisterSetAvailable(set))
+            ++sets;
+    }
+
+    return sets;
+}
+
+const RegisterSet *
+RegisterContextPOSIX_powerpc::GetRegisterSet(size_t set)
+{
+    if (IsRegisterSetAvailable(set))
+        return &g_reg_sets_powerpc[set];
+    else
+        return NULL;
+}
+
+const char *
+RegisterContextPOSIX_powerpc::GetRegisterName(unsigned reg)
+{
+    assert(reg < k_num_registers_powerpc && "Invalid register offset.");
+    return GetRegisterInfo()[reg].name;
+}
+
+lldb::ByteOrder
+RegisterContextPOSIX_powerpc::GetByteOrder()
+{
+    // Get the target process whose privileged thread was used for the register read.
+    lldb::ByteOrder byte_order = eByteOrderInvalid;
+    Process *process = CalculateProcess().get();
+
+    if (process)
+        byte_order = process->GetByteOrder();
+    return byte_order;
+}
+
+bool
+RegisterContextPOSIX_powerpc::IsRegisterSetAvailable(size_t set_index)
+{
+    size_t num_sets = k_num_register_sets;
+
+    return (set_index < num_sets);
+}
+
+// Used when parsing DWARF and EH frame information and any other
+// object file sections that contain register numbers in them.
+uint32_t
+RegisterContextPOSIX_powerpc::ConvertRegisterKindToRegisterNumber(lldb::RegisterKind kind,
+                                                                 uint32_t num)
+{
+    const uint32_t num_regs = GetRegisterCount();
+
+    assert (kind < kNumRegisterKinds);
+    for (uint32_t reg_idx = 0; reg_idx < num_regs; ++reg_idx)
+    {
+        const RegisterInfo *reg_info = GetRegisterInfoAtIndex (reg_idx);
+
+        if (reg_info->kinds[kind] == num)
+            return reg_idx;
+    }
+
+    return LLDB_INVALID_REGNUM;
+}
+
diff --git a/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterContextPOSIX_powerpc.h b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterContextPOSIX_powerpc.h
new file mode 100644
index 0000000..3194c39
--- /dev/null
+++ b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterContextPOSIX_powerpc.h
@@ -0,0 +1,173 @@
+//===-- RegisterContextPOSIX_powerpc.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_RegisterContextPOSIX_powerpc_H_
+#define liblldb_RegisterContextPOSIX_powerpc_H_
+
+#include "lldb/Core/Log.h"
+#include "RegisterContextPOSIX.h"
+#include "RegisterContext_powerpc.h"
+
+class ProcessMonitor;
+
+// ---------------------------------------------------------------------------
+// Internal codes for all powerpc registers.
+// ---------------------------------------------------------------------------
+enum
+{
+    k_first_gpr_powerpc,
+    gpr_r0_powerpc = k_first_gpr_powerpc,
+    gpr_r1_powerpc,
+    gpr_r2_powerpc,
+    gpr_r3_powerpc,
+    gpr_r4_powerpc,
+    gpr_r5_powerpc,
+    gpr_r6_powerpc,
+    gpr_r7_powerpc,
+    gpr_r8_powerpc,
+    gpr_r9_powerpc,
+    gpr_r10_powerpc,
+    gpr_r11_powerpc,
+    gpr_r12_powerpc,
+    gpr_r13_powerpc,
+    gpr_r14_powerpc,
+    gpr_r15_powerpc,
+    gpr_r16_powerpc,
+    gpr_r17_powerpc,
+    gpr_r18_powerpc,
+    gpr_r19_powerpc,
+    gpr_r20_powerpc,
+    gpr_r21_powerpc,
+    gpr_r22_powerpc,
+    gpr_r23_powerpc,
+    gpr_r24_powerpc,
+    gpr_r25_powerpc,
+    gpr_r26_powerpc,
+    gpr_r27_powerpc,
+    gpr_r28_powerpc,
+    gpr_r29_powerpc,
+    gpr_r30_powerpc,
+    gpr_r31_powerpc,
+    gpr_lr_powerpc,
+    gpr_cr_powerpc,
+    gpr_xer_powerpc,
+    gpr_ctr_powerpc,
+    gpr_pc_powerpc,
+    k_last_gpr_powerpc = gpr_pc_powerpc,
+
+    k_first_fpr,
+    fpr_f0_powerpc = k_first_fpr,
+    fpr_f1_powerpc,
+    fpr_f2_powerpc,
+    fpr_f3_powerpc,
+    fpr_f4_powerpc,
+    fpr_f5_powerpc,
+    fpr_f6_powerpc,
+    fpr_f7_powerpc,
+    fpr_f8_powerpc,
+    fpr_f9_powerpc,
+    fpr_f10_powerpc,
+    fpr_f11_powerpc,
+    fpr_f12_powerpc,
+    fpr_f13_powerpc,
+    fpr_f14_powerpc,
+    fpr_f15_powerpc,
+    fpr_f16_powerpc,
+    fpr_f17_powerpc,
+    fpr_f18_powerpc,
+    fpr_f19_powerpc,
+    fpr_f20_powerpc,
+    fpr_f21_powerpc,
+    fpr_f22_powerpc,
+    fpr_f23_powerpc,
+    fpr_f24_powerpc,
+    fpr_f25_powerpc,
+    fpr_f26_powerpc,
+    fpr_f27_powerpc,
+    fpr_f28_powerpc,
+    fpr_f29_powerpc,
+    fpr_f30_powerpc,
+    fpr_f31_powerpc,
+    fpr_fpscr_powerpc,
+    k_last_fpr = fpr_fpscr_powerpc,
+
+    k_num_registers_powerpc,
+    k_num_gpr_registers_powerpc = k_last_gpr_powerpc - k_first_gpr_powerpc + 1,
+    k_num_fpr_registers_powerpc = k_last_fpr - k_first_fpr + 1,
+};
+
+class RegisterContextPOSIX_powerpc
+  : public lldb_private::RegisterContext
+{
+public:
+    RegisterContextPOSIX_powerpc (lldb_private::Thread &thread,
+                            uint32_t concrete_frame_idx,
+                            lldb_private::RegisterInfoInterface *register_info);
+
+    ~RegisterContextPOSIX_powerpc();
+
+    void
+    Invalidate();
+
+    void
+    InvalidateAllRegisters();
+
+    size_t
+    GetRegisterCount();
+
+    virtual size_t
+    GetGPRSize();
+
+    virtual unsigned
+    GetRegisterSize(unsigned reg);
+
+    virtual unsigned
+    GetRegisterOffset(unsigned reg);
+
+    const lldb_private::RegisterInfo *
+    GetRegisterInfoAtIndex(size_t reg);
+
+    size_t
+    GetRegisterSetCount();
+
+    const lldb_private::RegisterSet *
+    GetRegisterSet(size_t set);
+
+    const char *
+    GetRegisterName(unsigned reg);
+
+    uint32_t
+    ConvertRegisterKindToRegisterNumber(lldb::RegisterKind kind, uint32_t num);
+
+protected:
+    uint64_t m_gpr_powerpc[k_num_gpr_registers_powerpc];         // general purpose registers.
+    std::unique_ptr<lldb_private::RegisterInfoInterface> m_register_info_ap; // Register Info Interface (FreeBSD or Linux)
+
+    // Determines if an extended register set is supported on the processor running the inferior process.
+    virtual bool
+    IsRegisterSetAvailable(size_t set_index);
+
+    virtual const lldb_private::RegisterInfo *
+    GetRegisterInfo();
+
+    bool
+    IsGPR(unsigned reg);
+
+    bool
+    IsFPR(unsigned reg);
+
+    lldb::ByteOrder GetByteOrder();
+
+    virtual bool ReadGPR() = 0;
+    virtual bool ReadFPR() = 0;
+    virtual bool WriteGPR() = 0;
+    virtual bool WriteFPR() = 0;
+};
+
+#endif // #ifndef liblldb_RegisterContextPOSIX_powerpc_H_
diff --git a/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterContextPOSIX_x86.cpp b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterContextPOSIX_x86.cpp
index 2925a33..77b6385 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterContextPOSIX_x86.cpp
+++ b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterContextPOSIX_x86.cpp
@@ -30,96 +30,96 @@ using namespace lldb;
 const uint32_t
 g_gpr_regnums_i386[] =
 {
-    gpr_eax_i386,
-    gpr_ebx_i386,
-    gpr_ecx_i386,
-    gpr_edx_i386,
-    gpr_edi_i386,
-    gpr_esi_i386,
-    gpr_ebp_i386,
-    gpr_esp_i386,
-    gpr_eip_i386,
-    gpr_eflags_i386,
-    gpr_cs_i386,
-    gpr_fs_i386,
-    gpr_gs_i386,
-    gpr_ss_i386,
-    gpr_ds_i386,
-    gpr_es_i386,
-    gpr_ax_i386,
-    gpr_bx_i386,
-    gpr_cx_i386,
-    gpr_dx_i386,
-    gpr_di_i386,
-    gpr_si_i386,
-    gpr_bp_i386,
-    gpr_sp_i386,
-    gpr_ah_i386,
-    gpr_bh_i386,
-    gpr_ch_i386,
-    gpr_dh_i386,
-    gpr_al_i386,
-    gpr_bl_i386,
-    gpr_cl_i386,
-    gpr_dl_i386,
+    lldb_eax_i386,
+    lldb_ebx_i386,
+    lldb_ecx_i386,
+    lldb_edx_i386,
+    lldb_edi_i386,
+    lldb_esi_i386,
+    lldb_ebp_i386,
+    lldb_esp_i386,
+    lldb_eip_i386,
+    lldb_eflags_i386,
+    lldb_cs_i386,
+    lldb_fs_i386,
+    lldb_gs_i386,
+    lldb_ss_i386,
+    lldb_ds_i386,
+    lldb_es_i386,
+    lldb_ax_i386,
+    lldb_bx_i386,
+    lldb_cx_i386,
+    lldb_dx_i386,
+    lldb_di_i386,
+    lldb_si_i386,
+    lldb_bp_i386,
+    lldb_sp_i386,
+    lldb_ah_i386,
+    lldb_bh_i386,
+    lldb_ch_i386,
+    lldb_dh_i386,
+    lldb_al_i386,
+    lldb_bl_i386,
+    lldb_cl_i386,
+    lldb_dl_i386,
     LLDB_INVALID_REGNUM, // Register sets must be terminated with LLDB_INVALID_REGNUM.
 };
 static_assert((sizeof(g_gpr_regnums_i386) / sizeof(g_gpr_regnums_i386[0])) - 1 == k_num_gpr_registers_i386,
     "g_gpr_regnums_i386 has wrong number of register infos");
 
 const uint32_t
-g_fpu_regnums_i386[] =
-{
-    fpu_fctrl_i386,
-    fpu_fstat_i386,
-    fpu_ftag_i386,
-    fpu_fop_i386,
-    fpu_fiseg_i386,
-    fpu_fioff_i386,
-    fpu_foseg_i386,
-    fpu_fooff_i386,
-    fpu_mxcsr_i386,
-    fpu_mxcsrmask_i386,
-    fpu_st0_i386,
-    fpu_st1_i386,
-    fpu_st2_i386,
-    fpu_st3_i386,
-    fpu_st4_i386,
-    fpu_st5_i386,
-    fpu_st6_i386,
-    fpu_st7_i386,
-    fpu_mm0_i386,
-    fpu_mm1_i386,
-    fpu_mm2_i386,
-    fpu_mm3_i386,
-    fpu_mm4_i386,
-    fpu_mm5_i386,
-    fpu_mm6_i386,
-    fpu_mm7_i386,
-    fpu_xmm0_i386,
-    fpu_xmm1_i386,
-    fpu_xmm2_i386,
-    fpu_xmm3_i386,
-    fpu_xmm4_i386,
-    fpu_xmm5_i386,
-    fpu_xmm6_i386,
-    fpu_xmm7_i386,
+g_lldb_regnums_i386[] =
+{
+    lldb_fctrl_i386,
+    lldb_fstat_i386,
+    lldb_ftag_i386,
+    lldb_fop_i386,
+    lldb_fiseg_i386,
+    lldb_fioff_i386,
+    lldb_foseg_i386,
+    lldb_fooff_i386,
+    lldb_mxcsr_i386,
+    lldb_mxcsrmask_i386,
+    lldb_st0_i386,
+    lldb_st1_i386,
+    lldb_st2_i386,
+    lldb_st3_i386,
+    lldb_st4_i386,
+    lldb_st5_i386,
+    lldb_st6_i386,
+    lldb_st7_i386,
+    lldb_mm0_i386,
+    lldb_mm1_i386,
+    lldb_mm2_i386,
+    lldb_mm3_i386,
+    lldb_mm4_i386,
+    lldb_mm5_i386,
+    lldb_mm6_i386,
+    lldb_mm7_i386,
+    lldb_xmm0_i386,
+    lldb_xmm1_i386,
+    lldb_xmm2_i386,
+    lldb_xmm3_i386,
+    lldb_xmm4_i386,
+    lldb_xmm5_i386,
+    lldb_xmm6_i386,
+    lldb_xmm7_i386,
     LLDB_INVALID_REGNUM // Register sets must be terminated with LLDB_INVALID_REGNUM.
 };
-static_assert((sizeof(g_fpu_regnums_i386) / sizeof(g_fpu_regnums_i386[0])) - 1 == k_num_fpr_registers_i386,
-    "g_fpu_regnums_i386 has wrong number of register infos");
+static_assert((sizeof(g_lldb_regnums_i386) / sizeof(g_lldb_regnums_i386[0])) - 1 == k_num_fpr_registers_i386,
+    "g_lldb_regnums_i386 has wrong number of register infos");
 
 const uint32_t
 g_avx_regnums_i386[] =
 {
-    fpu_ymm0_i386,
-    fpu_ymm1_i386,
-    fpu_ymm2_i386,
-    fpu_ymm3_i386,
-    fpu_ymm4_i386,
-    fpu_ymm5_i386,
-    fpu_ymm6_i386,
-    fpu_ymm7_i386,
+    lldb_ymm0_i386,
+    lldb_ymm1_i386,
+    lldb_ymm2_i386,
+    lldb_ymm3_i386,
+    lldb_ymm4_i386,
+    lldb_ymm5_i386,
+    lldb_ymm6_i386,
+    lldb_ymm7_i386,
     LLDB_INVALID_REGNUM // Register sets must be terminated with LLDB_INVALID_REGNUM.
 };
 static_assert((sizeof(g_avx_regnums_i386) / sizeof(g_avx_regnums_i386[0])) - 1 == k_num_avx_registers_i386,
@@ -128,212 +128,212 @@ static_assert((sizeof(g_avx_regnums_i386) / sizeof(g_avx_regnums_i386[0])) - 1 =
 static const
 uint32_t g_gpr_regnums_x86_64[] =
 {
-    gpr_rax_x86_64,
-    gpr_rbx_x86_64,
-    gpr_rcx_x86_64,
-    gpr_rdx_x86_64,
-    gpr_rdi_x86_64,
-    gpr_rsi_x86_64,
-    gpr_rbp_x86_64,
-    gpr_rsp_x86_64,
-    gpr_r8_x86_64,
-    gpr_r9_x86_64,
-    gpr_r10_x86_64,
-    gpr_r11_x86_64,
-    gpr_r12_x86_64,
-    gpr_r13_x86_64,
-    gpr_r14_x86_64,
-    gpr_r15_x86_64,
-    gpr_rip_x86_64,
-    gpr_rflags_x86_64,
-    gpr_cs_x86_64,
-    gpr_fs_x86_64,
-    gpr_gs_x86_64,
-    gpr_ss_x86_64,
-    gpr_ds_x86_64,
-    gpr_es_x86_64,
-    gpr_eax_x86_64,
-    gpr_ebx_x86_64,
-    gpr_ecx_x86_64,
-    gpr_edx_x86_64,
-    gpr_edi_x86_64,
-    gpr_esi_x86_64,
-    gpr_ebp_x86_64,
-    gpr_esp_x86_64,
-    gpr_r8d_x86_64,    // Low 32 bits or r8
-    gpr_r9d_x86_64,    // Low 32 bits or r9
-    gpr_r10d_x86_64,   // Low 32 bits or r10
-    gpr_r11d_x86_64,   // Low 32 bits or r11
-    gpr_r12d_x86_64,   // Low 32 bits or r12
-    gpr_r13d_x86_64,   // Low 32 bits or r13
-    gpr_r14d_x86_64,   // Low 32 bits or r14
-    gpr_r15d_x86_64,   // Low 32 bits or r15
-    gpr_ax_x86_64,
-    gpr_bx_x86_64,
-    gpr_cx_x86_64,
-    gpr_dx_x86_64,
-    gpr_di_x86_64,
-    gpr_si_x86_64,
-    gpr_bp_x86_64,
-    gpr_sp_x86_64,
-    gpr_r8w_x86_64,    // Low 16 bits or r8
-    gpr_r9w_x86_64,    // Low 16 bits or r9
-    gpr_r10w_x86_64,   // Low 16 bits or r10
-    gpr_r11w_x86_64,   // Low 16 bits or r11
-    gpr_r12w_x86_64,   // Low 16 bits or r12
-    gpr_r13w_x86_64,   // Low 16 bits or r13
-    gpr_r14w_x86_64,   // Low 16 bits or r14
-    gpr_r15w_x86_64,   // Low 16 bits or r15
-    gpr_ah_x86_64,
-    gpr_bh_x86_64,
-    gpr_ch_x86_64,
-    gpr_dh_x86_64,
-    gpr_al_x86_64,
-    gpr_bl_x86_64,
-    gpr_cl_x86_64,
-    gpr_dl_x86_64,
-    gpr_dil_x86_64,
-    gpr_sil_x86_64,
-    gpr_bpl_x86_64,
-    gpr_spl_x86_64,
-    gpr_r8l_x86_64,    // Low 8 bits or r8
-    gpr_r9l_x86_64,    // Low 8 bits or r9
-    gpr_r10l_x86_64,   // Low 8 bits or r10
-    gpr_r11l_x86_64,   // Low 8 bits or r11
-    gpr_r12l_x86_64,   // Low 8 bits or r12
-    gpr_r13l_x86_64,   // Low 8 bits or r13
-    gpr_r14l_x86_64,   // Low 8 bits or r14
-    gpr_r15l_x86_64,   // Low 8 bits or r15
+    lldb_rax_x86_64,
+    lldb_rbx_x86_64,
+    lldb_rcx_x86_64,
+    lldb_rdx_x86_64,
+    lldb_rdi_x86_64,
+    lldb_rsi_x86_64,
+    lldb_rbp_x86_64,
+    lldb_rsp_x86_64,
+    lldb_r8_x86_64,
+    lldb_r9_x86_64,
+    lldb_r10_x86_64,
+    lldb_r11_x86_64,
+    lldb_r12_x86_64,
+    lldb_r13_x86_64,
+    lldb_r14_x86_64,
+    lldb_r15_x86_64,
+    lldb_rip_x86_64,
+    lldb_rflags_x86_64,
+    lldb_cs_x86_64,
+    lldb_fs_x86_64,
+    lldb_gs_x86_64,
+    lldb_ss_x86_64,
+    lldb_ds_x86_64,
+    lldb_es_x86_64,
+    lldb_eax_x86_64,
+    lldb_ebx_x86_64,
+    lldb_ecx_x86_64,
+    lldb_edx_x86_64,
+    lldb_edi_x86_64,
+    lldb_esi_x86_64,
+    lldb_ebp_x86_64,
+    lldb_esp_x86_64,
+    lldb_r8d_x86_64,    // Low 32 bits or r8
+    lldb_r9d_x86_64,    // Low 32 bits or r9
+    lldb_r10d_x86_64,   // Low 32 bits or r10
+    lldb_r11d_x86_64,   // Low 32 bits or r11
+    lldb_r12d_x86_64,   // Low 32 bits or r12
+    lldb_r13d_x86_64,   // Low 32 bits or r13
+    lldb_r14d_x86_64,   // Low 32 bits or r14
+    lldb_r15d_x86_64,   // Low 32 bits or r15
+    lldb_ax_x86_64,
+    lldb_bx_x86_64,
+    lldb_cx_x86_64,
+    lldb_dx_x86_64,
+    lldb_di_x86_64,
+    lldb_si_x86_64,
+    lldb_bp_x86_64,
+    lldb_sp_x86_64,
+    lldb_r8w_x86_64,    // Low 16 bits or r8
+    lldb_r9w_x86_64,    // Low 16 bits or r9
+    lldb_r10w_x86_64,   // Low 16 bits or r10
+    lldb_r11w_x86_64,   // Low 16 bits or r11
+    lldb_r12w_x86_64,   // Low 16 bits or r12
+    lldb_r13w_x86_64,   // Low 16 bits or r13
+    lldb_r14w_x86_64,   // Low 16 bits or r14
+    lldb_r15w_x86_64,   // Low 16 bits or r15
+    lldb_ah_x86_64,
+    lldb_bh_x86_64,
+    lldb_ch_x86_64,
+    lldb_dh_x86_64,
+    lldb_al_x86_64,
+    lldb_bl_x86_64,
+    lldb_cl_x86_64,
+    lldb_dl_x86_64,
+    lldb_dil_x86_64,
+    lldb_sil_x86_64,
+    lldb_bpl_x86_64,
+    lldb_spl_x86_64,
+    lldb_r8l_x86_64,    // Low 8 bits or r8
+    lldb_r9l_x86_64,    // Low 8 bits or r9
+    lldb_r10l_x86_64,   // Low 8 bits or r10
+    lldb_r11l_x86_64,   // Low 8 bits or r11
+    lldb_r12l_x86_64,   // Low 8 bits or r12
+    lldb_r13l_x86_64,   // Low 8 bits or r13
+    lldb_r14l_x86_64,   // Low 8 bits or r14
+    lldb_r15l_x86_64,   // Low 8 bits or r15
     LLDB_INVALID_REGNUM // Register sets must be terminated with LLDB_INVALID_REGNUM.
 };
 static_assert((sizeof(g_gpr_regnums_x86_64) / sizeof(g_gpr_regnums_x86_64[0])) - 1 == k_num_gpr_registers_x86_64,
     "g_gpr_regnums_x86_64 has wrong number of register infos");
 
 static const uint32_t
-g_fpu_regnums_x86_64[] =
-{
-    fpu_fctrl_x86_64,
-    fpu_fstat_x86_64,
-    fpu_ftag_x86_64,
-    fpu_fop_x86_64,
-    fpu_fiseg_x86_64,
-    fpu_fioff_x86_64,
-    fpu_foseg_x86_64,
-    fpu_fooff_x86_64,
-    fpu_mxcsr_x86_64,
-    fpu_mxcsrmask_x86_64,
-    fpu_st0_x86_64,
-    fpu_st1_x86_64,
-    fpu_st2_x86_64,
-    fpu_st3_x86_64,
-    fpu_st4_x86_64,
-    fpu_st5_x86_64,
-    fpu_st6_x86_64,
-    fpu_st7_x86_64,
-    fpu_mm0_x86_64,
-    fpu_mm1_x86_64,
-    fpu_mm2_x86_64,
-    fpu_mm3_x86_64,
-    fpu_mm4_x86_64,
-    fpu_mm5_x86_64,
-    fpu_mm6_x86_64,
-    fpu_mm7_x86_64,
-    fpu_xmm0_x86_64,
-    fpu_xmm1_x86_64,
-    fpu_xmm2_x86_64,
-    fpu_xmm3_x86_64,
-    fpu_xmm4_x86_64,
-    fpu_xmm5_x86_64,
-    fpu_xmm6_x86_64,
-    fpu_xmm7_x86_64,
-    fpu_xmm8_x86_64,
-    fpu_xmm9_x86_64,
-    fpu_xmm10_x86_64,
-    fpu_xmm11_x86_64,
-    fpu_xmm12_x86_64,
-    fpu_xmm13_x86_64,
-    fpu_xmm14_x86_64,
-    fpu_xmm15_x86_64,
+g_lldb_regnums_x86_64[] =
+{
+    lldb_fctrl_x86_64,
+    lldb_fstat_x86_64,
+    lldb_ftag_x86_64,
+    lldb_fop_x86_64,
+    lldb_fiseg_x86_64,
+    lldb_fioff_x86_64,
+    lldb_foseg_x86_64,
+    lldb_fooff_x86_64,
+    lldb_mxcsr_x86_64,
+    lldb_mxcsrmask_x86_64,
+    lldb_st0_x86_64,
+    lldb_st1_x86_64,
+    lldb_st2_x86_64,
+    lldb_st3_x86_64,
+    lldb_st4_x86_64,
+    lldb_st5_x86_64,
+    lldb_st6_x86_64,
+    lldb_st7_x86_64,
+    lldb_mm0_x86_64,
+    lldb_mm1_x86_64,
+    lldb_mm2_x86_64,
+    lldb_mm3_x86_64,
+    lldb_mm4_x86_64,
+    lldb_mm5_x86_64,
+    lldb_mm6_x86_64,
+    lldb_mm7_x86_64,
+    lldb_xmm0_x86_64,
+    lldb_xmm1_x86_64,
+    lldb_xmm2_x86_64,
+    lldb_xmm3_x86_64,
+    lldb_xmm4_x86_64,
+    lldb_xmm5_x86_64,
+    lldb_xmm6_x86_64,
+    lldb_xmm7_x86_64,
+    lldb_xmm8_x86_64,
+    lldb_xmm9_x86_64,
+    lldb_xmm10_x86_64,
+    lldb_xmm11_x86_64,
+    lldb_xmm12_x86_64,
+    lldb_xmm13_x86_64,
+    lldb_xmm14_x86_64,
+    lldb_xmm15_x86_64,
     LLDB_INVALID_REGNUM // Register sets must be terminated with LLDB_INVALID_REGNUM.
 };
-static_assert((sizeof(g_fpu_regnums_x86_64) / sizeof(g_fpu_regnums_x86_64[0])) - 1 == k_num_fpr_registers_x86_64,
-    "g_fpu_regnums_x86_64 has wrong number of register infos");
+static_assert((sizeof(g_lldb_regnums_x86_64) / sizeof(g_lldb_regnums_x86_64[0])) - 1 == k_num_fpr_registers_x86_64,
+    "g_lldb_regnums_x86_64 has wrong number of register infos");
 
 static const uint32_t
 g_avx_regnums_x86_64[] =
 {
-    fpu_ymm0_x86_64,
-    fpu_ymm1_x86_64,
-    fpu_ymm2_x86_64,
-    fpu_ymm3_x86_64,
-    fpu_ymm4_x86_64,
-    fpu_ymm5_x86_64,
-    fpu_ymm6_x86_64,
-    fpu_ymm7_x86_64,
-    fpu_ymm8_x86_64,
-    fpu_ymm9_x86_64,
-    fpu_ymm10_x86_64,
-    fpu_ymm11_x86_64,
-    fpu_ymm12_x86_64,
-    fpu_ymm13_x86_64,
-    fpu_ymm14_x86_64,
-    fpu_ymm15_x86_64,
+    lldb_ymm0_x86_64,
+    lldb_ymm1_x86_64,
+    lldb_ymm2_x86_64,
+    lldb_ymm3_x86_64,
+    lldb_ymm4_x86_64,
+    lldb_ymm5_x86_64,
+    lldb_ymm6_x86_64,
+    lldb_ymm7_x86_64,
+    lldb_ymm8_x86_64,
+    lldb_ymm9_x86_64,
+    lldb_ymm10_x86_64,
+    lldb_ymm11_x86_64,
+    lldb_ymm12_x86_64,
+    lldb_ymm13_x86_64,
+    lldb_ymm14_x86_64,
+    lldb_ymm15_x86_64,
     LLDB_INVALID_REGNUM // Register sets must be terminated with LLDB_INVALID_REGNUM.
 };
 static_assert((sizeof(g_avx_regnums_x86_64) / sizeof(g_avx_regnums_x86_64[0])) - 1 == k_num_avx_registers_x86_64,
     "g_avx_regnums_x86_64 has wrong number of register infos");
 
-uint32_t RegisterContextPOSIX_x86::g_contained_eax[] = { gpr_eax_i386, LLDB_INVALID_REGNUM };
-uint32_t RegisterContextPOSIX_x86::g_contained_ebx[] = { gpr_ebx_i386, LLDB_INVALID_REGNUM };
-uint32_t RegisterContextPOSIX_x86::g_contained_ecx[] = { gpr_ecx_i386, LLDB_INVALID_REGNUM };
-uint32_t RegisterContextPOSIX_x86::g_contained_edx[] = { gpr_edx_i386, LLDB_INVALID_REGNUM };
-uint32_t RegisterContextPOSIX_x86::g_contained_edi[] = { gpr_edi_i386, LLDB_INVALID_REGNUM };
-uint32_t RegisterContextPOSIX_x86::g_contained_esi[] = { gpr_esi_i386, LLDB_INVALID_REGNUM };
-uint32_t RegisterContextPOSIX_x86::g_contained_ebp[] = { gpr_ebp_i386, LLDB_INVALID_REGNUM };
-uint32_t RegisterContextPOSIX_x86::g_contained_esp[] = { gpr_esp_i386, LLDB_INVALID_REGNUM };
-
-uint32_t RegisterContextPOSIX_x86::g_invalidate_eax[] = { gpr_eax_i386, gpr_ax_i386, gpr_ah_i386,  gpr_al_i386, LLDB_INVALID_REGNUM };
-uint32_t RegisterContextPOSIX_x86::g_invalidate_ebx[] = { gpr_ebx_i386, gpr_bx_i386, gpr_bh_i386,  gpr_bl_i386, LLDB_INVALID_REGNUM };
-uint32_t RegisterContextPOSIX_x86::g_invalidate_ecx[] = { gpr_ecx_i386, gpr_cx_i386, gpr_ch_i386,  gpr_cl_i386, LLDB_INVALID_REGNUM };
-uint32_t RegisterContextPOSIX_x86::g_invalidate_edx[] = { gpr_edx_i386, gpr_dx_i386, gpr_dh_i386,  gpr_dl_i386, LLDB_INVALID_REGNUM };
-uint32_t RegisterContextPOSIX_x86::g_invalidate_edi[] = { gpr_edi_i386, gpr_di_i386, LLDB_INVALID_REGNUM };
-uint32_t RegisterContextPOSIX_x86::g_invalidate_esi[] = { gpr_esi_i386, gpr_si_i386, LLDB_INVALID_REGNUM };
-uint32_t RegisterContextPOSIX_x86::g_invalidate_ebp[] = { gpr_ebp_i386, gpr_bp_i386, LLDB_INVALID_REGNUM };
-uint32_t RegisterContextPOSIX_x86::g_invalidate_esp[] = { gpr_esp_i386, gpr_sp_i386, LLDB_INVALID_REGNUM };
-
-uint32_t RegisterContextPOSIX_x86::g_contained_rax[] = { gpr_rax_x86_64, LLDB_INVALID_REGNUM };
-uint32_t RegisterContextPOSIX_x86::g_contained_rbx[] = { gpr_rbx_x86_64, LLDB_INVALID_REGNUM };
-uint32_t RegisterContextPOSIX_x86::g_contained_rcx[] = { gpr_rcx_x86_64, LLDB_INVALID_REGNUM };
-uint32_t RegisterContextPOSIX_x86::g_contained_rdx[] = { gpr_rdx_x86_64, LLDB_INVALID_REGNUM };
-uint32_t RegisterContextPOSIX_x86::g_contained_rdi[] = { gpr_rdi_x86_64, LLDB_INVALID_REGNUM };
-uint32_t RegisterContextPOSIX_x86::g_contained_rsi[] = { gpr_rsi_x86_64, LLDB_INVALID_REGNUM };
-uint32_t RegisterContextPOSIX_x86::g_contained_rbp[] = { gpr_rbp_x86_64, LLDB_INVALID_REGNUM };
-uint32_t RegisterContextPOSIX_x86::g_contained_rsp[] = { gpr_rsp_x86_64, LLDB_INVALID_REGNUM };
-uint32_t RegisterContextPOSIX_x86::g_contained_r8[]  = { gpr_r8_x86_64,  LLDB_INVALID_REGNUM };
-uint32_t RegisterContextPOSIX_x86::g_contained_r9[]  = { gpr_r9_x86_64,  LLDB_INVALID_REGNUM };
-uint32_t RegisterContextPOSIX_x86::g_contained_r10[] = { gpr_r10_x86_64, LLDB_INVALID_REGNUM };
-uint32_t RegisterContextPOSIX_x86::g_contained_r11[] = { gpr_r11_x86_64, LLDB_INVALID_REGNUM };
-uint32_t RegisterContextPOSIX_x86::g_contained_r12[] = { gpr_r12_x86_64, LLDB_INVALID_REGNUM };
-uint32_t RegisterContextPOSIX_x86::g_contained_r13[] = { gpr_r13_x86_64, LLDB_INVALID_REGNUM };
-uint32_t RegisterContextPOSIX_x86::g_contained_r14[] = { gpr_r14_x86_64, LLDB_INVALID_REGNUM };
-uint32_t RegisterContextPOSIX_x86::g_contained_r15[] = { gpr_r15_x86_64, LLDB_INVALID_REGNUM };
-
-uint32_t RegisterContextPOSIX_x86::g_invalidate_rax[] = { gpr_rax_x86_64, gpr_eax_x86_64,  gpr_ax_x86_64,   gpr_ah_x86_64,   gpr_al_x86_64, LLDB_INVALID_REGNUM };
-uint32_t RegisterContextPOSIX_x86::g_invalidate_rbx[] = { gpr_rbx_x86_64, gpr_ebx_x86_64,  gpr_bx_x86_64,   gpr_bh_x86_64,   gpr_bl_x86_64, LLDB_INVALID_REGNUM };
-uint32_t RegisterContextPOSIX_x86::g_invalidate_rcx[] = { gpr_rcx_x86_64, gpr_ecx_x86_64,  gpr_cx_x86_64,   gpr_ch_x86_64,   gpr_cl_x86_64, LLDB_INVALID_REGNUM };
-uint32_t RegisterContextPOSIX_x86::g_invalidate_rdx[] = { gpr_rdx_x86_64, gpr_edx_x86_64,  gpr_dx_x86_64,   gpr_dh_x86_64,   gpr_dl_x86_64, LLDB_INVALID_REGNUM };
-uint32_t RegisterContextPOSIX_x86::g_invalidate_rdi[] = { gpr_rdi_x86_64, gpr_edi_x86_64,  gpr_di_x86_64,   gpr_dil_x86_64,  LLDB_INVALID_REGNUM };
-uint32_t RegisterContextPOSIX_x86::g_invalidate_rsi[] = { gpr_rsi_x86_64, gpr_esi_x86_64,  gpr_si_x86_64,   gpr_sil_x86_64,  LLDB_INVALID_REGNUM };
-uint32_t RegisterContextPOSIX_x86::g_invalidate_rbp[] = { gpr_rbp_x86_64, gpr_ebp_x86_64,  gpr_bp_x86_64,   gpr_bpl_x86_64,  LLDB_INVALID_REGNUM };
-uint32_t RegisterContextPOSIX_x86::g_invalidate_rsp[] = { gpr_rsp_x86_64, gpr_esp_x86_64,  gpr_sp_x86_64,   gpr_spl_x86_64,  LLDB_INVALID_REGNUM };
-uint32_t RegisterContextPOSIX_x86::g_invalidate_r8[]  = { gpr_r8_x86_64,  gpr_r8d_x86_64,  gpr_r8w_x86_64,  gpr_r8l_x86_64,  LLDB_INVALID_REGNUM };
-uint32_t RegisterContextPOSIX_x86::g_invalidate_r9[]  = { gpr_r9_x86_64,  gpr_r9d_x86_64,  gpr_r9w_x86_64,  gpr_r9l_x86_64,  LLDB_INVALID_REGNUM };
-uint32_t RegisterContextPOSIX_x86::g_invalidate_r10[] = { gpr_r10_x86_64, gpr_r10d_x86_64, gpr_r10w_x86_64, gpr_r10l_x86_64, LLDB_INVALID_REGNUM };
-uint32_t RegisterContextPOSIX_x86::g_invalidate_r11[] = { gpr_r11_x86_64, gpr_r11d_x86_64, gpr_r11w_x86_64, gpr_r11l_x86_64, LLDB_INVALID_REGNUM };
-uint32_t RegisterContextPOSIX_x86::g_invalidate_r12[] = { gpr_r12_x86_64, gpr_r12d_x86_64, gpr_r12w_x86_64, gpr_r12l_x86_64, LLDB_INVALID_REGNUM };
-uint32_t RegisterContextPOSIX_x86::g_invalidate_r13[] = { gpr_r13_x86_64, gpr_r13d_x86_64, gpr_r13w_x86_64, gpr_r13l_x86_64, LLDB_INVALID_REGNUM };
-uint32_t RegisterContextPOSIX_x86::g_invalidate_r14[] = { gpr_r14_x86_64, gpr_r14d_x86_64, gpr_r14w_x86_64, gpr_r14l_x86_64, LLDB_INVALID_REGNUM };
-uint32_t RegisterContextPOSIX_x86::g_invalidate_r15[] = { gpr_r15_x86_64, gpr_r15d_x86_64, gpr_r15w_x86_64, gpr_r15l_x86_64, LLDB_INVALID_REGNUM };
+uint32_t RegisterContextPOSIX_x86::g_contained_eax[] = { lldb_eax_i386, LLDB_INVALID_REGNUM };
+uint32_t RegisterContextPOSIX_x86::g_contained_ebx[] = { lldb_ebx_i386, LLDB_INVALID_REGNUM };
+uint32_t RegisterContextPOSIX_x86::g_contained_ecx[] = { lldb_ecx_i386, LLDB_INVALID_REGNUM };
+uint32_t RegisterContextPOSIX_x86::g_contained_edx[] = { lldb_edx_i386, LLDB_INVALID_REGNUM };
+uint32_t RegisterContextPOSIX_x86::g_contained_edi[] = { lldb_edi_i386, LLDB_INVALID_REGNUM };
+uint32_t RegisterContextPOSIX_x86::g_contained_esi[] = { lldb_esi_i386, LLDB_INVALID_REGNUM };
+uint32_t RegisterContextPOSIX_x86::g_contained_ebp[] = { lldb_ebp_i386, LLDB_INVALID_REGNUM };
+uint32_t RegisterContextPOSIX_x86::g_contained_esp[] = { lldb_esp_i386, LLDB_INVALID_REGNUM };
+
+uint32_t RegisterContextPOSIX_x86::g_invalidate_eax[] = { lldb_eax_i386, lldb_ax_i386, lldb_ah_i386,  lldb_al_i386, LLDB_INVALID_REGNUM };
+uint32_t RegisterContextPOSIX_x86::g_invalidate_ebx[] = { lldb_ebx_i386, lldb_bx_i386, lldb_bh_i386,  lldb_bl_i386, LLDB_INVALID_REGNUM };
+uint32_t RegisterContextPOSIX_x86::g_invalidate_ecx[] = { lldb_ecx_i386, lldb_cx_i386, lldb_ch_i386,  lldb_cl_i386, LLDB_INVALID_REGNUM };
+uint32_t RegisterContextPOSIX_x86::g_invalidate_edx[] = { lldb_edx_i386, lldb_dx_i386, lldb_dh_i386,  lldb_dl_i386, LLDB_INVALID_REGNUM };
+uint32_t RegisterContextPOSIX_x86::g_invalidate_edi[] = { lldb_edi_i386, lldb_di_i386, LLDB_INVALID_REGNUM };
+uint32_t RegisterContextPOSIX_x86::g_invalidate_esi[] = { lldb_esi_i386, lldb_si_i386, LLDB_INVALID_REGNUM };
+uint32_t RegisterContextPOSIX_x86::g_invalidate_ebp[] = { lldb_ebp_i386, lldb_bp_i386, LLDB_INVALID_REGNUM };
+uint32_t RegisterContextPOSIX_x86::g_invalidate_esp[] = { lldb_esp_i386, lldb_sp_i386, LLDB_INVALID_REGNUM };
+
+uint32_t RegisterContextPOSIX_x86::g_contained_rax[] = { lldb_rax_x86_64, LLDB_INVALID_REGNUM };
+uint32_t RegisterContextPOSIX_x86::g_contained_rbx[] = { lldb_rbx_x86_64, LLDB_INVALID_REGNUM };
+uint32_t RegisterContextPOSIX_x86::g_contained_rcx[] = { lldb_rcx_x86_64, LLDB_INVALID_REGNUM };
+uint32_t RegisterContextPOSIX_x86::g_contained_rdx[] = { lldb_rdx_x86_64, LLDB_INVALID_REGNUM };
+uint32_t RegisterContextPOSIX_x86::g_contained_rdi[] = { lldb_rdi_x86_64, LLDB_INVALID_REGNUM };
+uint32_t RegisterContextPOSIX_x86::g_contained_rsi[] = { lldb_rsi_x86_64, LLDB_INVALID_REGNUM };
+uint32_t RegisterContextPOSIX_x86::g_contained_rbp[] = { lldb_rbp_x86_64, LLDB_INVALID_REGNUM };
+uint32_t RegisterContextPOSIX_x86::g_contained_rsp[] = { lldb_rsp_x86_64, LLDB_INVALID_REGNUM };
+uint32_t RegisterContextPOSIX_x86::g_contained_r8[]  = { lldb_r8_x86_64,  LLDB_INVALID_REGNUM };
+uint32_t RegisterContextPOSIX_x86::g_contained_r9[]  = { lldb_r9_x86_64,  LLDB_INVALID_REGNUM };
+uint32_t RegisterContextPOSIX_x86::g_contained_r10[] = { lldb_r10_x86_64, LLDB_INVALID_REGNUM };
+uint32_t RegisterContextPOSIX_x86::g_contained_r11[] = { lldb_r11_x86_64, LLDB_INVALID_REGNUM };
+uint32_t RegisterContextPOSIX_x86::g_contained_r12[] = { lldb_r12_x86_64, LLDB_INVALID_REGNUM };
+uint32_t RegisterContextPOSIX_x86::g_contained_r13[] = { lldb_r13_x86_64, LLDB_INVALID_REGNUM };
+uint32_t RegisterContextPOSIX_x86::g_contained_r14[] = { lldb_r14_x86_64, LLDB_INVALID_REGNUM };
+uint32_t RegisterContextPOSIX_x86::g_contained_r15[] = { lldb_r15_x86_64, LLDB_INVALID_REGNUM };
+
+uint32_t RegisterContextPOSIX_x86::g_invalidate_rax[] = { lldb_rax_x86_64, lldb_eax_x86_64,  lldb_ax_x86_64,   lldb_ah_x86_64,   lldb_al_x86_64, LLDB_INVALID_REGNUM };
+uint32_t RegisterContextPOSIX_x86::g_invalidate_rbx[] = { lldb_rbx_x86_64, lldb_ebx_x86_64,  lldb_bx_x86_64,   lldb_bh_x86_64,   lldb_bl_x86_64, LLDB_INVALID_REGNUM };
+uint32_t RegisterContextPOSIX_x86::g_invalidate_rcx[] = { lldb_rcx_x86_64, lldb_ecx_x86_64,  lldb_cx_x86_64,   lldb_ch_x86_64,   lldb_cl_x86_64, LLDB_INVALID_REGNUM };
+uint32_t RegisterContextPOSIX_x86::g_invalidate_rdx[] = { lldb_rdx_x86_64, lldb_edx_x86_64,  lldb_dx_x86_64,   lldb_dh_x86_64,   lldb_dl_x86_64, LLDB_INVALID_REGNUM };
+uint32_t RegisterContextPOSIX_x86::g_invalidate_rdi[] = { lldb_rdi_x86_64, lldb_edi_x86_64,  lldb_di_x86_64,   lldb_dil_x86_64,  LLDB_INVALID_REGNUM };
+uint32_t RegisterContextPOSIX_x86::g_invalidate_rsi[] = { lldb_rsi_x86_64, lldb_esi_x86_64,  lldb_si_x86_64,   lldb_sil_x86_64,  LLDB_INVALID_REGNUM };
+uint32_t RegisterContextPOSIX_x86::g_invalidate_rbp[] = { lldb_rbp_x86_64, lldb_ebp_x86_64,  lldb_bp_x86_64,   lldb_bpl_x86_64,  LLDB_INVALID_REGNUM };
+uint32_t RegisterContextPOSIX_x86::g_invalidate_rsp[] = { lldb_rsp_x86_64, lldb_esp_x86_64,  lldb_sp_x86_64,   lldb_spl_x86_64,  LLDB_INVALID_REGNUM };
+uint32_t RegisterContextPOSIX_x86::g_invalidate_r8[]  = { lldb_r8_x86_64,  lldb_r8d_x86_64,  lldb_r8w_x86_64,  lldb_r8l_x86_64,  LLDB_INVALID_REGNUM };
+uint32_t RegisterContextPOSIX_x86::g_invalidate_r9[]  = { lldb_r9_x86_64,  lldb_r9d_x86_64,  lldb_r9w_x86_64,  lldb_r9l_x86_64,  LLDB_INVALID_REGNUM };
+uint32_t RegisterContextPOSIX_x86::g_invalidate_r10[] = { lldb_r10_x86_64, lldb_r10d_x86_64, lldb_r10w_x86_64, lldb_r10l_x86_64, LLDB_INVALID_REGNUM };
+uint32_t RegisterContextPOSIX_x86::g_invalidate_r11[] = { lldb_r11_x86_64, lldb_r11d_x86_64, lldb_r11w_x86_64, lldb_r11l_x86_64, LLDB_INVALID_REGNUM };
+uint32_t RegisterContextPOSIX_x86::g_invalidate_r12[] = { lldb_r12_x86_64, lldb_r12d_x86_64, lldb_r12w_x86_64, lldb_r12l_x86_64, LLDB_INVALID_REGNUM };
+uint32_t RegisterContextPOSIX_x86::g_invalidate_r13[] = { lldb_r13_x86_64, lldb_r13d_x86_64, lldb_r13w_x86_64, lldb_r13l_x86_64, LLDB_INVALID_REGNUM };
+uint32_t RegisterContextPOSIX_x86::g_invalidate_r14[] = { lldb_r14_x86_64, lldb_r14d_x86_64, lldb_r14w_x86_64, lldb_r14l_x86_64, LLDB_INVALID_REGNUM };
+uint32_t RegisterContextPOSIX_x86::g_invalidate_r15[] = { lldb_r15_x86_64, lldb_r15d_x86_64, lldb_r15w_x86_64, lldb_r15l_x86_64, LLDB_INVALID_REGNUM };
 
 // Number of register sets provided by this context.
 enum
@@ -346,7 +346,7 @@ static const RegisterSet
 g_reg_sets_i386[k_num_register_sets] =
 {
     { "General Purpose Registers",  "gpr", k_num_gpr_registers_i386, g_gpr_regnums_i386 },
-    { "Floating Point Registers",   "fpu", k_num_fpr_registers_i386, g_fpu_regnums_i386 },
+    { "Floating Point Registers",   "fpu", k_num_fpr_registers_i386, g_lldb_regnums_i386 },
     { "Advanced Vector Extensions", "avx", k_num_avx_registers_i386, g_avx_regnums_i386 }
 };
 
@@ -354,7 +354,7 @@ static const RegisterSet
 g_reg_sets_x86_64[k_num_register_sets] =
 {
     { "General Purpose Registers",  "gpr", k_num_gpr_registers_x86_64, g_gpr_regnums_x86_64 },
-    { "Floating Point Registers",   "fpu", k_num_fpr_registers_x86_64, g_fpu_regnums_x86_64 },
+    { "Floating Point Registers",   "fpu", k_num_fpr_registers_x86_64, g_lldb_regnums_x86_64 },
     { "Advanced Vector Extensions", "avx", k_num_avx_registers_x86_64, g_avx_regnums_x86_64 }
 };
 
@@ -399,16 +399,16 @@ RegisterContextPOSIX_x86::RegisterContextPOSIX_x86(Thread &thread,
             m_reg_info.last_gpr             = k_last_gpr_i386;
             m_reg_info.first_fpr            = k_first_fpr_i386;
             m_reg_info.last_fpr             = k_last_fpr_i386;
-            m_reg_info.first_st             = fpu_st0_i386;
-            m_reg_info.last_st              = fpu_st7_i386;
-            m_reg_info.first_mm             = fpu_mm0_i386;
-            m_reg_info.last_mm              = fpu_mm7_i386;
-            m_reg_info.first_xmm            = fpu_xmm0_i386;
-            m_reg_info.last_xmm             = fpu_xmm7_i386;
-            m_reg_info.first_ymm            = fpu_ymm0_i386;
-            m_reg_info.last_ymm             = fpu_ymm7_i386;
-            m_reg_info.first_dr             = dr0_i386;
-            m_reg_info.gpr_flags            = gpr_eflags_i386;
+            m_reg_info.first_st             = lldb_st0_i386;
+            m_reg_info.last_st              = lldb_st7_i386;
+            m_reg_info.first_mm             = lldb_mm0_i386;
+            m_reg_info.last_mm              = lldb_mm7_i386;
+            m_reg_info.first_xmm            = lldb_xmm0_i386;
+            m_reg_info.last_xmm             = lldb_xmm7_i386;
+            m_reg_info.first_ymm            = lldb_ymm0_i386;
+            m_reg_info.last_ymm             = lldb_ymm7_i386;
+            m_reg_info.first_dr             = lldb_dr0_i386;
+            m_reg_info.gpr_flags            = lldb_eflags_i386;
             break;
         case llvm::Triple::x86_64:
             m_reg_info.num_registers        = k_num_registers_x86_64;
@@ -418,16 +418,16 @@ RegisterContextPOSIX_x86::RegisterContextPOSIX_x86(Thread &thread,
             m_reg_info.last_gpr             = k_last_gpr_x86_64;
             m_reg_info.first_fpr            = k_first_fpr_x86_64;
             m_reg_info.last_fpr             = k_last_fpr_x86_64;
-            m_reg_info.first_st             = fpu_st0_x86_64;
-            m_reg_info.last_st              = fpu_st7_x86_64;
-            m_reg_info.first_mm             = fpu_mm0_x86_64;
-            m_reg_info.last_mm              = fpu_mm7_x86_64;
-            m_reg_info.first_xmm            = fpu_xmm0_x86_64;
-            m_reg_info.last_xmm             = fpu_xmm15_x86_64;
-            m_reg_info.first_ymm            = fpu_ymm0_x86_64;
-            m_reg_info.last_ymm             = fpu_ymm15_x86_64;
-            m_reg_info.first_dr             = dr0_x86_64;
-            m_reg_info.gpr_flags            = gpr_rflags_x86_64;
+            m_reg_info.first_st             = lldb_st0_x86_64;
+            m_reg_info.last_st              = lldb_st7_x86_64;
+            m_reg_info.first_mm             = lldb_mm0_x86_64;
+            m_reg_info.last_mm              = lldb_mm7_x86_64;
+            m_reg_info.first_xmm            = lldb_xmm0_x86_64;
+            m_reg_info.last_xmm             = lldb_xmm15_x86_64;
+            m_reg_info.first_ymm            = lldb_ymm0_x86_64;
+            m_reg_info.last_ymm             = lldb_ymm15_x86_64;
+            m_reg_info.first_dr             = lldb_dr0_x86_64;
+            m_reg_info.gpr_flags            = lldb_rflags_x86_64;
             break;
         default:
             assert(false && "Unhandled target architecture.");
diff --git a/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterContextPOSIX_x86.h b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterContextPOSIX_x86.h
index 4db7802..0eec1d9 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterContextPOSIX_x86.h
+++ b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterContextPOSIX_x86.h
@@ -11,285 +11,12 @@
 #define liblldb_RegisterContextPOSIX_x86_H_
 
 #include "lldb/Core/Log.h"
+#include "lldb-x86-register-enums.h"
 #include "RegisterContextPOSIX.h"
 #include "RegisterContext_x86.h"
 
 class ProcessMonitor;
 
-//---------------------------------------------------------------------------
-// Internal codes for all i386 registers.
-//---------------------------------------------------------------------------
-enum
-{
-    k_first_gpr_i386,
-    gpr_eax_i386 = k_first_gpr_i386,
-    gpr_ebx_i386,
-    gpr_ecx_i386,
-    gpr_edx_i386,
-    gpr_edi_i386,
-    gpr_esi_i386,
-    gpr_ebp_i386,
-    gpr_esp_i386,
-    gpr_eip_i386,
-    gpr_eflags_i386,
-    gpr_cs_i386,
-    gpr_fs_i386,
-    gpr_gs_i386,
-    gpr_ss_i386,
-    gpr_ds_i386,
-    gpr_es_i386,
-
-    k_first_alias_i386,
-    gpr_ax_i386 = k_first_alias_i386,
-    gpr_bx_i386,
-    gpr_cx_i386,
-    gpr_dx_i386,
-    gpr_di_i386,
-    gpr_si_i386,
-    gpr_bp_i386,
-    gpr_sp_i386,
-    gpr_ah_i386,
-    gpr_bh_i386,
-    gpr_ch_i386,
-    gpr_dh_i386,
-    gpr_al_i386,
-    gpr_bl_i386,
-    gpr_cl_i386,
-    gpr_dl_i386,
-    k_last_alias_i386 = gpr_dl_i386,
-
-    k_last_gpr_i386 = k_last_alias_i386,
-
-    k_first_fpr_i386,
-    fpu_fctrl_i386 = k_first_fpr_i386,
-    fpu_fstat_i386,
-    fpu_ftag_i386,
-    fpu_fop_i386,
-    fpu_fiseg_i386,
-    fpu_fioff_i386,
-    fpu_foseg_i386,
-    fpu_fooff_i386,
-    fpu_mxcsr_i386,
-    fpu_mxcsrmask_i386,
-    fpu_st0_i386,
-    fpu_st1_i386,
-    fpu_st2_i386,
-    fpu_st3_i386,
-    fpu_st4_i386,
-    fpu_st5_i386,
-    fpu_st6_i386,
-    fpu_st7_i386,
-    fpu_mm0_i386,
-    fpu_mm1_i386,
-    fpu_mm2_i386,
-    fpu_mm3_i386,
-    fpu_mm4_i386,
-    fpu_mm5_i386,
-    fpu_mm6_i386,
-    fpu_mm7_i386,
-    fpu_xmm0_i386,
-    fpu_xmm1_i386,
-    fpu_xmm2_i386,
-    fpu_xmm3_i386,
-    fpu_xmm4_i386,
-    fpu_xmm5_i386,
-    fpu_xmm6_i386,
-    fpu_xmm7_i386,
-    k_last_fpr_i386 = fpu_xmm7_i386,
-
-    k_first_avx_i386,
-    fpu_ymm0_i386 = k_first_avx_i386,
-    fpu_ymm1_i386,
-    fpu_ymm2_i386,
-    fpu_ymm3_i386,
-    fpu_ymm4_i386,
-    fpu_ymm5_i386,
-    fpu_ymm6_i386,
-    fpu_ymm7_i386,
-    k_last_avx_i386 = fpu_ymm7_i386,
-
-    dr0_i386,
-    dr1_i386,
-    dr2_i386,
-    dr3_i386,
-    dr4_i386,
-    dr5_i386,
-    dr6_i386,
-    dr7_i386,
-
-    k_num_registers_i386,
-    k_num_gpr_registers_i386 = k_last_gpr_i386 - k_first_gpr_i386 + 1,
-    k_num_fpr_registers_i386 = k_last_fpr_i386 - k_first_fpr_i386 + 1,
-    k_num_avx_registers_i386 = k_last_avx_i386 - k_first_avx_i386 + 1
-};
-
-//---------------------------------------------------------------------------
-// Internal codes for all x86_64 registers.
-//---------------------------------------------------------------------------
-enum
-{
-    k_first_gpr_x86_64,
-    gpr_rax_x86_64 = k_first_gpr_x86_64,
-    gpr_rbx_x86_64,
-    gpr_rcx_x86_64,
-    gpr_rdx_x86_64,
-    gpr_rdi_x86_64,
-    gpr_rsi_x86_64,
-    gpr_rbp_x86_64,
-    gpr_rsp_x86_64,
-    gpr_r8_x86_64,
-    gpr_r9_x86_64,
-    gpr_r10_x86_64,
-    gpr_r11_x86_64,
-    gpr_r12_x86_64,
-    gpr_r13_x86_64,
-    gpr_r14_x86_64,
-    gpr_r15_x86_64,
-    gpr_rip_x86_64,
-    gpr_rflags_x86_64,
-    gpr_cs_x86_64,
-    gpr_fs_x86_64,
-    gpr_gs_x86_64,
-    gpr_ss_x86_64,
-    gpr_ds_x86_64,
-    gpr_es_x86_64,
-
-    k_first_alias_x86_64,
-    gpr_eax_x86_64 = k_first_alias_x86_64,
-    gpr_ebx_x86_64,
-    gpr_ecx_x86_64,
-    gpr_edx_x86_64,
-    gpr_edi_x86_64,
-    gpr_esi_x86_64,
-    gpr_ebp_x86_64,
-    gpr_esp_x86_64,
-    gpr_r8d_x86_64,    // Low 32 bits of r8
-    gpr_r9d_x86_64,    // Low 32 bits of r9
-    gpr_r10d_x86_64,   // Low 32 bits of r10
-    gpr_r11d_x86_64,   // Low 32 bits of r11
-    gpr_r12d_x86_64,   // Low 32 bits of r12
-    gpr_r13d_x86_64,   // Low 32 bits of r13
-    gpr_r14d_x86_64,   // Low 32 bits of r14
-    gpr_r15d_x86_64,   // Low 32 bits of r15
-    gpr_ax_x86_64,
-    gpr_bx_x86_64,
-    gpr_cx_x86_64,
-    gpr_dx_x86_64,
-    gpr_di_x86_64,
-    gpr_si_x86_64,
-    gpr_bp_x86_64,
-    gpr_sp_x86_64,
-    gpr_r8w_x86_64,    // Low 16 bits of r8
-    gpr_r9w_x86_64,    // Low 16 bits of r9
-    gpr_r10w_x86_64,   // Low 16 bits of r10
-    gpr_r11w_x86_64,   // Low 16 bits of r11
-    gpr_r12w_x86_64,   // Low 16 bits of r12
-    gpr_r13w_x86_64,   // Low 16 bits of r13
-    gpr_r14w_x86_64,   // Low 16 bits of r14
-    gpr_r15w_x86_64,   // Low 16 bits of r15
-    gpr_ah_x86_64,
-    gpr_bh_x86_64,
-    gpr_ch_x86_64,
-    gpr_dh_x86_64,
-    gpr_al_x86_64,
-    gpr_bl_x86_64,
-    gpr_cl_x86_64,
-    gpr_dl_x86_64,
-    gpr_dil_x86_64,
-    gpr_sil_x86_64,
-    gpr_bpl_x86_64,
-    gpr_spl_x86_64,
-    gpr_r8l_x86_64,    // Low 8 bits of r8
-    gpr_r9l_x86_64,    // Low 8 bits of r9
-    gpr_r10l_x86_64,   // Low 8 bits of r10
-    gpr_r11l_x86_64,   // Low 8 bits of r11
-    gpr_r12l_x86_64,   // Low 8 bits of r12
-    gpr_r13l_x86_64,   // Low 8 bits of r13
-    gpr_r14l_x86_64,   // Low 8 bits of r14
-    gpr_r15l_x86_64,   // Low 8 bits of r15
-    k_last_alias_x86_64 = gpr_r15l_x86_64,
-
-    k_last_gpr_x86_64 = k_last_alias_x86_64,
-
-    k_first_fpr_x86_64,
-    fpu_fctrl_x86_64 = k_first_fpr_x86_64,
-    fpu_fstat_x86_64,
-    fpu_ftag_x86_64,
-    fpu_fop_x86_64,
-    fpu_fiseg_x86_64,
-    fpu_fioff_x86_64,
-    fpu_foseg_x86_64,
-    fpu_fooff_x86_64,
-    fpu_mxcsr_x86_64,
-    fpu_mxcsrmask_x86_64,
-    fpu_st0_x86_64,
-    fpu_st1_x86_64,
-    fpu_st2_x86_64,
-    fpu_st3_x86_64,
-    fpu_st4_x86_64,
-    fpu_st5_x86_64,
-    fpu_st6_x86_64,
-    fpu_st7_x86_64,
-    fpu_mm0_x86_64,
-    fpu_mm1_x86_64,
-    fpu_mm2_x86_64,
-    fpu_mm3_x86_64,
-    fpu_mm4_x86_64,
-    fpu_mm5_x86_64,
-    fpu_mm6_x86_64,
-    fpu_mm7_x86_64,
-    fpu_xmm0_x86_64,
-    fpu_xmm1_x86_64,
-    fpu_xmm2_x86_64,
-    fpu_xmm3_x86_64,
-    fpu_xmm4_x86_64,
-    fpu_xmm5_x86_64,
-    fpu_xmm6_x86_64,
-    fpu_xmm7_x86_64,
-    fpu_xmm8_x86_64,
-    fpu_xmm9_x86_64,
-    fpu_xmm10_x86_64,
-    fpu_xmm11_x86_64,
-    fpu_xmm12_x86_64,
-    fpu_xmm13_x86_64,
-    fpu_xmm14_x86_64,
-    fpu_xmm15_x86_64,
-    k_last_fpr_x86_64 = fpu_xmm15_x86_64,
-
-    k_first_avx_x86_64,
-    fpu_ymm0_x86_64 = k_first_avx_x86_64,
-    fpu_ymm1_x86_64,
-    fpu_ymm2_x86_64,
-    fpu_ymm3_x86_64,
-    fpu_ymm4_x86_64,
-    fpu_ymm5_x86_64,
-    fpu_ymm6_x86_64,
-    fpu_ymm7_x86_64,
-    fpu_ymm8_x86_64,
-    fpu_ymm9_x86_64,
-    fpu_ymm10_x86_64,
-    fpu_ymm11_x86_64,
-    fpu_ymm12_x86_64,
-    fpu_ymm13_x86_64,
-    fpu_ymm14_x86_64,
-    fpu_ymm15_x86_64,
-    k_last_avx_x86_64 = fpu_ymm15_x86_64,
-
-    dr0_x86_64,
-    dr1_x86_64,
-    dr2_x86_64,
-    dr3_x86_64,
-    dr4_x86_64,
-    dr5_x86_64,
-    dr6_x86_64,
-    dr7_x86_64,
-
-    k_num_registers_x86_64,
-    k_num_gpr_registers_x86_64 = k_last_gpr_x86_64 - k_first_gpr_x86_64 + 1,
-    k_num_fpr_registers_x86_64 = k_last_fpr_x86_64 - k_first_fpr_x86_64 + 1,
-    k_num_avx_registers_x86_64 = k_last_avx_x86_64 - k_first_avx_x86_64 + 1
-};
-
 class RegisterContextPOSIX_x86
   : public lldb_private::RegisterContext
 {
@@ -422,7 +149,7 @@ protected:
         uint32_t gpr_flags;
     };
 
-    uint64_t m_gpr_x86_64[k_num_gpr_registers_x86_64];         // 64-bit general purpose registers.
+    uint64_t m_gpr_x86_64[lldb_private::k_num_gpr_registers_x86_64];   // 64-bit general purpose registers.
     RegInfo  m_reg_info;
     FPRType  m_fpr_type;                                       // determines the type of data stored by union FPR, if any.
     FPR      m_fpr;                                            // floating-point registers including extended register sets.
diff --git a/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterContextThreadMemory.cpp b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterContextThreadMemory.cpp
index 46dafa1..200ef4d 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterContextThreadMemory.cpp
+++ b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterContextThreadMemory.cpp
@@ -59,7 +59,7 @@ RegisterContextThreadMemory::UpdateRegisterContext ()
                 {
                     OperatingSystem *os = process_sp->GetOperatingSystem ();
                     if (os->IsOperatingSystemPluginThread (thread_sp))
-                        m_reg_ctx_sp = os->CreateRegisterContextForThread (thread_sp.get(), LLDB_INVALID_ADDRESS);
+                        m_reg_ctx_sp = os->CreateRegisterContextForThread (thread_sp.get(), m_register_data_addr);
                 }                
             }
         }
diff --git a/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterContext_powerpc.h b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterContext_powerpc.h
new file mode 100644
index 0000000..cf54cc0
--- /dev/null
+++ b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterContext_powerpc.h
@@ -0,0 +1,163 @@
+//===-- RegisterContext_powerpc.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_RegisterContext_powerpc_H_
+#define liblldb_RegisterContext_powerpc_H_
+
+// GCC and DWARF Register numbers (eRegisterKindGCC & eRegisterKindDWARF)
+enum
+{
+    gcc_dwarf_r0_powerpc = 0,
+    gcc_dwarf_r1_powerpc,
+    gcc_dwarf_r2_powerpc,
+    gcc_dwarf_r3_powerpc,
+    gcc_dwarf_r4_powerpc,
+    gcc_dwarf_r5_powerpc,
+    gcc_dwarf_r6_powerpc,
+    gcc_dwarf_r7_powerpc,
+    gcc_dwarf_r8_powerpc,
+    gcc_dwarf_r9_powerpc,
+    gcc_dwarf_r10_powerpc,
+    gcc_dwarf_r11_powerpc,
+    gcc_dwarf_r12_powerpc,
+    gcc_dwarf_r13_powerpc,
+    gcc_dwarf_r14_powerpc,
+    gcc_dwarf_r15_powerpc,
+    gcc_dwarf_r16_powerpc,
+    gcc_dwarf_r17_powerpc,
+    gcc_dwarf_r18_powerpc,
+    gcc_dwarf_r19_powerpc,
+    gcc_dwarf_r20_powerpc,
+    gcc_dwarf_r21_powerpc,
+    gcc_dwarf_r22_powerpc,
+    gcc_dwarf_r23_powerpc,
+    gcc_dwarf_r24_powerpc,
+    gcc_dwarf_r25_powerpc,
+    gcc_dwarf_r26_powerpc,
+    gcc_dwarf_r27_powerpc,
+    gcc_dwarf_r28_powerpc,
+    gcc_dwarf_r29_powerpc,
+    gcc_dwarf_r30_powerpc,
+    gcc_dwarf_r31_powerpc,
+    gcc_dwarf_f0_powerpc,
+    gcc_dwarf_f1_powerpc,
+    gcc_dwarf_f2_powerpc,
+    gcc_dwarf_f3_powerpc,
+    gcc_dwarf_f4_powerpc,
+    gcc_dwarf_f5_powerpc,
+    gcc_dwarf_f6_powerpc,
+    gcc_dwarf_f7_powerpc,
+    gcc_dwarf_f8_powerpc,
+    gcc_dwarf_f9_powerpc,
+    gcc_dwarf_f10_powerpc,
+    gcc_dwarf_f11_powerpc,
+    gcc_dwarf_f12_powerpc,
+    gcc_dwarf_f13_powerpc,
+    gcc_dwarf_f14_powerpc,
+    gcc_dwarf_f15_powerpc,
+    gcc_dwarf_f16_powerpc,
+    gcc_dwarf_f17_powerpc,
+    gcc_dwarf_f18_powerpc,
+    gcc_dwarf_f19_powerpc,
+    gcc_dwarf_f20_powerpc,
+    gcc_dwarf_f21_powerpc,
+    gcc_dwarf_f22_powerpc,
+    gcc_dwarf_f23_powerpc,
+    gcc_dwarf_f24_powerpc,
+    gcc_dwarf_f25_powerpc,
+    gcc_dwarf_f26_powerpc,
+    gcc_dwarf_f27_powerpc,
+    gcc_dwarf_f28_powerpc,
+    gcc_dwarf_f29_powerpc,
+    gcc_dwarf_f30_powerpc,
+    gcc_dwarf_f31_powerpc,
+    gcc_dwarf_cr_powerpc,
+    gcc_dwarf_fpscr_powerpc,
+    gcc_dwarf_xer_powerpc = 101,
+    gcc_dwarf_lr_powerpc = 108,
+    gcc_dwarf_ctr_powerpc,
+    gcc_dwarf_pc_powerpc,
+};
+
+// GDB Register numbers (eRegisterKindGDB)
+enum
+{
+    gdb_r0_powerpc = 0,
+    gdb_r1_powerpc,
+    gdb_r2_powerpc,
+    gdb_r3_powerpc,
+    gdb_r4_powerpc,
+    gdb_r5_powerpc,
+    gdb_r6_powerpc,
+    gdb_r7_powerpc,
+    gdb_r8_powerpc,
+    gdb_r9_powerpc,
+    gdb_r10_powerpc,
+    gdb_r11_powerpc,
+    gdb_r12_powerpc,
+    gdb_r13_powerpc,
+    gdb_r14_powerpc,
+    gdb_r15_powerpc,
+    gdb_r16_powerpc,
+    gdb_r17_powerpc,
+    gdb_r18_powerpc,
+    gdb_r19_powerpc,
+    gdb_r20_powerpc,
+    gdb_r21_powerpc,
+    gdb_r22_powerpc,
+    gdb_r23_powerpc,
+    gdb_r24_powerpc,
+    gdb_r25_powerpc,
+    gdb_r26_powerpc,
+    gdb_r27_powerpc,
+    gdb_r28_powerpc,
+    gdb_r29_powerpc,
+    gdb_r30_powerpc,
+    gdb_r31_powerpc,
+    gdb_f0_powerpc,
+    gdb_f1_powerpc,
+    gdb_f2_powerpc,
+    gdb_f3_powerpc,
+    gdb_f4_powerpc,
+    gdb_f5_powerpc,
+    gdb_f6_powerpc,
+    gdb_f7_powerpc,
+    gdb_f8_powerpc,
+    gdb_f9_powerpc,
+    gdb_f10_powerpc,
+    gdb_f11_powerpc,
+    gdb_f12_powerpc,
+    gdb_f13_powerpc,
+    gdb_f14_powerpc,
+    gdb_f15_powerpc,
+    gdb_f16_powerpc,
+    gdb_f17_powerpc,
+    gdb_f18_powerpc,
+    gdb_f19_powerpc,
+    gdb_f20_powerpc,
+    gdb_f21_powerpc,
+    gdb_f22_powerpc,
+    gdb_f23_powerpc,
+    gdb_f24_powerpc,
+    gdb_f25_powerpc,
+    gdb_f26_powerpc,
+    gdb_f27_powerpc,
+    gdb_f28_powerpc,
+    gdb_f29_powerpc,
+    gdb_f30_powerpc,
+    gdb_f31_powerpc,
+    gdb_cr_powerpc,
+    gdb_fpscr_powerpc,
+    gdb_xer_powerpc = 101,
+    gdb_lr_powerpc = 108,
+    gdb_ctr_powerpc,
+    gdb_pc_powerpc,
+};
+
+#endif // liblldb_RegisterContext_powerpc_H_
diff --git a/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterInfos_i386.h b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterInfos_i386.h
index fa152b4..fc94b8b 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterInfos_i386.h
+++ b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterInfos_i386.h
@@ -42,37 +42,37 @@
 // Note that the size and offset will be updated by platform-specific classes.
 #define DEFINE_GPR(reg, alt, kind1, kind2, kind3, kind4)            \
     { #reg, alt, sizeof(((GPR*)NULL)->reg), GPR_OFFSET(reg), eEncodingUint,  \
-      eFormatHex, { kind1, kind2, kind3, kind4, gpr_##reg##_i386 }, NULL, NULL }
+      eFormatHex, { kind1, kind2, kind3, kind4, lldb_##reg##_i386 }, NULL, NULL }
 
 #define DEFINE_FPR(name, reg, kind1, kind2, kind3, kind4)           \
     { #name, NULL, FPR_SIZE(reg), FPR_OFFSET(reg), eEncodingUint,   \
-      eFormatHex, { kind1, kind2, kind3, kind4, fpu_##name##_i386 }, NULL, NULL }
+      eFormatHex, { kind1, kind2, kind3, kind4, lldb_##name##_i386 }, NULL, NULL }
 
 // RegisterKind: GCC, DWARF, Generic, GDB, LLDB
 
 #define DEFINE_FP_ST(reg, i)                                       \
     { #reg#i, NULL, FP_SIZE, LLVM_EXTENSION FPR_OFFSET(stmm[i]),    \
       eEncodingVector, eFormatVectorOfUInt8,                       \
-      { gcc_st##i##_i386, dwarf_st##i##_i386, LLDB_INVALID_REGNUM, gdb_st##i##_i386, fpu_st##i##_i386 }, \
+      { gcc_st##i##_i386, dwarf_st##i##_i386, LLDB_INVALID_REGNUM, gdb_st##i##_i386, lldb_st##i##_i386 }, \
       NULL, NULL }
 
 #define DEFINE_FP_MM(reg, i)                                                \
     { #reg#i, NULL, sizeof(uint64_t), LLVM_EXTENSION FPR_OFFSET(stmm[i]),   \
       eEncodingUint, eFormatHex,                                            \
-      { gcc_mm##i##_i386, dwarf_mm##i##_i386, LLDB_INVALID_REGNUM, gdb_mm##i##_i386, fpu_mm##i##_i386 }, \
+      { gcc_mm##i##_i386, dwarf_mm##i##_i386, LLDB_INVALID_REGNUM, gdb_mm##i##_i386, lldb_mm##i##_i386 }, \
       NULL, NULL }
 
 #define DEFINE_XMM(reg, i)                                         \
     { #reg#i, NULL, XMM_SIZE, LLVM_EXTENSION FPR_OFFSET(reg[i]),   \
       eEncodingVector, eFormatVectorOfUInt8,                       \
-      { gcc_##reg##i##_i386, dwarf_##reg##i##_i386, LLDB_INVALID_REGNUM, gdb_##reg##i##_i386, fpu_##reg##i##_i386}, \
+      { gcc_##reg##i##_i386, dwarf_##reg##i##_i386, LLDB_INVALID_REGNUM, gdb_##reg##i##_i386, lldb_##reg##i##_i386}, \
       NULL, NULL }
 
 // I believe the YMM registers use dwarf_xmm_%_i386 register numbers and then differentiate based on register size.
 #define DEFINE_YMM(reg, i)                                         \
     { #reg#i, NULL, YMM_SIZE, LLVM_EXTENSION YMM_OFFSET(reg[i]),   \
       eEncodingVector, eFormatVectorOfUInt8,                       \
-      { LLDB_INVALID_REGNUM, dwarf_xmm##i##_i386, LLDB_INVALID_REGNUM, gdb_##reg##i##h_i386, fpu_##reg##i##_i386 }, \
+      { LLDB_INVALID_REGNUM, dwarf_xmm##i##_i386, LLDB_INVALID_REGNUM, gdb_##reg##i##h_i386, lldb_##reg##i##_i386 }, \
       NULL, NULL }
 
 #define DEFINE_DR(reg, i)                                               \
@@ -82,13 +82,13 @@
 
 #define DEFINE_GPR_PSEUDO_16(reg16, reg32)                  \
     { #reg16, NULL, 2, GPR_OFFSET(reg32), eEncodingUint,    \
-      eFormatHex, { LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, gpr_##reg16##_i386 }, RegisterContextPOSIX_x86::g_contained_##reg32, RegisterContextPOSIX_x86::g_invalidate_##reg32 }
+      eFormatHex, { LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, lldb_##reg16##_i386 }, RegisterContextPOSIX_x86::g_contained_##reg32, RegisterContextPOSIX_x86::g_invalidate_##reg32 }
 #define DEFINE_GPR_PSEUDO_8H(reg8, reg32)                   \
     { #reg8, NULL, 1, GPR_OFFSET(reg32)+1, eEncodingUint,   \
-      eFormatHex, { LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, gpr_##reg8##_i386 }, RegisterContextPOSIX_x86::g_contained_##reg32, RegisterContextPOSIX_x86::g_invalidate_##reg32 }
+      eFormatHex, { LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, lldb_##reg8##_i386 }, RegisterContextPOSIX_x86::g_contained_##reg32, RegisterContextPOSIX_x86::g_invalidate_##reg32 }
 #define DEFINE_GPR_PSEUDO_8L(reg8, reg32)                   \
     { #reg8, NULL, 1, GPR_OFFSET(reg32), eEncodingUint,     \
-      eFormatHex, { LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, gpr_##reg8##_i386 }, RegisterContextPOSIX_x86::g_contained_##reg32, RegisterContextPOSIX_x86::g_invalidate_##reg32 }
+      eFormatHex, { LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, lldb_##reg8##_i386 }, RegisterContextPOSIX_x86::g_contained_##reg32, RegisterContextPOSIX_x86::g_invalidate_##reg32 }
  
 static RegisterInfo
 g_register_infos_i386[] =
diff --git a/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterInfos_powerpc.h b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterInfos_powerpc.h
new file mode 100644
index 0000000..0454266
--- /dev/null
+++ b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterInfos_powerpc.h
@@ -0,0 +1,144 @@
+//===-- RegisterInfos_powerpc.h ---------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===---------------------------------------------------------------------===//
+
+#include <stddef.h>
+
+// Computes the offset of the given GPR in the user data area.
+#define GPR_OFFSET(regname)                                                 \
+    (offsetof(GPR, regname))
+#define FPR_OFFSET(regname)                                                 \
+    (offsetof(FPR, regname))
+#define GPR_SIZE(regname)                                                   \
+    (sizeof(((GPR*)NULL)->regname))
+
+#ifdef DECLARE_REGISTER_INFOS_POWERPC_STRUCT
+
+// Note that the size and offset will be updated by platform-specific classes.
+#define DEFINE_GPR(reg, alt, lldb_kind)           \
+    { #reg, alt, GPR_SIZE(reg), GPR_OFFSET(reg), eEncodingUint, \
+      eFormatHex, { gcc_dwarf_##reg##_powerpc, gcc_dwarf_##reg##_powerpc, lldb_kind, gdb_##reg##_powerpc, gpr_##reg##_powerpc }, NULL, NULL }
+#define DEFINE_FPR(reg, lldb_kind)           \
+    { #reg, NULL, 8, FPR_OFFSET(reg), eEncodingIEEE754, \
+      eFormatFloat, { gcc_dwarf_##reg##_powerpc, gcc_dwarf_##reg##_powerpc, lldb_kind, gdb_##reg##_powerpc, fpr_##reg##_powerpc }, NULL, NULL }
+
+    // General purpose registers.                 GCC,                  DWARF,              Generic,                GDB
+#define POWERPC_REGS \
+    DEFINE_GPR(r0,       NULL,  LLDB_INVALID_REGNUM), \
+    DEFINE_GPR(r1,       "sp",  LLDB_REGNUM_GENERIC_SP), \
+    DEFINE_GPR(r2,       NULL,  LLDB_INVALID_REGNUM), \
+    DEFINE_GPR(r3,       "arg1",LLDB_REGNUM_GENERIC_ARG1), \
+    DEFINE_GPR(r4,       "arg2",LLDB_REGNUM_GENERIC_ARG2), \
+    DEFINE_GPR(r5,       "arg3",LLDB_REGNUM_GENERIC_ARG3), \
+    DEFINE_GPR(r6,       "arg4",LLDB_REGNUM_GENERIC_ARG4), \
+    DEFINE_GPR(r7,       "arg5",LLDB_REGNUM_GENERIC_ARG5), \
+    DEFINE_GPR(r8,       "arg6",LLDB_REGNUM_GENERIC_ARG6), \
+    DEFINE_GPR(r9,       "arg7",LLDB_REGNUM_GENERIC_ARG7), \
+    DEFINE_GPR(r10,      "arg8",LLDB_REGNUM_GENERIC_ARG8), \
+    DEFINE_GPR(r11,      NULL,  LLDB_INVALID_REGNUM), \
+    DEFINE_GPR(r12,      NULL,  LLDB_INVALID_REGNUM), \
+    DEFINE_GPR(r13,      NULL,  LLDB_INVALID_REGNUM), \
+    DEFINE_GPR(r14,      NULL,  LLDB_INVALID_REGNUM), \
+    DEFINE_GPR(r15,      NULL,  LLDB_INVALID_REGNUM), \
+    DEFINE_GPR(r16,      NULL,  LLDB_INVALID_REGNUM), \
+    DEFINE_GPR(r17,      NULL,  LLDB_INVALID_REGNUM), \
+    DEFINE_GPR(r18,      NULL,  LLDB_INVALID_REGNUM), \
+    DEFINE_GPR(r19,      NULL,  LLDB_INVALID_REGNUM), \
+    DEFINE_GPR(r20,      NULL,  LLDB_INVALID_REGNUM), \
+    DEFINE_GPR(r21,      NULL,  LLDB_INVALID_REGNUM), \
+    DEFINE_GPR(r22,      NULL,  LLDB_INVALID_REGNUM), \
+    DEFINE_GPR(r23,      NULL,  LLDB_INVALID_REGNUM), \
+    DEFINE_GPR(r24,      NULL,  LLDB_INVALID_REGNUM), \
+    DEFINE_GPR(r25,      NULL,  LLDB_INVALID_REGNUM), \
+    DEFINE_GPR(r26,      NULL,  LLDB_INVALID_REGNUM), \
+    DEFINE_GPR(r27,      NULL,  LLDB_INVALID_REGNUM), \
+    DEFINE_GPR(r28,      NULL,  LLDB_INVALID_REGNUM), \
+    DEFINE_GPR(r29,      NULL,  LLDB_INVALID_REGNUM), \
+    DEFINE_GPR(r30,      NULL,  LLDB_INVALID_REGNUM), \
+    DEFINE_GPR(r31,      NULL,  LLDB_INVALID_REGNUM), \
+    DEFINE_GPR(lr,       "lr",  LLDB_REGNUM_GENERIC_RA), \
+    DEFINE_GPR(cr,       "cr",  LLDB_REGNUM_GENERIC_FLAGS), \
+    DEFINE_GPR(xer,      "xer", LLDB_INVALID_REGNUM), \
+    DEFINE_GPR(ctr,      "ctr", LLDB_INVALID_REGNUM), \
+    DEFINE_GPR(pc,       "pc",  LLDB_REGNUM_GENERIC_PC), \
+    DEFINE_FPR(f0,       LLDB_INVALID_REGNUM), \
+    DEFINE_FPR(f1,       LLDB_INVALID_REGNUM), \
+    DEFINE_FPR(f2,       LLDB_INVALID_REGNUM), \
+    DEFINE_FPR(f3,       LLDB_INVALID_REGNUM), \
+    DEFINE_FPR(f4,       LLDB_INVALID_REGNUM), \
+    DEFINE_FPR(f5,       LLDB_INVALID_REGNUM), \
+    DEFINE_FPR(f6,       LLDB_INVALID_REGNUM), \
+    DEFINE_FPR(f7,       LLDB_INVALID_REGNUM), \
+    DEFINE_FPR(f8,       LLDB_INVALID_REGNUM), \
+    DEFINE_FPR(f9,       LLDB_INVALID_REGNUM), \
+    DEFINE_FPR(f10,      LLDB_INVALID_REGNUM), \
+    DEFINE_FPR(f11,      LLDB_INVALID_REGNUM), \
+    DEFINE_FPR(f12,      LLDB_INVALID_REGNUM), \
+    DEFINE_FPR(f13,      LLDB_INVALID_REGNUM), \
+    DEFINE_FPR(f14,      LLDB_INVALID_REGNUM), \
+    DEFINE_FPR(f15,      LLDB_INVALID_REGNUM), \
+    DEFINE_FPR(f16,      LLDB_INVALID_REGNUM), \
+    DEFINE_FPR(f17,      LLDB_INVALID_REGNUM), \
+    DEFINE_FPR(f18,      LLDB_INVALID_REGNUM), \
+    DEFINE_FPR(f19,      LLDB_INVALID_REGNUM), \
+    DEFINE_FPR(f20,      LLDB_INVALID_REGNUM), \
+    DEFINE_FPR(f21,      LLDB_INVALID_REGNUM), \
+    DEFINE_FPR(f22,      LLDB_INVALID_REGNUM), \
+    DEFINE_FPR(f23,      LLDB_INVALID_REGNUM), \
+    DEFINE_FPR(f24,      LLDB_INVALID_REGNUM), \
+    DEFINE_FPR(f25,      LLDB_INVALID_REGNUM), \
+    DEFINE_FPR(f26,      LLDB_INVALID_REGNUM), \
+    DEFINE_FPR(f27,      LLDB_INVALID_REGNUM), \
+    DEFINE_FPR(f28,      LLDB_INVALID_REGNUM), \
+    DEFINE_FPR(f29,      LLDB_INVALID_REGNUM), \
+    DEFINE_FPR(f30,      LLDB_INVALID_REGNUM), \
+    DEFINE_FPR(f31,      LLDB_INVALID_REGNUM), \
+    { "fpscr", NULL, 8, FPR_OFFSET(fpscr), eEncodingUint, eFormatHex, { gcc_dwarf_fpscr_powerpc, gcc_dwarf_fpscr_powerpc, LLDB_INVALID_REGNUM, gdb_fpscr_powerpc, fpr_fpscr_powerpc }, NULL, NULL },
+static RegisterInfo
+g_register_infos_powerpc64[] =
+{
+#define GPR GPR64
+    POWERPC_REGS
+#undef GPR
+};
+
+static RegisterInfo
+g_register_infos_powerpc32[] =
+{
+#define GPR GPR32
+    POWERPC_REGS
+#undef GPR
+};
+
+static RegisterInfo
+g_register_infos_powerpc64_32[] =
+{
+#define GPR GPR64
+#undef GPR_SIZE
+#define GPR_SIZE(reg)   (sizeof(uint32_t))
+#undef GPR_OFFSET
+#define GPR_OFFSET(regname)                                                 \
+    (offsetof(GPR, regname) + (sizeof(((GPR *)NULL)->regname) - GPR_SIZE(reg)))
+    POWERPC_REGS
+#undef GPR
+};
+
+static_assert((sizeof(g_register_infos_powerpc32) / sizeof(g_register_infos_powerpc32[0])) == k_num_registers_powerpc,
+    "g_register_infos_powerpc32 has wrong number of register infos");
+static_assert((sizeof(g_register_infos_powerpc64) / sizeof(g_register_infos_powerpc64[0])) == k_num_registers_powerpc,
+    "g_register_infos_powerpc64 has wrong number of register infos");
+static_assert(sizeof(g_register_infos_powerpc64_32) == sizeof(g_register_infos_powerpc64),
+    "g_register_infos_powerpc64_32 doesn't match size of g_register_infos_powerpc64");
+
+#undef DEFINE_FPR
+#undef DEFINE_GPR
+
+#endif // DECLARE_REGISTER_INFOS_POWERPC_STRUCT
+
+#undef GPR_OFFSET
+
diff --git a/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterInfos_x86_64.h b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterInfos_x86_64.h
index c4dc604..c1bcd27 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterInfos_x86_64.h
+++ b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/RegisterInfos_x86_64.h
@@ -42,34 +42,34 @@
 // Note that the size and offset will be updated by platform-specific classes.
 #define DEFINE_GPR(reg, alt, kind1, kind2, kind3, kind4)    \
     { #reg, alt, sizeof(((GPR*)NULL)->reg), GPR_OFFSET(reg), eEncodingUint, \
-      eFormatHex, { kind1, kind2, kind3, kind4, gpr_##reg##_x86_64 }, NULL, NULL }
+      eFormatHex, { kind1, kind2, kind3, kind4, lldb_##reg##_x86_64 }, NULL, NULL }
 
 #define DEFINE_FPR(name, reg, kind1, kind2, kind3, kind4)    \
     { #name, NULL, FPR_SIZE(reg), FPR_OFFSET(reg), eEncodingUint,   \
-      eFormatHex, { kind1, kind2, kind3, kind4, fpu_##name##_x86_64 }, NULL, NULL }
+      eFormatHex, { kind1, kind2, kind3, kind4, lldb_##name##_x86_64 }, NULL, NULL }
 
 #define DEFINE_FP_ST(reg, i)                                       \
     { #reg#i, NULL, FP_SIZE, LLVM_EXTENSION FPR_OFFSET(stmm[i]),   \
       eEncodingVector, eFormatVectorOfUInt8,                       \
-      { gcc_dwarf_st##i##_x86_64, gcc_dwarf_st##i##_x86_64, LLDB_INVALID_REGNUM, gdb_st##i##_x86_64, fpu_st##i##_x86_64 }, \
+      { gcc_dwarf_st##i##_x86_64, gcc_dwarf_st##i##_x86_64, LLDB_INVALID_REGNUM, gdb_st##i##_x86_64, lldb_st##i##_x86_64 }, \
       NULL, NULL }
 
 #define DEFINE_FP_MM(reg, i)                                                \
     { #reg#i, NULL, sizeof(uint64_t), LLVM_EXTENSION FPR_OFFSET(stmm[i]),   \
       eEncodingUint, eFormatHex,                                            \
-      { gcc_dwarf_mm##i##_x86_64, gcc_dwarf_mm##i##_x86_64, LLDB_INVALID_REGNUM, gdb_st##i##_x86_64, fpu_mm##i##_x86_64 }, \
+      { gcc_dwarf_mm##i##_x86_64, gcc_dwarf_mm##i##_x86_64, LLDB_INVALID_REGNUM, gdb_st##i##_x86_64, lldb_mm##i##_x86_64 }, \
       NULL, NULL }
 
 #define DEFINE_XMM(reg, i)                                         \
     { #reg#i, NULL, XMM_SIZE, LLVM_EXTENSION FPR_OFFSET(reg[i]),   \
       eEncodingVector, eFormatVectorOfUInt8,                       \
-      { gcc_dwarf_##reg##i##_x86_64, gcc_dwarf_##reg##i##_x86_64, LLDB_INVALID_REGNUM, gdb_##reg##i##_x86_64, fpu_##reg##i##_x86_64}, \
+      { gcc_dwarf_##reg##i##_x86_64, gcc_dwarf_##reg##i##_x86_64, LLDB_INVALID_REGNUM, gdb_##reg##i##_x86_64, lldb_##reg##i##_x86_64}, \
       NULL, NULL }
 
 #define DEFINE_YMM(reg, i)                                                          \
     { #reg#i, NULL, YMM_SIZE, LLVM_EXTENSION YMM_OFFSET(reg[i]),                    \
       eEncodingVector, eFormatVectorOfUInt8,                                        \
-      { gcc_dwarf_##reg##i##h_x86_64, gcc_dwarf_##reg##i##h_x86_64, LLDB_INVALID_REGNUM, gdb_##reg##i##h_x86_64, fpu_##reg##i##_x86_64 }, \
+      { gcc_dwarf_##reg##i##h_x86_64, gcc_dwarf_##reg##i##h_x86_64, LLDB_INVALID_REGNUM, gdb_##reg##i##h_x86_64, lldb_##reg##i##_x86_64 }, \
       NULL, NULL }
 
 #define DEFINE_DR(reg, i)                                               \
@@ -79,16 +79,16 @@
 
 #define DEFINE_GPR_PSEUDO_32(reg32, reg64)          \
     { #reg32, NULL, 4, GPR_OFFSET(reg64), eEncodingUint,   \
-      eFormatHex, { LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, gpr_##reg32##_x86_64 }, RegisterContextPOSIX_x86::g_contained_##reg64, RegisterContextPOSIX_x86::g_invalidate_##reg64 }
+      eFormatHex, { LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, lldb_##reg32##_x86_64 }, RegisterContextPOSIX_x86::g_contained_##reg64, RegisterContextPOSIX_x86::g_invalidate_##reg64 }
 #define DEFINE_GPR_PSEUDO_16(reg16, reg64)          \
     { #reg16, NULL, 2, GPR_OFFSET(reg64), eEncodingUint,   \
-      eFormatHex, { LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, gpr_##reg16##_x86_64 }, RegisterContextPOSIX_x86::g_contained_##reg64, RegisterContextPOSIX_x86::g_invalidate_##reg64 }
+      eFormatHex, { LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, lldb_##reg16##_x86_64 }, RegisterContextPOSIX_x86::g_contained_##reg64, RegisterContextPOSIX_x86::g_invalidate_##reg64 }
 #define DEFINE_GPR_PSEUDO_8H(reg8, reg64)           \
     { #reg8, NULL, 1, GPR_OFFSET(reg64)+1, eEncodingUint,  \
-      eFormatHex, { LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, gpr_##reg8##_x86_64 }, RegisterContextPOSIX_x86::g_contained_##reg64, RegisterContextPOSIX_x86::g_invalidate_##reg64 }
+      eFormatHex, { LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, lldb_##reg8##_x86_64 }, RegisterContextPOSIX_x86::g_contained_##reg64, RegisterContextPOSIX_x86::g_invalidate_##reg64 }
 #define DEFINE_GPR_PSEUDO_8L(reg8, reg64)           \
     { #reg8, NULL, 1, GPR_OFFSET(reg64), eEncodingUint,    \
-      eFormatHex, { LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, gpr_##reg8##_x86_64 }, RegisterContextPOSIX_x86::g_contained_##reg64, RegisterContextPOSIX_x86::g_invalidate_##reg64 }
+      eFormatHex, { LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, lldb_##reg8##_x86_64 }, RegisterContextPOSIX_x86::g_contained_##reg64, RegisterContextPOSIX_x86::g_invalidate_##reg64 }
 
 static RegisterInfo
 g_register_infos_x86_64[] =
@@ -273,37 +273,37 @@ static_assert((sizeof(g_register_infos_x86_64) / sizeof(g_register_infos_x86_64[
 
 #define UPDATE_GPR_INFO(reg, reg64)                                             \
 do {                                                                            \
-    g_register_infos[gpr_##reg##_i386].byte_offset = GPR_OFFSET(reg64);         \
+    g_register_infos[lldb_##reg##_i386].byte_offset = GPR_OFFSET(reg64);         \
 } while(false);
 
 #define UPDATE_GPR_INFO_8H(reg, reg64)                                          \
 do {                                                                            \
-    g_register_infos[gpr_##reg##_i386].byte_offset = GPR_OFFSET(reg64) + 1;     \
+    g_register_infos[lldb_##reg##_i386].byte_offset = GPR_OFFSET(reg64) + 1;     \
 } while(false);
 
 #define UPDATE_FPR_INFO(reg, reg64)                                             \
 do {                                                                            \
-    g_register_infos[fpu_##reg##_i386].byte_offset = FPR_OFFSET(reg64);         \
+    g_register_infos[lldb_##reg##_i386].byte_offset = FPR_OFFSET(reg64);         \
 } while(false);
 
 #define UPDATE_FP_INFO(reg, i)                                                  \
 do {                                                                            \
-    g_register_infos[fpu_##reg##i##_i386].byte_offset = FPR_OFFSET(stmm[i]);    \
+    g_register_infos[lldb_##reg##i##_i386].byte_offset = FPR_OFFSET(stmm[i]);    \
 } while(false);
 
 #define UPDATE_XMM_INFO(reg, i)                                                 \
 do {                                                                            \
-    g_register_infos[fpu_##reg##i##_i386].byte_offset = FPR_OFFSET(reg[i]);     \
+    g_register_infos[lldb_##reg##i##_i386].byte_offset = FPR_OFFSET(reg[i]);     \
 } while(false);
 
 #define UPDATE_YMM_INFO(reg, i)                                                 \
 do {                                                                            \
-    g_register_infos[fpu_##reg##i##_i386].byte_offset = YMM_OFFSET(reg[i]);     \
+    g_register_infos[lldb_##reg##i##_i386].byte_offset = YMM_OFFSET(reg[i]);     \
 } while(false);
 
 #define UPDATE_DR_INFO(reg_index)                                               \
 do {                                                                            \
-    g_register_infos[dr##reg_index##_i386].byte_offset = DR_OFFSET(reg_index);  \
+    g_register_infos[lldb_dr##reg_index##_i386].byte_offset = DR_OFFSET(reg_index);  \
 } while(false);
 
     // Update the register offsets
diff --git a/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/StopInfoMachException.cpp b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/StopInfoMachException.cpp
index 0e3e559..a69b38b 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/StopInfoMachException.cpp
+++ b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/StopInfoMachException.cpp
@@ -423,9 +423,11 @@ StopInfoMachException::CreateStopReasonWithMachException
                                 wp_sp->SetHardwareIndex((uint32_t)exc_sub_sub_code);
                             return StopInfo::CreateStopReasonWithWatchpointID(thread, wp_sp->GetID());
                         }
-                        // EXC_ARM_DA_DEBUG seems to be reused for EXC_BREAKPOINT as well as EXC_BAD_ACCESS
-                        if (thread.GetTemporaryResumeState() == eStateStepping)
-                            return StopInfo::CreateStopReasonToTrace(thread);
+                        else
+                        {
+                            is_actual_breakpoint = true;
+                            is_trace_if_actual_breakpoint_missing = true;
+                        }
                     }
                     else if (exc_code == 1) // EXC_ARM_BREAKPOINT
                     {
diff --git a/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/UnwindLLDB.cpp b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/UnwindLLDB.cpp
index 37fd4f4..fc592e6 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/UnwindLLDB.cpp
+++ b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/UnwindLLDB.cpp
@@ -172,8 +172,9 @@ UnwindLLDB::AddOneMoreFrame (ABI *abi)
 
     if (!reg_ctx_sp->IsValid())
     {
-        // If the RegisterContextLLDB has a fallback UnwindPlan, it will switch to that and return
-        // true.  Subsequent calls to TryFallbackUnwindPlan() will return false.
+        // We failed to get a valid RegisterContext.
+        // See if the regctx below this on the stack has a fallback unwind plan it can use.
+        // Subsequent calls to TryFallbackUnwindPlan() will return false.
         if (m_frames[cur_idx - 1]->reg_ctx_lldb_sp->TryFallbackUnwindPlan())
         {
             return AddOneMoreFrame (abi);
@@ -207,18 +208,35 @@ UnwindLLDB::AddOneMoreFrame (ABI *abi)
         // these.
         if (reg_ctx_sp->IsTrapHandlerFrame() == false)
         {
-            // If the RegisterContextLLDB has a fallback UnwindPlan, it will switch to that and return
-            // true.  Subsequent calls to TryFallbackUnwindPlan() will return false.
-            if (m_frames[cur_idx - 1]->reg_ctx_lldb_sp->TryFallbackUnwindPlan())
+            // See if we can find a fallback unwind plan for THIS frame.  It may be
+            // that the UnwindPlan we're using for THIS frame was bad and gave us a
+            // bad CFA.  
+            // If that's not it, then see if we can change the UnwindPlan for the frame
+            // below us ("NEXT") -- see if using that other UnwindPlan gets us a better
+            // unwind state.
+            if (reg_ctx_sp->TryFallbackUnwindPlan() == false
+                || reg_ctx_sp->GetCFA (cursor_sp->cfa) == false
+                || abi->CallFrameAddressIsValid(cursor_sp->cfa) == false)
             {
-                return AddOneMoreFrame (abi);
+                if (m_frames[cur_idx - 1]->reg_ctx_lldb_sp->TryFallbackUnwindPlan())
+                {
+                    return AddOneMoreFrame (abi);
+                }
+                if (log)
+                {
+                    log->Printf("%*sFrame %d did not get a valid CFA for this frame, stopping stack walk",
+                                cur_idx < 100 ? cur_idx : 100, "", cur_idx);
+                }
+                goto unwind_done;
             }
-            if (log)
+            else
             {
-                log->Printf("%*sFrame %d did not get a valid CFA for this frame, stopping stack walk",
-                            cur_idx < 100 ? cur_idx : 100, "", cur_idx);
+                if (log)
+                {
+                    log->Printf("%*sFrame %d had a bad CFA value but we switched the UnwindPlan being used and got one that looks more realistic.",
+                                cur_idx < 100 ? cur_idx : 100, "", cur_idx);
+                }
             }
-            goto unwind_done;
         }
     }
     if (!reg_ctx_sp->ReadPC (cursor_sp->start_pc))
@@ -366,6 +384,14 @@ UnwindLLDB::SearchForSavedLocationForRegister (uint32_t lldb_regnum, lldb_privat
         UnwindLLDB::RegisterSearchResult result;
         result = m_frames[frame_num]->reg_ctx_lldb_sp->SavedLocationForRegister (lldb_regnum, regloc);
 
+        // We descended down to the live register context aka stack frame 0 and are reading the value
+        // out of a live register.
+        if (result == UnwindLLDB::RegisterSearchResult::eRegisterFound
+            && regloc.type == UnwindLLDB::RegisterLocation::eRegisterInLiveRegisterContext)
+        {
+            return true;
+        }
+
         // If we have unwind instructions saying that register N is saved in register M in the middle of
         // the stack (and N can equal M here, meaning the register was not used in this function), then
         // change the register number we're looking for to M and keep looking for a concrete  location 
diff --git a/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/UnwindLLDB.h b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/UnwindLLDB.h
index eb54003..35d85e2 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/UnwindLLDB.h
+++ b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/UnwindLLDB.h
@@ -48,7 +48,8 @@ protected:
             eRegisterSavedAtMemoryLocation,     // register is saved at a specific word of target mem (target_memory_location)
             eRegisterInRegister,                // register is available in a (possible other) register (register_number)
             eRegisterSavedAtHostMemoryLocation, // register is saved at a word in lldb's address space
-            eRegisterValueInferred              // register val was computed (and is in inferred_value)
+            eRegisterValueInferred,             // register val was computed (and is in inferred_value)
+            eRegisterInLiveRegisterContext      // register value is in a live (stack frame #0) register
         };
         int type;
         union
diff --git a/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/lldb-x86-register-enums.h b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/lldb-x86-register-enums.h
index c4706d5..99fca30 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/lldb-x86-register-enums.h
+++ b/contrib/llvm/tools/lldb/source/Plugins/Process/Utility/lldb-x86-register-enums.h
@@ -12,6 +12,7 @@
 
 namespace lldb_private
 {
+    // LLDB register codes (e.g. RegisterKind == eRegisterKindLLDB)
 
     //---------------------------------------------------------------------------
     // Internal codes for all i386 registers.
@@ -19,100 +20,100 @@ namespace lldb_private
     enum
     {
         k_first_gpr_i386,
-        gpr_eax_i386 = k_first_gpr_i386,
-        gpr_ebx_i386,
-        gpr_ecx_i386,
-        gpr_edx_i386,
-        gpr_edi_i386,
-        gpr_esi_i386,
-        gpr_ebp_i386,
-        gpr_esp_i386,
-        gpr_eip_i386,
-        gpr_eflags_i386,
-        gpr_cs_i386,
-        gpr_fs_i386,
-        gpr_gs_i386,
-        gpr_ss_i386,
-        gpr_ds_i386,
-        gpr_es_i386,
+        lldb_eax_i386 = k_first_gpr_i386,
+        lldb_ebx_i386,
+        lldb_ecx_i386,
+        lldb_edx_i386,
+        lldb_edi_i386,
+        lldb_esi_i386,
+        lldb_ebp_i386,
+        lldb_esp_i386,
+        lldb_eip_i386,
+        lldb_eflags_i386,
+        lldb_cs_i386,
+        lldb_fs_i386,
+        lldb_gs_i386,
+        lldb_ss_i386,
+        lldb_ds_i386,
+        lldb_es_i386,
 
         k_first_alias_i386,
-        gpr_ax_i386 = k_first_alias_i386,
-        gpr_bx_i386,
-        gpr_cx_i386,
-        gpr_dx_i386,
-        gpr_di_i386,
-        gpr_si_i386,
-        gpr_bp_i386,
-        gpr_sp_i386,
-        gpr_ah_i386,
-        gpr_bh_i386,
-        gpr_ch_i386,
-        gpr_dh_i386,
-        gpr_al_i386,
-        gpr_bl_i386,
-        gpr_cl_i386,
-        gpr_dl_i386,
-        k_last_alias_i386 = gpr_dl_i386,
+        lldb_ax_i386 = k_first_alias_i386,
+        lldb_bx_i386,
+        lldb_cx_i386,
+        lldb_dx_i386,
+        lldb_di_i386,
+        lldb_si_i386,
+        lldb_bp_i386,
+        lldb_sp_i386,
+        lldb_ah_i386,
+        lldb_bh_i386,
+        lldb_ch_i386,
+        lldb_dh_i386,
+        lldb_al_i386,
+        lldb_bl_i386,
+        lldb_cl_i386,
+        lldb_dl_i386,
+        k_last_alias_i386 = lldb_dl_i386,
 
         k_last_gpr_i386 = k_last_alias_i386,
 
         k_first_fpr_i386,
-        fpu_fctrl_i386 = k_first_fpr_i386,
-        fpu_fstat_i386,
-        fpu_ftag_i386,
-        fpu_fop_i386,
-        fpu_fiseg_i386,
-        fpu_fioff_i386,
-        fpu_foseg_i386,
-        fpu_fooff_i386,
-        fpu_mxcsr_i386,
-        fpu_mxcsrmask_i386,
-        fpu_st0_i386,
-        fpu_st1_i386,
-        fpu_st2_i386,
-        fpu_st3_i386,
-        fpu_st4_i386,
-        fpu_st5_i386,
-        fpu_st6_i386,
-        fpu_st7_i386,
-        fpu_mm0_i386,
-        fpu_mm1_i386,
-        fpu_mm2_i386,
-        fpu_mm3_i386,
-        fpu_mm4_i386,
-        fpu_mm5_i386,
-        fpu_mm6_i386,
-        fpu_mm7_i386,
-        fpu_xmm0_i386,
-        fpu_xmm1_i386,
-        fpu_xmm2_i386,
-        fpu_xmm3_i386,
-        fpu_xmm4_i386,
-        fpu_xmm5_i386,
-        fpu_xmm6_i386,
-        fpu_xmm7_i386,
-        k_last_fpr_i386 = fpu_xmm7_i386,
+        lldb_fctrl_i386 = k_first_fpr_i386,
+        lldb_fstat_i386,
+        lldb_ftag_i386,
+        lldb_fop_i386,
+        lldb_fiseg_i386,
+        lldb_fioff_i386,
+        lldb_foseg_i386,
+        lldb_fooff_i386,
+        lldb_mxcsr_i386,
+        lldb_mxcsrmask_i386,
+        lldb_st0_i386,
+        lldb_st1_i386,
+        lldb_st2_i386,
+        lldb_st3_i386,
+        lldb_st4_i386,
+        lldb_st5_i386,
+        lldb_st6_i386,
+        lldb_st7_i386,
+        lldb_mm0_i386,
+        lldb_mm1_i386,
+        lldb_mm2_i386,
+        lldb_mm3_i386,
+        lldb_mm4_i386,
+        lldb_mm5_i386,
+        lldb_mm6_i386,
+        lldb_mm7_i386,
+        lldb_xmm0_i386,
+        lldb_xmm1_i386,
+        lldb_xmm2_i386,
+        lldb_xmm3_i386,
+        lldb_xmm4_i386,
+        lldb_xmm5_i386,
+        lldb_xmm6_i386,
+        lldb_xmm7_i386,
+        k_last_fpr_i386 = lldb_xmm7_i386,
 
         k_first_avx_i386,
-        fpu_ymm0_i386 = k_first_avx_i386,
-        fpu_ymm1_i386,
-        fpu_ymm2_i386,
-        fpu_ymm3_i386,
-        fpu_ymm4_i386,
-        fpu_ymm5_i386,
-        fpu_ymm6_i386,
-        fpu_ymm7_i386,
-        k_last_avx_i386 = fpu_ymm7_i386,
+        lldb_ymm0_i386 = k_first_avx_i386,
+        lldb_ymm1_i386,
+        lldb_ymm2_i386,
+        lldb_ymm3_i386,
+        lldb_ymm4_i386,
+        lldb_ymm5_i386,
+        lldb_ymm6_i386,
+        lldb_ymm7_i386,
+        k_last_avx_i386 = lldb_ymm7_i386,
 
-        dr0_i386,
-        dr1_i386,
-        dr2_i386,
-        dr3_i386,
-        dr4_i386,
-        dr5_i386,
-        dr6_i386,
-        dr7_i386,
+        lldb_dr0_i386,
+        lldb_dr1_i386,
+        lldb_dr2_i386,
+        lldb_dr3_i386,
+        lldb_dr4_i386,
+        lldb_dr5_i386,
+        lldb_dr6_i386,
+        lldb_dr7_i386,
 
         k_num_registers_i386,
         k_num_gpr_registers_i386 = k_last_gpr_i386 - k_first_gpr_i386 + 1,
@@ -126,160 +127,160 @@ namespace lldb_private
     enum
     {
         k_first_gpr_x86_64,
-        gpr_rax_x86_64 = k_first_gpr_x86_64,
-        gpr_rbx_x86_64,
-        gpr_rcx_x86_64,
-        gpr_rdx_x86_64,
-        gpr_rdi_x86_64,
-        gpr_rsi_x86_64,
-        gpr_rbp_x86_64,
-        gpr_rsp_x86_64,
-        gpr_r8_x86_64,
-        gpr_r9_x86_64,
-        gpr_r10_x86_64,
-        gpr_r11_x86_64,
-        gpr_r12_x86_64,
-        gpr_r13_x86_64,
-        gpr_r14_x86_64,
-        gpr_r15_x86_64,
-        gpr_rip_x86_64,
-        gpr_rflags_x86_64,
-        gpr_cs_x86_64,
-        gpr_fs_x86_64,
-        gpr_gs_x86_64,
-        gpr_ss_x86_64,
-        gpr_ds_x86_64,
-        gpr_es_x86_64,
+        lldb_rax_x86_64 = k_first_gpr_x86_64,
+        lldb_rbx_x86_64,
+        lldb_rcx_x86_64,
+        lldb_rdx_x86_64,
+        lldb_rdi_x86_64,
+        lldb_rsi_x86_64,
+        lldb_rbp_x86_64,
+        lldb_rsp_x86_64,
+        lldb_r8_x86_64,
+        lldb_r9_x86_64,
+        lldb_r10_x86_64,
+        lldb_r11_x86_64,
+        lldb_r12_x86_64,
+        lldb_r13_x86_64,
+        lldb_r14_x86_64,
+        lldb_r15_x86_64,
+        lldb_rip_x86_64,
+        lldb_rflags_x86_64,
+        lldb_cs_x86_64,
+        lldb_fs_x86_64,
+        lldb_gs_x86_64,
+        lldb_ss_x86_64,
+        lldb_ds_x86_64,
+        lldb_es_x86_64,
 
         k_first_alias_x86_64,
-        gpr_eax_x86_64 = k_first_alias_x86_64,
-        gpr_ebx_x86_64,
-        gpr_ecx_x86_64,
-        gpr_edx_x86_64,
-        gpr_edi_x86_64,
-        gpr_esi_x86_64,
-        gpr_ebp_x86_64,
-        gpr_esp_x86_64,
-        gpr_r8d_x86_64,    // Low 32 bits of r8
-        gpr_r9d_x86_64,    // Low 32 bits of r9
-        gpr_r10d_x86_64,   // Low 32 bits of r10
-        gpr_r11d_x86_64,   // Low 32 bits of r11
-        gpr_r12d_x86_64,   // Low 32 bits of r12
-        gpr_r13d_x86_64,   // Low 32 bits of r13
-        gpr_r14d_x86_64,   // Low 32 bits of r14
-        gpr_r15d_x86_64,   // Low 32 bits of r15
-        gpr_ax_x86_64,
-        gpr_bx_x86_64,
-        gpr_cx_x86_64,
-        gpr_dx_x86_64,
-        gpr_di_x86_64,
-        gpr_si_x86_64,
-        gpr_bp_x86_64,
-        gpr_sp_x86_64,
-        gpr_r8w_x86_64,    // Low 16 bits of r8
-        gpr_r9w_x86_64,    // Low 16 bits of r9
-        gpr_r10w_x86_64,   // Low 16 bits of r10
-        gpr_r11w_x86_64,   // Low 16 bits of r11
-        gpr_r12w_x86_64,   // Low 16 bits of r12
-        gpr_r13w_x86_64,   // Low 16 bits of r13
-        gpr_r14w_x86_64,   // Low 16 bits of r14
-        gpr_r15w_x86_64,   // Low 16 bits of r15
-        gpr_ah_x86_64,
-        gpr_bh_x86_64,
-        gpr_ch_x86_64,
-        gpr_dh_x86_64,
-        gpr_al_x86_64,
-        gpr_bl_x86_64,
-        gpr_cl_x86_64,
-        gpr_dl_x86_64,
-        gpr_dil_x86_64,
-        gpr_sil_x86_64,
-        gpr_bpl_x86_64,
-        gpr_spl_x86_64,
-        gpr_r8l_x86_64,    // Low 8 bits of r8
-        gpr_r9l_x86_64,    // Low 8 bits of r9
-        gpr_r10l_x86_64,   // Low 8 bits of r10
-        gpr_r11l_x86_64,   // Low 8 bits of r11
-        gpr_r12l_x86_64,   // Low 8 bits of r12
-        gpr_r13l_x86_64,   // Low 8 bits of r13
-        gpr_r14l_x86_64,   // Low 8 bits of r14
-        gpr_r15l_x86_64,   // Low 8 bits of r15
-        k_last_alias_x86_64 = gpr_r15l_x86_64,
+        lldb_eax_x86_64 = k_first_alias_x86_64,
+        lldb_ebx_x86_64,
+        lldb_ecx_x86_64,
+        lldb_edx_x86_64,
+        lldb_edi_x86_64,
+        lldb_esi_x86_64,
+        lldb_ebp_x86_64,
+        lldb_esp_x86_64,
+        lldb_r8d_x86_64,    // Low 32 bits of r8
+        lldb_r9d_x86_64,    // Low 32 bits of r9
+        lldb_r10d_x86_64,   // Low 32 bits of r10
+        lldb_r11d_x86_64,   // Low 32 bits of r11
+        lldb_r12d_x86_64,   // Low 32 bits of r12
+        lldb_r13d_x86_64,   // Low 32 bits of r13
+        lldb_r14d_x86_64,   // Low 32 bits of r14
+        lldb_r15d_x86_64,   // Low 32 bits of r15
+        lldb_ax_x86_64,
+        lldb_bx_x86_64,
+        lldb_cx_x86_64,
+        lldb_dx_x86_64,
+        lldb_di_x86_64,
+        lldb_si_x86_64,
+        lldb_bp_x86_64,
+        lldb_sp_x86_64,
+        lldb_r8w_x86_64,    // Low 16 bits of r8
+        lldb_r9w_x86_64,    // Low 16 bits of r9
+        lldb_r10w_x86_64,   // Low 16 bits of r10
+        lldb_r11w_x86_64,   // Low 16 bits of r11
+        lldb_r12w_x86_64,   // Low 16 bits of r12
+        lldb_r13w_x86_64,   // Low 16 bits of r13
+        lldb_r14w_x86_64,   // Low 16 bits of r14
+        lldb_r15w_x86_64,   // Low 16 bits of r15
+        lldb_ah_x86_64,
+        lldb_bh_x86_64,
+        lldb_ch_x86_64,
+        lldb_dh_x86_64,
+        lldb_al_x86_64,
+        lldb_bl_x86_64,
+        lldb_cl_x86_64,
+        lldb_dl_x86_64,
+        lldb_dil_x86_64,
+        lldb_sil_x86_64,
+        lldb_bpl_x86_64,
+        lldb_spl_x86_64,
+        lldb_r8l_x86_64,    // Low 8 bits of r8
+        lldb_r9l_x86_64,    // Low 8 bits of r9
+        lldb_r10l_x86_64,   // Low 8 bits of r10
+        lldb_r11l_x86_64,   // Low 8 bits of r11
+        lldb_r12l_x86_64,   // Low 8 bits of r12
+        lldb_r13l_x86_64,   // Low 8 bits of r13
+        lldb_r14l_x86_64,   // Low 8 bits of r14
+        lldb_r15l_x86_64,   // Low 8 bits of r15
+        k_last_alias_x86_64 = lldb_r15l_x86_64,
 
         k_last_gpr_x86_64 = k_last_alias_x86_64,
 
         k_first_fpr_x86_64,
-        fpu_fctrl_x86_64 = k_first_fpr_x86_64,
-        fpu_fstat_x86_64,
-        fpu_ftag_x86_64,
-        fpu_fop_x86_64,
-        fpu_fiseg_x86_64,
-        fpu_fioff_x86_64,
-        fpu_foseg_x86_64,
-        fpu_fooff_x86_64,
-        fpu_mxcsr_x86_64,
-        fpu_mxcsrmask_x86_64,
-        fpu_st0_x86_64,
-        fpu_st1_x86_64,
-        fpu_st2_x86_64,
-        fpu_st3_x86_64,
-        fpu_st4_x86_64,
-        fpu_st5_x86_64,
-        fpu_st6_x86_64,
-        fpu_st7_x86_64,
-        fpu_mm0_x86_64,
-        fpu_mm1_x86_64,
-        fpu_mm2_x86_64,
-        fpu_mm3_x86_64,
-        fpu_mm4_x86_64,
-        fpu_mm5_x86_64,
-        fpu_mm6_x86_64,
-        fpu_mm7_x86_64,
-        fpu_xmm0_x86_64,
-        fpu_xmm1_x86_64,
-        fpu_xmm2_x86_64,
-        fpu_xmm3_x86_64,
-        fpu_xmm4_x86_64,
-        fpu_xmm5_x86_64,
-        fpu_xmm6_x86_64,
-        fpu_xmm7_x86_64,
-        fpu_xmm8_x86_64,
-        fpu_xmm9_x86_64,
-        fpu_xmm10_x86_64,
-        fpu_xmm11_x86_64,
-        fpu_xmm12_x86_64,
-        fpu_xmm13_x86_64,
-        fpu_xmm14_x86_64,
-        fpu_xmm15_x86_64,
-        k_last_fpr_x86_64 = fpu_xmm15_x86_64,
+        lldb_fctrl_x86_64 = k_first_fpr_x86_64,
+        lldb_fstat_x86_64,
+        lldb_ftag_x86_64,
+        lldb_fop_x86_64,
+        lldb_fiseg_x86_64,
+        lldb_fioff_x86_64,
+        lldb_foseg_x86_64,
+        lldb_fooff_x86_64,
+        lldb_mxcsr_x86_64,
+        lldb_mxcsrmask_x86_64,
+        lldb_st0_x86_64,
+        lldb_st1_x86_64,
+        lldb_st2_x86_64,
+        lldb_st3_x86_64,
+        lldb_st4_x86_64,
+        lldb_st5_x86_64,
+        lldb_st6_x86_64,
+        lldb_st7_x86_64,
+        lldb_mm0_x86_64,
+        lldb_mm1_x86_64,
+        lldb_mm2_x86_64,
+        lldb_mm3_x86_64,
+        lldb_mm4_x86_64,
+        lldb_mm5_x86_64,
+        lldb_mm6_x86_64,
+        lldb_mm7_x86_64,
+        lldb_xmm0_x86_64,
+        lldb_xmm1_x86_64,
+        lldb_xmm2_x86_64,
+        lldb_xmm3_x86_64,
+        lldb_xmm4_x86_64,
+        lldb_xmm5_x86_64,
+        lldb_xmm6_x86_64,
+        lldb_xmm7_x86_64,
+        lldb_xmm8_x86_64,
+        lldb_xmm9_x86_64,
+        lldb_xmm10_x86_64,
+        lldb_xmm11_x86_64,
+        lldb_xmm12_x86_64,
+        lldb_xmm13_x86_64,
+        lldb_xmm14_x86_64,
+        lldb_xmm15_x86_64,
+        k_last_fpr_x86_64 = lldb_xmm15_x86_64,
 
         k_first_avx_x86_64,
-        fpu_ymm0_x86_64 = k_first_avx_x86_64,
-        fpu_ymm1_x86_64,
-        fpu_ymm2_x86_64,
-        fpu_ymm3_x86_64,
-        fpu_ymm4_x86_64,
-        fpu_ymm5_x86_64,
-        fpu_ymm6_x86_64,
-        fpu_ymm7_x86_64,
-        fpu_ymm8_x86_64,
-        fpu_ymm9_x86_64,
-        fpu_ymm10_x86_64,
-        fpu_ymm11_x86_64,
-        fpu_ymm12_x86_64,
-        fpu_ymm13_x86_64,
-        fpu_ymm14_x86_64,
-        fpu_ymm15_x86_64,
-        k_last_avx_x86_64 = fpu_ymm15_x86_64,
+        lldb_ymm0_x86_64 = k_first_avx_x86_64,
+        lldb_ymm1_x86_64,
+        lldb_ymm2_x86_64,
+        lldb_ymm3_x86_64,
+        lldb_ymm4_x86_64,
+        lldb_ymm5_x86_64,
+        lldb_ymm6_x86_64,
+        lldb_ymm7_x86_64,
+        lldb_ymm8_x86_64,
+        lldb_ymm9_x86_64,
+        lldb_ymm10_x86_64,
+        lldb_ymm11_x86_64,
+        lldb_ymm12_x86_64,
+        lldb_ymm13_x86_64,
+        lldb_ymm14_x86_64,
+        lldb_ymm15_x86_64,
+        k_last_avx_x86_64 = lldb_ymm15_x86_64,
 
-        dr0_x86_64,
-        dr1_x86_64,
-        dr2_x86_64,
-        dr3_x86_64,
-        dr4_x86_64,
-        dr5_x86_64,
-        dr6_x86_64,
-        dr7_x86_64,
+        lldb_dr0_x86_64,
+        lldb_dr1_x86_64,
+        lldb_dr2_x86_64,
+        lldb_dr3_x86_64,
+        lldb_dr4_x86_64,
+        lldb_dr5_x86_64,
+        lldb_dr6_x86_64,
+        lldb_dr7_x86_64,
 
         k_num_registers_x86_64,
         k_num_gpr_registers_x86_64 = k_last_gpr_x86_64 - k_first_gpr_x86_64 + 1,