[LLDB] Send SVE vg register in custom expedited registerset

[omjavaid]

Summary

This patch ovverides GetExpeditedRegisterSet for NativeRegisterContextLinux_arm64 to send vector granule register in expedited register set if SVE mode is selected.

[omjavaid]

This revision updated after rebase.

[omjavaid]

@labath ping!

[omjavaid]

Updated after changes to parent rev D82853

[labath]

This looks good, though it would be nice to add a test for it. It looks like TestGdbRemoteExpeditedRegisters.py has a lot of functionality that could be reused for this purpose.

[omjavaid]

Added test case for vg testing.

[labath]

lldb/test/API/tools/lldb-server/TestGdbRemoteExpeditedRegisters.py

185

"must be available" ?

lldb/packages/Python/lldbsuite/test/tools/lldb-server/gdbremote_testcase.py

     def find_generic_register_with_name(self, reg_infos, generic_name):
         self.assertIsNotNone(reg_infos)
         for reg_info in reg_infos:
             if ("generic" in reg_info) and (
                     reg_info["generic"] == generic_name):
                 return reg_info
         return None
 
+    def find_register_with_name_and_dwarf_regnum(self, reg_infos, name, dwarf_num):
+        self.assertIsNotNone(reg_infos)
+        for reg_info in reg_infos:
+            if (reg_info["name"] == name) and (reg_info["dwarf"] == dwarf_num):
+                return reg_info
+        return None
+
     def decode_gdbremote_binary(self, encoded_bytes):
         decoded_bytes = ""
         i = 0
         while i < len(encoded_bytes):
             if encoded_bytes[i] == "}":
                 # Handle escaped char.
                 self.assertTrue(i + 1 < len(encoded_bytes))
                 decoded_bytes += chr(ord(encoded_bytes[i + 1]) ^ 0x20)

lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux_arm64.h

Status WriteRegister(const RegisterInfo *reg_info,
                        const RegisterValue &reg_value) override;
 
   Status ReadAllRegisterValues(lldb::DataBufferSP &data_sp) override;
 
   Status WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) override;
 
   void InvalidateAllRegisters() override;
 
+  std::vector<uint32_t>
+  GetExpeditedRegisters(ExpeditedRegs expType) const override;
+
   // Hardware breakpoints/watchpoint management functions
 
   uint32_t NumSupportedHardwareBreakpoints() override;
 
   uint32_t SetHardwareBreakpoint(lldb::addr_t addr, size_t size) override;
 
   bool ClearHardwareBreakpoint(uint32_t hw_idx) override;
 

lldb/source/Plugins/Process/Linux/NativeRegisterContextLinux_arm64.cpp

 
 void *NativeRegisterContextLinux_arm64::GetSVEBuffer() {
   if (m_sve_state == SVEState::FPSIMD)
     return m_sve_ptrace_payload.data() + SVE_PT_FPSIMD_OFFSET;
 
   return m_sve_ptrace_payload.data();
 }
 
+std::vector<uint32_t> NativeRegisterContextLinux_arm64::GetExpeditedRegisters(
+    ExpeditedRegs expType) const {
+  std::vector<uint32_t> expedited_reg_nums =
+      NativeRegisterContext::GetExpeditedRegisters(expType);
+  if (m_sve_state == SVEState::FPSIMD || m_sve_state == SVEState::Full)
+    expedited_reg_nums.push_back(GetRegisterInfo().GetRegNumSVEVG());
+
+  return expedited_reg_nums;
+}
+
 #endif // defined (__arm64__) || defined (__aarch64__)

lldb/source/Plugins/Process/Utility/RegisterInfoPOSIX_arm64.h

public:
   bool IsSVEZReg(unsigned reg) const;
   bool IsSVEPReg(unsigned reg) const;
   bool IsSVERegVG(unsigned reg) const;
 
   uint32_t GetRegNumSVEZ0() const;
   uint32_t GetRegNumSVEFFR() const;
   uint32_t GetRegNumFPCR() const;
   uint32_t GetRegNumFPSR() const;
