[LLDB][MIPS] Fix FPU Size Based on Dynamic FR

[nitesh.jain]

Summary

In MIPS, the size of FPU registers is based on FR in Status registers. The user can change the FR bits during runtime which affects the size of FPU registers. This patch detects the state of these bits to decide the size of floating point registers while reading/writing FPU registers.

[nitesh.jain]

Hi Greg/jingham,

Could you please find some time to review this ?

[clayborg]

This patch adds architecture specific code to generic GDB remote classes which should not happen. If we are going to fix correctly in the GDB remote classes, we need to abstract this. No mention of MIPS or any mips flags should be made inside of the GDB remote classes. The qRegisterInfo or the target XML data that is received from the GDB server describes all registers, you will need to add key/value pairs to the FP registers that describe these limitations then modify the DynamicRegisterInfo do the right thing. It shouldn't be too hard to add functionality that says that the byte size of a register depends on a value in another register.

[clayborg]

One way we could abstract the size is to add a key named "bitsize-expr" that is a DWARF expression. The expression in your case would be a DWARF expression:

DW_OP_regx(32) DW_OP_lit1 DW_OP_lit26 DW_OP_shl

"DW_OP_regx(32)" would push the value of register 32 onto the stack. Then it would push 1 onto the stack (DW_OP_lit1) followed by 26 onto the stack (DW_OP_lit26) and then shift 1 << 26 with DW_OP_shl... Etc. The DWARF expression would result in the byte size being on the stack at the end as the DWARF expressions can branch and do other things. So it would be possible to come up with a byte stream that can be used by all registers that is agnostic to the architecture.

Then if a register has a "bitsize-expr", the size would need to be determined by running a DWARF expression.

[nitesh.jain]

Added field "dynamic_size" in struct RegisterInfo. If the value of this field is 1 then register size should be detected at runtime. In case of MIPS, the value of this field will be always 1 for all floating point registers. Then the size of register will be evaluated based on result of Dwarf Expression.

[clayborg]

So this is close. My idea was that the lldb-server would not just set a key/value pair named "dynamic_size" to "1" in the "qRegisterInfo" or "$qXfer:features:read:target.xml:0,1ffff" XML data, it would add a key value pair: whose name is "dynamic_size_dwarf_expr" whose value is the HEX ASCII bytes encded. So qRegisterInfo would have:

dynamic_size_dwarf_expr:112233AABB

where "112233AABB" are the bytes for the DWARF expression:

llvm::dwarf::DW_OP_regx, sr_reg_num, llvm::dwarf::DW_OP_lit1,
llvm::dwarf::DW_OP_lit26, llvm::dwarf::DW_OP_shl, llvm::dwarf::DW_OP_and,
llvm::dwarf::DW_OP_regx, config5_reg_num, llvm::dwarf::DW_OP_lit1,
llvm::dwarf::DW_OP_lit8, llvm::dwarf::DW_OP_shl, llvm::dwarf::DW_OP_and,
llvm::dwarf::DW_OP_lit18, llvm::dwarf::DW_OP_shl, 
llvm::dwarf::DW_OP_xor

The result of the expression should be the byte size for the register, not a zero or 1. This way, any target can hook up to LLDB and provide the needed info and LLDB will just work. With the above solution, you must go and modify LLDB source code.

See inlined comments for more details.

I really want to get this dynamic register size stuff right so the next target that needs it just works with no modifications to existing code. Thanks for making all the changes.

include/lldb/lldb-private-types.h

57–58

We shouldn't have to add this as any register size adjustments can be taken care of in:

const RegisterInfo * RegisterContext::GetRegisterInfoAtIndex (uint32_t reg_index) const;

Another thing we could do is store the DWARF expression bytes right in the RegisterInfo:

const uint8_t *dynamic_size_dwarf_expr_bytes; // A DWARF expression that when evaluated gives the byte size of this register
size_t dynamic_size_dwarf_len; // The length of the DWARF expression in bytes in the dynamic_size_dwarf_expr_bytes member

source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.cpp

495 ↗

