[lldb] Fix up code addresses in RegisterContextUnwind

[JDevlieghere]

Summary

Call into the ABI to fixup code addresses in RegisterContextUnwind. We need this in order to debug on Apple Silicon where libraries like libSystem are arm64e even when the inferior is arm64.

[JDevlieghere]

Check for mask == -1

[jasonmolenda]

This looks good. Jonas, what do you think about having FixDataAddress() methods in the ABI's. We're going to be quickly sprinkling FixCodeAddress calls throughout lldb at places where Linux/Darwin ABI need them, and it'd be nice if we have the FixDataAddress method available (even if they're identical right now) so someone doesn't need to audit all the calls in the future and adjust them as appropriate.

Or we can go with FixCodeAddress and leave this for someone to do when it actually matters -- some people will probably pick the wrong call as we add them, so it's not going to work bug-free when such a system exists. I'm honestly fine with just landing this and leaving that work for when it would actually be exercised.

(the two cases I can think of, where you'd call FixDataAddress, on Darwin might be where we get the vtable pointer, and when a ptrauth qualifier has been added to a type by the user in their program.)

[JDevlieghere]

Implement both FixCodeAddress and FixDataAddress.

[JDevlieghere]

In D100521#2693669, @jasonmolenda wrote:

This looks good. Jonas, what do you think about having FixDataAddress() methods in the ABI's. We're going to be quickly sprinkling FixCodeAddress calls throughout lldb at places where Linux/Darwin ABI need them, and it'd be nice if we have the FixDataAddress method available (even if they're identical right now) so someone doesn't need to audit all the calls in the future and adjust them as appropriate.

Or we can go with FixCodeAddress and leave this for someone to do when it actually matters -- some people will probably pick the wrong call as we add them, so it's not going to work bug-free when such a system exists. I'm honestly fine with just landing this and leaving that work for when it would actually be exercised.

(the two cases I can think of, where you'd call FixDataAddress, on Darwin might be where we get the vtable pointer, and when a ptrauth qualifier has been added to a type by the user in their program.)

Yep, that all makes sense. I added the method and implemented both in terms of FixAddress (which takes a pc and a mask) allowing me to avoid the some of the code duplication.

[JDevlieghere]

Save a line or two

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 {
public:
   // the ABI, and false otherwise. This is used by the generic stack frame
   // unwinding code to help determine when a stack ends.
   virtual bool CallFrameAddressIsValid(lldb::addr_t cfa) = 0;
 
   // Validates a possible PC value and returns true if an opcode can be at
   // "pc".
   virtual bool CodeAddressIsValid(lldb::addr_t pc) = 0;
 
-  virtual lldb::addr_t FixCodeAddress(lldb::addr_t pc) {
-    // Some targets might use bits in a code address to indicate a mode switch.
-    // ARM uses bit zero to signify a code address is thumb, so any ARM ABI
-    // plug-ins would strip those bits.
-    return pc;
-  }
+  /// Some targets might use bits in a code address to indicate a mode switch.
+  /// ARM uses bit zero to signify a code address is thumb, so any ARM ABI
+  /// 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;
 
   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");
   }
 
   /// Utility function to construct a MCRegisterInfo using the ArchSpec triple.
   /// Plugins wishing to customize the construction can construct the
   /// MCRegisterInfo themselves.
   static std::unique_ptr<llvm::MCRegisterInfo>
   MakeMCRegisterInfo(const ArchSpec &arch);
 
   lldb::ProcessWP m_process_wp;
   std::unique_ptr<llvm::MCRegisterInfo> m_mc_register_info_up;
 
+  virtual lldb::addr_t FixCodeAddress(lldb::addr_t pc, lldb::addr_t mask) {
+    return pc;
+  }
+
 private:
   ABI(const ABI &) = delete;
   const ABI &operator=(const ABI &) = delete;
 };
 
 class RegInfoBasedABI : public ABI {
 public:
   void AugmentRegisterInfo(RegisterInfo &info) override;

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;
 
   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"
 
 LLDB_PLUGIN_DEFINE(ABIAArch64)
 
 void ABIAArch64::Initialize() {
   ABISysV_arm64::Initialize();
   ABIMacOSX_arm64::Initialize();
 }
 
 void ABIAArch64::Terminate() {
   ABISysV_arm64::Terminate();
   ABIMacOSX_arm64::Terminate();
 }
 
+lldb::addr_t ABIAArch64::FixCodeAddress(lldb::addr_t pc) {
+  lldb::ProcessSP process_sp = GetProcessSP();
+  if (!process_sp)
+    return pc;
+  return FixAddress(pc, process_sp->GetCodeAddressMask());
+}
+
+lldb::addr_t ABIAArch64::FixDataAddress(lldb::addr_t pc) {
+  lldb::ProcessSP process_sp = GetProcessSP();
+  if (!process_sp)
+    return pc;
+  return FixAddress(pc, process_sp->GetDataAddressMask());
+}
+
 std::pair<uint32_t, uint32_t>
 ABIAArch64::GetEHAndDWARFNums(llvm::StringRef name) {
   if (name == "pc")
     return {LLDB_INVALID_REGNUM, arm64_dwarf::pc};
   if (name == "cpsr")
     return {LLDB_INVALID_REGNUM, arm64_dwarf::cpsr};
   return MCBasedABI::GetEHAndDWARFNums(name);
 }

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

 //===-- ABIMacOSX_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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SOURCE_PLUGINS_ABI_AARCH64_ABIMACOSX_ARM64_H
 #define LLDB_SOURCE_PLUGINS_ABI_AARCH64_ABIMACOSX_ARM64_H
 
 #include "Plugins/ABI/AArch64/ABIAArch64.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/lldb-private.h"
 
 class ABIMacOSX_arm64 : public ABIAArch64 {
 public:
   ~ABIMacOSX_arm64() override = default;
 
   size_t GetRedZoneSize() const override;
public:
   bool CodeAddressIsValid(lldb::addr_t pc) override {
     if (pc & (4ull - 1ull))
       return false; // Not 4 byte aligned
 
     // Anything else if fair game..
     return true;
   }
 
+  lldb::addr_t FixAddress(lldb::addr_t pc, lldb::addr_t mask) override;
+
   // Static Functions
 
   static void Initialize();
 
   static void Terminate();
 
   static lldb::ABISP CreateInstance(lldb::ProcessSP process_sp, const lldb_private::ArchSpec &arch);
 

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

if (LoadValueFromConsecutiveGPRRegisters(
             data)) {
       return_valobj_sp = ValueObjectConstResult::Create(
           &thread, return_compiler_type, ConstString(""), data);
     }
   }
   return return_valobj_sp;
 }
 