+  uint32_t GetRegNumSVEVG() const;
 
 private:
   typedef std::map<uint32_t, std::vector<lldb_private::RegisterInfo>>
       per_vq_register_infos;
 
   per_vq_register_infos m_per_vq_reg_infos;
 
   uint32_t m_vector_reg_vq = eVectorQuadwordAArch64;
 
   const lldb_private::RegisterInfo *m_register_info_p;
   uint32_t m_register_info_count;
 };
 
 #endif

lldb/source/Plugins/Process/Utility/RegisterInfoPOSIX_arm64.cpp

 
 uint32_t RegisterInfoPOSIX_arm64::GetRegNumSVEZ0() const { return sve_z0; }
 
 uint32_t RegisterInfoPOSIX_arm64::GetRegNumSVEFFR() const { return sve_ffr; }
 
 uint32_t RegisterInfoPOSIX_arm64::GetRegNumFPCR() const { return fpu_fpcr; }
 
 uint32_t RegisterInfoPOSIX_arm64::GetRegNumFPSR() const { return fpu_fpsr; }
+
+uint32_t RegisterInfoPOSIX_arm64::GetRegNumSVEVG() const { return sve_vg; }

lldb/test/API/tools/lldb-server/TestGdbRemoteExpeditedRegisters.py

 import gdbremote_testcase
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestGdbRemoteExpeditedRegisters(
         gdbremote_testcase.GdbRemoteTestCaseBase):
 
     mydir = TestBase.compute_mydir(__file__)
-    @skipIfDarwinEmbedded # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
-
+    # <rdar://problem/34539270> lldb-server tests not updated to work on ios etc yet
+    @skipIfDarwinEmbedded
     def gather_expedited_registers(self):
         # Setup the stub and set the gdb remote command stream.
         procs = self.prep_debug_monitor_and_inferior(inferior_args=["sleep:2"])
         self.test_sequence.add_log_lines([
             # Start up the inferior.
             "read packet: $c#63",
             # Immediately tell it to stop.  We want to see what it reports.
             "read packet: {}".format(chr(3)),
def stop_notification_contains_generic_register(
         reg_info = self.find_generic_register_with_name(
             reg_infos, generic_register_name)
         self.assertIsNotNone(reg_info)
 
         # Ensure the expedited registers contained it.
         self.assertTrue(reg_info["lldb_register_index"] in expedited_registers)
         self.trace("{} reg_info:{}".format(generic_register_name, reg_info))
 
+    def stop_notification_contains_aarch64_vg_register(self):
+        # Generate a stop reply, parse out expedited registers from stop
+        # notification.
+        expedited_registers = self.gather_expedited_registers()
+        self.assertIsNotNone(expedited_registers)
+        self.assertTrue(len(expedited_registers) > 0)
+
+        # Gather target register infos.
+        reg_infos = self.gather_register_infos()
+
+        # Find the vg register.
+        reg_info = self.find_register_with_name_and_dwarf_regnum(
+            reg_infos, 'vg', '46')
+        self.assertIsNotNone(reg_info)
+
+        # Ensure the expedited registers contained it.
+        self.assertTrue(reg_info["lldb_register_index"] in expedited_registers)
+        self.trace("{} reg_info:{}".format('vg', reg_info))
+
     def stop_notification_contains_any_registers(self):
         # Generate a stop reply, parse out expedited registers from stop
         # notification.
         expedited_registers = self.gather_expedited_registers()
         # Verify we have at least one expedited register.
         self.assertTrue(len(expedited_registers) > 0)
 
     @debugserver_test
def test_stop_notification_contains_sp_register_debugserver(self):
         self.stop_notification_contains_sp_register()
 
     @llgs_test
     def test_stop_notification_contains_sp_register_llgs(self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_launch()
         self.stop_notification_contains_sp_register()
+
+    @llgs_test
+    @skipIf(archs=no_match(["aarch64"]))
+    @skipIf(oslist=no_match(['linux']))
+    def test_stop_notification_contains_vg_register_llgs(self):
+        if not self.isAArch64SVE():
+            self.skipTest('SVE registers must be supported.')
+        self.init_llgs_test()
+        self.build()
+        self.set_inferior_startup_launch()
+        self.stop_notification_contains_aarch64_vg_register()