[lldb][Process/FreeBSD] Add support for address masks on aarch64

[andrew]

Summary

Read the mask using ptrace with PT_GETREGSET with NT_ARM_ADDR_MASK
for live processes, or from the NT_ARM_ADDR_MASK note in a core
file.

As NT_ARM_ADDR_MASK is on FreeBSD is the same value as NT_ARM_PAC_MASK
and it contains a structure with the same layout and a superset of the
same data use this when reading a core file.

[emaste]

lldb/source/Plugins/Process/FreeBSD/NativeRegisterContextFreeBSD_arm64.cpp

127

This #define is coming from our headers? We need to provide this constant within LLVM so this will be available on non-FreeBSD hosts.

[emaste]

We need to make sure a test covers this as well, perhaps just enabling lldb/test/API/functionalities/unwind/aarch64_unwind_pac/TestAArch64UnwindPAC.py?

[andrew]

lldb/source/Plugins/Process/FreeBSD/NativeRegisterContextFreeBSD_arm64.cpp

127

My understanding is this file is used on FreeBSD as it's used when debugging a currently running process.

[emaste]

lldb/source/Plugins/Process/FreeBSD/NativeRegisterContextFreeBSD_arm64.cpp

127

Oh yes of course.

[andrew]

In D120485#3343538, @emaste wrote:

We need to make sure a test covers this as well, perhaps just enabling lldb/test/API/functionalities/unwind/aarch64_unwind_pac/TestAArch64UnwindPAC.py?

I have a local change to use the test, however it depends on forcing isAArch64PAuth in lldb/packages/Python/lldbsuite/test/lldbtest.py to return true. We'll need a way to detect which CPU features are supported. On Linux it reads /proc/cpuinfo, however there isn't a similar simple method on FreeBSD.

[labath]

Can you detect it from inside the debugee? You could have it exit with some predefined error code if the feature is not available (and then skip the test based on that)...

[andrew]

It's easy to detect in the debugee as it can check which hardware capabilities are passed to it from the kernel.

Another option could be to have a build tool that prints these capabilities and have the test decide based on it as they are identical on FreeBSD and Linux.

[DavidSpickett]

I did something along these lines for lldb-server memory tagging tests in lldb/test/API/tools/lldb-server/memory-tagging/main.c. In that case you've got 3 points where you we could skip the test, and you could check the auxv but that was overkill for this example.

