[lldb] [ABI/AArch64] Add pseudo-regs if missing

[mgorny]

Summary

Create pseudo-registers on the AArch64 target if they are not provided
by the remote server. This is the case for gdbserver. The created
registers are:

• 32-bit wN partials for 64-bit xN registers
• double precision floating-point dN registers (overlapping with vN)
• single precision floating-point sN registers (overlapping with vN)

[mgorny]

(so far with ugly hacks, to get some initial ideas on how to proceed with this)

[mgorny]

@labath, I think the biggest problem here is that DynamicRegisterInfo is defined only inside source tree. I'm not sure if I should continue with a forward declaration like this or aim to move DynamicRegisterInfo into public headers. if the former, should I move it into lldb_private namespace?

[mgorny]

Use public API to determine next regnums.

[labath]

I think we could move the DynamicRegisterInfo class into non-plugin code, but I need to give it more thought.

In the mean time (and maybe before that), I'd like to understand why do you need to mess with the process plugin register numbers in this class. It doesn't seem like a good idea for that class to be assuming anything about how those numbers are allocated and used..

[mgorny]

In D109876#3003630, @labath wrote:

In the mean time (and maybe before that), I'd like to understand why do you need to mess with the process plugin register numbers in this class. It doesn't seem like a good idea for that class to be assuming anything about how those numbers are allocated and used..

For some reason, I have assumed that I need to allocate some unique numbers for the new registers. Thinking about it, I'm going to try if things work if I just put LLDB_INVALID_REGNUM there.

[mgorny]

Ok, I definitely need some 'process plugin' IDs to handle invalidate_regs between pseudo-registers.

[mgorny]

Cover FPU registers.

[mgorny]

Rebase. Clang-format. Eliminate remote regnums entirely.

[mgorny]

Update for DynamicRegisterInfo move.

[labath]

lldb/include/lldb/Target/ABI.h

133–136

Ideally, I would like to subsume the AugmentRegisterInfo functionality into this function, so that one would just call abi->Augment(Dynamic)RegisterInfo(dyn_reg_info) and it would automatically fill it in with all the necessary information. The old AugmentRegisterInfo function could become a private/protected implementation detail.

Would such a thing be possible? Perhaps with some preparatory refactoring patch?

[mgorny]

Update to use the new AugmentRegisterInfo() API.

[mgorny]

Rewrite for std::vector<RemoteRegisterInfo>-based augmentation.

[mgorny]

Rebase.

[mgorny]

Arrays need explicit initialization.

[mgorny]

Remove unused next_regnum_lldb arg.

[mgorny]

Rename the set to 'supplementary registers'.

[labath]

lldb/source/Plugins/ABI/AArch64/ABIAArch64.cpp

81–87

This might be reason enough to make me replace array<uint32_t> with array<Optional<uint32_t> and array<bool> with std::bitset

100–104

It might be worth making a utility function for this as well (or maybe moving the for loop into the existing utility function).

lldb/test/API/functionalities/gdb_remote_client/TestGDBServerTargetXML.py

383

what's up with the [:]? Can we just drop that?

[mgorny]

lldb/source/Plugins/ABI/AArch64/ABIAArch64.cpp

81–87

Makes sense.

100–104

I inlined the for loop and renamed the function to addPartialRegisters().

lldb/test/API/functionalities/gdb_remote_client/TestGDBServerTargetXML.py

383

It was necessary to modify the reg_data variable from higher function instead of declaring a new local variable but I think we can move it to class variable now to make it cleaner.

lldb/include/lldb/Target/ABI.h

 //===-- ABI.h ---------------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_TARGET_ABI_H
 #define LLDB_TARGET_ABI_H
 
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Symbol/UnwindPlan.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/lldb-private.h"
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/MC/MCRegisterInfo.h"
 
 namespace llvm {
 class Type;
 }
 
