<rdar://problem/13020634>

Fixed the 32, 16, and 8 bit pseudo regs for x86_64 (real reg of "rax" which subvalues "eax", "ax", etc...) to correctly get updated when stepping. Also fixed it so actual registers can specify what other registers must be invalidated when a register is modified. Previously, only pseudo registers could invalidate other registers.

Modified the LLDB qRegisterInfo extension to the GDB remote interface to support specifying the containing registers with the new "container-regs" key whose value is a comma separated list of register numbers. Also added a "invalidate-regs" key whose value is also a comma separated list of register numbers. 

Removed the hack GDBRemoteDynamicRegisterInfo::Addx86_64ConvenienceRegisters() function and modified "debugserver" to specify the registers correctly using the new "container-regs" and "invalidate-regs" keys.

llvm-svn: 173096

3 files changed, 145 insertions, 156 deletions

diff --git a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.cpp b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.cpp
index 7c4a51e3cc5..921d08eaa65 100644
--- a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.cpp
+++ b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.cpp
@@ -134,13 +134,13 @@ GDBRemoteRegisterContext::PrivateSetRegisterValue (uint32_t reg, StringExtractor
     bool success = bytes_copied == reg_byte_size;
     if (success)
     {
-        m_reg_valid[reg] = true;
+        SetRegisterIsValid(reg, true);
     }
     else if (bytes_copied > 0)
     {
         // Only set register is valid to false if we copied some bytes, else
         // leave it as it was.
-        m_reg_valid[reg] = false;
+        SetRegisterIsValid(reg, false);
     }
     return success;
 }
@@ -180,7 +180,7 @@ GDBRemoteRegisterContext::ReadRegisterBytes (const RegisterInfo *reg_info, DataE
 
     const uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
 
-    if (!m_reg_valid[reg])
+    if (!GetRegisterIsValid(reg))
     {
         Mutex::Locker locker;
         if (gdb_comm.GetSequenceMutex (locker, "Didn't get sequence mutex for read register."))
@@ -207,40 +207,43 @@ GDBRemoteRegisterContext::ReadRegisterBytes (const RegisterInfo *reg_info, DataE
                                 SetAllRegisterValid (true);
                     }
                 }
-                else if (!reg_info->value_regs)
-                {
-                    // Get each register individually
-                    GetPrimordialRegister(reg_info, gdb_comm);
-                }
-                else
+                else if (reg_info->value_regs)
                 {
                     // Process this composite register request by delegating to the constituent
                     // primordial registers.
-
+                    
                     // Index of the primordial register.
-                    uint32_t prim_reg_idx;
                     bool success = true;
-                    for (uint32_t idx = 0;
-                         (prim_reg_idx = reg_info->value_regs[idx]) != LLDB_INVALID_REGNUM;
-                         ++idx)
+                    for (uint32_t idx = 0; success; ++idx)
                     {
+                        const uint32_t prim_reg = reg_info->value_regs[idx];
+                        if (prim_reg == LLDB_INVALID_REGNUM)
+                            break;
                         // We have a valid primordial regsiter as our constituent.
                         // Grab the corresponding register info.
-                        const RegisterInfo *prim_reg_info = GetRegisterInfoAtIndex(prim_reg_idx);
-                        if (!GetPrimordialRegister(prim_reg_info, gdb_comm))
-                        {
+                        const RegisterInfo *prim_reg_info = GetRegisterInfoAtIndex(prim_reg);
+                        if (prim_reg_info == NULL)
                             success = false;
-                            // Some failure occurred.  Let's break out of the for loop.
-                            break;
+                        else
+                        {
+                            // Read the containing register if it hasn't already been read
+                            if (!GetRegisterIsValid(prim_reg))
+                                success = GetPrimordialRegister(prim_reg_info, gdb_comm);
                         }
                     }
+
                     if (success)
                     {
                         // If we reach this point, all primordial register requests have succeeded.
                         // Validate this composite register.
-                        m_reg_valid[reg_info->kinds[eRegisterKindLLDB]] = true;
+                        SetRegisterIsValid (reg_info, true);
                     }
                 }
+                else
+                {
+                    // Get each register individually
+                    GetPrimordialRegister(reg_info, gdb_comm);
+                }
             }
         }
         else
