diff --git a/lldb/source/Plugins/Platform/FreeBSD/PlatformFreeBSD.cpp b/lldb/source/Plugins/Platform/FreeBSD/PlatformFreeBSD.cpp index f4d44eb7e74566..0c9068e5c42145 100644 --- a/lldb/source/Plugins/Platform/FreeBSD/PlatformFreeBSD.cpp +++ b/lldb/source/Plugins/Platform/FreeBSD/PlatformFreeBSD.cpp @@ -253,9 +253,9 @@ bool PlatformFreeBSD::CanDebugProcess() { bool use_legacy_plugin; switch (host_triple.getArch()) { + case llvm::Triple::aarch64: case llvm::Triple::x86: case llvm::Triple::x86_64: - // FreeBSDRemote plugin supports x86 only at the moment use_legacy_plugin = !!getenv("FREEBSD_LEGACY_PLUGIN"); break; default: diff --git a/lldb/source/Plugins/Process/FreeBSDRemote/CMakeLists.txt b/lldb/source/Plugins/Process/FreeBSDRemote/CMakeLists.txt index 8c1cec52fb15dd..2b192559d059b7 100644 --- a/lldb/source/Plugins/Process/FreeBSDRemote/CMakeLists.txt +++ b/lldb/source/Plugins/Process/FreeBSDRemote/CMakeLists.txt @@ -1,6 +1,7 @@ add_lldb_library(lldbPluginProcessFreeBSDRemote NativeProcessFreeBSD.cpp NativeRegisterContextFreeBSD.cpp + NativeRegisterContextFreeBSD_arm64.cpp NativeRegisterContextFreeBSD_x86_64.cpp NativeThreadFreeBSD.cpp diff --git a/lldb/source/Plugins/Process/FreeBSDRemote/NativeRegisterContextFreeBSD_arm64.cpp b/lldb/source/Plugins/Process/FreeBSDRemote/NativeRegisterContextFreeBSD_arm64.cpp new file mode 100644 index 00000000000000..25e83e98fa2622 --- /dev/null +++ b/lldb/source/Plugins/Process/FreeBSDRemote/NativeRegisterContextFreeBSD_arm64.cpp @@ -0,0 +1,209 @@ +//===-- NativeRegisterContextFreeBSD_arm64.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 +// +//===----------------------------------------------------------------------===// + +#if defined(__aarch64__) + +#include "NativeRegisterContextFreeBSD_arm64.h" + +#include "lldb/Utility/DataBufferHeap.h" +#include "lldb/Utility/RegisterValue.h" +#include "lldb/Utility/Status.h" + +#include "Plugins/Process/FreeBSDRemote/NativeProcessFreeBSD.h" +#include "Plugins/Process/Utility/RegisterInfoPOSIX_arm64.h" + +// clang-format off +#include +#include +#include +// clang-format on + +using namespace lldb; +using namespace lldb_private; +using namespace lldb_private::process_freebsd; + +NativeRegisterContextFreeBSD * +NativeRegisterContextFreeBSD::CreateHostNativeRegisterContextFreeBSD( + const ArchSpec &target_arch, NativeThreadProtocol &native_thread) { + return new NativeRegisterContextFreeBSD_arm64(target_arch, native_thread); +} + +NativeRegisterContextFreeBSD_arm64::NativeRegisterContextFreeBSD_arm64( + const ArchSpec &target_arch, NativeThreadProtocol &native_thread) + : NativeRegisterContextRegisterInfo( + native_thread, new RegisterInfoPOSIX_arm64(target_arch)) { + GetRegisterInfo().ConfigureVectorRegisterInfos( + RegisterInfoPOSIX_arm64::eVectorQuadwordAArch64); +} + +RegisterInfoPOSIX_arm64 & +NativeRegisterContextFreeBSD_arm64::GetRegisterInfo() const { + return static_cast(*m_register_info_interface_up); +} + +uint32_t NativeRegisterContextFreeBSD_arm64::GetRegisterSetCount() const { + return GetRegisterInfo().GetRegisterSetCount(); +} + +const RegisterSet * +NativeRegisterContextFreeBSD_arm64::GetRegisterSet(uint32_t set_index) const { + return GetRegisterInfo().GetRegisterSet(set_index); +} + +uint32_t NativeRegisterContextFreeBSD_arm64::GetUserRegisterCount() const { + uint32_t count = 0; + for (uint32_t set_index = 0; set_index < GetRegisterSetCount(); ++set_index) + count += GetRegisterSet(set_index)->num_registers; + return count; +} + +Status NativeRegisterContextFreeBSD_arm64::ReadRegisterSet(uint32_t set) { + switch (set) { + case RegisterInfoPOSIX_arm64::GPRegSet: + return NativeProcessFreeBSD::PtraceWrapper(PT_GETREGS, m_thread.GetID(), + m_reg_data.data()); + case RegisterInfoPOSIX_arm64::FPRegSet: + return NativeProcessFreeBSD::PtraceWrapper( + PT_GETFPREGS, m_thread.GetID(), + m_reg_data.data() + sizeof(RegisterInfoPOSIX_arm64::GPR)); + case RegisterInfoPOSIX_arm64::SVERegSet: + return Status("not supported"); + } + llvm_unreachable("NativeRegisterContextFreeBSD_arm64::ReadRegisterSet"); +} + +Status NativeRegisterContextFreeBSD_arm64::WriteRegisterSet(uint32_t set) { + switch (set) { + case RegisterInfoPOSIX_arm64::GPRegSet: + return NativeProcessFreeBSD::PtraceWrapper(PT_SETREGS, m_thread.GetID(), + m_reg_data.data()); + case RegisterInfoPOSIX_arm64::FPRegSet: + return NativeProcessFreeBSD::PtraceWrapper( + PT_SETFPREGS, m_thread.GetID(), + m_reg_data.data() + sizeof(RegisterInfoPOSIX_arm64::GPR)); + case RegisterInfoPOSIX_arm64::SVERegSet: + return Status("not supported"); + } + llvm_unreachable("NativeRegisterContextFreeBSD_arm64::WriteRegisterSet"); +} + +Status +NativeRegisterContextFreeBSD_arm64::ReadRegister(const RegisterInfo *reg_info, + RegisterValue ®_value) { + Status error; + + if (!reg_info) { + error.SetErrorString("reg_info NULL"); + return error; + } + + const uint32_t reg = reg_info->kinds[lldb::eRegisterKindLLDB]; + + if (reg == LLDB_INVALID_REGNUM) + return Status("no lldb regnum for %s", reg_info && reg_info->name + ? reg_info->name + : ""); + + uint32_t set = GetRegisterInfo().GetRegisterSetFromRegisterIndex(reg); + error = ReadRegisterSet(set); + if (error.Fail()) + return error; + + assert(reg_info->byte_offset + reg_info->byte_size <= m_reg_data.size()); + reg_value.SetBytes(m_reg_data.data() + reg_info->byte_offset, + reg_info->byte_size, endian::InlHostByteOrder()); + return error; +} + +Status NativeRegisterContextFreeBSD_arm64::WriteRegister( + const RegisterInfo *reg_info, const RegisterValue ®_value) { + Status error; + + if (!reg_info) + return Status("reg_info NULL"); + + const uint32_t reg = reg_info->kinds[lldb::eRegisterKindLLDB]; + + if (reg == LLDB_INVALID_REGNUM) + return Status("no lldb regnum for %s", reg_info && reg_info->name + ? reg_info->name + : ""); + + uint32_t set = GetRegisterInfo().GetRegisterSetFromRegisterIndex(reg); + error = ReadRegisterSet(set); + if (error.Fail()) + return error; + + assert(reg_info->byte_offset + reg_info->byte_size <= m_reg_data.size()); + ::memcpy(m_reg_data.data() + reg_info->byte_offset, reg_value.GetBytes(), + reg_info->byte_size); + + return WriteRegisterSet(set); +} + +Status NativeRegisterContextFreeBSD_arm64::ReadAllRegisterValues( + lldb::DataBufferSP &data_sp) { + Status error; + + error = ReadRegisterSet(RegisterInfoPOSIX_arm64::GPRegSet); + if (error.Fail()) + return error; + + error = ReadRegisterSet(RegisterInfoPOSIX_arm64::FPRegSet); + if (error.Fail()) + return error; + + data_sp.reset(new DataBufferHeap(m_reg_data.size(), 0)); + uint8_t *dst = data_sp->GetBytes(); + ::memcpy(dst, m_reg_data.data(), m_reg_data.size()); + + return error; +} + +Status NativeRegisterContextFreeBSD_arm64::WriteAllRegisterValues( + const lldb::DataBufferSP &data_sp) { + Status error; + + if (!data_sp) { + error.SetErrorStringWithFormat( + "NativeRegisterContextFreeBSD_arm64::%s invalid data_sp provided", + __FUNCTION__); + return error; + } + + if (data_sp->GetByteSize() != m_reg_data.size()) { + error.SetErrorStringWithFormat( + "NativeRegisterContextFreeBSD_arm64::%s data_sp contained mismatched " + "data size, expected %" PRIu64 ", actual %" PRIu64, + __FUNCTION__, m_reg_data.size(), data_sp->GetByteSize()); + return error; + } + + uint8_t *src = data_sp->GetBytes(); + if (src == nullptr) { + error.SetErrorStringWithFormat("NativeRegisterContextFreeBSD_arm64::%s " + "DataBuffer::GetBytes() returned a null " + "pointer", + __FUNCTION__); + return error; + } + ::memcpy(m_reg_data.data(), src, m_reg_data.size()); + + error = WriteRegisterSet(RegisterInfoPOSIX_arm64::GPRegSet); + if (error.Fail()) + return error; + + return WriteRegisterSet(RegisterInfoPOSIX_arm64::FPRegSet); +} + +llvm::Error NativeRegisterContextFreeBSD_arm64::CopyHardwareWatchpointsFrom( + NativeRegisterContextFreeBSD &source) { + return llvm::Error::success(); +} + +#endif // defined (__aarch64__) diff --git a/lldb/source/Plugins/Process/FreeBSDRemote/NativeRegisterContextFreeBSD_arm64.h b/lldb/source/Plugins/Process/FreeBSDRemote/NativeRegisterContextFreeBSD_arm64.h new file mode 100644 index 00000000000000..a3f8f54e4b7d27 --- /dev/null +++ b/lldb/source/Plugins/Process/FreeBSDRemote/NativeRegisterContextFreeBSD_arm64.h @@ -0,0 +1,71 @@ +//===-- NativeRegisterContextFreeBSD_arm64.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 +// +//===----------------------------------------------------------------------===// + +#if defined(__aarch64__) + +#ifndef lldb_NativeRegisterContextFreeBSD_arm64_h +#define lldb_NativeRegisterContextFreeBSD_arm64_h + +// clang-format off +#include +#include +// clang-format on + +#include "Plugins/Process/FreeBSDRemote/NativeRegisterContextFreeBSD.h" +#include "Plugins/Process/Utility/RegisterInfoPOSIX_arm64.h" + +#include + +namespace lldb_private { +namespace process_freebsd { + +class NativeProcessFreeBSD; + +class NativeRegisterContextFreeBSD_arm64 : public NativeRegisterContextFreeBSD { +public: + NativeRegisterContextFreeBSD_arm64(const ArchSpec &target_arch, + NativeThreadProtocol &native_thread); + + uint32_t GetRegisterSetCount() const override; + + uint32_t GetUserRegisterCount() const override; + + const RegisterSet *GetRegisterSet(uint32_t set_index) const override; + + Status ReadRegister(const RegisterInfo *reg_info, + RegisterValue ®_value) override; + + Status WriteRegister(const RegisterInfo *reg_info, + const RegisterValue ®_value) override; + + Status ReadAllRegisterValues(lldb::DataBufferSP &data_sp) override; + + Status WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) override; + + llvm::Error + CopyHardwareWatchpointsFrom(NativeRegisterContextFreeBSD &source) override; + +private: + // Due to alignment, FreeBSD reg/fpreg are a few bytes larger than + // LLDB's GPR/FPU structs. However, all fields have matching offsets + // and sizes, so we do not have to worry about these (and we have + // a unittest to assert that). + std::array m_reg_data; + + Status ReadRegisterSet(uint32_t set); + Status WriteRegisterSet(uint32_t set); + + RegisterInfoPOSIX_arm64 &GetRegisterInfo() const; +}; + +} // namespace process_freebsd +} // namespace lldb_private + +#endif // #ifndef lldb_NativeRegisterContextFreeBSD_arm64_h + +#endif // defined (__aarch64__) diff --git a/lldb/unittests/Process/Utility/RegisterContextFreeBSDTest.cpp b/lldb/unittests/Process/Utility/RegisterContextFreeBSDTest.cpp index fe516d537662f9..083e29d228b554 100644 --- a/lldb/unittests/Process/Utility/RegisterContextFreeBSDTest.cpp +++ b/lldb/unittests/Process/Utility/RegisterContextFreeBSDTest.cpp @@ -17,6 +17,8 @@ #include "Plugins/Process/Utility/lldb-x86-register-enums.h" #include "Plugins/Process/Utility/RegisterContextFreeBSD_i386.h" #include "Plugins/Process/Utility/RegisterContextFreeBSD_x86_64.h" +#include "Plugins/Process/Utility/RegisterInfoPOSIX_arm64.h" +#include "Plugins/Process/Utility/lldb-arm64-register-enums.h" using namespace lldb; using namespace lldb_private; @@ -231,3 +233,92 @@ TEST(RegisterContextFreeBSDTest, i386) { } #endif // defined(__i386__) || defined(__x86_64__) + +#if defined(__aarch64__) + +#define EXPECT_GPR_ARM64(lldb_reg, fbsd_reg) \ + EXPECT_THAT(GetRegParams(reg_ctx, gpr_##lldb_reg##_arm64), \ + ::testing::Pair(offsetof(reg, fbsd_reg), sizeof(reg::fbsd_reg))) +#define EXPECT_FPU_ARM64(lldb_reg, fbsd_reg) \ + EXPECT_THAT(GetRegParams(reg_ctx, fpu_##lldb_reg##_arm64), \ + ::testing::Pair(offsetof(fpreg, fbsd_reg) + base_offset, \ + sizeof(fpreg::fbsd_reg))) + +TEST(RegisterContextFreeBSDTest, arm64) { + ArchSpec arch{"aarch64-unknown-freebsd"}; + RegisterInfoPOSIX_arm64 reg_ctx{arch}; + + EXPECT_GPR_ARM64(x0, x[0]); + EXPECT_GPR_ARM64(x1, x[1]); + EXPECT_GPR_ARM64(x2, x[2]); + EXPECT_GPR_ARM64(x3, x[3]); + EXPECT_GPR_ARM64(x4, x[4]); + EXPECT_GPR_ARM64(x5, x[5]); + EXPECT_GPR_ARM64(x6, x[6]); + EXPECT_GPR_ARM64(x7, x[7]); + EXPECT_GPR_ARM64(x8, x[8]); + EXPECT_GPR_ARM64(x9, x[9]); + EXPECT_GPR_ARM64(x10, x[10]); + EXPECT_GPR_ARM64(x11, x[11]); + EXPECT_GPR_ARM64(x12, x[12]); + EXPECT_GPR_ARM64(x13, x[13]); + EXPECT_GPR_ARM64(x14, x[14]); + EXPECT_GPR_ARM64(x15, x[15]); + EXPECT_GPR_ARM64(x16, x[16]); + EXPECT_GPR_ARM64(x17, x[17]); + EXPECT_GPR_ARM64(x18, x[18]); + EXPECT_GPR_ARM64(x19, x[19]); + EXPECT_GPR_ARM64(x20, x[20]); + EXPECT_GPR_ARM64(x21, x[21]); + EXPECT_GPR_ARM64(x22, x[22]); + EXPECT_GPR_ARM64(x23, x[23]); + EXPECT_GPR_ARM64(x24, x[24]); + EXPECT_GPR_ARM64(x25, x[25]); + EXPECT_GPR_ARM64(x26, x[26]); + EXPECT_GPR_ARM64(x27, x[27]); + EXPECT_GPR_ARM64(x28, x[28]); + EXPECT_GPR_ARM64(fp, x[29]); + EXPECT_GPR_ARM64(lr, lr); + EXPECT_GPR_ARM64(sp, sp); + EXPECT_GPR_ARM64(pc, elr); + EXPECT_GPR_ARM64(cpsr, spsr); + + size_t base_offset = reg_ctx.GetRegisterInfo()[fpu_v0_arm64].byte_offset; + + EXPECT_FPU_ARM64(v0, fp_q[0]); + EXPECT_FPU_ARM64(v1, fp_q[1]); + EXPECT_FPU_ARM64(v2, fp_q[2]); + EXPECT_FPU_ARM64(v3, fp_q[3]); + EXPECT_FPU_ARM64(v4, fp_q[4]); + EXPECT_FPU_ARM64(v5, fp_q[5]); + EXPECT_FPU_ARM64(v6, fp_q[6]); + EXPECT_FPU_ARM64(v7, fp_q[7]); + EXPECT_FPU_ARM64(v8, fp_q[8]); + EXPECT_FPU_ARM64(v9, fp_q[9]); + EXPECT_FPU_ARM64(v10, fp_q[10]); + EXPECT_FPU_ARM64(v11, fp_q[11]); + EXPECT_FPU_ARM64(v12, fp_q[12]); + EXPECT_FPU_ARM64(v13, fp_q[13]); + EXPECT_FPU_ARM64(v14, fp_q[14]); + EXPECT_FPU_ARM64(v15, fp_q[15]); + EXPECT_FPU_ARM64(v16, fp_q[16]); + EXPECT_FPU_ARM64(v17, fp_q[17]); + EXPECT_FPU_ARM64(v18, fp_q[18]); + EXPECT_FPU_ARM64(v19, fp_q[19]); + EXPECT_FPU_ARM64(v20, fp_q[20]); + EXPECT_FPU_ARM64(v21, fp_q[21]); + EXPECT_FPU_ARM64(v22, fp_q[22]); + EXPECT_FPU_ARM64(v23, fp_q[23]); + EXPECT_FPU_ARM64(v24, fp_q[24]); + EXPECT_FPU_ARM64(v25, fp_q[25]); + EXPECT_FPU_ARM64(v26, fp_q[26]); + EXPECT_FPU_ARM64(v27, fp_q[27]); + EXPECT_FPU_ARM64(v28, fp_q[28]); + EXPECT_FPU_ARM64(v29, fp_q[29]); + EXPECT_FPU_ARM64(v30, fp_q[30]); + EXPECT_FPU_ARM64(v31, fp_q[31]); + EXPECT_FPU_ARM64(fpsr, fp_sr); + EXPECT_FPU_ARM64(fpcr, fp_cr); +} + +#endif // defined(__aarch64__)