[lldb] Remove non address bits when looking up memory regions

[DavidSpickett]

Summary

On AArch64 we have various things using the non address bits
of pointers. This means when you lookup their containing region
you won't find it if you don't remove them.

This changes Process GetMemoryRegionInfo to a non virtual method
that uses the current ABI plugin to remove those bits. Then it
calls DoGetMemoryRegionInfo.

That function does the actual work and is virtual to be overriden
by Process implementations.

A test case is added that runs on AArch64 Linux using the top
byte ignore feature.

[DavidSpickett]

One of the main reasons the MTE commands need to handle addresses is to lookup memory regions, this generalises the handling of that. I'm not sure yet if the "GetStuff" in process and "DoGetStuff" in subclasses is viable for all the areas where non address bits are important. If there's a lot of instances maybe we'd go in the direction of handling "smart" address parameters that know what their address bits are but that's more involved.

I need to add a corefile test but I'm pretty sure the ABI plugin approach should work there. (Omair was able to use a core file in https://reviews.llvm.org/D99944)

Also there is the issue that in GetMemoryRegion we don't know if it's a code or data pointer which is relevant for PAC. (though you could apply both masks, assuming the VA size is the same for code and data, seems reasonable)

@jasonmolenda / @vsk You might have something downstream that tackles the same issue. I wonder if we're on the same track.

[omjavaid]

Now that we are stripping away top byte is there any information that may be useful for the remote side and we are removing that on the host side. I am thinking why we should strip top byte on host side rather than making it the responsibility of the remote end?

[DavidSpickett]

In D102757#2781561, @omjavaid wrote:

Now that we are stripping away top byte is there any information that may be useful for the remote side and we are removing that on the host side. I am thinking why we should strip top byte on host side rather than making it the responsibility of the remote end?

I don't think there'd be anything in there the remote needs. Not for qMemoryRegionInfo.

lldb-server will need to remove memory tags somehow anyway (because the tag packet spec says you can send tagged addresses) so we could have it do all of it. My unknown there is "non remote" kinda targets like ELF cores or minidumps, does using the ABI for just those get for those targets get messy.

[DavidSpickett]

One thing that you might think of would be the top bits set for kernel alloations. However if we're using the masks and TBI correctly those will be left intact.

[omjavaid]

In D102757#2781677, @DavidSpickett wrote:

In D102757#2781561, @omjavaid wrote:

Now that we are stripping away top byte is there any information that may be useful for the remote side and we are removing that on the host side. I am thinking why we should strip top byte on host side rather than making it the responsibility of the remote end?

I don't think there'd be anything in there the remote needs. Not for qMemoryRegionInfo.

lldb-server will need to remove memory tags somehow anyway (because the tag packet spec says you can send tagged addresses) so we could have it do all of it. My unknown there is "non remote" kinda targets like ELF cores or minidumps, does using the ABI for just those get for those targets get messy.

This looks ok but keep in mind it has effect on ProcessWinodws and Minidump that we are not currently testing.

[omjavaid]

lldb/source/Target/Process.cpp

5902

Yes this is ok for now as both Data and Code masks are same in case of Linux. If anything changes in future we ll take care of that at that time.

[DavidSpickett]

lldb/source/Target/Process.cpp

5902

Cool. I was also thinking that if they were different you could just apply both masks. Since the virtual address size will be the same for either type of pointer.

I'll remove this comment.

[DavidSpickett]

Remove TODO.

[DavidSpickett]

• Move DoGetMemoryRegionInfo into protected section, GetMemoryRegionInfo is the public part.
• Fix a comment typo.

[DavidSpickett]

Do you think this needs a test with a core file as well?

[omjavaid]

In D102757#2826611, @DavidSpickett wrote:

Do you think this needs a test with a core file as well?

I guess it wont be needed. Included test is fine to check whether we remove non-address bits or not. Rest functionality does not change for elf-core.

[DavidSpickett]

• Rebase onto main
• Add DoGetMemoryRegionInfo for ScriptedProcess

I'm going to build this and the follow up patch on Windows
to get some more coverage.

[DavidSpickett]

Rebase

[DavidSpickett]