(On Diff #61654)

Just check if reg_index is in the FPUs. We shouldn't need to add the dynamic_size to RegisterInfo, or we just check the new "dynamic_size_dwarf_expr_bytes" field in RegisterInfo.

497–505 ↗

(On Diff #61654)

If we don't add anything to RegisterInfo, then this code is fine. Else we will need to check "reg_info->dynamic_size_dwarf_expr_bytes" and evaluate the DWARF expression to get the size.

930–963 ↗

(On Diff #61654)

This whole function goes away if we add "dynamic_size_dwarf_expr_bytes" to RegisterInfo. Else this stays.

source/Plugins/Process/Utility/DynamicRegisterInfo.cpp

297–299

I would change this to get a "dynamic_size_dwarf_expr" key whose value is a string that has HEXASCII encoded DWARF DW_OP bytes. We wouldn't store this in the "reg_info", but somewhere else locally in this class. Maybe a map of register number to DWARFExpression:

typedef std::map<uint32_t, DWARFExpression> DynamicRegisterSizeMap;

If we modify RegisterInfo to add the "dynamic_size_dwarf_expr_bytes", then we would store the bytes in there, but we will need to make a copy of the bytes.

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

1637–1640

Remove? Or we can change RegisterInfo to contain a "const uint8_t *dynamic_size_dwarf_expr_bytes; size_t dynamic_size_dwarf_len;".

source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.cpp

951–995

This should be removed in favor or having the DWARF expression supplied to us via the qRegisterInfo or $qXfer:features:read:target.xml:0,1ffff packets. The XML would have a key/value pair for "dynamic_size_dwarf_expr" that would be the DWARF expression.

source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.h

49–55 ↗

(On Diff #61654)

Remove this and just evaluate the DWARF expression that was given to us via the qRegisterInfo or $qXfer:features:read:target.xml:0,1ffff

source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

560

remove

644–647

change to:

else if (name.compare("dynamic_size_dwarf_expr") == 0)
{
    // TODO: store DWARF expression somewhere
}

[nitesh.jain]

source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.cpp

497–505 ↗

(On Diff #61654)

If Dwarf expression need to be evaluate at server side, then we need to add one more function in DWARFExpression::Evaluate to take NativeRegisterContext has a parameter. So should I add one more functionality in it ?

Thanks

[labath]

source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.cpp

497–505 ↗

(On Diff #61654)

Please be careful about pulling more code to lldb-server, as it may cause the size to blow up due to transitive dependencies. If you're going to do that, please check the impact on the binary size, but I think it would be best to keep dwarf expression evaluation out of the server altogether.

[clayborg]

There should be no need to add code on the lldb-server side. It would just send the DWARF expression bytes over when qRegisterInfo or the target xml is sent to the host. The host would store this expression and run it each time the register info is asked for for a register so that the host can set the register byte size correctly.

[nitesh.jain]

Update diff as per suggestion. In case of FRE mode, FPU registers are all 64 bit.

[labath]

source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.cpp

94

Can we get rid of these const_casts? It looks like UpdateDynamicRegisterSize does not actually need this to be non-const.

[nitesh.jain]

source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.cpp

94

No, it require so that we can modify the reg_info->byte_size member.

[labath]

source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.cpp

94

In that case, there is something else wrong with the design here. Well behaved code should never need to call const_cast.

m_reg_info is non-const, so maybe you just need a non-const version of DynamicRegisterInfo::GetRegisterInfoAtIndex or something like that...

[nitesh.jain]

Added lldb_private::RegisterInfo * DynamicRegisterInfo::GetRegisterInfoAtIndex (uint32_t i)

[nitesh.jain]

Hi Greg,

Please could you find some time to review this ?

Thanks

[clayborg]

Many issues. See inlined comments.

include/lldb/lldb-private-types.h

57–58

If you choose to add these fields to RegisterInfo.h, then you will need to update all macros for that create arrays of RegisterInfo structs to fill in NULL into dynamic_size_dwarf_expr_bytes, and 0 into dynamic_size_dwarf_len.

source/Plugins/Process/Utility/DynamicRegisterInfo.cpp

298–299

We don't need a key named "dynamic_size_dwarf_len", we just need "dynamic_size_dwarf_expr_bytes". We can fill in "reg_info.dynamic_size_dwarf_len" after decoding the bytes in "dynamic_size_dwarf_expr_bytes".

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

1639

We really don't need a "dynamic_size_dwarf_len" key. Just "dynamic_size_dwarf_expr_bytes" and we can determine the byte size from how many bytes are encoded as hex ASCII chars.

source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.cpp

92–102

Put these two statements inside the "if (reg_info->dynamic_size_dwarf_len)" statement

95

add space and make sure "reg_info" isn't NULL.

if (reg_info && reg_info->dynamic_size_dwarf_len)

951–991

This should be a function in RegisterContext.h/RegisterContext.cpp and then the first two arguments are not needed. See previous comment for reasons why.

source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.h

50–55 ↗

(On Diff #63224)

This should be moved to RegisterContext.h as any register from any context can have DWARF expressions that describe the byte size. If this is a function on the RegisterContext class, you won't need to first two parameters "exe_ctx" and "reg_ctx" since the RegisterContext contains a member variable named "m_thread" which is a "lldb_private::Thread &".

source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

542

We are going to assume that 8 bytes is enough for any size expression?

658

We can't use "dwarf_opcode" here. It is a local variable above:

uint8_t dwarf_opcode[8];

Then the register info will point to random data on the stack after this function. This need to be dynamically stored on the dynamic register info class so that it maintains a reference to the data so that it lives as long as the RegisterInfo structs do.

4402

We can't use a local variable for the dwarf_opcode data.

4512–4515

Don't need this key, remove this code.

4525

You must dynamically store the dwarf opcode bytes in the dynamic register info class so it keeps the bytes alive as long as the register info structs.

[nitesh.jain]

Removed dynamic_size_dwarf_len field from RegisterInfo struct.

[clayborg]

A few comments:

• we need the DWARF opcode length in RegisterInfo, but not in the structured data (XML or JSON)
• all macros that initialize RegisterInfo structs must be expended to null and zero out the opcode pointer and size (in all register contexts for all archs)
• remove all virtual and overrides for GetDwarfOpcodeLength()

include/lldb/Host/common/NativeRegisterContext.h

90–92

Remove this, the length needs to stay in the RegisterInfo.

include/lldb/Host/common/NativeRegisterContextRegisterInfo.h

40–42

Remove this, the length needs to stay in the RegisterInfo.

include/lldb/Target/RegisterContext.h

53

Remove opcode_len, the length needs to stay in the RegisterInfo.

include/lldb/lldb-private-types.h

57–58

So we either remove both fields from RegisterInfo, or we leave both in. If we remove them both, then getting the register info from the RegisterContext will update the register info automatically if needed as determined by the RegisterContext subclass. I don't mind them being in RegisterInfo and I think both should stay. In this case, we do need the length for the expression in the RegisterInfo struct, we just don't need to *send* the length in the structured data (XML or JSON).

source/Host/common/NativeRegisterContext.cpp

273–278

Remove this, the length needs to stay in the RegisterInfo.

source/Host/common/NativeRegisterContextRegisterInfo.cpp

52–58

Remove this, the length needs to stay in the RegisterInfo.

source/Plugins/Process/Utility/DynamicRegisterInfo.cpp

317

set the length in RegisterInfo from the size of the bytes extracted.

320

set the opcode length to zero here.

424–428

remove.

435

remove dwarf_expr_bytes_len.

source/Plugins/Process/Utility/DynamicRegisterInfo.h

43

Remove the dwarf_expr_bytes_len, the length needs to stay in the RegisterInfo. If the opcode and length are non-zero, then a copy of the data will need to be made so it can persist. We already do this with the value_regs and invalidate_regs fields in RegisterInfo.

57–59

remove

source/Plugins/Process/Utility/RegisterContextLinux_mips.cpp

72–84

remove

source/Plugins/Process/Utility/RegisterContextLinux_mips.h

34–35

remove

source/Plugins/Process/Utility/RegisterContextLinux_mips64.cpp

124–136

remove

source/Plugins/Process/Utility/RegisterContextLinux_mips64.h

36–38

remove

source/Plugins/Process/Utility/RegisterInfoInterface.h

51–56

remove

[nitesh.jain]

Update diff as per suggestion.

[clayborg]

Looks good, thanks for all of the updates.

[nitesh.jain]

Thanks Greg for all your help.

include/lldb/Host/common/NativeRegisterContext.h

public:
     NumSupportedHardwareBreakpoints ();
 
     virtual uint32_t
     SetHardwareBreakpoint (lldb::addr_t addr, size_t size);
 
     virtual bool
     ClearHardwareBreakpoint (uint32_t hw_idx);
 
+    virtual size_t
+    GetDwarfOpcodeLength (const uint32_t i) const;
+
     virtual uint32_t
     NumSupportedHardwareWatchpoints ();
 
     virtual uint32_t
     SetHardwareWatchpoint (lldb::addr_t addr, size_t size, uint32_t watch_flags);
 
     virtual bool
     ClearHardwareWatchpoint (uint32_t hw_index);

include/lldb/Host/common/NativeRegisterContextRegisterInfo.h

public:
         GetRegisterCount () const override;
 
         uint32_t
         GetUserRegisterCount () const override;
 
         const RegisterInfo *
         GetRegisterInfoAtIndex (uint32_t reg_index) const override;
 
+        size_t
+        GetDwarfOpcodeLength (const uint32_t i) const override;
+
         const RegisterInfoInterface&
         GetRegisterInfoInterface () const;
 
     private:
         std::unique_ptr<RegisterInfoInterface> m_register_info_interface_up;
     };
 }
 #endif

include/lldb/Target/RegisterContext.h

public:
     InvalidateAllRegisters () = 0;
 
     virtual size_t
     GetRegisterCount () = 0;
 
     virtual const RegisterInfo *
     GetRegisterInfoAtIndex (size_t reg) = 0;
 
+    // Detect the register size dynamically.
+    uint32_t
+    UpdateDynamicRegisterSize (const lldb_private::ArchSpec &arch,
+                               RegisterInfo* reg_info,
+                               size_t opcode_len);
+
     virtual size_t
     GetRegisterSetCount () = 0;
 
     virtual const RegisterSet *
     GetRegisterSet (size_t reg_set) = 0;
 
     virtual bool
     ReadRegister (const RegisterInfo *reg_info, RegisterValue &reg_value) = 0;

include/lldb/lldb-private-types.h

struct RegisterInfo
         uint32_t *value_regs;      // List of registers (terminated with LLDB_INVALID_REGNUM).  If this value is not
                                    // null, all registers in this list will be read first, at which point the value 
                                    // for this register will be valid.  For example, the value list for ah
                                    // would be eax (x86) or rax (x64).
         uint32_t *invalidate_regs; // List of registers (terminated with LLDB_INVALID_REGNUM).  If this value is not
                                    // null, all registers in this list will be invalidated when the value of this
                                    // register changes.  For example, the invalidate list for eax would be rax
                                    // ax, ah, and al.
+        const uint8_t *dynamic_size_dwarf_expr_bytes; // A DWARF expression that when evaluated gives 
+                                                      // the byte size of this register. 
     };
 
     //----------------------------------------------------------------------
     // Registers are grouped into register sets
     //----------------------------------------------------------------------
     struct RegisterSet
     {
         const char *name;           // Name of this register set

source/Host/common/NativeRegisterContext.cpp

 }
 
 uint32_t
 NativeRegisterContext::NumSupportedHardwareBreakpoints ()
 {
     return 0;
 }
 
+size_t
+NativeRegisterContext::GetDwarfOpcodeLength (const uint32_t i) const
+{
+    return 0;
+}
+
 uint32_t
 NativeRegisterContext::SetHardwareBreakpoint (lldb::addr_t addr, size_t size)
 {
     return LLDB_INVALID_INDEX32;
 }
 
 bool
 NativeRegisterContext::ClearHardwareBreakpoint (uint32_t hw_idx)

source/Host/common/NativeRegisterContextRegisterInfo.cpp

else
         return nullptr;
 }
 
 const RegisterInfoInterface&
 NativeRegisterContextRegisterInfo::GetRegisterInfoInterface () const
 {
     return *m_register_info_interface_up;
 }
+
+size_t
+NativeRegisterContextRegisterInfo::GetDwarfOpcodeLength (const uint32_t i) const
+{
+    const RegisterInfoInterface& reg_info_interface = GetRegisterInfoInterface ();
+    return reg_info_interface.GetDwarfOpcodeLength (i);
+}
+

source/Plugins/Process/Utility/DynamicRegisterInfo.h

public:
 
     size_t SetRegisterInfo(const lldb_private::StructuredData::Dictionary &dict,
                            const lldb_private::ArchSpec &arch);
 
     void
     AddRegister (lldb_private::RegisterInfo &reg_info, 
                  lldb_private::ConstString &reg_name, 
                  lldb_private::ConstString &reg_alt_name, 
-                 lldb_private::ConstString &set_name);
+                 lldb_private::ConstString &set_name,
+                 uint32_t dwarf_expr_bytes_len = 0);
 
     void
     Finalize (const lldb_private::ArchSpec &arch);
 
     size_t
     GetNumRegisters() const;
 
     size_t
     GetNumRegisterSets() const;
 
     size_t
     GetRegisterDataByteSize() const;
 
+    // Get length of the Dwarf Opcode
+    size_t
+    GetDwarfOpcodeLength (uint32_t i);
+
     const lldb_private::RegisterInfo *
     GetRegisterInfoAtIndex (uint32_t i) const;
 
+    lldb_private::RegisterInfo *
+    GetRegisterInfoAtIndex (uint32_t i);
+
     const lldb_private::RegisterSet *
     GetRegisterSet (uint32_t i) const;
 
     uint32_t
     GetRegisterSetIndexByName (lldb_private::ConstString &set_name, bool can_create);
 
     uint32_t
     ConvertRegisterKindToRegisterNumber (uint32_t kind, uint32_t num) const;
protected:
     // Classes that inherit from DynamicRegisterInfo can see and modify these
     //------------------------------------------------------------------
     typedef std::vector <lldb_private::RegisterInfo> reg_collection;
     typedef std::vector <lldb_private::RegisterSet> set_collection;
     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;
+    typedef std::vector <uint8_t> dwarf_opcode;
+    typedef std::map<uint32_t, dwarf_opcode> dynamic_reg_size_map;
 
     lldb_private::RegisterInfo *
     GetRegisterInfo (const lldb_private::ConstString &reg_name);
 
     reg_collection m_regs;
     set_collection m_sets;
     set_reg_num_collection m_set_reg_nums;
     name_collection m_set_names;
     reg_to_regs_map m_value_regs_map;
     reg_to_regs_map m_invalidate_regs_map;
+    dynamic_reg_size_map m_dynamic_reg_size_map;
     size_t m_reg_data_byte_size;   // The number of bytes required to store all registers
     bool m_finalized;
 };
 
 #endif  // lldb_DynamicRegisterInfo_h_

source/Plugins/Process/Utility/DynamicRegisterInfo.cpp

 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Core/RegularExpression.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/StructuredData.h"
 #include "lldb/DataFormatters/FormatManager.h"
 #include "lldb/Host/StringConvert.h"
-
+#include "lldb/Utility/StringExtractor.h"
 using namespace lldb;
 using namespace lldb_private;
 
 DynamicRegisterInfo::DynamicRegisterInfo () :
     m_regs (),
     m_sets (),
     m_set_reg_nums (),
     m_set_names (),
     m_value_regs_map (),
     m_invalidate_regs_map (),
+    m_dynamic_reg_size_map (),
     m_reg_data_byte_size (0),
     m_finalized (false)
 {
 }
 
 DynamicRegisterInfo::DynamicRegisterInfo(const lldb_private::StructuredData::Dictionary &dict,
                                          const lldb_private::ArchSpec &arch) :
     m_regs (),
     m_sets (),
     m_set_reg_nums (),
     m_set_names (),
     m_value_regs_map (),
     m_invalidate_regs_map (),
+    m_dynamic_reg_size_map (),
     m_reg_data_byte_size (0),
     m_finalized (false)
 {
     SetRegisterInfo (dict, arch);
 }
 
 DynamicRegisterInfo::~DynamicRegisterInfo ()
 {
for (uint32_t i = 0; i < num_regs; ++i)
             Clear();
             printf("error: invalid or missing 'bitsize' key/value pair in register dictionary\n");
             reg_info_dict->DumpToStdout();
             return 0;
         }
 
         reg_info.byte_size = bitsize / 8;
 
+        std::string dwarf_opcode_string;
+        if (reg_info_dict->GetValueForKeyAsString("dynamic_size_dwarf_expr_bytes", dwarf_opcode_string))
+        {
+            uint8_t *dwarf_opcode_ptr = NULL;
+            uint32_t dwarf_expr_bytes_len = dwarf_opcode_string.length () / 2;
+            uint32_t j;
+            StringExtractor name_extractor;
+            dwarf_opcode_ptr = new uint8_t[dwarf_expr_bytes_len];
+            if (dwarf_opcode_ptr)
+            {
+                // Swap "dwarf_opcode_string" over into "name_extractor"
+                name_extractor.GetStringRef ().swap (dwarf_opcode_string);
+                uint32_t ret_val = name_extractor.GetHexBytesAvail (dwarf_opcode_ptr, dwarf_expr_bytes_len);
+                assert(ret_val == dwarf_expr_bytes_len);
+                for (j = 0; j < dwarf_expr_bytes_len; ++j)
+                    m_dynamic_reg_size_map[i].push_back(dwarf_opcode_ptr[j]);
+
+                delete[] dwarf_opcode_ptr;
+
+                // Update the actual location
+                reg_info.dynamic_size_dwarf_expr_bytes = m_dynamic_reg_size_map[i].data ();
+            }
+            else
+                reg_info.dynamic_size_dwarf_expr_bytes = NULL;
+        }
         std::string format_str;
         if (reg_info_dict->GetValueForKeyAsString("format", format_str, nullptr))
         {
             if (Args::StringToFormat(format_str.c_str(), reg_info.format, NULL).Fail())
             {
                 Clear();
                 printf("error: invalid 'format' value in register dictionary\n");
                 reg_info_dict->DumpToStdout();
for (uint32_t i = 0; i < num_regs; ++i)
 
         m_regs.push_back(reg_info);
         m_set_reg_nums[set].push_back(i);
     }
     Finalize(arch);
     return m_regs.size();
 }
 
+size_t
+DynamicRegisterInfo::GetDwarfOpcodeLength (uint32_t i)
+{
+    return m_dynamic_reg_size_map[i].size();
+}
 
 void
 DynamicRegisterInfo::AddRegister (RegisterInfo &reg_info,
                                   ConstString &reg_name, 
                                   ConstString &reg_alt_name, 
-                                  ConstString &set_name)
+                                  ConstString &set_name,
+                                  uint32_t dwarf_expr_bytes_len)
 {
     assert(!m_finalized);
     const uint32_t reg_num = m_regs.size();
     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]);
     }
     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]);
     }
