[LLDB] Pull AuxVec info into NativeRegisterContextLinux_arm64

[omjavaid]

Summary

This patch builds on D96458 and add ability to pull in Aux Vector HWCAP information into NativeRegisterContextLinux_arm64.

In following up patches we will use this information to decide on whether we need to support certain Arm64 feature registers or not.

[DavidSpickett]

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

104

Do I understand correctly that this will be filled in in a further patch? So right now it's only returning 0 because it's not hooked up yet.
For the sake of clean patches I'd rather it just returned 0, then put the rest of the work in the follow up.

[omjavaid]

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

104

Agreed. We can move implementation details to next inline patch where MTE/PAuth regs are being added.

[omjavaid]

Rebased after updates to parent.

[DavidSpickett]

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

2038

Do we not get this from the protected GetAuxValue on NativeProcessELF?

[omjavaid]

Rebased after changes in parent.

[DavidSpickett]

LGTM

[labath]

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

2038

Indeed. We should not reimplement that here. I don't think there's any reason the NativeProcessELF function can't be public.

[labath]

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

169

This should be a result instead of a by-ref argument.

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

NativeProcessLinux(::pid_t pid, int terminal_fd, NativeDelegate &delegate,
                      const ArchSpec &arch, MainLoop &mainloop,
                      llvm::ArrayRef<::pid_t> tids);
 
   // Returns a list of process threads that we have attached to.
   static llvm::Expected<std::vector<::pid_t>> Attach(::pid_t pid);
 
   static Status SetDefaultPtraceOpts(const lldb::pid_t);
 
+  llvm::Optional<uint64_t> GetAuxValue(enum AuxVector::EntryType type);
+
   void MonitorCallback(lldb::pid_t pid, bool exited, WaitStatus status);
 
   void WaitForNewThread(::pid_t tid);
 
   void MonitorSIGTRAP(const siginfo_t &info, NativeThreadLinux &thread);
 
   void MonitorTrace(NativeThreadLinux &thread);
 

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

if (traceid == m_pt_proces_trace_id) {
     // group.
     LLDB_LOG(log, "traceid maps to process");
     m_pt_traced_thread_group.erase(thread);
   }
   m_processor_trace_monitor.erase(iter);
 
   return error;
 }
+
+llvm::Optional<uint64_t>
+NativeProcessLinux::GetAuxValue(enum AuxVector::EntryType type) {
+  if (m_aux_vector == nullptr) {
+    auto buffer_or_error = GetAuxvData();
+    if (!buffer_or_error)
+      return llvm::None;
+    DataExtractor auxv_data(buffer_or_error.get()->getBufferStart(),
+                            buffer_or_error.get()->getBufferSize(),
+                            GetByteOrder(), GetAddressByteSize());
+    m_aux_vector = std::make_unique<AuxVector>(auxv_data);
+  }
+
+  return m_aux_vector->GetAuxValue(type);
+}

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

private:
   void *GetSVEBuffer();
 
   size_t GetSVEHeaderSize() { return sizeof(m_sve_header); }
 
   size_t GetSVEBufferSize() { return m_sve_ptrace_payload.size(); }
 
   Status ReadHardwareDebugInfo();
 
+  uint32_t QueryAuxvForOptionalRegset();
+
   Status WriteHardwareDebugRegs(int hwbType);
 
   uint32_t CalculateFprOffset(const RegisterInfo *reg_info) const;
 
   RegisterInfoPOSIX_arm64 &GetRegisterInfo() const;
 
   void ConfigureRegisterContext();
 

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

 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/Status.h"
 
 #include "Plugins/Process/Linux/NativeProcessLinux.h"
 #include "Plugins/Process/Linux/Procfs.h"
 #include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
+#include "Plugins/Process/Utility/AuxVector.h"
 #include "Plugins/Process/Utility/RegisterInfoPOSIX_arm64.h"
 
 // System includes - They have to be included after framework includes because
 // they define some macros which collide with variable names in other modules
 #include <sys/socket.h>
 // NT_PRSTATUS and NT_FPREGSET definition
 #include <elf.h>
 
NativeRegisterContextLinux_arm64::NativeRegisterContextLinux_arm64(
   m_sve_state = SVEState::Unknown;
 }
 
 RegisterInfoPOSIX_arm64 &
 NativeRegisterContextLinux_arm64::GetRegisterInfo() const {
   return static_cast<RegisterInfoPOSIX_arm64 &>(*m_register_info_interface_up);
 }
 
+uint32_t NativeRegisterContextLinux_arm64::QueryAuxvForOptionalRegset() {
+  NativeProcessProtocol &process = m_thread.GetProcess();
+  auto buffer_or_error = process.GetAuxvData();
+  if (!buffer_or_error)
+    return 0;
+
+  DataExtractor auxv_data(buffer_or_error.get()->getBufferStart(),
+                          buffer_or_error.get()->getBufferSize(),
+                          process.GetByteOrder(), process.GetAddressByteSize());
+
+  std::unique_ptr<AuxVector> aux_vector =
+      std::make_unique<AuxVector>(auxv_data);
+
+  llvm::Optional<uint64_t> auxv_at_hwcap =
+      aux_vector->GetAuxValue(AuxVector::AUXV_AT_HWCAP);
+
+  return 0;
+}
+
 uint32_t NativeRegisterContextLinux_arm64::GetRegisterSetCount() const {
   return GetRegisterInfo().GetRegisterSetCount();
 }
 
 const RegisterSet *
 NativeRegisterContextLinux_arm64::GetRegisterSet(uint32_t set_index) const {
   return GetRegisterInfo().GetRegisterSet(set_index);
 }
Status NativeRegisterContextLinux_arm64::WriteAllSVE() {
 
   return WriteRegisterSet(&ioVec, GetSVEBufferSize(), NT_ARM_SVE);
 }
 
 void NativeRegisterContextLinux_arm64::ConfigureRegisterContext() {
   // Read SVE configuration data and configure register infos.
   if (!m_sve_header_is_valid && m_sve_state != SVEState::Disabled) {
     Status error = ReadSVEHeader();
-    uint32_t opt_regset = ARM64_REGS_CONFIG_DEFAULT;
     if (m_sve_state == SVEState::Unknown) {
+      uint32_t opt_regset = QueryAuxvForOptionalRegset();
       if (error.Success()) {
         opt_regset |= ARM64_REGS_CONFIG_SVE;
         GetRegisterInfo().ConfigureRegisterInfos(opt_regset);
       } else {
         m_sve_state = SVEState::Disabled;
         GetRegisterInfo().ConfigureRegisterInfos(opt_regset);
         return;
       }