[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

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

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

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

source/Plugins/Process/Utility/DynamicRegisterInfo.cpp

295–297

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

956–1000

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

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

557

remove

642–645

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

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

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

98

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

98

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

[labath]

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

98

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

300–301

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

96–107

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

99

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

if (reg_info && reg_info->dynamic_size_dwarf_len)

956–996

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

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?

656

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.

4381

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

4488–4491

Don't need this key, remove this code.

4501

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 ↗

(On Diff #64693)

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

include/lldb/Host/common/NativeRegisterContextRegisterInfo.h

40–42 ↗

(On Diff #64693)

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

include/lldb/Target/RegisterContext.h

53 ↗

(On Diff #64693)

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 ↗

(On Diff #64693)

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

source/Host/common/NativeRegisterContextRegisterInfo.cpp

52–58 ↗

(On Diff #64693)

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

source/Plugins/Process/Utility/DynamicRegisterInfo.cpp

319

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

322

set the opcode length to zero here.

401–405

remove.

407

remove dwarf_expr_bytes_len.

source/Plugins/Process/Utility/DynamicRegisterInfo.h

43 ↗

(On Diff #64693)

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 ↗

(On Diff #64693)

remove

source/Plugins/Process/Utility/RegisterContextLinux_mips.cpp

72–84 ↗

(On Diff #64693)

remove

source/Plugins/Process/Utility/RegisterContextLinux_mips.h

34–35 ↗

(On Diff #64693)

remove

source/Plugins/Process/Utility/RegisterContextLinux_mips64.cpp

124–136 ↗

(On Diff #64693)

remove

source/Plugins/Process/Utility/RegisterContextLinux_mips64.h

36–38 ↗

(On Diff #64693)

remove

source/Plugins/Process/Utility/RegisterInfoInterface.h

51–56 ↗

(On Diff #64693)

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/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.
+        uint8_t dynamic_size;      // if this value is 1 then size of this register is decided at run time. 
+                                   // Default value is 0
     };
 
     //----------------------------------------------------------------------
     // Registers are grouped into register sets
     //----------------------------------------------------------------------
     struct RegisterSet
     {
         const char *name;           // Name of this register set

source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.h

namespace process_linux {
     public:
         NativeRegisterContextLinux_mips64 (const ArchSpec& target_arch,
                                            NativeThreadProtocol &native_thread, 
                                            uint32_t concrete_frame_idx);
 
         uint32_t
         GetRegisterSetCount () const override;
 
+        const RegisterInfo *
+        GetRegisterInfoAtIndex (uint32_t reg_index) const override;
+
         lldb::addr_t
         GetPCfromBreakpointLocation (lldb::addr_t fail_value = LLDB_INVALID_ADDRESS) override;
 
         lldb::addr_t
         GetWatchpointHitAddress (uint32_t wp_index) override;
 
         const RegisterSet *
         GetRegisterSet (uint32_t set_index) const override;
protected:
         DoReadWatchPointRegisterValue(lldb::tid_t tid, void* watch_readback);
 
         Error
         DoWriteWatchPointRegisterValue(lldb::tid_t tid, void* watch_readback);
 
         bool
         IsFR0();
 
+        void
+        IsFR1_FRE (bool &fr1, bool &fre) const;
+
         bool
         IsFRE();
 
         bool
         IsFPR(uint32_t reg_index) const;
 
         bool
         IsMSA(uint32_t reg_index) const;

source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.cpp

 }
 
 uint32_t
 NativeRegisterContextLinux_mips64::GetRegisterSetCount () const
 {
     return k_num_register_sets;
 }
 
+
+const RegisterInfo *
+NativeRegisterContextLinux_mips64::GetRegisterInfoAtIndex (uint32_t reg_index) const
+{
+    if (reg_index <= GetRegisterCount ())
+    {
+         const RegisterInfoInterface& reg_info_interface = GetRegisterInfoInterface ();
+         RegisterInfo* reg_info = const_cast<RegisterInfo *>(reg_info_interface.GetRegisterInfo ()) + reg_index;
+
+         if (reg_info->dynamic_size)
+         {
+            bool fre;
+            bool fr1;
+            IsFR1_FRE (fr1, fre);
+
+            // fr1  fre fpu_reg_size
+            // 1    0   64
+            // 1    1   32
+            // 0    0   32
+            reg_info->byte_size = (fr1 ^ fre) ? 8 : 4;
+         }
+         return const_cast<const RegisterInfo *>(reg_info); 
+    }
+    return nullptr;
+}
+
 lldb::addr_t
 NativeRegisterContextLinux_mips64::GetPCfromBreakpointLocation (lldb::addr_t fail_value)
 {
     Error error;
     RegisterValue pc_value;
     lldb::addr_t pc = fail_value;
     Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));
     
NativeRegisterContextLinux_mips64::IsFR0()
     RegisterValue reg_value;
     ReadRegister (reg_info_p, reg_value);
 
     uint64_t value = reg_value.GetAsUInt64();
 
     return (!(value & SR_FR));
 }
 
+void
+NativeRegisterContextLinux_mips64::IsFR1_FRE (bool& fr1, bool& fre) const
+{
+    GPR_linux_mips regs;
+    RegisterValue reg_value;
+    const RegisterInfoInterface& reg_info_interface = GetRegisterInfoInterface ();
+    const RegisterInfo*  reg_info_sr = reg_info_interface.GetRegisterInfo () + gpr_sr_mips64 ;
+    const RegisterInfo*  reg_info_config5 = reg_info_interface.GetRegisterInfo () + gpr_config5_mips;
+    lldb_private::ArchSpec arch;
+    ::memset (&regs, 0, sizeof(GPR_linux_mips));
+
+    fre = 0;
+    if (!(m_thread.GetProcess ()->GetArchitecture (arch)))
+       assert (false && "Failed to get Architecture.");
+
+    errno = 0;
+
+    // Reading SR/Config5 using PTRACE_PEEKUSER is not supported. So read entire register set
+    Error error = NativeProcessLinux::PtraceWrapper (PTRACE_GETREGS, m_thread.GetID(), NULL, &regs, sizeof regs);
+    if (!error.Success())
+        assert (false && "Unable to Read Register");
+
+    void* target_address = ((uint8_t*)&regs) + reg_info_sr->byte_offset + 4 * (arch.GetMachine () == llvm::Triple::mips);
+    reg_value.SetBytes (target_address, 4, arch.GetByteOrder());
+    fr1 = reg_value.GetAsUInt32() & SR_FR;
+
+    // FRE is valid only when FR bit is set
+    if (fr1) 
+    {
+        target_address = ((uint8_t*)&regs) + reg_info_config5->byte_offset + 
+                          4 * (arch.GetMachine () == llvm::Triple::mips);
+        reg_value.SetBytes(target_address, 4, arch.GetByteOrder ());
+        fre = reg_value.GetAsUInt32() & CONFIG5_FRE;
+    }
+}
+
 bool
 NativeRegisterContextLinux_mips64::IsFRE()
 {
     const RegisterInfo *const reg_info_p = GetRegisterInfoAtIndex (gpr_config5_mips64);
 
     RegisterValue reg_value;
     ReadRegister (reg_info_p, reg_value);
 

source/Plugins/Process/Utility/DynamicRegisterInfo.cpp

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;
         
+        uint8_t dynamic_size = 0;
+        reg_info_dict->GetValueForKeyAsInteger("dynamic_size", dynamic_size);
+        reg_info.dynamic_size = dynamic_size;
+
         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();
                 return 0;
             }
         }
         else
         {
             reg_info_dict->GetValueForKeyAsInteger("format", reg_info.format, eFormatHex);
         }
 
         std::string encoding_str;
         if (reg_info_dict->GetValueForKeyAsString("encoding", encoding_str))
             reg_info.encoding = Args::StringToEncoding(encoding_str.c_str(), eEncodingUint);
         else
             reg_info_dict->GetValueForKeyAsInteger("encoding", reg_info.encoding, eEncodingUint);
 
         size_t set = 0;
         if (!reg_info_dict->GetValueForKeyAsInteger<size_t>("set", set, -1) || set >= m_sets.size())
         {
             Clear();
             printf("error: invalid 'set' value in register dictionary, valid values are 0 - %i\n", (int)set);
             reg_info_dict->DumpToStdout();
             return 0;
         }
 
         // Fill in the register numbers
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();
 }
 
 
 void
 DynamicRegisterInfo::AddRegister (RegisterInfo &reg_info,
                                   ConstString &reg_name, 
                                   ConstString &reg_alt_name, 
                                   ConstString &set_name)
 {
     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)
     {

 {
     StreamFile s(stdout, false);
     const size_t num_regs = m_regs.size();
     s.Printf("%p: DynamicRegisterInfo contains %" PRIu64 " registers:\n",
              static_cast<const void*>(this), static_cast<uint64_t>(num_regs));
     for (size_t i=0; i<num_regs; ++i)
     {
         s.Printf("[%3" PRIu64 "] name = %-10s", (uint64_t)i, m_regs[i].name);
-        s.Printf(", size = %2u, offset = %4u, encoding = %u, format = %-10s",
+        s.Printf(", size = %2u, offset = %4u, encoding = %u, format = %-10s, dynamic_size = %u",
                  m_regs[i].byte_size,
                  m_regs[i].byte_offset,
                  m_regs[i].encoding,
-                 FormatManager::GetFormatAsCString (m_regs[i].format));
+                 FormatManager::GetFormatAsCString (m_regs[i].format),
+                 m_regs[i].dynamic_size);
         if (m_regs[i].kinds[eRegisterKindProcessPlugin] != LLDB_INVALID_REGNUM)
             s.Printf(", process plugin = %3u", m_regs[i].kinds[eRegisterKindProcessPlugin]);
         if (m_regs[i].kinds[eRegisterKindDWARF] != LLDB_INVALID_REGNUM)
             s.Printf(", dwarf = %3u", m_regs[i].kinds[eRegisterKindDWARF]);
         if (m_regs[i].kinds[eRegisterKindEHFrame] != LLDB_INVALID_REGNUM)
             s.Printf(", ehframe = %3u", m_regs[i].kinds[eRegisterKindEHFrame]);
         if (m_regs[i].kinds[eRegisterKindGeneric] != LLDB_INVALID_REGNUM)
             s.Printf(", generic = %3u", m_regs[i].kinds[eRegisterKindGeneric]);

source/Plugins/Process/Utility/RegisterInfos_mips.h

 
 // 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 }
 
 #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, 1}
 
 #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 }
 
 #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 }

source/Plugins/Process/Utility/RegisterInfos_mips64.h

 #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 }
 
 #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, 1}
 
 #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 }
 
 #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 }

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)
+    {
+       response.Printf ("dynamic_size:%" PRIu32 ";", 1);
+    }
     return SendPacketNoLock(response.GetData(), response.GetSize());
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_qfThreadInfo (StringExtractorGDBRemote &packet)
 {
     Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
 

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

GDBRemoteDynamicRegisterInfo () :
         DynamicRegisterInfo()
     {
     }
 
     ~GDBRemoteDynamicRegisterInfo() override = default;
 
     void
     HardcodeARMRegisters(bool from_scratch);
+
+    // Detect the register size dynamically.
+    bool
+    UpdateDynamicRegisterSize (ExecutionContext *exe_ctx,
+                               RegisterContext *reg_ctx,
+                               const lldb_private::ArchSpec &arch,
+                               lldb::RegisterKind reg_kind);
 };
 
 class GDBRemoteRegisterContext : public RegisterContext
 {
 public:
     GDBRemoteRegisterContext (ThreadGDBRemote &thread,
                               uint32_t concrete_frame_idx,
                               GDBRemoteDynamicRegisterInfo &reg_info,

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

 #include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Core/DataExtractor.h"
 #include "lldb/Core/RegisterValue.h"
 #include "lldb/Core/Scalar.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/Utils.h"
+#include "lldb/Core/Module.h"
+#include "lldb/Expression/DWARFExpression.h"
+#include "lldb/Core/dwarf.h"
+#include "lldb/Core/Value.h"
 // Project includes
 #include "Utility/StringExtractorGDBRemote.h"
 #include "ProcessGDBRemote.h"
 #include "ProcessGDBRemoteLog.h"
 #include "ThreadGDBRemote.h"
 #include "Utility/ARM_DWARF_Registers.h"
 #include "Utility/ARM_ehframe_Registers.h"
 

 GDBRemoteRegisterContext::GetRegisterCount ()
 {
     return m_reg_info.GetNumRegisters ();
 }
 
 const RegisterInfo *
 GDBRemoteRegisterContext::GetRegisterInfoAtIndex (size_t reg)
 {
-    return m_reg_info.GetRegisterInfoAtIndex (reg);
+    ExecutionContext exe_ctx (CalculateThread());
+    const ArchSpec &arch = m_thread.GetProcess()->GetTarget().GetArchitecture();
+    RegisterInfo* reg_info = const_cast<RegisterInfo *>(m_reg_info.GetRegisterInfoAtIndex (reg));
+    if(reg_info->dynamic_size)
+    {
+        if (! (m_reg_info.UpdateDynamicRegisterSize (&exe_ctx, this, arch, eRegisterKindDWARF)))
+            reg_info->byte_size = 4;
+        else
+            reg_info->byte_size = 8;
+    }
+    return const_cast<const RegisterInfo *>(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);
 }
 
+bool
+GDBRemoteDynamicRegisterInfo::UpdateDynamicRegisterSize (ExecutionContext *exe_ctx,
+                                                         RegisterContext *reg_ctx,
+                                                         const lldb_private::ArchSpec &arch,
+                                                         lldb::RegisterKind reg_kind)
+{
+    lldb_private::ConstString sr_reg_name("sr");
+    lldb_private::RegisterInfo *reg_info = GetRegisterInfo (sr_reg_name);
+    uint8_t sr_reg_num = reg_info->kinds[reg_kind];
+    lldb_private::ConstString config_reg_name("config5");
+    reg_info = GetRegisterInfo (config_reg_name);
+    uint8_t config5_reg_num = reg_info->kinds[reg_kind];
+
+    // In MIPS, the floating point registers size is depends on FR and FRE bit.
+    // if SR.26 ^ config5.8 == 1 then all floating point registers are 64 bits.
+    // else they are all 32 bits. 
+    const uint8_t dwarf_opcode [] = {
+                                        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
+                                    };
+
+
+    uint32_t addr_size =  arch.GetAddressByteSize ();
+    DataExtractor dwarf_data (dwarf_opcode, sizeof(dwarf_opcode), arch.GetByteOrder (),
+                              addr_size);
+    ModuleSP opcode_ctx;
+    DWARFExpression dwarf_expr (opcode_ctx, dwarf_data, nullptr, 0,sizeof(dwarf_opcode));
+    Value result;
+    Error error;
+    const lldb::offset_t offset = 0;
+    if(dwarf_expr.Evaluate (exe_ctx, nullptr, nullptr, reg_ctx, opcode_ctx, dwarf_data, nullptr,
+                            offset, sizeof(dwarf_opcode), reg_kind, nullptr, nullptr, result, &error))
+    {
+        return result.GetScalar().UInt(1);
+    }
+    else
+    {
+        printf("Error executing DwarfExpression::Evaluate %s\n", error.AsCString());
+        return true;
+    }
+}
 
 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)

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;
                 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,
+                    0                    // dynamic_size default value
                 };
 
                 while (response.GetNameColonValue(name, value))
                 {
                     if (name.compare("name") == 0)
                     {
                         reg_name.SetCString(value.c_str());
                     }
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") == 0)
+                    {
+                        reg_info.dynamic_size = 1;
+                    }
                 }
 
                 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.
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;
         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
             {
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
             {
                 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))
         {
             if (gdb_type.find("int") == 0)
             {
                 reg_info.format = eFormatHex;
                 reg_info.encoding = eEncodingUint;
             }
             else if (gdb_type == "data_ptr" || gdb_type == "code_ptr")
             {
                 reg_info.format = eFormatAddressInfo;
                 reg_info.encoding = eEncodingUint;
             }
             else if (gdb_type == "i387_ext" || gdb_type == "float")
             {
                 reg_info.format = eFormatFloat;