+lldb::addr_t ABIMacOSX_arm64::FixAddress(addr_t pc, addr_t mask) {
+  if (mask == (lldb::addr_t)-1)
+    return pc;
+  lldb::addr_t pac_sign_extension = 0x0080000000000000ULL;
+  return (pc & pac_sign_extension) ? pc | mask : pc & (~mask);
+}
+
 void ABIMacOSX_arm64::Initialize() {
   PluginManager::RegisterPlugin(GetPluginNameStatic(), pluginDesc,
                                 CreateInstance);
 }
 
 void ABIMacOSX_arm64::Terminate() {
   PluginManager::UnregisterPlugin(CreateInstance);
 }

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

 //===-- ABISysV_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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SOURCE_PLUGINS_ABI_AARCH64_ABISYSV_ARM64_H
 #define LLDB_SOURCE_PLUGINS_ABI_AARCH64_ABISYSV_ARM64_H
 
 #include "Plugins/ABI/AArch64/ABIAArch64.h"
 #include "lldb/lldb-private.h"
 
 class ABISysV_arm64 : public ABIAArch64 {
 public:
   ~ABISysV_arm64() override = default;
 
   size_t GetRedZoneSize() const override;
 
if (pc & (4ull - 1ull))
       return false; // Not 4 byte aligned
 
     // Anything else if fair game..
     return true;
   }
 
   bool GetPointerReturnRegister(const char *&name) override;
 
+  lldb::addr_t FixAddress(lldb::addr_t pc, lldb::addr_t mask) override;
+
   // Static Functions
 
   static void Initialize();
 
   static void Terminate();
 
   static lldb::ABISP CreateInstance(lldb::ProcessSP process_sp, const lldb_private::ArchSpec &arch);
 

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

if (LoadValueFromConsecutiveGPRRegisters(
             data)) {
       return_valobj_sp = ValueObjectConstResult::Create(
           &thread, return_compiler_type, ConstString(""), data);
     }
   }
   return return_valobj_sp;
 }
 