@@ -269,7 +272,7 @@ GDBRemoteRegisterContext::ReadRegisterBytes (const RegisterInfo *reg_info, DataE
         }
 
         // Make sure we got a valid register value after reading it
-        if (!m_reg_valid[reg])
+        if (!GetRegisterIsValid(reg))
             return false;
     }
 
@@ -314,7 +317,7 @@ GDBRemoteRegisterContext::SetPrimordialRegister(const lldb_private::RegisterInfo
         packet.Printf (";thread:%4.4" PRIx64 ";", m_thread.GetID());
 
     // Invalidate just this register
-    m_reg_valid[reg] = false;
+    SetRegisterIsValid(reg, false);
     if (gdb_comm.SendPacketAndWaitForResponse(packet.GetString().c_str(),
                                               packet.GetString().size(),
                                               response,
@@ -387,6 +390,7 @@ GDBRemoteRegisterContext::WriteRegisterBytes (const lldb_private::RegisterInfo *
             {
                 StreamString packet;
                 StringExtractorGDBRemote response;
+                
                 if (m_read_all_at_once)
                 {
                     // Set all registers in one packet
@@ -414,52 +418,50 @@ GDBRemoteRegisterContext::WriteRegisterBytes (const lldb_private::RegisterInfo *
                         }
                     }
                 }
-                else if (!reg_info->value_regs)
-                {
-                    // Set each register individually
-                    return SetPrimordialRegister(reg_info, gdb_comm);
-                }
                 else
                 {
-                    // Process this composite register request by delegating to the constituent
-                    // primordial registers.
-
-                    // Invalidate this composite register first.
-                    m_reg_valid[reg_info->kinds[eRegisterKindLLDB]] = false;
-
-                    // Index of the primordial register.
-                    uint32_t prim_reg_idx;
-                    // For loop index.
-                    uint32_t idx;
+                    bool success = true;
 
-                    // Invalidate the invalidate_regs, if present.
-                    if (reg_info->invalidate_regs)
+                    if (reg_info->value_regs)
                     {
-                        for (idx = 0;
-                             (prim_reg_idx = reg_info->invalidate_regs[idx]) != LLDB_INVALID_REGNUM;
-                             ++idx)
+                        // This register is part of another register. In this case we read the actual
+                        // register data for any "value_regs", and once all that data is read, we will
+                        // have enough data in our register context bytes for the value of this register
+                        
+                        // Invalidate this composite register first.
+                        
+                        for (uint32_t idx = 0; success; ++idx)
                         {
-                            // Grab the invalidate register info.
-                            const RegisterInfo *prim_reg_info = GetRegisterInfoAtIndex(prim_reg_idx);
-                            m_reg_valid[prim_reg_info->kinds[eRegisterKindLLDB]] = false;
+                            const uint32_t reg = reg_info->value_regs[idx];
+                            if (reg == LLDB_INVALID_REGNUM)
+                                break;
+                            // We have a valid primordial regsiter as our constituent.
+                            // Grab the corresponding register info.
+                            const RegisterInfo *value_reg_info = GetRegisterInfoAtIndex(reg);
+                            if (value_reg_info == NULL)
+                                success = false;
+                            else
+                                success = SetPrimordialRegister(value_reg_info, gdb_comm);
                         }
                     }
+                    else
+                    {
+                        // This is an actual register, write it
+                        success = SetPrimordialRegister(reg_info, gdb_comm);
+                    }
 
-                    bool success = true;
-                    for (idx = 0;
-                         (prim_reg_idx = reg_info->value_regs[idx]) != LLDB_INVALID_REGNUM;
-                         ++idx)
+                    // Check if writing this register will invalidate any other register values?
+                    // If so, invalidate them
+                    if (reg_info->invalidate_regs)
                     {
-                        // We have a valid primordial regsiter as our constituent.
-                        // Grab the corresponding register info.
-                        const RegisterInfo *prim_reg_info = GetRegisterInfoAtIndex(prim_reg_idx);
-                        if (!SetPrimordialRegister(prim_reg_info, gdb_comm))
+                        for (uint32_t idx = 0, reg = reg_info->invalidate_regs[0];
+                             reg != LLDB_INVALID_REGNUM;
+                             reg = reg_info->invalidate_regs[++idx])
                         {
-                            success = false;
-                            // Some failure occurred.  Let's break out of the for loop.
-                            break;
+                            SetRegisterIsValid(reg, false);
                         }
                     }
+                    
                     return success;
                 }
             }
@@ -633,7 +635,7 @@ GDBRemoteRegisterContext::WriteAllRegisterValues (const lldb::DataBufferSP &data
                         const char *restore_src = (const char *)restore_data.PeekData(reg_byte_offset, reg_byte_size);
                         if (restore_src)
                         {
-                            if (m_reg_valid[reg])
+                            if (GetRegisterIsValid(reg))
                             {
                                 const char *current_src = (const char *)m_reg_data.PeekData(reg_byte_offset, reg_byte_size);
                                 if (current_src)
@@ -652,7 +654,7 @@ GDBRemoteRegisterContext::WriteAllRegisterValues (const lldb::DataBufferSP &data
                                 if (thread_suffix_supported)
                                     packet.Printf (";thread:%4.4" PRIx64 ";", m_thread.GetID());
 
-                                m_reg_valid[reg] = false;
+                                SetRegisterIsValid(reg, false);
                                 if (gdb_comm.SendPacketAndWaitForResponse(packet.GetString().c_str(),
                                                                           packet.GetString().size(),
                                                                           response,
@@ -931,93 +933,3 @@ GDBRemoteDynamicRegisterInfo::HardcodeARMRegisters(bool from_scratch)
         }
     }
 }
-
-void
-GDBRemoteDynamicRegisterInfo::Addx86_64ConvenienceRegisters()
-{
-    // For eax, ebx, ecx, edx, esi, edi, ebp, esp register mapping.
-    static const char* g_mapped_names[] = {
-        "rax", "rbx", "rcx", "rdx", "rdi", "rsi", "rbp", "rsp",
-        "rax", "rbx", "rcx", "rdx", "rdi", "rsi", "rbp", "rsp",
-        "rax", "rbx", "rcx", "rdx",
-        "rax", "rbx", "rcx", "rdx", "rdi", "rsi", "rbp", "rsp"
-    };
-
-    // These value regs are to be populated with the corresponding primordial register index.
-    // For example,
-    static uint32_t g_eax_regs[] =  { 0, LLDB_INVALID_REGNUM }; // 0 is to be replaced with rax's index.
-    static uint32_t g_ebx_regs[] =  { 0, LLDB_INVALID_REGNUM };
-    static uint32_t g_ecx_regs[] =  { 0, LLDB_INVALID_REGNUM };
-    static uint32_t g_edx_regs[] =  { 0, LLDB_INVALID_REGNUM };
-    static uint32_t g_edi_regs[] =  { 0, LLDB_INVALID_REGNUM };
-    static uint32_t g_esi_regs[] =  { 0, LLDB_INVALID_REGNUM };
-    static uint32_t g_ebp_regs[] =  { 0, LLDB_INVALID_REGNUM };
-    static uint32_t g_esp_regs[] =  { 0, LLDB_INVALID_REGNUM };
-    
-    static RegisterInfo g_conv_register_infos[] = 
-    {
-//    NAME      ALT      SZ OFF ENCODING         FORMAT                COMPILER              DWARF                 GENERIC                      GDB                   LLDB NATIVE            VALUE REGS    INVALIDATE REGS
-//    ======    =======  == === =============    ============          ===================== ===================== ============================ ====================  ====================== ==========    ===============
-    { "eax"   , NULL,    4,  0, eEncodingUint  , eFormatHex          , { LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM      , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM }, g_eax_regs,              NULL},
-    { "ebx"   , NULL,    4,  0, eEncodingUint  , eFormatHex          , { LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM      , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM }, g_ebx_regs,              NULL},
-    { "ecx"   , NULL,    4,  0, eEncodingUint  , eFormatHex          , { LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM      , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM }, g_ecx_regs,              NULL},
-    { "edx"   , NULL,    4,  0, eEncodingUint  , eFormatHex          , { LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM      , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM }, g_edx_regs,              NULL},
-    { "edi"   , NULL,    4,  0, eEncodingUint  , eFormatHex          , { LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM      , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM }, g_edi_regs,              NULL},
-    { "esi"   , NULL,    4,  0, eEncodingUint  , eFormatHex          , { LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM      , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM }, g_esi_regs,              NULL},
-    { "ebp"   , NULL,    4,  0, eEncodingUint  , eFormatHex          , { LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM      , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM }, g_ebp_regs,              NULL},
-    { "esp"   , NULL,    4,  0, eEncodingUint  , eFormatHex          , { LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM      , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM }, g_esp_regs,              NULL},
-    { "ax"    , NULL,    2,  0, eEncodingUint  , eFormatHex          , { LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM      , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM }, g_eax_regs,              NULL},
-    { "bx"    , NULL,    2,  0, eEncodingUint  , eFormatHex          , { LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM      , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM }, g_ebx_regs,              NULL},
-    { "cx"    , NULL,    2,  0, eEncodingUint  , eFormatHex          , { LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM      , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM }, g_ecx_regs,              NULL},
-    { "dx"    , NULL,    2,  0, eEncodingUint  , eFormatHex          , { LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM      , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM }, g_edx_regs,              NULL},
-    { "di"    , NULL,    2,  0, eEncodingUint  , eFormatHex          , { LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM      , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM }, g_edi_regs,              NULL},
-    { "si"    , NULL,    2,  0, eEncodingUint  , eFormatHex          , { LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM      , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM }, g_esi_regs,              NULL},
-    { "bp"    , NULL,    2,  0, eEncodingUint  , eFormatHex          , { LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM      , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM }, g_ebp_regs,              NULL},
-    { "sp"    , NULL,    2,  0, eEncodingUint  , eFormatHex          , { LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM      , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM }, g_esp_regs,              NULL},
-    { "ah"    , NULL,    1,  1, eEncodingUint  , eFormatHex          , { LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM      , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM }, g_eax_regs,              NULL},
-    { "bh"    , NULL,    1,  1, eEncodingUint  , eFormatHex          , { LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM      , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM }, g_ebx_regs,              NULL},
-    { "ch"    , NULL,    1,  1, eEncodingUint  , eFormatHex          , { LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM      , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM }, g_ecx_regs,              NULL},
-    { "dh"    , NULL,    1,  1, eEncodingUint  , eFormatHex          , { LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM      , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM }, g_edx_regs,              NULL},
-    { "al"    , NULL,    1,  0, eEncodingUint  , eFormatHex          , { LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM      , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM }, g_eax_regs,              NULL},
-    { "bl"    , NULL,    1,  0, eEncodingUint  , eFormatHex          , { LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM      , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM }, g_ebx_regs,              NULL},
-    { "cl"    , NULL,    1,  0, eEncodingUint  , eFormatHex          , { LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM      , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM }, g_ecx_regs,              NULL},
-    { "dl"    , NULL,    1,  0, eEncodingUint  , eFormatHex          , { LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM      , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM }, g_edx_regs,              NULL},
-    { "dil"   , NULL,    1,  0, eEncodingUint  , eFormatHex          , { LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM      , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM }, g_edi_regs,              NULL},
-    { "sil"   , NULL,    1,  0, eEncodingUint  , eFormatHex          , { LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM      , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM }, g_esi_regs,              NULL},
-    { "bpl"   , NULL,    1,  0, eEncodingUint  , eFormatHex          , { LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM      , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM }, g_ebp_regs,              NULL},
-    { "spl"   , NULL,    1,  0, eEncodingUint  , eFormatHex          , { LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM      , LLDB_INVALID_REGNUM , LLDB_INVALID_REGNUM }, g_esp_regs,              NULL}
-    };
-
-    static const uint32_t num_conv_regs = llvm::array_lengthof(g_mapped_names);
-    static ConstString gpr_reg_set ("General Purpose Registers");
-    
-    // Add convenience registers to our primordial registers.
-    const uint32_t num_primordials = GetNumRegisters();
-    uint32_t reg_kind = num_primordials;
-    for (uint32_t i=0; i<num_conv_regs; ++i)
-    {
-        ConstString name;
-        ConstString alt_name;
-        const char *prim_reg_name = g_mapped_names[i];
-        if (prim_reg_name && prim_reg_name[0])
-        {
-            for (uint32_t j = 0; j < num_primordials; ++j)
-            {
-                const RegisterInfo *reg_info = GetRegisterInfoAtIndex(j);
-                // Find a matching primordial register info entry.
-                if (reg_info && reg_info->name && ::strcasecmp(reg_info->name, prim_reg_name) == 0)
-                {
-                    // The name matches the existing primordial entry.
-                    // Find and assign the offset, and then add this composite register entry.
-                    g_conv_register_infos[i].byte_offset = reg_info->byte_offset + g_conv_register_infos[i].byte_offset;
-                    // Update the value_regs and the kinds fields in order to delegate to the primordial register.
-                    g_conv_register_infos[i].value_regs[0] = j;
-                    g_conv_register_infos[i].kinds[eRegisterKindLLDB] = ++reg_kind;
-                    name.SetCString(g_conv_register_infos[i].name);
-                    AddRegister(g_conv_register_infos[i], name, alt_name, gpr_reg_set);
-                }
-            }
-        }
-    }
-}
-
diff --git a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.h b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.h
index e3141761c9e..672af4b9ee1 100644
--- a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.h
+++ b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.h
@@ -57,6 +57,21 @@ public:
         reg_info.name = reg_name.AsCString();
         assert (reg_info.name);
         reg_info.alt_name = reg_alt_name.AsCString(NULL);
+        uint32_t i;
+        if (reg_info.value_regs)
+        {
+            for (i=0; reg_info.value_regs[i] != LLDB_INVALID_REGNUM; ++i)
+                m_value_regs_map[reg_num].push_back(reg_info.value_regs[i]);
+            m_value_regs_map[reg_num].push_back(LLDB_INVALID_REGNUM);
+            reg_info.value_regs = m_value_regs_map[reg_num].data();
+        }
+        if (reg_info.invalidate_regs)
+        {
+            for (i=0; reg_info.invalidate_regs[i] != LLDB_INVALID_REGNUM; ++i)
+                m_invalidate_regs_map[reg_num].push_back(reg_info.invalidate_regs[i]);
+            m_invalidate_regs_map[reg_num].push_back(LLDB_INVALID_REGNUM);
+            reg_info.invalidate_regs = m_invalidate_regs_map[reg_num].data();
+        }
         m_regs.push_back (reg_info);
         uint32_t set = GetRegisterSetIndexByName (set_name, true);
         assert (set < m_sets.size());
@@ -156,9 +171,6 @@ public:
     void
     HardcodeARMRegisters(bool from_scratch);
 
-    void
-    Addx86_64ConvenienceRegisters();
-
 protected:
     //------------------------------------------------------------------
     // Classes that inherit from GDBRemoteRegisterContext can see and modify these
@@ -168,6 +180,7 @@ protected:
     typedef std::vector <uint32_t> reg_num_collection;
     typedef std::vector <reg_num_collection> set_reg_num_collection;
     typedef std::vector <lldb_private::ConstString> name_collection;
+    typedef std::map<uint32_t, reg_num_collection> reg_to_regs_map;
 
     reg_collection m_regs;
     set_collection m_sets;
@@ -175,6 +188,8 @@ protected:
     name_collection m_reg_names;
     name_collection m_reg_alt_names;
     name_collection m_set_names;
+    reg_to_regs_map m_value_regs_map;
+    reg_to_regs_map m_invalidate_regs_map;
     size_t m_reg_data_byte_size;   // The number of bytes required to store all registers
 };
 
@@ -243,6 +258,34 @@ protected:
     void
     SetAllRegisterValid (bool b);
 
+    bool
+    GetRegisterIsValid (uint32_t reg) const
+    {
+#if defined (LLDB_CONFIGURATION_DEBUG)
+        assert (reg < m_reg_valid.size());
+#endif
+        if (reg < m_reg_valid.size())
+            return m_reg_valid[reg];
+        return false;
+    }
+
+    void
+    SetRegisterIsValid (const lldb_private::RegisterInfo *reg_info, bool valid)
+    {
+        if (reg_info)
+            return SetRegisterIsValid (reg_info->kinds[lldb::eRegisterKindLLDB], valid);
+    }
+
+    void
+    SetRegisterIsValid (uint32_t reg, bool valid)
+    {
+#if defined (LLDB_CONFIGURATION_DEBUG)
+        assert (reg < m_reg_valid.size());
+#endif
+        if (reg < m_reg_valid.size())
+            m_reg_valid[reg] = valid;
+    }
+
     void
     SyncThreadState(lldb_private::Process *process);  // Assumes the sequence mutex has already been acquired.
     
diff --git a/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp b/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
index e476d10cfb9..ce220d33abd 100644
--- a/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
+++ b/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
@@ -280,6 +280,8 @@ ProcessGDBRemote::BuildDynamicRegisterInfo (bool force)
                 ConstString reg_name;
                 ConstString alt_name;
                 ConstString set_name;
+                std::vector<uint32_t> value_regs;
+                std::vector<uint32_t> invalidate_regs;
                 RegisterInfo reg_info = { NULL,                 // Name
                     NULL,                 // Alt name
                     0,                    // byte size
@@ -371,11 +373,48 @@ ProcessGDBRemote::BuildDynamicRegisterInfo (bool force)
                     {
                         reg_info.kinds[eRegisterKindGeneric] = Args::StringToGenericRegister (value.c_str());
                     }
+                    else if (name.compare("container-regs") == 0)
+                    {
+                        std::pair<llvm::StringRef, llvm::StringRef> value_pair;
+                        value_pair.second = value;
+                        do
+                        {
+                            value_pair = value_pair.second.split(',');
+                            if (!value_pair.first.empty())
+                            {
+                                value_regs.push_back (Args::StringToUInt32 (value_pair.first.str().c_str()));
+                            }
+                        } while (!value_pair.second.empty());
+                    }
+                    else if (name.compare("invalidate-regs") == 0)
+                    {
+                        std::pair<llvm::StringRef, llvm::StringRef> value_pair;
+                        value_pair.second = value;
+                        do
+                        {
+                            value_pair = value_pair.second.split(',');
+                            if (!value_pair.first.empty())
+                            {
+                                invalidate_regs.push_back (Args::StringToUInt32 (value_pair.first.str().c_str()));
+                            }
+                        } while (!value_pair.second.empty());
+                    }
                 }
 
                 reg_info.byte_offset = reg_offset;
                 assert (reg_info.byte_size != 0);
                 reg_offset += reg_info.byte_size;
+                if (!value_regs.empty())
+                {
+                    value_regs.push_back(LLDB_INVALID_REGNUM);
+                    reg_info.value_regs = value_regs.data();
+                }
+                if (!invalidate_regs.empty())
+                {
+                    invalidate_regs.push_back(LLDB_INVALID_REGNUM);
+                    reg_info.invalidate_regs = invalidate_regs.data();
+                }
+
                 m_register_info.AddRegister(reg_info, reg_name, alt_name, set_name);
             }
         }
@@ -415,11 +454,6 @@ ProcessGDBRemote::BuildDynamicRegisterInfo (bool force)
         m_register_info.HardcodeARMRegisters(from_scratch);
     }
 
-    // Add some convenience registers (eax, ebx, ecx, edx, esi, edi, ebp, esp) to x86_64.
-    if ((target_arch.IsValid() && target_arch.GetMachine() == llvm::Triple::x86_64)
-        || (remote_arch.IsValid() && remote_arch.GetMachine() == llvm::Triple::x86_64))
-        m_register_info.Addx86_64ConvenienceRegisters();
-
     // At this point, we can finalize our register info.
     m_register_info.Finalize ();
 }