[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 ↗

(On Diff #382777)

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/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;
     }

lldb/source/Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.cpp

 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/TypeList.h"
 #include "lldb/Symbol/Variable.h"
 #include "lldb/Target/Target.h"
+#include "lldb/Target/ABI.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Timer.h"
 
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/DJB.h"
 
 using namespace lldb;
 using namespace lldb_private;
ObjCLanguageRuntime::GetNonKVOClassDescriptor(ValueObject &valobj) {
   }
   return ClassDescriptorSP();
 }
 
 ObjCLanguageRuntime::ClassDescriptorSP
 ObjCLanguageRuntime::GetClassDescriptorFromISA(ObjCISA isa) {
   if (isa) {
     UpdateISAToDescriptorMap();
+
     ObjCLanguageRuntime::ISAToDescriptorIterator pos =
         m_isa_to_descriptor.find(isa);
     if (pos != m_isa_to_descriptor.end())
       return pos->second;
+
+    if (ABISP abi_sp = m_process->GetABI()) {
+      pos = m_isa_to_descriptor.find(abi_sp->FixCodeAddress(isa));
+      if (pos != m_isa_to_descriptor.end())
+        return pos->second;
+    }
   }
   return ClassDescriptorSP();
 }
 
 ObjCLanguageRuntime::ClassDescriptorSP
 ObjCLanguageRuntime::GetNonKVOClassDescriptor(ObjCISA isa) {
   if (isa) {
     ClassDescriptorSP objc_class_sp = GetClassDescriptorFromISA(isa);