+    if (reg_info.dynamic_size_dwarf_expr_bytes)
+    {
+        for (i = 0; i < dwarf_expr_bytes_len; ++i)
+           m_dynamic_reg_size_map[reg_num].push_back(reg_info.dynamic_size_dwarf_expr_bytes[i]);
+
+        // Update the actual location
+        reg_info.dynamic_size_dwarf_expr_bytes = m_dynamic_reg_size_map[reg_num].data ();
+    }
     m_regs.push_back (reg_info);
     uint32_t set = GetRegisterSetIndexByName (set_name, true);
     assert (set < m_sets.size());
     assert (set < m_set_reg_nums.size());
     assert (set < m_set_names.size());
     m_set_reg_nums[set].push_back(reg_num);
     size_t end_reg_offset = reg_info.byte_offset + reg_info.byte_size;
     if (m_reg_data_byte_size < end_reg_offset)

 const RegisterInfo *
 DynamicRegisterInfo::GetRegisterInfoAtIndex (uint32_t i) const
 {
     if (i < m_regs.size())
         return &m_regs[i];
     return NULL;
 }
 
+RegisterInfo *
+DynamicRegisterInfo::GetRegisterInfoAtIndex (uint32_t i)
+{
+    if (i < m_regs.size())
+        return &m_regs[i];
+    return NULL;
+}
+
 const RegisterSet *
 DynamicRegisterInfo::GetRegisterSet (uint32_t i) const
 {
     if (i < m_sets.size())
         return &m_sets[i];
     return NULL;
 }
 

 DynamicRegisterInfo::Clear()
 {
     m_regs.clear();
     m_sets.clear();
     m_set_reg_nums.clear();
     m_set_names.clear();
     m_value_regs_map.clear();
     m_invalidate_regs_map.clear();
+    m_dynamic_reg_size_map.clear();
     m_reg_data_byte_size = 0;
     m_finalized = false;
 }
 
 void
 DynamicRegisterInfo::Dump () const
 {
     StreamFile s(stdout, false);

source/Plugins/Process/Utility/RegisterContextLinux_mips.h

public:
     GetRegisterInfo() const override;
 
     uint32_t
     GetRegisterCount () const override;
 
     uint32_t
     GetUserRegisterCount () const override;
 
+    size_t
+    GetDwarfOpcodeLength (const uint32_t i) const override;
+
 private:
     uint32_t m_user_register_count;
 };
 
 #endif