Rebase onto latest main.

Remove pointer auth from the test. This means we can run it on current buildbots
more easily. There are other tests that look at pauth specifically, here we just
care that the ABI plugin was queried at all.

[DavidSpickett]

Update comments.

[DavidSpickett]

Change ProcessDebugger to DoGetMemoryRegionInfo also, to reduce confusion.

[thakis]

Looks like this breaks the build on Windows: http://45.33.8.238/win/48210/step_4.txt

Please take a look.

[DavidSpickett]

Looks like this breaks the build on Windows

Should be fixed now.

lldb/include/lldb/Target/Process.h

/// \see Process::Notifications
   ///     LLDB_INVALID_ADDRESS if the resolution failed.
   virtual lldb::addr_t ResolveIndirectFunction(const Address *address,
                                                Status &error);
 
   /// Locate the memory region that contains load_addr.
   ///
   /// If load_addr is within the address space the process has mapped
   /// range_info will be filled in with the start and end of that range as
-  /// well as the permissions for that range and range_info.GetMapped will
+  /// well as the permissions for that range and range_info. GetMapped will
   /// return true.
   ///
   /// If load_addr is outside any mapped region then range_info will have its
   /// start address set to load_addr and the end of the range will indicate
   /// the start of the next mapped range or be set to LLDB_INVALID_ADDRESS if
   /// there are no valid mapped ranges between load_addr and the end of the
   /// process address space.
   ///
-  /// GetMemoryRegionInfo will only return an error if it is unimplemented for
-  /// the current process.
+  /// GetMemoryRegionInfo calls DoGetMemoryRegionInfo. Override that function in
+  /// process subclasses.
   ///
   /// \param[in] load_addr
-  ///     The load address to query the range_info for.
+  ///     The load address to query the range_info for. May include non
+  ///     address bits, these will be removed by the the ABI plugin if there is
+  ///     one.
   ///
   /// \param[out] range_info
   ///     An range_info value containing the details of the range.
   ///
   /// \return
   ///     An error value.
-  virtual Status GetMemoryRegionInfo(lldb::addr_t load_addr,
-                                     MemoryRegionInfo &range_info) {
-    Status error;
-    error.SetErrorString("Process::GetMemoryRegionInfo() not supported");
-    return error;
-  }
+  Status GetMemoryRegionInfo(lldb::addr_t load_addr,
+                             MemoryRegionInfo &range_info);
 
   /// Obtain all the mapped memory regions within this process.
   ///
   /// \param[out] region_list
   ///     A vector to contain MemoryRegionInfo objects for all mapped
   ///     ranges.
   ///
   /// \return
protected:
   ///     will be returned.
   ///
   /// \return
   ///     The number of bytes that were actually read into \a buf.
   ///     Zero is returned in the case of an error.
   virtual size_t DoReadMemory(lldb::addr_t vm_addr, void *buf, size_t size,
                               Status &error) = 0;
 
+  /// DoGetMemoryRegionInfo is called by GetMemoryRegionInfo after it has
+  /// removed non address bits from load_addr. Override this method in
+  /// subclasses of Process.
+  ///
+  /// See GetMemoryRegionInfo for details of the logic.
+  ///
+  /// \param[in] load_addr
+  ///     The load address to query the range_info for. (non address bits
+  ///     removed)
+  ///
+  /// \param[out] range_info
+  ///     An range_info value containing the details of the range.
+  ///
+  /// \return
+  ///     An error value.
+  virtual Status DoGetMemoryRegionInfo(lldb::addr_t load_addr,
+                                       MemoryRegionInfo &range_info) {
+    return Status("Process::DoGetMemoryRegionInfo() not supported");
+  }
+
   lldb::StateType GetPrivateState();
 
   /// The "private" side of resuming a process.  This doesn't alter the state
   /// of m_run_lock, but just causes the process to resume.
   ///
   /// \return
   ///     An Status object describing the success or failure of the resume.
   Status PrivateResume();

lldb/source/Plugins/Process/Windows/Common/ProcessDebugger.h