Does FreeBSD have an equivalent to the auxv feature bits? (we could always sprinkle some #defines around if not).

[andrew]

Add support for the PAC test

[DavidSpickett]

Thanks for enabling the test, great to see support for this outside Linux.

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

817

I was going to suggest deduping this and the Linux function but then I found a problem with the Linux one that needs fixing. https://reviews.llvm.org/D122411#change-cwOvKZ9JBiEU

We could probably move everything within the if thread_sp into a function to reuse it but I can do that after I get the Linux one correct.

lldb/source/Plugins/Process/FreeBSD/NativeRegisterContextFreeBSD_arm64.cpp

104

Remove the extra newline here.

lldb/test/API/functionalities/unwind/aarch64_unwind_pac/TestAArch64UnwindPAC.py

37–38

Might as well delete these lines then. Perhaps a comment before backtrace = "# Between Linux and FreeBSD the last frames differ". (first frames? I get them mixed up sometimes)

40

You could do:

if frame.GetFunctionName().startswith(""___lldb_unnamed_symbol"):

If I understand correctly, on FreeBSD this unamed symbol marks the end of the backtrace basically? If so please comment before the if to say so.

lldb/test/API/functionalities/unwind/aarch64_unwind_pac/main.c

19

Do you have any worry that HWCAP_PACA might not be defined or has it been around long enough at this point to be ok? I don't know what toolchains you usually build with.

For Linux we've sometimes done #ifndef something #define it to what we know the constant should be, but other times we just use it, with mixed results.

22

Add a comment like:

// We expect Linux to check for PAC up front using /proc/cpuinfo.

[andrew]

Cleanup based on feedback

[DavidSpickett]

Looks good to me but final decision for @mgorny .

lldb/test/API/python_api/sbvalue_const_addrof/main.cpp

2 ↗

(On Diff #426993)

Stray change.

[andrew]

Remove a stray change

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

 //===-- ABISysV_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
 //
 //===----------------------------------------------------------------------===//
 

 }
 
 lldb::addr_t ABISysV_arm64::FixAddress(addr_t pc, addr_t mask) {
   lldb::addr_t pac_sign_extension = 0x0080000000000000ULL;
   return (pc & pac_sign_extension) ? pc | mask : pc & (~mask);
 }
 
 // Reads code or data address mask for the current Linux process.
+static lldb::addr_t ReadFreeBSDProcessAddressMask(lldb::ProcessSP process_sp,
+                                                  llvm::StringRef reg_name) {
+  uint64_t address_mask = 0;
+
+  // If Pointer Authentication feature is enabled then FreeBSD exposes
+  // PAC data and code mask register. Try reading relevant register
+  // below and merge it with default address mask calculated above.
+  lldb::ThreadSP thread_sp = process_sp->GetThreadList().GetSelectedThread();
+  if (thread_sp) {
+    lldb::RegisterContextSP reg_ctx_sp = thread_sp->GetRegisterContext();
+    if (reg_ctx_sp) {
+      const RegisterInfo *reg_info =
+          reg_ctx_sp->GetRegisterInfoByName(reg_name, 0);
+      if (reg_info) {
+        lldb::addr_t mask_reg_val = reg_ctx_sp->ReadRegisterAsUnsigned(
+            reg_info->kinds[eRegisterKindLLDB], LLDB_INVALID_ADDRESS);
+        if (mask_reg_val != LLDB_INVALID_ADDRESS)
+          address_mask |= mask_reg_val;
+      }
+    }
+  }
+  return address_mask;
+}
+
+// Reads code or data address mask for the current Linux process.
 static lldb::addr_t ReadLinuxProcessAddressMask(lldb::ProcessSP process_sp,
                                                 llvm::StringRef reg_name) {
   // Linux configures user-space virtual addresses with top byte ignored.
   // We set default value of mask such that top byte is masked out.
   uint64_t address_mask = ~((1ULL << 56) - 1);
   // If Pointer Authentication feature is enabled then Linux exposes
   // PAC data and code mask register. Try reading relevant register
   // below and merge it with default address mask calculated above.

 }
 
 lldb::addr_t ABISysV_arm64::FixCodeAddress(lldb::addr_t pc) {
   if (lldb::ProcessSP process_sp = GetProcessSP()) {
     if (process_sp->GetTarget().GetArchitecture().GetTriple().isOSLinux() &&
         !process_sp->GetCodeAddressMask())
       process_sp->SetCodeAddressMask(
           ReadLinuxProcessAddressMask(process_sp, "code_mask"));
+    else if (process_sp->GetTarget().GetArchitecture().GetTriple().isOSFreeBSD() &&
+        !process_sp->GetCodeAddressMask())
+      process_sp->SetCodeAddressMask(
+          ReadFreeBSDProcessAddressMask(process_sp, "code_mask"));
 
     return FixAddress(pc, process_sp->GetCodeAddressMask());
   }
   return pc;
 }
 
 lldb::addr_t ABISysV_arm64::FixDataAddress(lldb::addr_t pc) {
   if (lldb::ProcessSP process_sp = GetProcessSP()) {
     if (process_sp->GetTarget().GetArchitecture().GetTriple().isOSLinux() &&
         !process_sp->GetDataAddressMask())
       process_sp->SetDataAddressMask(
           ReadLinuxProcessAddressMask(process_sp, "data_mask"));
+    else if (process_sp->GetTarget().GetArchitecture().GetTriple().isOSFreeBSD() &&
+        !process_sp->GetDataAddressMask())
+      process_sp->SetDataAddressMask(
+          ReadFreeBSDProcessAddressMask(process_sp, "data_mask"));
 
     return FixAddress(pc, process_sp->GetDataAddressMask());
   }
   return pc;
 }
 
 void ABISysV_arm64::Initialize() {
   PluginManager::RegisterPlugin(GetPluginNameStatic(),
                                 "SysV ABI for AArch64 targets", CreateInstance);
 }
 
 void ABISysV_arm64::Terminate() {
   PluginManager::UnregisterPlugin(CreateInstance);
 }

lldb/source/Plugins/Process/FreeBSD/NativeRegisterContextFreeBSD_arm64.h

 //===-- 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
 //
 //===----------------------------------------------------------------------===//
 

 namespace process_freebsd {
 
 class NativeProcessFreeBSD;
 
 class NativeRegisterContextFreeBSD_arm64
     : public NativeRegisterContextFreeBSD,
       public NativeRegisterContextDBReg_arm64 {
 public:
-  NativeRegisterContextFreeBSD_arm64(const ArchSpec &target_arch,
-                                     NativeThreadProtocol &native_thread);
+  NativeRegisterContextFreeBSD_arm64(
+      const ArchSpec &target_arch,
+      NativeThreadProtocol &native_thread,
+      std::unique_ptr<RegisterInfoPOSIX_arm64> register_info_up);
 
   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,

 
 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<uint8_t, sizeof(reg)> m_reg_data;
   std::array<uint8_t, sizeof(fpreg)> m_fpreg_data;
+
+  struct arm64_addr_mask {
+    uint64_t data_mask;
+    uint64_t insn_mask;
+  };
+
+  bool m_addr_mask_is_valid;
+  struct arm64_addr_mask m_addr_mask;
+
 #ifdef LLDB_HAS_FREEBSD_WATCHPOINT
   dbreg m_dbreg;
   bool m_read_dbreg;
 #endif
 
   void *GetGPRBuffer() { return &m_reg_data; }
   size_t GetGPRBufferSize() { return sizeof(m_reg_data); }
 
   void *GetFPRBuffer() { return &m_fpreg_data; }
   size_t GetFPRSize() { return sizeof(m_fpreg_data); }
 
+  void *GetAddrMaskBuffer() { return &m_addr_mask; }
+  size_t GetAddrMaskBufferSize() { return sizeof(m_addr_mask); }
+
   bool IsGPR(unsigned reg) const;
   bool IsFPR(unsigned reg) const;
+  bool IsAddrMask(unsigned reg) const;
 
   Status ReadGPR();
   Status WriteGPR();
+  Status ReadAddrMask();
 
   Status ReadFPR();
   Status WriteFPR();
 
   uint32_t CalculateFprOffset(const RegisterInfo *reg_info) const;
+  uint32_t CalculateAddrMaskOffset(const RegisterInfo *reg_info) const;
 
   llvm::Error ReadHardwareDebugInfo() override;
   llvm::Error WriteHardwareDebugRegs(DREGType hwbType) override;
 
   RegisterInfoPOSIX_arm64 &GetRegisterInfo() const;
 };
 
 } // namespace process_freebsd
 } // namespace lldb_private
 
 #endif // #ifndef lldb_NativeRegisterContextFreeBSD_arm64_h
 
 #endif // defined (__aarch64__)

lldb/source/Plugins/Process/FreeBSD/NativeRegisterContextFreeBSD_arm64.cpp

 //===-- 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/FreeBSD/NativeProcessFreeBSD.h"
 #include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
 #include "Plugins/Process/Utility/RegisterInfoPOSIX_arm64.h"
 
 // clang-format off
+#include <sys/elf.h>
 #include <sys/param.h>
 #include <sys/ptrace.h>
 #include <sys/types.h>
+#include <sys/uio.h>
 // clang-format on
 
 #define REG_CONTEXT_SIZE (GetGPRSize() + GetFPRSize())
 
 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);