source/Plugins/Process/Utility/RegisterContextLinux_mips.cpp

 }
 
 uint32_t
 RegisterContextLinux_mips::GetRegisterCount () const
 {
     return static_cast<uint32_t> (sizeof (g_register_infos_mips) / sizeof (g_register_infos_mips [0]));
 }
 
+size_t
+RegisterContextLinux_mips::GetDwarfOpcodeLength (const uint32_t i) const
+{
+    if (i < GetRegisterCount ())
+    {
+        const RegisterInfo *reg_info = GetRegisterInfo() + i;
+
+        if (reg_info && reg_info->dynamic_size_dwarf_expr_bytes)
+            return sizeof(dwarf_opcode_mips);
+    }
+    return 0;
+}
+
 uint32_t
 RegisterContextLinux_mips::GetUserRegisterCount () const
 {
     return static_cast<uint32_t> (m_user_register_count);
 }

source/Plugins/Process/Utility/RegisterContextLinux_mips64.h

public:
     GetRegisterInfo() const override;
 
     uint32_t
     GetRegisterCount () const override;
 
     uint32_t
     GetUserRegisterCount () const override;
 
+    size_t
+    GetDwarfOpcodeLength (const uint32_t i) const override;
+
 private:
     const lldb_private::RegisterInfo *m_register_info_p;
     uint32_t m_register_info_count;
     uint32_t m_user_register_count;
 };
 
 #endif
 
 #endif

source/Plugins/Process/Utility/RegisterContextLinux_mips64.cpp

 }
 
 uint32_t
 RegisterContextLinux_mips64::GetRegisterCount () const
 {
     return m_register_info_count;
 }
 
+size_t
+RegisterContextLinux_mips64::GetDwarfOpcodeLength (const uint32_t i) const
+{
+    if (i < GetRegisterCount ())
+    {
+        const RegisterInfo *reg_info = GetRegisterInfo() + i;
+
+        if (reg_info && reg_info->dynamic_size_dwarf_expr_bytes)
+            return sizeof(dwarf_opcode_mips64);
+    }
+    return 0;
+}
+
 uint32_t
 RegisterContextLinux_mips64::GetUserRegisterCount () const
 {
     return m_user_register_count;
 }
 
 #endif

source/Plugins/Process/Utility/RegisterInfoInterface.h

public:
         // kept for lldb internal use only). Subclasses should override it if
         // they belongs to an architecture with lldb internal registers.
         virtual uint32_t
         GetUserRegisterCount () const
         {
             return GetRegisterCount();
         }
 
