vendor/lldb/lldb-release_390-r280324vendor/lldb/lldb-release_39-r279689vendor/lldb/lldb-release_39-r279477vendor/lldb/lldb-release_39-r278877

3 files changed, 63 insertions, 5 deletions

diff --git a/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp b/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp
index fc6b31ec088ed..c468ba33e8582 100644
--- a/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp
+++ b/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp
@@ -1630,6 +1630,14 @@ GDBRemoteCommunicationServerLLGS::Handle_qRegisterInfo (StringExtractorGDBRemote
         response.PutChar (';');
     }
 
+    if (reg_info->dynamic_size_dwarf_expr_bytes)
+    {
+       const size_t dwarf_opcode_len = reg_info->dynamic_size_dwarf_len;
+       response.PutCString("dynamic_size_dwarf_expr_bytes:");
+       for(uint32_t i = 0; i < dwarf_opcode_len; ++i)
+           response.PutHex8 (reg_info->dynamic_size_dwarf_expr_bytes[i]);
+       response.PutChar(';');
+    }
     return SendPacketNoLock(response.GetData(), response.GetSize());
 }
 
@@ -1825,7 +1833,10 @@ GDBRemoteCommunicationServerLLGS::Handle_P (StringExtractorGDBRemote &packet)
         return SendErrorResponse (0x47);
     }
 
-    if (reg_size != reg_info->byte_size)
+    // The dwarf expression are evaluate on host site
+    // which may cause register size to change
+    // Hence the reg_size may not be same as reg_info->bytes_size
+    if ((reg_size != reg_info->byte_size) && !(reg_info->dynamic_size_dwarf_expr_bytes))
     {
         return SendIllFormedResponse (packet, "P packet register size is incorrect");
     }
diff --git a/source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.cpp b/source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.cpp
index e5b347c9f72db..57983c4979a64 100644
--- a/source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.cpp
+++ b/source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.cpp
@@ -89,7 +89,15 @@ GDBRemoteRegisterContext::GetRegisterCount ()
 const RegisterInfo *
 GDBRemoteRegisterContext::GetRegisterInfoAtIndex (size_t reg)
 {
-    return m_reg_info.GetRegisterInfoAtIndex (reg);
+    RegisterInfo* reg_info = m_reg_info.GetRegisterInfoAtIndex (reg);
+
+    if (reg_info && reg_info->dynamic_size_dwarf_expr_bytes)
+    {
+        const ArchSpec &arch = m_thread.GetProcess ()->GetTarget ().GetArchitecture ();
+        uint8_t reg_size = UpdateDynamicRegisterSize (arch, reg_info);
+        reg_info->byte_size = reg_size;
+    }
+    return reg_info;
 }
 
 size_t
diff --git a/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp b/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
index 4d56f6ea3ba1b..f501e43b00d76 100644
--- a/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
+++ b/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
@@ -539,6 +539,7 @@ ProcessGDBRemote::BuildDynamicRegisterInfo (bool force)
                 ConstString set_name;
                 std::vector<uint32_t> value_regs;
                 std::vector<uint32_t> invalidate_regs;
+                std::vector<uint8_t> dwarf_opcode_bytes;
                 RegisterInfo reg_info = { NULL,                 // Name
                     NULL,                 // Alt name
                     0,                    // byte size
@@ -553,7 +554,9 @@ ProcessGDBRemote::BuildDynamicRegisterInfo (bool force)
                         reg_num           // native register number
                     },
                     NULL,
-                    NULL
+                    NULL,
+                    NULL, // Dwarf expression opcode bytes pointer
+                    0     // Dwarf expression opcode bytes length
                 };
 
                 while (response.GetNameColonValue(name, value))
@@ -638,6 +641,23 @@ ProcessGDBRemote::BuildDynamicRegisterInfo (bool force)
                     {
                         SplitCommaSeparatedRegisterNumberString(value, invalidate_regs, 16);
                     }
+                    else if (name.compare("dynamic_size_dwarf_expr_bytes") == 0)
+                    {
+                       size_t dwarf_opcode_len = value.length () / 2;
+                       assert (dwarf_opcode_len > 0);
+
+                       dwarf_opcode_bytes.resize (dwarf_opcode_len);
+                       StringExtractor opcode_extractor;
+                       reg_info.dynamic_size_dwarf_len = dwarf_opcode_len; 
+
+                       // Swap "value" over into "opcode_extractor"
+                       opcode_extractor.GetStringRef ().swap (value);
+                       uint32_t ret_val = opcode_extractor.GetHexBytesAvail (dwarf_opcode_bytes.data (),
+                                                                           dwarf_opcode_len);
+                       assert (dwarf_opcode_len == ret_val);
+
+                       reg_info.dynamic_size_dwarf_expr_bytes = dwarf_opcode_bytes.data ();
+                    }
                 }
 
                 reg_info.byte_offset = reg_offset;
@@ -4373,6 +4393,7 @@ ParseRegisters (XMLNode feature_node, GdbServerTargetInfo &target_info, GDBRemot
         ConstString set_name;
         std::vector<uint32_t> value_regs;
         std::vector<uint32_t> invalidate_regs;
+        std::vector<uint8_t> dwarf_opcode_bytes;
         bool encoding_set = false;
         bool format_set = false;
         RegisterInfo reg_info = { NULL,                 // Name
@@ -4389,10 +4410,12 @@ ParseRegisters (XMLNode feature_node, GdbServerTargetInfo &target_info, GDBRemot
                 cur_reg_num         // native register number
             },
             NULL,
-            NULL
+            NULL,
+            NULL,  // Dwarf Expression opcode bytes pointer
+            0      // Dwarf Expression opcode bytes length 
         };
 
-        reg_node.ForEachAttribute([&target_info, &gdb_group, &gdb_type, &reg_name, &alt_name, &set_name, &value_regs, &invalidate_regs, &encoding_set, &format_set, &reg_info, &cur_reg_num, &reg_offset](const llvm::StringRef &name, const llvm::StringRef &value) -> bool {
+        reg_node.ForEachAttribute([&target_info, &gdb_group, &gdb_type, &reg_name, &alt_name, &set_name, &value_regs, &invalidate_regs, &encoding_set, &format_set, &reg_info, &cur_reg_num, &reg_offset, &dwarf_opcode_bytes](const llvm::StringRef &name, const llvm::StringRef &value) -> bool {
             if (name == "name")
             {
                 reg_name.SetString(value);
@@ -4480,6 +4503,22 @@ ParseRegisters (XMLNode feature_node, GdbServerTargetInfo &target_info, GDBRemot
             {
                 SplitCommaSeparatedRegisterNumberString(value, invalidate_regs, 0);
             }
+            else if (name == "dynamic_size_dwarf_expr_bytes")
+            {
+                StringExtractor opcode_extractor;
+                std::string opcode_string = value.str ();
+                size_t dwarf_opcode_len = opcode_string.length () / 2;
+                assert (dwarf_opcode_len > 0);
+
+                dwarf_opcode_bytes.resize (dwarf_opcode_len);
+                reg_info.dynamic_size_dwarf_len = dwarf_opcode_len;
+                opcode_extractor.GetStringRef ().swap (opcode_string);
+                uint32_t ret_val = opcode_extractor.GetHexBytesAvail (dwarf_opcode_bytes.data (),
+                                                                    dwarf_opcode_len);
+                assert (dwarf_opcode_len == ret_val);
+
+                reg_info.dynamic_size_dwarf_expr_bytes = dwarf_opcode_bytes.data ();
+            }
             else
             {
                 printf("unhandled attribute %s = %s\n", name.data(), value.data());