+  Flags opt_regsets;
+  opt_regsets.Set(RegisterInfoPOSIX_arm64::eRegsetMaskPAuth);
+  auto register_info_up =
+      std::make_unique<RegisterInfoPOSIX_arm64>(target_arch, opt_regsets);
+  return new NativeRegisterContextFreeBSD_arm64(target_arch, native_thread,
+      std::move(register_info_up));
 }
 
 NativeRegisterContextFreeBSD_arm64::NativeRegisterContextFreeBSD_arm64(
-    const ArchSpec &target_arch, NativeThreadProtocol &native_thread)
-    : NativeRegisterContextRegisterInfo(
-          native_thread, new RegisterInfoPOSIX_arm64(target_arch, 0))
+    const ArchSpec &target_arch, NativeThreadProtocol &native_thread,
+    std::unique_ptr<RegisterInfoPOSIX_arm64> register_info_up)
+    : NativeRegisterContextRegisterInfo(native_thread,
+                                        register_info_up.release())
 #ifdef LLDB_HAS_FREEBSD_WATCHPOINT
       ,
       m_read_dbreg(false)
 #endif
 {
   ::memset(&m_hwp_regs, 0, sizeof(m_hwp_regs));
   ::memset(&m_hbp_regs, 0, sizeof(m_hbp_regs));
+  ::memset(&m_addr_mask, 0, sizeof(m_addr_mask));
+
+  m_addr_mask_is_valid = false;
 }
 
 RegisterInfoPOSIX_arm64 &
 NativeRegisterContextFreeBSD_arm64::GetRegisterInfo() const {
   return static_cast<RegisterInfoPOSIX_arm64 &>(*m_register_info_interface_up);
 }
 
 uint32_t NativeRegisterContextFreeBSD_arm64::GetRegisterSetCount() const {

 
 bool NativeRegisterContextFreeBSD_arm64::IsFPR(unsigned reg) const {
   if (GetRegisterInfo().GetRegisterSetFromRegisterIndex(reg) ==
       RegisterInfoPOSIX_arm64::FPRegSet)
     return true;
   return false;
 }
 
+bool NativeRegisterContextFreeBSD_arm64::IsAddrMask(unsigned reg) const {
+  // Reuse the Linux PAuth mask register for now. On FreeBSD it can be
+  // used when PAC isn't available, e.g. with TBI.
+  return GetRegisterInfo().IsPAuthReg(reg);
+}
+
 Status NativeRegisterContextFreeBSD_arm64::ReadGPR() {
   return NativeProcessFreeBSD::PtraceWrapper(
       PT_GETREGS, m_thread.GetID(), m_reg_data.data());
 }
 
 Status NativeRegisterContextFreeBSD_arm64::WriteGPR() {
   return NativeProcessFreeBSD::PtraceWrapper(
       PT_SETREGS, m_thread.GetID(), m_reg_data.data());
 }
 
 Status NativeRegisterContextFreeBSD_arm64::ReadFPR() {
   return NativeProcessFreeBSD::PtraceWrapper(
       PT_GETFPREGS, m_thread.GetID(), m_fpreg_data.data());
 }
 
 Status NativeRegisterContextFreeBSD_arm64::WriteFPR() {
   return NativeProcessFreeBSD::PtraceWrapper(
       PT_SETFPREGS, m_thread.GetID(), m_fpreg_data.data());
 }
 
+Status NativeRegisterContextFreeBSD_arm64::ReadAddrMask() {
+  Status error;
+
+#ifdef NT_ARM_ADDR_MASK
+  if (m_addr_mask_is_valid)
+    return error;
+
+  struct iovec ioVec;
+  ioVec.iov_base = GetAddrMaskBuffer();
+  ioVec.iov_len = GetAddrMaskBufferSize();
+
+  error = NativeProcessFreeBSD::PtraceWrapper(
+      PT_GETREGSET, m_thread.GetID(), &ioVec, NT_ARM_ADDR_MASK);
+
+  if (error.Success())
+    m_addr_mask_is_valid = true;
+#endif
+
+  return error;
+}
+
 uint32_t NativeRegisterContextFreeBSD_arm64::CalculateFprOffset(
     const RegisterInfo *reg_info) const {
   return reg_info->byte_offset - GetGPRSize();
 }
 
+uint32_t NativeRegisterContextFreeBSD_arm64::CalculateAddrMaskOffset(
+    const RegisterInfo *reg_info) const {
+  return reg_info->byte_offset - GetRegisterInfo().GetPAuthOffset();
+}
+
 Status
 NativeRegisterContextFreeBSD_arm64::ReadRegister(const RegisterInfo *reg_info,
                                                  RegisterValue &reg_value) {
   Status error;
 
   if (!reg_info) {
     error.SetErrorString("reg_info NULL");
     return error;
NativeRegisterContextFreeBSD_arm64::ReadRegister(const RegisterInfo *reg_info,
   } else if (IsFPR(reg)) {
     error = ReadFPR();
     if (error.Fail())
       return error;
 
     offset = CalculateFprOffset(reg_info);
     assert(offset < GetFPRSize());
     src = (uint8_t *)GetFPRBuffer() + offset;
+  } else if (IsAddrMask(reg)) {
+    error = ReadAddrMask();
+    if (error.Fail())
+      return error;
+
+    offset = CalculateAddrMaskOffset(reg_info);
+    assert(offset < GetAddrMaskBufferSize());
+    src = (uint8_t *)GetAddrMaskBuffer() + offset;
   } else
     return Status("Failed to read register value");
 
   reg_value.SetFromMemoryData(reg_info, src, reg_info->byte_size,
                               endian::InlHostByteOrder(), error);
   return error;
 }
 

lldb/source/Plugins/Process/elf-core/RegisterUtilities.h

 //===-- RegisterUtilities.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
 //
 //===----------------------------------------------------------------------===//
 
constexpr RegsetDesc FPR_Desc[] = {
     {llvm::Triple::OpenBSD, llvm::Triple::UnknownArch, OPENBSD::NT_FPREGS},
 };
 
 constexpr RegsetDesc AARCH64_SVE_Desc[] = {
     {llvm::Triple::Linux, llvm::Triple::aarch64, llvm::ELF::NT_ARM_SVE},
 };
 
 constexpr RegsetDesc AARCH64_PAC_Desc[] = {
+    {llvm::Triple::FreeBSD, llvm::Triple::aarch64, llvm::ELF::NT_ARM_PAC_MASK},
     {llvm::Triple::Linux, llvm::Triple::aarch64, llvm::ELF::NT_ARM_PAC_MASK},
 };
 
 constexpr RegsetDesc PPC_VMX_Desc[] = {
     {llvm::Triple::FreeBSD, llvm::Triple::UnknownArch, llvm::ELF::NT_PPC_VMX},
     {llvm::Triple::Linux, llvm::Triple::UnknownArch, llvm::ELF::NT_PPC_VMX},
 };
 
 constexpr RegsetDesc PPC_VSX_Desc[] = {
     {llvm::Triple::Linux, llvm::Triple::UnknownArch, llvm::ELF::NT_PPC_VSX},
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_PROCESS_ELF_CORE_REGISTERUTILITIES_H

lldb/test/API/functionalities/unwind/aarch64_unwind_pac/TestAArch64UnwindPAC.py

 """
 Test that we can backtrace correctly when AArch64 PAC is enabled
 """
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
+import re
 
 
 class AArch64UnwindPAC(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
-    @skipIf(archs=no_match(["aarch64"]))
-    @skipIf(oslist=no_match(['linux']))
-    def test(self):
-        """Test that we can backtrace correctly when AArch64 PAC is enabled"""
-        if not self.isAArch64PAuth():
-            self.skipTest('Target must support Pointer Authentication.')
-
+    def common(self, backtrace_tail):
         self.build()
 
         self.line = line_number('main.c', '// Frame func_c')
 
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
-
         lldbutil.run_break_set_by_file_and_line(
             self, "main.c", self.line, num_expected_locations=1)
         self.runCmd("run", RUN_SUCCEEDED)
+        if re.match('Process .* exited with status = 1[^0-9]', self.res.GetOutput()):
+            # No PAC support
+            self.skipTest('Target must support Pointer Authentication.')
+
         self.expect("thread backtrace", STOPPED_DUE_TO_BREAKPOINT,
                     substrs=["stop reason = breakpoint 1."])
 
         target = self.dbg.GetSelectedTarget()
         process = target.GetProcess()
         thread = process.GetThreadAtIndex(0)
 
-        backtrace = ["func_c", "func_b", "func_a", "main", "__libc_start_main", "_start"]
-        self.assertEqual(thread.GetNumFrames(), len(backtrace))
+        backtrace = ["func_c", "func_b", "func_a", "main"] + backtrace_tail
         for frame_idx, frame in enumerate(thread.frames):
             frame = thread.GetFrameAtIndex(frame_idx)
+            # On FreeBSD we get ___lldb_unnamed_symbol symbols at the bottom
+            # of the stack. Ignore these and assume we have walked the entire
+            # stack, however check this assumption is correct.
+            if frame.GetFunctionName().startswith("___lldb_unnamed_symbol"):
+                self.assertEqual(len(backtrace), frame_idx)
+                break
             self.assertTrue(frame)
             self.assertEqual(frame.GetFunctionName(), backtrace[frame_idx])
       # Check line number for functions in main.c
             if (frame_idx < 4):
                 self.assertEqual(frame.GetLineEntry().GetLine(),
                                  line_number("main.c", "Frame " + backtrace[frame_idx]))
+
+    @skipIf(archs=no_match(["aarch64"]))
+    @skipIf(oslist=no_match(['freebsd']))
+    def test_freebsd(self):
+        """Test that we can backtrace correctly when AArch64 PAC is enabled"""
+        self.common(["__start"])
+
+    @skipIf(archs=no_match(["aarch64"]))
+    @skipIf(oslist=no_match(['linux']))
+    def test_linux(self):
+        """Test that we can backtrace correctly when AArch64 PAC is enabled"""
+        if not self.isAArch64PAuth():
+            self.skipTest('Target must support Pointer Authentication.')
+
+        self.common(["__libc_start_main", "_start"])

lldb/test/API/functionalities/unwind/aarch64_unwind_pac/main.c

 // This program makes a multi tier nested function call to test AArch64
 // Pointer Authentication feature.
 
 // To enable PAC return address signing compile with following clang arguments:
 // -march=armv8.3-a -mbranch-protection=pac-ret+leaf
 
+#include <stdbool.h>
 #include <stdlib.h>
 
+#if defined(__FreeBSD__)
+#include <sys/auxv.h>
+
+// Added in FreeBSD 12.2, can be removed when all supported branches define it.
+#if !defined(HWCAP_PACA)
+#define HWCAP_PACA  0x40000000
+#endif
+
+static bool pac_supported(void) {
+  unsigned long hwcap;
+
+  if (elf_aux_info(AT_HWCAP, &hwcap, sizeof(hwcap)) != 0)
+    return false;
+
+  return (hwcap & HWCAP_PACA) != 0;
+}
+#else
+static bool pac_supported(void) {
+  // We expect Linux to check for PAC up front using /proc/cpuinfo.
+  return true;
+}
+#endif
+
 static void __attribute__((noinline)) func_c(void) {
   exit(0); // Frame func_c
 }
 
 static void __attribute__((noinline)) func_b(void) {
   func_c(); // Frame func_b
 }
 
 static void __attribute__((noinline)) func_a(void) {
   func_b(); // Frame func_a
 }
 
 int main(int argc, char *argv[]) {
+  if (!pac_supported())
+    return 1;
+
   func_a(); // Frame main
   return 0;
 }