protected:
 
   Status AttachProcess(lldb::pid_t pid, const ProcessAttachInfo &attach_info,
                        DebugDelegateSP delegate);
 
   Status DestroyProcess(lldb::StateType process_state);
 
   Status HaltProcess(bool &caused_stop);
 
-  Status GetMemoryRegionInfo(lldb::addr_t load_addr,
+  Status DoGetMemoryRegionInfo(lldb::addr_t load_addr,
                                MemoryRegionInfo &range_info);
 
   Status ReadMemory(lldb::addr_t addr, void *buf, size_t size,
                     size_t &bytes_read);
 
   Status WriteMemory(lldb::addr_t addr, const void *buf, size_t size,
                      size_t &bytes_written);
 
   Status AllocateMemory(size_t size, uint32_t permissions, lldb::addr_t &addr);

lldb/source/Plugins/Process/Windows/Common/ProcessDebugger.cpp

if (!::VirtualFreeEx(handle, reinterpret_cast<LPVOID>(vm_addr), 0,
                        MEM_RELEASE)) {
     result.SetError(GetLastError(), eErrorTypeWin32);
     LLDB_LOG(log, "deallocating failed with error: {0}", result);
   }
 
   return result;
 }
 
-Status ProcessDebugger::GetMemoryRegionInfo(lldb::addr_t vm_addr,
+Status ProcessDebugger::DoGetMemoryRegionInfo(lldb::addr_t vm_addr,
                                               MemoryRegionInfo &info) {
   Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_MEMORY);
   Status error;
   llvm::sys::ScopedLock lock(m_mutex);
   info.Clear();
 
   if (!m_session_data) {
     error.SetErrorString(
-        "GetMemoryRegionInfo called with no debugging session.");
+        "DoGetMemoryRegionInfo called with no debugging session.");
     LLDB_LOG(log, "error: {0}", error);
     return error;
   }
   HostProcess process = m_session_data->m_debugger->GetProcess();
   lldb::process_t handle = process.GetNativeProcess().GetSystemHandle();
   if (handle == nullptr || handle == LLDB_INVALID_PROCESS) {
     error.SetErrorString(
-        "GetMemoryRegionInfo called with an invalid target process.");
+        "DoGetMemoryRegionInfo called with an invalid target process.");
     LLDB_LOG(log, "error: {0}", error);
     return error;
   }
 
   LLDB_LOG(log, "getting info for address {0:x}", vm_addr);
 
   void *addr = reinterpret_cast<void *>(vm_addr);
   MEMORY_BASIC_INFORMATION mem_info = {};

lldb/source/Plugins/Process/Windows/Common/ProcessWindows.h

public:
 
   size_t DoReadMemory(lldb::addr_t vm_addr, void *buf, size_t size,
                       Status &error) override;
   size_t DoWriteMemory(lldb::addr_t vm_addr, const void *buf, size_t size,
                        Status &error) override;
   lldb::addr_t DoAllocateMemory(size_t size, uint32_t permissions,
                                 Status &error) override;
   Status DoDeallocateMemory(lldb::addr_t ptr) override;
-  Status GetMemoryRegionInfo(lldb::addr_t vm_addr,
-                             MemoryRegionInfo &info) override;
 
   lldb::addr_t GetImageInfoAddress() override;
 
   DynamicLoaderWindowsDYLD *GetDynamicLoader() override;
 
   // IDebugDelegate overrides.
   void OnExitProcess(uint32_t exit_code) override;
   void OnDebuggerConnected(lldb::addr_t image_base) override;
   ExceptionResult OnDebugException(bool first_chance,
                                    const ExceptionRecord &record) override;
   void OnCreateThread(const HostThread &thread) override;
   void OnExitThread(lldb::tid_t thread_id, uint32_t exit_code) override;
   void OnLoadDll(const ModuleSpec &module_spec,
                  lldb::addr_t module_addr) override;
   void OnUnloadDll(lldb::addr_t module_addr) override;
   void OnDebugString(const std::string &string) override;
   void OnDebuggerError(const Status &error, uint32_t type) override;
 
   Status GetWatchpointSupportInfo(uint32_t &num) override;
   Status GetWatchpointSupportInfo(uint32_t &num, bool &after) override;
   Status EnableWatchpoint(Watchpoint *wp, bool notify = true) override;
   Status DisableWatchpoint(Watchpoint *wp, bool notify = true) override;
 