+lldb::addr_t ABISysV_arm64::FixAddress(addr_t pc, addr_t mask) {
+  if (mask == (lldb::addr_t)-1)
+    return pc;
+  lldb::addr_t pac_sign_extension = 0x0080000000000000ULL;
+  return (pc & pac_sign_extension) ? pc | mask : pc & (~mask);
+}
+
 void ABISysV_arm64::Initialize() {
   PluginManager::RegisterPlugin(GetPluginNameStatic(),
                                 "SysV ABI for AArch64 targets", CreateInstance);
 }
 
 void ABISysV_arm64::Terminate() {
   PluginManager::UnregisterPlugin(CreateInstance);
 }

lldb/source/Target/RegisterContextUnwind.cpp

 //===-- RegisterContextUnwind.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/Target/RegisterContextUnwind.h"
 #include "lldb/Core/Address.h"
 #include "lldb/Core/AddressRange.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Expression/DWARFExpression.h"
 #include "lldb/Symbol/ArmUnwindInfo.h"
 #include "lldb/Symbol/CallFrameInfo.h"
 #include "lldb/Symbol/DWARFCallFrameInfo.h"
void RegisterContextUnwind::InitializeNonZerothFrame() {
 
   const bool allow_section_end = true;
   m_current_pc.SetLoadAddress(pc, &process->GetTarget(), allow_section_end);
 
   // If we don't have a Module for some reason, we're not going to find
   // symbol/function information - just stick in some reasonable defaults and
   // hope we can unwind past this frame.  If we're above a trap handler,
   // we may be at a bogus address because we jumped through a bogus function
-  // pointer and trapped, so don't force the arch default unwind plan in that 
+  // pointer and trapped, so don't force the arch default unwind plan in that
   // case.
   ModuleSP pc_module_sp(m_current_pc.GetModule());
   if ((!m_current_pc.IsValid() || !pc_module_sp) &&
       above_trap_handler == false) {
     UnwindLogMsg("using architectural default unwind method");
 
     // Test the pc value to see if we know it's in an unmapped/non-executable
     // region of memory.
if (regnum.GetAsKind(unwindplan_registerkind) == LLDB_INVALID_REGNUM) {
       return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
     }
     // The architecture default unwind plan marks unknown registers as
     // Undefined so that we don't forward them up the stack when a
     // jitted stack frame may have overwritten them.  But when the
     // arch default unwind plan is used as the Fast Unwind Plan, we
     // need to recognize this & switch over to the Full Unwind Plan
     // to see what unwind rule that (more knoweldgeable, probably)
-    // UnwindPlan has.  If the full UnwindPlan says the register 
+    // UnwindPlan has.  If the full UnwindPlan says the register
     // location is Undefined, then it really is.
     if (active_row->GetRegisterInfo(regnum.GetAsKind(unwindplan_registerkind),
                                     unwindplan_regloc) &&
         !unwindplan_regloc.IsUndefined()) {
       UnwindLogMsg(
           "supplying caller's saved %s (%d)'s location using FastUnwindPlan",
           regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
       have_unwindplan_regloc = true;
if (m_full_unwind_plan_sp) {
 
       // If we're fetching the saved pc and this UnwindPlan defines a
       // ReturnAddress register (e.g. lr on arm), look for the return address
       // register number in the UnwindPlan's row.
       if (pc_regnum.IsValid() && pc_regnum == regnum &&
           m_full_unwind_plan_sp->GetReturnAddressRegister() !=
               LLDB_INVALID_REGNUM) {
         // If this is a trap handler frame, we should have access to
-        // the complete register context when the interrupt/async 
+        // the complete register context when the interrupt/async
         // signal was received, we should fetch the actual saved $pc
         // value instead of the Return Address register.
         // If $pc is not available, fall back to the RA reg.
         UnwindPlan::Row::RegisterLocation scratch;
         if (m_frame_type == eTrapHandlerFrame &&
-            active_row->GetRegisterInfo 
-              (pc_regnum.GetAsKind (unwindplan_registerkind), scratch)) {
+            active_row->GetRegisterInfo(
+                pc_regnum.GetAsKind(unwindplan_registerkind), scratch)) {
           UnwindLogMsg("Providing pc register instead of rewriting to "
                        "RA reg because this is a trap handler and there is "
                        "a location for the saved pc register value.");
         } else {
           return_address_reg.init(
               m_thread, m_full_unwind_plan_sp->GetRegisterKind(),
               m_full_unwind_plan_sp->GetReturnAddressRegister());
           regnum = return_address_reg;
if (SavedLocationForRegister(pc_regnum.GetAsKind(eRegisterKindLLDB),
                                regloc) ==
       UnwindLLDB::RegisterSearchResult::eRegisterFound) {
     const RegisterInfo *reg_info =
         GetRegisterInfoAtIndex(pc_regnum.GetAsKind(eRegisterKindLLDB));
     if (reg_info) {
       RegisterValue reg_value;
       if (ReadRegisterValueFromRegisterLocation(regloc, reg_info, reg_value)) {
         old_caller_pc_value = reg_value.GetAsUInt64();
+        ProcessSP process_sp(m_thread.GetProcess());
+        if (process_sp) {
+          ABI *abi = process_sp->GetABI().get();
+          if (abi)
+            old_caller_pc_value = abi->FixCodeAddress(old_caller_pc_value);
+        }
       }
     }
   }
 
   // This is a tricky wrinkle!  If SavedLocationForRegister() detects a really
   // impossible register location for the full unwind plan, it may call
   // ForceSwitchToFallbackUnwindPlan() which in turn replaces the full
   // unwindplan with the fallback... in short, we're done, we're using the
if (SavedLocationForRegister(pc_regnum.GetAsKind(eRegisterKindLLDB),
         UnwindLLDB::RegisterSearchResult::eRegisterFound) {
       const RegisterInfo *reg_info =
           GetRegisterInfoAtIndex(pc_regnum.GetAsKind(eRegisterKindLLDB));
       if (reg_info) {
         RegisterValue reg_value;
         if (ReadRegisterValueFromRegisterLocation(regloc, reg_info,
                                                   reg_value)) {
           new_caller_pc_value = reg_value.GetAsUInt64();
+          ProcessSP process_sp(m_thread.GetProcess());
+          if (process_sp) {
+            ABI *abi = process_sp->GetABI().get();
+            if (abi)
+              new_caller_pc_value = abi->FixCodeAddress(new_caller_pc_value);
+          }
         }
       }
     }
 
     if (new_caller_pc_value == LLDB_INVALID_ADDRESS) {
       UnwindLogMsg("failed to get a pc value for the caller frame with the "
                    "fallback unwind plan");
       m_fallback_unwind_plan_sp.reset();
bool RegisterContextUnwind::ReadGPRValue(lldb::RegisterKind register_kind,
 
   lldb_private::UnwindLLDB::RegisterLocation regloc;
   if (!m_parent_unwind.SearchForSavedLocationForRegister(
           lldb_regnum, regloc, m_frame_number - 1, pc_register)) {
     return false;
   }
   if (ReadRegisterValueFromRegisterLocation(regloc, reg_info, reg_value)) {
     value = reg_value.GetAsUInt64();
+    if (pc_register) {
+      ProcessSP process_sp(m_thread.GetProcess());
+      if (process_sp) {
+        ABI *abi = process_sp->GetABI().get();
+        if (abi)
+          value = abi->FixCodeAddress(value);
+      }
+    }
     return true;
   }
   return false;
 }
 
 bool RegisterContextUnwind::ReadGPRValue(const RegisterNumber &regnum,
                                          addr_t &value) {
   return ReadGPRValue(regnum.GetRegisterKind(), regnum.GetRegisterNumber(),
bool RegisterContextUnwind::ReadRegister(const RegisterInfo *reg_info,
   }
 
   lldb_private::UnwindLLDB::RegisterLocation regloc;
   // Find out where the NEXT frame saved THIS frame's register contents
   if (!m_parent_unwind.SearchForSavedLocationForRegister(
           lldb_regnum, regloc, m_frame_number - 1, is_pc_regnum))
     return false;
 
-  return ReadRegisterValueFromRegisterLocation(regloc, reg_info, value);
+  bool result = ReadRegisterValueFromRegisterLocation(regloc, reg_info, value);
+  if (result) {
+    if (is_pc_regnum && value.GetType() == RegisterValue::eTypeUInt64) {
+      ProcessSP process_sp(m_thread.GetProcess());
+      addr_t reg_value = value.GetAsUInt64(LLDB_INVALID_ADDRESS);
+      if (process_sp && reg_value != LLDB_INVALID_ADDRESS) {
+        ABI *abi = process_sp->GetABI().get();
+        if (abi)
+          value = abi->FixCodeAddress(reg_value);
+      }
+    }
+  }
+  return result;
 }
 
 bool RegisterContextUnwind::WriteRegister(const RegisterInfo *reg_info,
                                           const RegisterValue &value) {
   if (!IsValid())
     return false;
 
   const uint32_t lldb_regnum = reg_info->kinds[eRegisterKindLLDB];