+        virtual size_t
+        GetDwarfOpcodeLength (const uint32_t i) const
+        {
+            return 0;  
+        }
+
         const lldb_private::ArchSpec&
         GetTargetArchitecture() const
             { return m_target_arch; }
 
         virtual const lldb_private::RegisterInfo *
         GetDynamicRegisterInfo(const char *reg_name) const
         {
             const std::vector <lldb_private::RegisterInfo> * d_register_infos = GetDynamicRegisterInfoP();

source/Plugins/Process/Utility/RegisterInfos_mips.h

 //===-- RegisterInfos_mips.h -----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===---------------------------------------------------------------------===//
 
 // C Includes
 #include <stddef.h>
 
 // C++ Includes
 // Other libraries and framework includes
 #include "llvm/Support/Compiler.h"
-
+#include "lldb/Core/dwarf.h"
 // Project includes
 
 #ifdef DECLARE_REGISTER_INFOS_MIPS_STRUCT
 
 // Computes the offset of the given GPR in the user data area.
 #define GPR_OFFSET(regname) \
     (LLVM_EXTENSION offsetof(UserArea, gpr) + \
      LLVM_EXTENSION offsetof(GPR_linux_mips, regname))
 
 // Computes the offset of the given FPR in the extended data area.
 #define FPR_OFFSET(regname)  \
      (LLVM_EXTENSION offsetof(UserArea, fpr) + \
       LLVM_EXTENSION offsetof(FPR_linux_mips, regname))
 
 // Computes the offset of the given MSA in the extended data area.
 #define MSA_OFFSET(regname)  \
      (LLVM_EXTENSION offsetof(UserArea, msa) + \
       LLVM_EXTENSION offsetof(MSA_linux_mips, regname))
 
 // 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_linux_mips*)NULL)->reg) / 2, GPR_OFFSET(reg), eEncodingUint,  \
-      eFormatHex, { kind1, kind2, kind3, kind4, gpr_##reg##_mips }, NULL, NULL }
+      eFormatHex, { kind1, kind2, kind3, kind4, gpr_##reg##_mips }, NULL, NULL, NULL}
+
+const uint8_t dwarf_opcode_mips [] = {
+                                        llvm::dwarf::DW_OP_regx, dwarf_sr_mips, llvm::dwarf::DW_OP_lit1,
+                                        llvm::dwarf::DW_OP_lit26, llvm::dwarf::DW_OP_shl, llvm::dwarf::DW_OP_and,
+                                        llvm::dwarf::DW_OP_lit26, llvm::dwarf::DW_OP_shr
+                                     };
 
 #define DEFINE_FPR(reg, alt, kind1, kind2, kind3, kind4)           \
     { #reg, alt, sizeof(((FPR_linux_mips*)NULL)->reg), FPR_OFFSET(reg), eEncodingIEEE754,   \
-      eFormatFloat, { kind1, kind2, kind3, kind4, fpr_##reg##_mips }, NULL, NULL }
+      eFormatFloat, { kind1, kind2, kind3, kind4, fpr_##reg##_mips }, NULL, NULL, dwarf_opcode_mips}
 
 #define DEFINE_FPR_INFO(reg, alt, kind1, kind2, kind3, kind4)      \
    { #reg, alt, sizeof(((FPR_linux_mips*)NULL)->reg), FPR_OFFSET(reg), eEncodingUint,   \
-     eFormatHex, { kind1, kind2, kind3, kind4, fpr_##reg##_mips }, NULL, NULL }
+     eFormatHex, { kind1, kind2, kind3, kind4, fpr_##reg##_mips }, NULL, NULL, NULL}
 
 #define DEFINE_MSA(reg, alt, kind1, kind2, kind3, kind4)    \
     { #reg, alt, sizeof(((MSA_linux_mips*)0)->reg), MSA_OFFSET(reg), eEncodingVector,   \
-      eFormatVectorOfUInt8, { kind1, kind2, kind3, kind4, msa_##reg##_mips }, NULL, NULL }
+      eFormatVectorOfUInt8, { kind1, kind2, kind3, kind4, msa_##reg##_mips }, NULL, NULL, NULL}
 
 #define DEFINE_MSA_INFO(reg, alt, kind1, kind2, kind3, kind4)    \
     { #reg, alt, sizeof(((MSA_linux_mips*)0)->reg), MSA_OFFSET(reg), eEncodingUint, \
-      eFormatHex, { kind1, kind2, kind3, kind4, msa_##reg##_mips }, NULL, NULL }
+      eFormatHex, { kind1, kind2, kind3, kind4, msa_##reg##_mips }, NULL, NULL, NULL}
 
 // RegisterKind: EH_Frame, DWARF, Generic, Procss Plugin, LLDB
 
 static RegisterInfo
 g_register_infos_mips[] =
 {
     DEFINE_GPR (zero,     "zero",     dwarf_zero_mips,      dwarf_zero_mips,  LLDB_INVALID_REGNUM,    LLDB_INVALID_REGNUM),
     DEFINE_GPR (r1,       "at",       dwarf_r1_mips,        dwarf_r1_mips,    LLDB_INVALID_REGNUM,    LLDB_INVALID_REGNUM),

source/Plugins/Process/Utility/RegisterInfos_mips64.h

 //===-- RegisterInfos_mips64.h ----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // C Includes
 #include <stddef.h>
 
 // C++ Includes
 // Other libraries and framework includes
 #include "llvm/Support/Compiler.h"
-
+#include "lldb/Core/dwarf.h"
 // Project includes
 
 #ifdef DECLARE_REGISTER_INFOS_MIPS64_STRUCT
 
 // Computes the offset of the given GPR in the user data area.
 #ifdef LINUX_MIPS64
     #define GPR_OFFSET(regname) \
         (LLVM_EXTENSION offsetof(UserArea, gpr) + \
(LLVM_EXTENSION offsetof(UserArea, msa) + \
       LLVM_EXTENSION offsetof(MSA_linux_mips, regname))
 
 // RegisterKind: EHFrame, DWARF, Generic, Process Plugin, LLDB
 
 // Note that the size and offset will be updated by platform-specific classes.
 #ifdef LINUX_MIPS64
     #define DEFINE_GPR(reg, alt, kind1, kind2, kind3, kind4) \
          { #reg, alt, sizeof(((GPR_linux_mips*)0)->reg), GPR_OFFSET(reg), eEncodingUint, \
-          eFormatHex, { kind1, kind2, kind3, kind4, gpr_##reg##_mips64 }, NULL, NULL }
+          eFormatHex, { kind1, kind2, kind3, kind4, gpr_##reg##_mips64 }, NULL, NULL, NULL}
 #else
     #define DEFINE_GPR(reg, alt, kind1, kind2, kind3, kind4)    \
          { #reg, alt, sizeof(((GPR_freebsd_mips*)0)->reg), GPR_OFFSET(reg), eEncodingUint, \
-          eFormatHex, { kind1, kind2, kind3, kind4, gpr_##reg##_mips64 }, NULL, NULL }
+          eFormatHex, { kind1, kind2, kind3, kind4, gpr_##reg##_mips64 }, NULL, NULL, NULL}
 #endif
 
 #define DEFINE_GPR_INFO(reg, alt, kind1, kind2, kind3, kind4)    \
     { #reg, alt, sizeof(((GPR_linux_mips*)0)->reg) / 2, GPR_OFFSET(reg), eEncodingUint, \
-      eFormatHex, { kind1, kind2, kind3, kind4, gpr_##reg##_mips64 }, NULL, NULL }
+      eFormatHex, { kind1, kind2, kind3, kind4, gpr_##reg##_mips64 }, NULL, NULL, NULL}
+
+const uint8_t dwarf_opcode_mips64 [] = {
+                                           llvm::dwarf::DW_OP_regx, dwarf_sr_mips64, llvm::dwarf::DW_OP_lit1,
+                                           llvm::dwarf::DW_OP_lit26, llvm::dwarf::DW_OP_shl, llvm::dwarf::DW_OP_and, 
+                                           llvm::dwarf::DW_OP_lit26, llvm::dwarf::DW_OP_shr
+                                       };
+
 
 #define DEFINE_FPR(reg, alt, kind1, kind2, kind3, kind4)    \
     { #reg, alt, sizeof(((FPR_linux_mips*)0)->reg), FPR_OFFSET(reg), eEncodingIEEE754,  \
-      eFormatFloat, { kind1, kind2, kind3, kind4, fpr_##reg##_mips64 }, NULL, NULL }
+      eFormatFloat, { kind1, kind2, kind3, kind4, fpr_##reg##_mips64 }, NULL, NULL, dwarf_opcode_mips64}
 
 #define DEFINE_FPR_INFO(reg, alt, kind1, kind2, kind3, kind4)    \
     { #reg, alt, sizeof(((FPR_linux_mips*)0)->reg), FPR_OFFSET(reg), eEncodingUint,   \
-      eFormatHex, { kind1, kind2, kind3, kind4, fpr_##reg##_mips64 }, NULL, NULL }
+      eFormatHex, { kind1, kind2, kind3, kind4, fpr_##reg##_mips64 }, NULL, NULL, NULL}
 
 #define DEFINE_MSA(reg, alt, kind1, kind2, kind3, kind4)    \
     { #reg, alt, sizeof(((MSA_linux_mips*)0)->reg), MSA_OFFSET(reg), eEncodingVector,   \
-      eFormatVectorOfUInt8, { kind1, kind2, kind3, kind4, msa_##reg##_mips64 }, NULL, NULL }
+      eFormatVectorOfUInt8, { kind1, kind2, kind3, kind4, msa_##reg##_mips64 }, NULL, NULL, NULL}
 
 #define DEFINE_MSA_INFO(reg, alt, kind1, kind2, kind3, kind4)    \
     { #reg, alt, sizeof(((MSA_linux_mips*)0)->reg), MSA_OFFSET(reg), eEncodingUint,   \
-      eFormatHex, { kind1, kind2, kind3, kind4, msa_##reg##_mips64 }, NULL, NULL }
+      eFormatHex, { kind1, kind2, kind3, kind4, msa_##reg##_mips64 }, NULL, NULL, NULL}
 
 static RegisterInfo
 g_register_infos_mips64[] =
 {
     // General purpose registers.            EH_Frame,                  DWARF,              Generic,    Process Plugin
 #ifndef LINUX_MIPS64
     DEFINE_GPR(zero,     "r0",      dwarf_zero_mips64,      dwarf_zero_mips64,  LLDB_INVALID_REGNUM,    LLDB_INVALID_REGNUM),
     DEFINE_GPR(r1,       nullptr,   dwarf_r1_mips64,        dwarf_r1_mips64,    LLDB_INVALID_REGNUM,    LLDB_INVALID_REGNUM),

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

if (reg_info->invalidate_regs && reg_info->invalidate_regs[0])
         {
             if (i > 0)
                 response.PutChar (',');
             response.Printf ("%" PRIx32, *reg_num);
         }
         response.PutChar (';');
     }
 
+    if (reg_info->dynamic_size_dwarf_expr_bytes)
+    {
+       const size_t dwarf_opcode_len = reg_context_sp->GetDwarfOpcodeLength (reg_index);
+       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());
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_qfThreadInfo (StringExtractorGDBRemote &packet)
 {
     Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
 
GDBRemoteCommunicationServerLLGS::Handle_P (StringExtractorGDBRemote &packet)
     // Return the end of registers response if we've iterated one past the end of the register set.
     if (reg_index >= reg_context_sp->GetUserRegisterCount ())
     {
         if (log)
             log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, requested register %" PRIu32 " beyond register count %" PRIu32, __FUNCTION__, reg_index, reg_context_sp->GetUserRegisterCount ());
         return SendErrorResponse (0x47);
     }
 
-    if (reg_size != reg_info->byte_size)
+    // The dwarf expression are evaluate on LLDB side
+    // which may cause register size to change
+    // Hence the reg_size may not be same as reg_info->bytes_size
+    if ((reg_size != reg_info->byte_size) && !(reg_info->dynamic_size_dwarf_expr_bytes))
     {
         return SendIllFormedResponse (packet, "P packet register size is incorrect");
     }
 
     // Build the reginfos response.
     StreamGDBRemote response;
 
     RegisterValue reg_value (reg_bytes, reg_size, process_arch.GetByteOrder ());

source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.cpp

 GDBRemoteRegisterContext::GetRegisterCount ()
 {
     return m_reg_info.GetNumRegisters ();
 }
 
 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();
+        size_t opcode_len = m_reg_info.GetDwarfOpcodeLength (reg);
+        uint8_t reg_size = UpdateDynamicRegisterSize (arch, reg_info, opcode_len);
+        reg_info->byte_size = reg_size;
+    }
+    return reg_info;
 }
 
 size_t
 GDBRemoteRegisterContext::GetRegisterSetCount ()
 {
     return m_reg_info.GetNumRegisterSets ();
 }
 
 

 
 
 uint32_t
 GDBRemoteRegisterContext::ConvertRegisterKindToRegisterNumber (lldb::RegisterKind kind, uint32_t num)
 {
     return m_reg_info.ConvertRegisterKindToRegisterNumber (kind, num);
 }
 
 
 void
 GDBRemoteDynamicRegisterInfo::HardcodeARMRegisters(bool from_scratch)
 {
     // For Advanced SIMD and VFP register mapping.
     static uint32_t g_d0_regs[] =  { 26, 27, LLDB_INVALID_REGNUM }; // (s0, s1)
     static uint32_t g_d1_regs[] =  { 28, 29, LLDB_INVALID_REGNUM }; // (s2, s3)
     static uint32_t g_d2_regs[] =  { 30, 31, LLDB_INVALID_REGNUM }; // (s4, s5)
     static uint32_t g_d3_regs[] =  { 32, 33, LLDB_INVALID_REGNUM }; // (s6, s7)
     static uint32_t g_d4_regs[] =  { 34, 35, LLDB_INVALID_REGNUM }; // (s8, s9)
     static uint32_t g_d5_regs[] =  { 36, 37, LLDB_INVALID_REGNUM }; // (s10, s11)
     static uint32_t g_d6_regs[] =  { 38, 39, LLDB_INVALID_REGNUM }; // (s12, s13)
     static uint32_t g_d7_regs[] =  { 40, 41, LLDB_INVALID_REGNUM }; // (s14, s15)
     static uint32_t g_d8_regs[] =  { 42, 43, LLDB_INVALID_REGNUM }; // (s16, s17)
     static uint32_t g_d9_regs[] =  { 44, 45, LLDB_INVALID_REGNUM }; // (s18, s19)
     static uint32_t g_d10_regs[] = { 46, 47, LLDB_INVALID_REGNUM }; // (s20, s21)
     static uint32_t g_d11_regs[] = { 48, 49, LLDB_INVALID_REGNUM }; // (s22, s23)
     static uint32_t g_d12_regs[] = { 50, 51, LLDB_INVALID_REGNUM }; // (s24, s25)
     static uint32_t g_d13_regs[] = { 52, 53, LLDB_INVALID_REGNUM }; // (s26, s27)
     static uint32_t g_d14_regs[] = { 54, 55, LLDB_INVALID_REGNUM }; // (s28, s29)
     static uint32_t g_d15_regs[] = { 56, 57, LLDB_INVALID_REGNUM }; // (s30, s31)
     static uint32_t g_q0_regs[] =  { 26, 27, 28, 29, LLDB_INVALID_REGNUM }; // (d0, d1) -> (s0, s1, s2, s3)
     static uint32_t g_q1_regs[] =  { 30, 31, 32, 33, LLDB_INVALID_REGNUM }; // (d2, d3) -> (s4, s5, s6, s7)
     static uint32_t g_q2_regs[] =  { 34, 35, 36, 37, LLDB_INVALID_REGNUM }; // (d4, d5) -> (s8, s9, s10, s11)
     static uint32_t g_q3_regs[] =  { 38, 39, 40, 41, LLDB_INVALID_REGNUM }; // (d6, d7) -> (s12, s13, s14, s15)
     static uint32_t g_q4_regs[] =  { 42, 43, 44, 45, LLDB_INVALID_REGNUM }; // (d8, d9) -> (s16, s17, s18, s19)
     static uint32_t g_q5_regs[] =  { 46, 47, 48, 49, LLDB_INVALID_REGNUM }; // (d10, d11) -> (s20, s21, s22, s23)
     static uint32_t g_q6_regs[] =  { 50, 51, 52, 53, LLDB_INVALID_REGNUM }; // (d12, d13) -> (s24, s25, s26, s27)
     static uint32_t g_q7_regs[] =  { 54, 55, 56, 57, LLDB_INVALID_REGNUM }; // (d14, d15) -> (s28, s29, s30, s31)
     static uint32_t g_q8_regs[] =  { 59, 60, LLDB_INVALID_REGNUM }; // (d16, d17)
     static uint32_t g_q9_regs[] =  { 61, 62, LLDB_INVALID_REGNUM }; // (d18, d19)
     static uint32_t g_q10_regs[] = { 63, 64, LLDB_INVALID_REGNUM }; // (d20, d21)
     static uint32_t g_q11_regs[] = { 65, 66, LLDB_INVALID_REGNUM }; // (d22, d23)
     static uint32_t g_q12_regs[] = { 67, 68, LLDB_INVALID_REGNUM }; // (d24, d25)
     static uint32_t g_q13_regs[] = { 69, 70, LLDB_INVALID_REGNUM }; // (d26, d27)
     static uint32_t g_q14_regs[] = { 71, 72, LLDB_INVALID_REGNUM }; // (d28, d29)
     static uint32_t g_q15_regs[] = { 73, 74, LLDB_INVALID_REGNUM }; // (d30, d31)
 
     // This is our array of composite registers, with each element coming from the above register mappings.
     static uint32_t *g_composites[] = {
         g_d0_regs, g_d1_regs,  g_d2_regs,  g_d3_regs,  g_d4_regs,  g_d5_regs,  g_d6_regs,  g_d7_regs,
         g_d8_regs, g_d9_regs, g_d10_regs, g_d11_regs, g_d12_regs, g_d13_regs, g_d14_regs, g_d15_regs,
         g_q0_regs, g_q1_regs,  g_q2_regs,  g_q3_regs,  g_q4_regs,  g_q5_regs,  g_q6_regs,  g_q7_regs,
         g_q8_regs, g_q9_regs, g_q10_regs, g_q11_regs, g_q12_regs, g_q13_regs, g_q14_regs, g_q15_regs
     };
 
     static RegisterInfo g_register_infos[] = {
 //   NAME    ALT    SZ  OFF  ENCODING          FORMAT          EH_FRAME             DWARF                GENERIC                 PROCESS PLUGIN  LLDB      VALUE REGS    INVALIDATE REGS
 //   ======  ====== === ===  =============     ============    ===================  ===================  ======================  =============   ====      ==========    ===============
     { "r0", "arg1",   4,   0, eEncodingUint,    eFormatHex,   { ehframe_r0,          dwarf_r0,            LLDB_REGNUM_GENERIC_ARG1,0,               0 },        NULL,              NULL},
     { "r1", "arg2",   4,   0, eEncodingUint,    eFormatHex,   { ehframe_r1,          dwarf_r1,            LLDB_REGNUM_GENERIC_ARG2,1,               1 },        NULL,              NULL},
     { "r2", "arg3",   4,   0, eEncodingUint,    eFormatHex,   { ehframe_r2,          dwarf_r2,            LLDB_REGNUM_GENERIC_ARG3,2,               2 },        NULL,              NULL},
     { "r3", "arg4",   4,   0, eEncodingUint,    eFormatHex,   { ehframe_r3,          dwarf_r3,            LLDB_REGNUM_GENERIC_ARG4,3,               3 },        NULL,              NULL},

source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

for (StringExtractorGDBRemote::ResponseType response_type = StringExtractorGDBRemote::eResponse;
             {
                 std::string name;
                 std::string value;
                 ConstString reg_name;
                 ConstString alt_name;
                 ConstString set_name;
                 std::vector<uint32_t> value_regs;
                 std::vector<uint32_t> invalidate_regs;
+                uint8_t *dwarf_opcode_bytes = NULL;
+                uint32_t dwarf_expr_bytes_len;
                 RegisterInfo reg_info = { NULL,                 // Name
                     NULL,                 // Alt name
                     0,                    // byte size
                     reg_offset,           // offset
                     eEncodingUint,        // encoding
                     eFormatHex,           // format
                     {
                         LLDB_INVALID_REGNUM, // eh_frame reg num
                         LLDB_INVALID_REGNUM, // DWARF reg num
                         LLDB_INVALID_REGNUM, // generic reg num
                         reg_num,             // process plugin reg num
                         reg_num           // native register number
                     },
                     NULL,
+                    NULL,
                     NULL
                 };
 
                 while (response.GetNameColonValue(name, value))
                 {
                     if (name.compare("name") == 0)
                     {
                         reg_name.SetCString(value.c_str());
                     }
                     else if (name.compare("alt-name") == 0)
for (StringExtractorGDBRemote::ResponseType response_type = StringExtractorGDBRemote::eResponse;
                     else if (name.compare("container-regs") == 0)
                     {
                         SplitCommaSeparatedRegisterNumberString(value, value_regs, 16);
                     }
                     else if (name.compare("invalidate-regs") == 0)
                     {
                         SplitCommaSeparatedRegisterNumberString(value, invalidate_regs, 16);
                     }
+                    else if (name.compare("dynamic_size_dwarf_expr_bytes") == 0)
+                    {
+                       dwarf_expr_bytes_len = value.length () / 2;
+                       assert(dwarf_expr_bytes_len > 0);
+                       dwarf_opcode_bytes = new uint8_t[dwarf_expr_bytes_len];
+                       StringExtractor name_extractor;
+                       
+                       if (dwarf_opcode_bytes)
+                       {
+                           // Swap "value" over into "name_extractor"
+                           name_extractor.GetStringRef().swap(value);
+                           uint32_t ret_val = name_extractor.GetHexBytesAvail (dwarf_opcode_bytes, dwarf_expr_bytes_len);
+                           assert (dwarf_expr_bytes_len == ret_val);
+
+                           // Right now the dynamic_size_dwarf_expr_bytes is pointing to a temporary location
+                           // the actual location will be updated in DynamicRegisterInfo class
+                           reg_info.dynamic_size_dwarf_expr_bytes = dwarf_opcode_bytes;
+                       }
+                    }
                 }
 
                 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();
                 }
 
                 // We have to make a temporary ABI here, and not use the GetABI because this code
                 // gets called in DidAttach, when the target architecture (and consequently the ABI we'll get from
                 // the process) may be wrong.
                 ABISP abi_to_use = ABI::FindPlugin(arch_to_use);
 
                 AugmentRegisterInfoViaABI (reg_info, reg_name, abi_to_use);
 
-                m_register_info.AddRegister(reg_info, reg_name, alt_name, set_name);
+                m_register_info.AddRegister(reg_info, reg_name, alt_name, set_name, dwarf_expr_bytes_len);
+
+                // Free the allocated memory
+                if (dwarf_opcode_bytes)
+                    delete[] dwarf_opcode_bytes; 
             }
             else
             {
                 break;  // ensure exit before reg_num is incremented
             }
         }
         else
         {
ParseRegisters (XMLNode feature_node, GdbServerTargetInfo &target_info, GDBRemoteDynamicRegisterInfo &dyn_reg_info, ABISP abi_sp, uint32_t &cur_reg_num, uint32_t &reg_offset)
     feature_node.ForEachChildElementWithName("reg", [&target_info, &dyn_reg_info, &cur_reg_num, &reg_offset, &abi_sp](const XMLNode &reg_node) -> bool {
         std::string gdb_group;
         std::string gdb_type;
         ConstString reg_name;
         ConstString alt_name;
         ConstString set_name;
         std::vector<uint32_t> value_regs;
         std::vector<uint32_t> invalidate_regs;
+        uint8_t *dwarf_opcode_bytes = NULL;
+        uint32_t dwarf_expr_bytes_len;
         bool encoding_set = false;
         bool format_set = false;
         RegisterInfo reg_info = { NULL,                 // Name
             NULL,                 // Alt name
             0,                    // byte size
             reg_offset,           // offset
             eEncodingUint,        // encoding
             eFormatHex,           // format
             {
                 LLDB_INVALID_REGNUM, // eh_frame reg num
                 LLDB_INVALID_REGNUM, // DWARF reg num
                 LLDB_INVALID_REGNUM, // generic reg num
                 cur_reg_num,        // process plugin reg num
                 cur_reg_num         // native register number
             },
             NULL,
+            NULL,
             NULL
         };
 
-        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_expr_bytes_len, &dwarf_opcode_bytes](const llvm::StringRef &name, const llvm::StringRef &value) -> bool {
             if (name == "name")
             {
                 reg_name.SetString(value);
             }
             else if (name == "bitsize")
             {
                 reg_info.byte_size = StringConvert::ToUInt32(value.data(), 0, 0) / CHAR_BIT;
             }
feature_node.ForEachChildElementWithName("reg", [&target_info, &dyn_reg_info, &cur_reg_num, &reg_offset, &abi_sp](const XMLNode &reg_node) -> bool {
             else if (name == "value_regnums")
             {
                 SplitCommaSeparatedRegisterNumberString(value, value_regs, 0);
             }
             else if (name == "invalidate_regnums")
             {
                 SplitCommaSeparatedRegisterNumberString(value, invalidate_regs, 0);
             }
+            else if (name == "dynamic_size_dwarf_expr_bytes")
+            {
+                StringExtractor name_extractor;
+                std::string opcode_string = value.str();
+                dwarf_expr_bytes_len = opcode_string.length() / 2;
+                assert(dwarf_expr_bytes_len > 0);
+                dwarf_opcode_bytes = new uint8_t[dwarf_expr_bytes_len];
+
+                if (dwarf_opcode_bytes)
+                {    
+                    name_extractor.GetStringRef().swap(opcode_string);
+                    uint32_t ret_val = name_extractor.GetHexBytesAvail (dwarf_opcode_bytes, dwarf_expr_bytes_len);
+                    assert(dwarf_expr_bytes_len == ret_val);
+
+                    // Right now the dynamic_size_dwarf_expr_bytes point to temporary location
+                    // the actual location will be updated in DynamicRegisterInfo
+                    reg_info.dynamic_size_dwarf_expr_bytes = dwarf_opcode_bytes;
+                }
+            }
             else
             {
                 printf("unhandled attribute %s = %s\n", name.data(), value.data());
             }
             return true; // Keep iterating through all attributes
         });
 
         if (!gdb_type.empty() && !(encoding_set || format_set))
feature_node.ForEachChildElementWithName("reg", [&target_info, &dyn_reg_info, &cur_reg_num, &reg_offset, &abi_sp](const XMLNode &reg_node) -> bool {
         if (!invalidate_regs.empty())
         {
             invalidate_regs.push_back(LLDB_INVALID_REGNUM);
             reg_info.invalidate_regs = invalidate_regs.data();
         }
 
         ++cur_reg_num;
         AugmentRegisterInfoViaABI (reg_info, reg_name, abi_sp);
-        dyn_reg_info.AddRegister(reg_info, reg_name, alt_name, set_name);
+        dyn_reg_info.AddRegister(reg_info, reg_name, alt_name, set_name, dwarf_expr_bytes_len);
+
+        //Free allocated memory
+        if (dwarf_opcode_bytes)
+            delete[] dwarf_opcode_bytes;
 
         return true; // Keep iterating through all "reg" elements
     });
     return true;
 }
 
 } // namespace {}
 

source/Target/RegisterContext.cpp

 #include "lldb/Core/RegisterValue.h"
 #include "lldb/Core/Scalar.h"
 #include "lldb/Host/Endian.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/Target.h"
-
+#include "lldb/Core/Module.h"
+#include "lldb/Expression/DWARFExpression.h"
+#include "lldb/Core/Value.h"
 using namespace lldb;
 using namespace lldb_private;
 
 RegisterContext::RegisterContext (Thread &thread, uint32_t concrete_frame_idx) :
     m_thread (thread),
     m_concrete_frame_idx (concrete_frame_idx),
     m_stop_id (thread.GetProcess()->GetStopID())
 {
if (reg_name && reg_name[0])
             {
                 return reg_info;
             }
         }
     }
     return nullptr;
 }
 
+uint32_t
+RegisterContext::UpdateDynamicRegisterSize (const lldb_private::ArchSpec &arch,
+                                            RegisterInfo* reg_info,
+                                            size_t opcode_len)
+{
+    ExecutionContext exe_ctx (CalculateThread());
+
+    // In MIPS, the floating point registers size is depends on FR bit of SR register.
+    // if SR.FR  == 1 then all floating point registers are 64 bits.
+    // else they are all 32 bits.
+    
+    int expr_result;
+    uint32_t addr_size =  arch.GetAddressByteSize ();
+    const uint8_t* opcode_ptr = reg_info->dynamic_size_dwarf_expr_bytes;
+
+    DataExtractor dwarf_data (opcode_ptr, opcode_len, 
+                              arch.GetByteOrder (), addr_size);
+    ModuleSP opcode_ctx;
+    DWARFExpression dwarf_expr (opcode_ctx, dwarf_data, nullptr, 0, opcode_len);
+    Value result;
+    Error error;
+    const lldb::offset_t offset = 0;
+    if(dwarf_expr.Evaluate (&exe_ctx, nullptr, nullptr, this, opcode_ctx, dwarf_data, nullptr,
+                            offset, opcode_len, eRegisterKindDWARF, nullptr, nullptr, result, &error))
+    {
+        expr_result = result.GetScalar().SInt(-1);
+        switch (expr_result)
+        {
+            case 0: return 4;
+            case 1: return 8;
+            default: return reg_info->byte_size;
+        }
+    }
+    else
+    {
+        printf("Error executing DwarfExpression::Evaluate %s\n", error.AsCString());
+        return reg_info->byte_size;
+    }
+}
+
 const RegisterInfo *
 RegisterContext::GetRegisterInfo (lldb::RegisterKind kind, uint32_t num)
 {
     const uint32_t reg_num = ConvertRegisterKindToRegisterNumber(kind, num);
     if (reg_num == LLDB_INVALID_REGNUM)
         return nullptr;
     return GetRegisterInfoAtIndex (reg_num);
 }