+protected:
+  Status DoGetMemoryRegionInfo(lldb::addr_t vm_addr,
+                               MemoryRegionInfo &info) override;
+
 private:
   struct WatchpointInfo {
     uint32_t slot_id;
     lldb::addr_t address;
     uint32_t size;
     bool read;
     bool write;
   };
   std::map<lldb::break_id_t, WatchpointInfo> m_watchpoints;
   std::vector<lldb::break_id_t> m_watchpoint_ids;
 };
 } // namespace lldb_private
 
 #endif // liblldb_Plugins_Process_Windows_Common_ProcessWindows_H_

lldb/source/Plugins/Process/Windows/Common/ProcessWindows.cpp

lldb::addr_t ProcessWindows::DoAllocateMemory(size_t size, uint32_t permissions,
   error = ProcessDebugger::AllocateMemory(size, permissions, vm_addr);
   return vm_addr;
 }
 
 Status ProcessWindows::DoDeallocateMemory(lldb::addr_t ptr) {
   return ProcessDebugger::DeallocateMemory(ptr);
 }
 
-Status ProcessWindows::GetMemoryRegionInfo(lldb::addr_t vm_addr,
+Status ProcessWindows::DoGetMemoryRegionInfo(lldb::addr_t vm_addr,
                                              MemoryRegionInfo &info) {
-  return ProcessDebugger::GetMemoryRegionInfo(vm_addr, info);
+  return ProcessDebugger::DoGetMemoryRegionInfo(vm_addr, info);
 }
 
 lldb::addr_t ProcessWindows::GetImageInfoAddress() {
   Target &target = GetTarget();
   ObjectFile *obj_file = target.GetExecutableModule()->GetObjectFile();
   Address addr = obj_file->GetImageInfoAddress(&target);
   if (addr.IsValid())
     return addr.GetLoadAddress(&target);

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

public:
 
   // Process Memory
   size_t ReadMemory(lldb::addr_t addr, void *buf, size_t size,
                     lldb_private::Status &error) override;
 
   size_t DoReadMemory(lldb::addr_t addr, void *buf, size_t size,
                       lldb_private::Status &error) override;
 
-  lldb_private::Status
-  GetMemoryRegionInfo(lldb::addr_t load_addr,
-                      lldb_private::MemoryRegionInfo &region_info) override;
-
   lldb::addr_t GetImageInfoAddress() override;
 
   lldb_private::ArchSpec GetArchitecture();
 
   // Returns AUXV structure found in the core file
   lldb_private::DataExtractor GetAuxvData() override;
 
   bool GetProcessInfo(lldb_private::ProcessInstanceInfo &info) override;
 
 protected:
   void Clear();
 
   bool DoUpdateThreadList(lldb_private::ThreadList &old_thread_list,
                           lldb_private::ThreadList &new_thread_list) override;
 
+  lldb_private::Status
+  DoGetMemoryRegionInfo(lldb::addr_t load_addr,
+                        lldb_private::MemoryRegionInfo &region_info) override;
+
 private:
   struct NT_FILE_Entry {
     lldb::addr_t start;
     lldb::addr_t end;
     lldb::addr_t file_ofs;
     lldb_private::ConstString path;
   };
 

lldb/source/Plugins/Process/elf-core/ProcessElfCore.cpp

 // Process Memory
 size_t ProcessElfCore::ReadMemory(lldb::addr_t addr, void *buf, size_t size,
                                   Status &error) {
   // Don't allow the caching that lldb_private::Process::ReadMemory does since
   // in core files we have it all cached our our core file anyway.
   return DoReadMemory(addr, buf, size, error);
 }
 
-Status ProcessElfCore::GetMemoryRegionInfo(lldb::addr_t load_addr,
+Status ProcessElfCore::DoGetMemoryRegionInfo(lldb::addr_t load_addr,
                                              MemoryRegionInfo &region_info) {
   region_info.Clear();
   const VMRangeToPermissions::Entry *permission_entry =
       m_core_range_infos.FindEntryThatContainsOrFollows(load_addr);
   if (permission_entry) {
     if (permission_entry->Contains(load_addr)) {
       region_info.GetRange().SetRangeBase(permission_entry->GetRangeBase());
       region_info.GetRange().SetRangeEnd(permission_entry->GetRangeEnd());
       const Flags permissions(permission_entry->data);

lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.h

public:
   WriteObjectFile(std::vector<ObjectFile::LoadableData> entries) override;
 
   size_t DoWriteMemory(lldb::addr_t addr, const void *buf, size_t size,
                        Status &error) override;
 
   lldb::addr_t DoAllocateMemory(size_t size, uint32_t permissions,
                                 Status &error) override;
 
-  Status GetMemoryRegionInfo(lldb::addr_t load_addr,
-                             MemoryRegionInfo &region_info) override;
-
   Status DoDeallocateMemory(lldb::addr_t ptr) override;
 
   // Process STDIO
   size_t PutSTDIN(const char *buf, size_t buf_size, Status &error) override;
 
   // Process Breakpoints
   Status EnableBreakpointSite(BreakpointSite *bp_site) override;
 
protected:
   bool HasErased(FlashRange range);
 
   llvm::Expected<std::vector<uint8_t>>
   DoReadMemoryTags(lldb::addr_t addr, size_t len, int32_t type) override;
 
   Status DoWriteMemoryTags(lldb::addr_t addr, size_t len, int32_t type,
                            const std::vector<uint8_t> &tags) override;
 
+  Status DoGetMemoryRegionInfo(lldb::addr_t load_addr,
+                               MemoryRegionInfo &region_info) override;
+
 private:
   // For ProcessGDBRemote only
   std::string m_partial_profile_data;
   std::map<uint64_t, uint32_t> m_thread_id_to_used_usec_map;
   uint64_t m_last_signals_version = 0;
 
   static bool NewThreadNotifyBreakpointHit(void *baton,
                                            StoppointCallbackContext *context,

lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

if (allocated_addr == LLDB_INVALID_ADDRESS)
     error.SetErrorStringWithFormat(
         "unable to allocate %" PRIu64 " bytes of memory with permissions %s",
         (uint64_t)size, GetPermissionsAsCString(permissions));
   else
     error.Clear();
   return allocated_addr;
 }
 
-Status ProcessGDBRemote::GetMemoryRegionInfo(addr_t load_addr,
+Status ProcessGDBRemote::DoGetMemoryRegionInfo(addr_t load_addr,
                                                MemoryRegionInfo &region_info) {
 
   Status error(m_gdb_comm.GetMemoryRegionInfo(load_addr, region_info));
   return error;
 }
 
 Status ProcessGDBRemote::GetWatchpointSupportInfo(uint32_t &num) {
 
   Status error(m_gdb_comm.GetWatchpointSupportInfo(num));

lldb/source/Plugins/Process/mach-core/ProcessMachCore.h

public:
 
   // Process Memory
   size_t ReadMemory(lldb::addr_t addr, void *buf, size_t size,
                     lldb_private::Status &error) override;
 
   size_t DoReadMemory(lldb::addr_t addr, void *buf, size_t size,
                       lldb_private::Status &error) override;
 
-  lldb_private::Status
-  GetMemoryRegionInfo(lldb::addr_t load_addr,
-                      lldb_private::MemoryRegionInfo &region_info) override;
-
   lldb::addr_t GetImageInfoAddress() override;
 
 protected:
   friend class ThreadMachCore;
 
   void Clear();
 
   bool DoUpdateThreadList(lldb_private::ThreadList &old_thread_list,
                           lldb_private::ThreadList &new_thread_list) override;
 
   lldb_private::ObjectFile *GetCoreObjectFile();
 
+  lldb_private::Status
+  DoGetMemoryRegionInfo(lldb::addr_t load_addr,
+                        lldb_private::MemoryRegionInfo &region_info) override;
+
 private:
   bool GetDynamicLoaderAddress(lldb::addr_t addr);
 
   enum CorefilePreference { eUserProcessCorefile, eKernelCorefile };
 
   /// If a core file can be interpreted multiple ways, this establishes
   /// which style wins.
   ///

lldb/source/Plugins/Process/mach-core/ProcessMachCore.cpp

while (bytes_read < size) {
         break;
       }
     }
   }
 
   return bytes_read;
 }
 
-Status ProcessMachCore::GetMemoryRegionInfo(addr_t load_addr,
+Status ProcessMachCore::DoGetMemoryRegionInfo(addr_t load_addr,
                                               MemoryRegionInfo &region_info) {
   region_info.Clear();
   const VMRangeToPermissions::Entry *permission_entry =
       m_core_range_infos.FindEntryThatContainsOrFollows(load_addr);
   if (permission_entry) {
     if (permission_entry->Contains(load_addr)) {
       region_info.GetRange().SetRangeBase(permission_entry->GetRangeBase());
       region_info.GetRange().SetRangeEnd(permission_entry->GetRangeEnd());
       const Flags permissions(permission_entry->data);

lldb/source/Plugins/Process/minidump/ProcessMinidump.h

public:
   size_t ReadMemory(lldb::addr_t addr, void *buf, size_t size,
                     Status &error) override;
 
   size_t DoReadMemory(lldb::addr_t addr, void *buf, size_t size,
                       Status &error) override;
 
   ArchSpec GetArchitecture();
 
-  Status GetMemoryRegionInfo(lldb::addr_t load_addr,
-                             MemoryRegionInfo &range_info) override;
-
   Status GetMemoryRegions(
       lldb_private::MemoryRegionInfos &region_list) override;
 
   bool GetProcessInfo(ProcessInstanceInfo &info) override;
 
   Status WillResume() override {
     Status error;
     error.SetErrorStringWithFormatv(
         "error: {0} does not support resuming processes", GetPluginName());
     return error;
   }
 
   llvm::Optional<MinidumpParser> m_minidump_parser;
 
 protected:
   void Clear();
 
   bool DoUpdateThreadList(ThreadList &old_thread_list,
                           ThreadList &new_thread_list) override;
 
+  Status DoGetMemoryRegionInfo(lldb::addr_t load_addr,
+                               MemoryRegionInfo &range_info) override;
+
   void ReadModuleList();
 
   lldb::ModuleSP GetOrCreateModule(lldb_private::UUID minidump_uuid,
                                    llvm::StringRef name,
                                    lldb_private::ModuleSpec module_spec);
 
   JITLoaderList &GetJITLoaders() override;
 

lldb/source/Plugins/Process/minidump/ProcessMinidump.cpp

modules.ForEach([&](const ModuleSP &module_sp) {
     }
     return true;
   });
   m_memory_regions->insert(m_memory_regions->end(), to_add.begin(),
                            to_add.end());
   llvm::sort(*m_memory_regions);
 }
 
-Status ProcessMinidump::GetMemoryRegionInfo(lldb::addr_t load_addr,
+Status ProcessMinidump::DoGetMemoryRegionInfo(lldb::addr_t load_addr,
                                               MemoryRegionInfo &region) {
   BuildMemoryRegions();
   region = MinidumpParser::GetMemoryRegionInfo(*m_memory_regions, load_addr);
   return Status();
 }
 
 Status ProcessMinidump::GetMemoryRegions(MemoryRegionInfos &region_list) {
   BuildMemoryRegions();
   region_list = *m_memory_regions;

lldb/source/Plugins/Process/scripted/ScriptedProcess.h

public:
 
   bool IsAlive() override;
 
   size_t DoReadMemory(lldb::addr_t addr, void *buf, size_t size,
                       Status &error) override;
 
   ArchSpec GetArchitecture();
 
-  Status GetMemoryRegionInfo(lldb::addr_t load_addr,
-                             MemoryRegionInfo &range_info) override;
-
   Status
   GetMemoryRegions(lldb_private::MemoryRegionInfos &region_list) override;
 
   bool GetProcessInfo(ProcessInstanceInfo &info) override;
 
 protected:
   Status DoStop();
 
   void Clear();
 
   bool DoUpdateThreadList(ThreadList &old_thread_list,
                           ThreadList &new_thread_list) override;
 
+  Status DoGetMemoryRegionInfo(lldb::addr_t load_addr,
+                               MemoryRegionInfo &range_info) override;
+
 private:
   friend class ScriptedThread;
 
   void CheckInterpreterAndScriptObject() const;
   ScriptedProcessInterface &GetInterface() const;
   static bool IsScriptLanguageSupported(lldb::ScriptLanguage language);
 
   // Member variables.

lldb/source/Plugins/Process/scripted/ScriptedProcess.cpp

size_t ScriptedProcess::DoReadMemory(lldb::addr_t addr, void *buf, size_t size,
 
   return size;
 }
 
 ArchSpec ScriptedProcess::GetArchitecture() {
   return GetTarget().GetArchitecture();
 }
 
-Status ScriptedProcess::GetMemoryRegionInfo(lldb::addr_t load_addr,
+Status ScriptedProcess::DoGetMemoryRegionInfo(lldb::addr_t load_addr,
                                               MemoryRegionInfo &region) {
   CheckInterpreterAndScriptObject();
 
   Status error;
   if (auto region_or_err =
           GetInterface().GetMemoryRegionContainingAddress(load_addr, error))
     region = *region_or_err;
 
   return error;

lldb/source/Target/Process.cpp

if (next_branch_insn_address.IsValid() &&
         range_bounds.ContainsFileAddress(next_branch_insn_address)) {
       retval = next_branch_insn_address;
     }
   }
 
   return retval;
 }
 
+Status Process::GetMemoryRegionInfo(lldb::addr_t load_addr,
+                                    MemoryRegionInfo &range_info) {
+  if (auto abi = GetABI())
+    load_addr = abi->FixDataAddress(load_addr);
+  return DoGetMemoryRegionInfo(load_addr, range_info);
+}
+
 Status
 Process::GetMemoryRegions(lldb_private::MemoryRegionInfos &region_list) {
 
   Status error;
 
   lldb::addr_t range_end = 0;
 
   region_list.clear();

lldb/test/API/linux/aarch64/tagged_memory_region/Makefile

+C_SOURCES := main.c
+
+include Makefile.rules

lldb/test/API/linux/aarch64/tagged_memory_region/TestAArch64LinuxTaggedMemoryRegion.py

+"""
+Test that "memory region" lookup uses the ABI plugin to remove
+non address bits from addresses before lookup.
+"""
+
+
+
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class AArch64LinuxTaggedMemoryRegionTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    NO_DEBUG_INFO_TESTCASE = True
+
+    # AArch64 Linux always enables the top byte ignore feature
+    @skipUnlessArch("aarch64")
+    @skipUnlessPlatform(["linux"])
+    def test_mte_regions(self):
+        self.build()
+        self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
+
+        lldbutil.run_break_set_by_file_and_line(self, "main.c",
+            line_number('main.c', '// Set break point at this line.'),
+            num_expected_locations=1)
+
+        self.runCmd("run", RUN_SUCCEEDED)
+
+        if self.process().GetState() == lldb.eStateExited:
+            self.fail("Test program failed to run.")
+
+        self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
+            substrs=['stopped',
+                     'stop reason = breakpoint'])
+
+        # Despite the non address bits we should find a region
+        self.expect("memory region the_page", patterns=[
+            "\[0x[0-9A-Fa-f]+-0x[0-9A-Fa-f]+\) r-x"])

lldb/test/API/linux/aarch64/tagged_memory_region/main.c

+#include <asm/hwcap.h>
+#include <sys/auxv.h>
+#include <sys/mman.h>
+#include <unistd.h>
+
+int main(int argc, char const *argv[]) {
+  void *the_page = mmap(0, sysconf(_SC_PAGESIZE), PROT_READ | PROT_EXEC,
+                        MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+  if (the_page == MAP_FAILED)
+    return 1;
+
+  // Put something in the top byte (AArch64 Linux always enables top byte
+  // ignore)
+  the_page = (void *)((size_t)the_page | ((size_t)0x34 << 56));
+
+  return 0; // Set break point at this line.
+}