[lldb] Fixup code addresses in the Objective-C language runtime

[JDevlieghere]

Summary

Upstream the calls to ABI::FixCodeAddress in the Objective-C language
runtime.

[aprantl]

This is all good of course, but I wonder if we should lift this into the type system and have functions returned a UnstrippedAddress type that you can only turn into an addr_t by calling FixCodeAddress.

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp

2705

Why not sink this into m_runtime.GetClassDescriptorFromISA?

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCClassDescriptorV2.cpp

 //===-- AppleObjCClassDescriptorV2.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 "AppleObjCClassDescriptorV2.h"
 
 #include "lldb/Expression/FunctionCaller.h"
+#include "lldb/Target/ABI.h"
 #include "lldb/Utility/Log.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 bool ClassDescriptorV2::Read_objc_class(
     Process *process, std::unique_ptr<objc_class_t> &objc_class) const {
   objc_class = std::make_unique<objc_class_t>();
bool ClassDescriptorV2::objc_class_t::Read(Process *process,
   m_cache_ptr = extractor.GetAddress_unchecked(&cursor);  // void *cache;
   m_vtable_ptr = extractor.GetAddress_unchecked(&cursor); // IMP *vtable;
   lldb::addr_t data_NEVER_USE =
       extractor.GetAddress_unchecked(&cursor); // uintptr_t data_NEVER_USE;
 
   m_flags = (uint8_t)(data_NEVER_USE & (lldb::addr_t)3);
   m_data_ptr = data_NEVER_USE & GetClassDataMask(process);
 
+  if (ABISP abi_sp = process->GetABI()) {
+    m_isa = abi_sp->FixCodeAddress(m_isa);
+    m_superclass = abi_sp->FixCodeAddress(m_superclass);
+  }
   return true;
 }
 
 bool ClassDescriptorV2::class_rw_t::Read(Process *process, lldb::addr_t addr) {
   size_t ptr_size = process->GetAddressByteSize();
 
   size_t size = sizeof(uint32_t)   // uint32_t flags;
                 + sizeof(uint32_t) // uint32_t version;
bool ClassDescriptorV2::class_rw_t::Read(Process *process, lldb::addr_t addr) {
   DataExtractor extractor(buffer.GetBytes(), size, process->GetByteOrder(),
                           process->GetAddressByteSize());
 
   lldb::offset_t cursor = 0;
 
   m_flags = extractor.GetU32_unchecked(&cursor);
   m_version = extractor.GetU32_unchecked(&cursor);
   m_ro_ptr = extractor.GetAddress_unchecked(&cursor);
+  if (ABISP abi_sp = process->GetABI())
+    m_ro_ptr = abi_sp->FixCodeAddress(m_ro_ptr);
   m_method_list_ptr = extractor.GetAddress_unchecked(&cursor);
   m_properties_ptr = extractor.GetAddress_unchecked(&cursor);
   m_firstSubclass = extractor.GetAddress_unchecked(&cursor);
   m_nextSiblingClass = extractor.GetAddress_unchecked(&cursor);
 
   if (m_ro_ptr & 1) {
     DataBufferHeap buffer(ptr_size, '\0');
     process->ReadMemory(m_ro_ptr ^ 1, buffer.GetBytes(), ptr_size, error);
     if (error.Fail())
       return false;
     cursor = 0;
     DataExtractor extractor(buffer.GetBytes(), ptr_size,
                             process->GetByteOrder(),
                             process->GetAddressByteSize());
     m_ro_ptr = extractor.GetAddress_unchecked(&cursor);
+    if (ABISP abi_sp = process->GetABI())
+      m_ro_ptr = abi_sp->FixCodeAddress(m_ro_ptr);
   }
 
   return true;
 }
 
 bool ClassDescriptorV2::class_ro_t::Read(Process *process, lldb::addr_t addr) {
   size_t ptr_size = process->GetAddressByteSize();
 

 bool ClassDescriptorV2::method_list_t::Read(Process *process,
                                             lldb::addr_t addr) {
   size_t size = sizeof(uint32_t)    // uint32_t entsize_NEVER_USE;
                 + sizeof(uint32_t); // uint32_t count;
 
   DataBufferHeap buffer(size, '\0');
   Status error;
 
+  if (ABISP abi_sp = process->GetABI())
+    addr = abi_sp->FixCodeAddress(addr);
   process->ReadMemory(addr, buffer.GetBytes(), size, error);
   if (error.Fail()) {
     return false;
   }
 
   DataExtractor extractor(buffer.GetBytes(), size, process->GetByteOrder(),
                           process->GetAddressByteSize());
 

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCRuntimeV2.cpp

if (!process)
     return objc_class_sp;
 
   Status error;
   ObjCISA isa = process->ReadPointerFromMemory(isa_pointer, error);
   if (isa == LLDB_INVALID_ADDRESS)
     return objc_class_sp;
 
   objc_class_sp = GetClassDescriptorFromISA(isa);
-  if (isa && !objc_class_sp) {
-    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_TYPES));
-    LLDB_LOGF(log,
-              "0x%" PRIx64 ": AppleObjCRuntimeV2::GetClassDescriptor() ISA was "
-              "not in class descriptor cache 0x%" PRIx64,
-              isa_pointer, isa);
-  }
+  if (!objc_class_sp) {
+    if (ABISP abi_sp = process->GetABI()) {
+      isa = abi_sp->FixCodeAddress(isa);
+      objc_class_sp = GetClassDescriptorFromISA(isa);
+    }
+  }
+
+  if (objc_class_sp)
+    return objc_class_sp;
+
   return objc_class_sp;
 }
 
 lldb::addr_t AppleObjCRuntimeV2::GetTaggedPointerObfuscator() {
   if (m_tagged_pointer_obfuscator != LLDB_INVALID_ADDRESS)
     return m_tagged_pointer_obfuscator;
 
   Process *process = GetProcess();
if (iterator != end) {
     uintptr_t slot_ptr = slot * process->GetAddressByteSize() +
                          m_objc_debug_taggedpointer_classes;
     Status error;
     uintptr_t slot_data = process->ReadPointerFromMemory(slot_ptr, error);
     if (error.Fail() || slot_data == 0 ||
         slot_data == uintptr_t(LLDB_INVALID_ADDRESS))
       return nullptr;
     actual_class_descriptor_sp =
         m_runtime.GetClassDescriptorFromISA((ObjCISA)slot_data);
+    if (!actual_class_descriptor_sp) {
+      if (ABISP abi_sp = process->GetABI()) {
+        ObjCISA fixed_isa = abi_sp->FixCodeAddress((ObjCISA)slot_data);
+        actual_class_descriptor_sp =
+            m_runtime.GetClassDescriptorFromISA(fixed_isa);
+      }
+    }
     if (!actual_class_descriptor_sp)
       return ObjCLanguageRuntime::ClassDescriptorSP();
     m_cache[slot] = actual_class_descriptor_sp;
   }
 
   uint64_t data_payload =
       (((uint64_t)unobfuscated << m_objc_debug_taggedpointer_payload_lshift) >>
        m_objc_debug_taggedpointer_payload_rshift);

lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleThreadPlanStepThroughObjCTrampoline.cpp

 //===-- AppleThreadPlanStepThroughObjCTrampoline.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 "AppleThreadPlanStepThroughObjCTrampoline.h"
 
 #include "AppleObjCTrampolineHandler.h"
 #include "lldb/Expression/DiagnosticManager.h"
 #include "lldb/Expression/FunctionCaller.h"
 #include "lldb/Expression/UtilityFunction.h"
+#include "lldb/Target/ABI.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadPlanRunToAddress.h"
 #include "lldb/Target/ThreadPlanStepOut.h"
 #include "lldb/Utility/Log.h"
 
 #include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h"
bool AppleThreadPlanStepThroughObjCTrampoline::ShouldStop(Event *event_ptr) {
   if (!m_run_to_sp) {
     Value target_addr_value;
     ExecutionContext exc_ctx;
     GetThread().CalculateExecutionContext(exc_ctx);
     m_impl_function->FetchFunctionResults(exc_ctx, m_args_addr,
                                           target_addr_value);
     m_impl_function->DeallocateFunctionResults(exc_ctx, m_args_addr);
     lldb::addr_t target_addr = target_addr_value.GetScalar().ULongLong();
+
+    if (ABISP abi_sp = GetThread().GetProcess()->GetABI()) {
+      target_addr = abi_sp->FixCodeAddress(target_addr);
+    }
     Address target_so_addr;
     target_so_addr.SetOpcodeLoadAddress(target_addr, exc_ctx.GetTargetPtr());
     Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_STEP));
     if (target_addr == 0) {
       LLDB_LOGF(log, "Got target implementation of 0x0, stopping.");
       SetPlanComplete();
       return true;
     }