+// TODO
+class DynamicRegisterInfo;
+
 namespace lldb_private {
 
 class ABI : public PluginInterface {
 public:
   struct CallArgument {
     enum eType {
       HostPointer = 0, /* pointer to host data */
       TargetValue,     /* value is on the target or literal */
public:
   /// plug-ins would strip those bits.
   /// @{
   virtual lldb::addr_t FixCodeAddress(lldb::addr_t pc) { return pc; }
   virtual lldb::addr_t FixDataAddress(lldb::addr_t pc) { return pc; }
   /// @}
 
   llvm::MCRegisterInfo &GetMCRegisterInfo() { return *m_mc_register_info_up; }
 
   virtual void AugmentRegisterInfo(RegisterInfo &info) = 0;
+  // Routine called before DynamicRegisterInfo::Finalize().
+  virtual void PreFinalizeDynamicRegisterInfo(DynamicRegisterInfo &info) {}
 
   virtual bool GetPointerReturnRegister(const char *&name) { return false; }
 
   static lldb::ABISP FindPlugin(lldb::ProcessSP process_sp, const ArchSpec &arch);
 
 protected:
   ABI(lldb::ProcessSP process_sp, std::unique_ptr<llvm::MCRegisterInfo> info_up)
       : m_process_wp(process_sp), m_mc_register_info_up(std::move(info_up)) {
     assert(m_mc_register_info_up && "ABI must have MCRegisterInfo");

lldb/source/Plugins/ABI/AArch64/ABIAArch64.h

 //===-- AArch64.h -----------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SOURCE_PLUGINS_ABI_AARCH64_ABIAARCH64_H
 #define LLDB_SOURCE_PLUGINS_ABI_AARCH64_ABIAARCH64_H
 
 #include "lldb/Target/ABI.h"
 
 class ABIAArch64: public lldb_private::MCBasedABI {
 public:
   static void Initialize();
   static void Terminate();
 
   virtual lldb::addr_t FixCodeAddress(lldb::addr_t pc) override;
   virtual lldb::addr_t FixDataAddress(lldb::addr_t pc) override;
 
 protected:
   virtual lldb::addr_t FixAddress(lldb::addr_t pc, lldb::addr_t mask) {
     return pc;
   }
 
   std::pair<uint32_t, uint32_t>
   GetEHAndDWARFNums(llvm::StringRef name) override;
 
   std::string GetMCName(std::string reg) override;
 
   uint32_t GetGenericNum(llvm::StringRef name) override;
 
   void AugmentRegisterInfo(lldb_private::RegisterInfo &info) override;
+  void PreFinalizeDynamicRegisterInfo(DynamicRegisterInfo &info) override;
 
   using lldb_private::MCBasedABI::MCBasedABI;
 };
 #endif

lldb/source/Plugins/ABI/AArch64/ABIAArch64.cpp

 //===-- AArch66.h ---------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "ABIAArch64.h"
 #include "ABIMacOSX_arm64.h"
 #include "ABISysV_arm64.h"
 #include "Utility/ARM64_DWARF_Registers.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Target/Process.h"
 
+#include "Plugins/Process/Utility/DynamicRegisterInfo.h"
+
 LLDB_PLUGIN_DEFINE(ABIAArch64)
 
 void ABIAArch64::Initialize() {
   ABISysV_arm64::Initialize();
   ABIMacOSX_arm64::Initialize();
 }
 
 void ABIAArch64::Terminate() {
return llvm::StringSwitch<uint32_t>(name)
       .Default(LLDB_INVALID_REGNUM);
 }
 
 void ABIAArch64::AugmentRegisterInfo(lldb_private::RegisterInfo &info) {
   lldb_private::MCBasedABI::AugmentRegisterInfo(info);
 
   // GDB sends x31 as "sp".  Add the "x31" alt_name for convenience.
   if (!strcmp(info.name, "sp") && !info.alt_name)
     info.alt_name = "x31";
 }
+
+static uint32_t tmp_value_regs[32][2];
+
+void ABIAArch64::PreFinalizeDynamicRegisterInfo(DynamicRegisterInfo &info) {
+  uint32_t next_regnum_process = 0;
+  uint32_t next_regnum_lldb = info.GetNumRegisters();
+  for (uint32_t i = 0; i < next_regnum_lldb; i++) {
+    lldb_private::RegisterInfo *reginfo = info.GetRegisterInfoAtIndex(i);
+    assert(reginfo);
+    next_regnum_process = std::max(next_regnum_process, reginfo->kinds[lldb::eRegisterKindProcessPlugin]);
+  }
+  next_regnum_process++;
+
+  lldb_private::ConstString group{"partial registers"};
+
+  // Create wN aliases for xN registers if missing.
+  for (int i = 0; i < 32; i++) {
+    std::string r64_name = llvm::formatv("x{0}", i);
+    std::string r32_name = llvm::formatv("w{0}", i);
+    const lldb_private::RegisterInfo* r64 = info.GetRegisterInfo(r64_name);
+    const lldb_private::RegisterInfo* r32 = info.GetRegisterInfo(r32_name);
+    if (r64 && !r32 && r64->byte_size == 8) {
+      lldb_private::ConstString r32_name_const{r32_name};
+      // TODO
+      tmp_value_regs[i][0] = r64->kinds[lldb::eRegisterKindProcessPlugin];
+      tmp_value_regs[i][1] = LLDB_INVALID_REGNUM;
+
+      struct lldb_private::RegisterInfo new_reg {
+        r32_name_const.AsCString(), nullptr, 4,
+            LLDB_INVALID_INDEX32, r64->encoding, r64->format,
+            {
+                LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM,
+                LLDB_INVALID_REGNUM, next_regnum_process++,
+                next_regnum_lldb++,
+            },
+            tmp_value_regs[i], nullptr,
+            nullptr, 0
+      };
+
+      info.AddRegister(new_reg, group);
+    }
+  }
+}

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

 //===-- ProcessGDBRemote.cpp ----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Host/Config.h"
 
 #include <cerrno>
 #include <cstdlib>
 #if LLDB_ENABLE_POSIX
 #include <netinet/in.h>
 #include <sys/mman.h>
 #include <sys/socket.h>
 #include <unistd.h>
else
     arch_to_use = remote_host_arch;
 
   if (!arch_to_use.IsValid())
     arch_to_use = target_arch;
 
   if (GetGDBServerRegisterInfo(arch_to_use))
     return;
 
+  ABISP abi_sp = ABI::FindPlugin(shared_from_this(), arch_to_use);
   char packet[128];
   uint32_t reg_offset = LLDB_INVALID_INDEX32;
   uint32_t reg_num = 0;
   for (StringExtractorGDBRemote::ResponseType response_type =
            StringExtractorGDBRemote::eResponse;
        response_type == StringExtractorGDBRemote::eResponse; ++reg_num) {
     const int packet_len =
         ::snprintf(packet, sizeof(packet), "qRegisterInfo%x", reg_num);
if (m_gdb_comm.SendPacketAndWaitForResponse(packet, response) ==
           reg_info.invalidate_regs = invalidate_regs.data();
         }
 
         reg_info.name = reg_name.AsCString();
         reg_info.alt_name = alt_name.AsCString();
         // 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.
-        if (ABISP abi_sp = ABI::FindPlugin(shared_from_this(), arch_to_use))
+        if (abi_sp)
           abi_sp->AugmentRegisterInfo(reg_info);
 
         m_register_info_sp->AddRegister(reg_info, set_name);
       } else {
         break; // ensure exit before reg_num is incremented
       }
     } else {
       break;
     }
   }
 
   if (m_register_info_sp->GetNumRegisters() > 0) {
+    if (abi_sp)
+      abi_sp->PreFinalizeDynamicRegisterInfo(*m_register_info_sp);
     m_register_info_sp->Finalize(GetTarget().GetArchitecture());
     return;
   }
 
   // We didn't get anything if the accumulated reg_num is zero.  See if we are
   // debugging ARM and fill with a hard coded register set until we can get an
   // updated debugserver down on the devices. On the other hand, if the
   // accumulated reg_num is positive, see if we can add composite registers to
   // the existing primordial ones.
   bool from_scratch = (m_register_info_sp->GetNumRegisters() == 0);
 
   if (!target_arch.IsValid()) {
     if (arch_to_use.IsValid() &&
         (arch_to_use.GetMachine() == llvm::Triple::arm ||
          arch_to_use.GetMachine() == llvm::Triple::thumb) &&
         arch_to_use.GetTriple().getVendor() == llvm::Triple::Apple)
       m_register_info_sp->HardcodeARMRegisters(from_scratch);
   } else if (target_arch.GetMachine() == llvm::Triple::arm ||
              target_arch.GetMachine() == llvm::Triple::thumb) {
     m_register_info_sp->HardcodeARMRegisters(from_scratch);
   }
 
   // At this point, we can finalize our register info.
+  if (abi_sp)
+    abi_sp->PreFinalizeDynamicRegisterInfo(*m_register_info_sp);
   m_register_info_sp->Finalize(GetTarget().GetArchitecture());
 }
 
 Status ProcessGDBRemote::WillLaunch(lldb_private::Module *module) {
   return WillLaunchOrAttach();
 }
 
 Status ProcessGDBRemote::WillAttachToProcessWithID(lldb::pid_t pid) {
bool ProcessGDBRemote::GetGDBServerRegisterInfo(ArchSpec &arch_to_use) {
 
   // check that we have extended feature read support
   if (!m_gdb_comm.GetQXferFeaturesReadSupported())
     return false;
 
   uint32_t reg_num_remote = 0;
   uint32_t reg_num_local = 0;
   if (GetGDBServerRegisterInfoXMLAndProcess(arch_to_use, "target.xml",
-                                            reg_num_remote, reg_num_local))
+                                            reg_num_remote, reg_num_local)) {
+    ABISP abi_sp = ABI::FindPlugin(shared_from_this(), arch_to_use);
+    if (abi_sp)
+      abi_sp->PreFinalizeDynamicRegisterInfo(*m_register_info_sp);
     this->m_register_info_sp->Finalize(arch_to_use);
+  }
 
   return m_register_info_sp->GetNumRegisters() > 0;
 }
 
 llvm::Expected<LoadedModuleInfoList> ProcessGDBRemote::GetLoadedModuleList() {
   // Make sure LLDB has an XML parser it can use first
   if (!XMLDocument::XMLEnabled())
     return llvm::createStringError(llvm::inconvertibleErrorCode(),

lldb/test/API/functionalities/gdb_remote_client/TestGDBServerTargetXML.py

def test_aarch64_regs(self):
 
             def readRegister(self, regnum):
                 return ""
 
             def readRegisters(self):
                 return "".join(reg_data)
 
             def writeRegisters(self, reg_hex):
                 return "OK"
 
             def haltReason(self):
                 return "T02thread:1ff0d;threads:1ff0d;thread-pcs:000000010001bc00;07:0102030405060708;10:1112131415161718;"
 
         self.server.responder = MyResponder()
 
         target = self.createTarget("basic_eh_frame-aarch64.yaml")
         process = self.connect(target)
def test_aarch64_regs(self):
         self.match("register read fp",
                    ["x29 = 0x3837363534333231"])
         self.match("register read lr",
                    ["x30 = 0x4847464544434241"])
         self.match("register read ra",
                    ["x30 = 0x4847464544434241"])
         self.match("register read flags",
                    ["cpsr = 0x74737271"])
+
+        # test partial registers
+        self.match("register read w0",
+                   ["w0 = 0x04030201"])