[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

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

 
 #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) {
+  if (lldb::ProcessSP process_sp = GetProcessSP())
+    return FixAddress(pc, process_sp->GetCodeAddressMask());
+  return pc;
+}
+
+lldb::addr_t ABIAArch64::FixDataAddress(lldb::addr_t pc) {
+  if (lldb::ProcessSP process_sp = GetProcessSP())
+    return FixAddress(pc, process_sp->GetDataAddressMask());
+  return pc;
+}
+
 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

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) {
+  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

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) {
+  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

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();
+        if (ProcessSP process_sp = m_thread.GetProcess()) {
+          if (ABISP abi = process_sp->GetABI())
+            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();
+          if (ProcessSP process_sp = m_thread.GetProcess()) {
+            if (ABISP abi = process_sp->GetABI())
+              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) {
+      if (ProcessSP process_sp = m_thread.GetProcess()) {
+        if (ABISP abi = process_sp->GetABI())
+          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) {
+      addr_t reg_value = value.GetAsUInt64(LLDB_INVALID_ADDRESS);
+      if (reg_value != LLDB_INVALID_ADDRESS) {
+        if(ProcessSP process_sp = m_thread.GetProcess()) {
+          if (ABISP abi = process_sp->GetABI())
+            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];