diff --git a/lldb/include/lldb/API/SBProcess.h b/lldb/include/lldb/API/SBProcess.h
--- a/lldb/include/lldb/API/SBProcess.h
+++ b/lldb/include/lldb/API/SBProcess.h
@@ -398,6 +398,60 @@
   /// valid.
   lldb::SBProcessInfo GetProcessInfo();
 
+  /// Get the current address mask that may be applied to addresses
+  /// before reading from memory.  The bits which are not relevant/valid
+  /// for addressing should be set.
+  ///
+  /// The user may override this value via the
+  /// target.process.virtual-addressable-bits setting, and the FixCodeAddress /
+  /// FixDataAddress will use the setting value instead of the Process address
+  /// mask.
+  ///
+  /// If the low ten bits are the only valid bits for addressing,
+  /// this would be the correct mask:
+  ///
+  /// (lldb) p/x ~((1ULL << 10) - 1)
+  /// (unsigned long long) 0xfffffffffffffc00
+  lldb::addr_t GetCodeAddressMask();
+  lldb::addr_t GetDataAddressMask();
+
+  /// If there is a separate address mask for low memory (starts with 0)
+  /// addresses high memory (starts with 0xf) addresses, this will return
+  /// the high memory address masks.  It is uncommon to have a target
+  /// that executes in both high and low memory, with different address masks,
+  /// but it does occur.
+  lldb::addr_t GetHighmemCodeAddressMask();
+  lldb::addr_t GetHighmemDataAddressMask();
+
+  /// Set the current address mask that may be applied to addresses
+  /// before reading from memory.  The bits which are not relevant/valid
+  /// for addressing will be set.
+  ///
+  /// If the low ten bits are the only valid bits for addressing,
+  /// this would be the mask returned:
+  ///
+  /// (lldb) p/x ~((1ULL << 10) - 1)
+  /// (unsigned long long) 0xfffffffffffffc00
+  void SetCodeAddressMask(lldb::addr_t mask);
+  void SetDataAddressMask(lldb::addr_t mask);
+
+  /// If there is a separate address mask for low memory (starts with 0)
+  /// addresses high memory (starts with 0xf) addresses, this will set
+  /// the high memory address masks.  It is uncommon to have a target
+  /// that executes in both high and low memory, with different address masks,
+  /// but it does occur.
+  void SetHighmemCodeAddressMask(lldb::addr_t mask);
+  void SetHighmemDataAddressMask(lldb::addr_t mask);
+
+  /// Given an address that may contain non-addressable metadata, and
+  /// we want to resolve it to addressable memory, this will use the
+  /// process address masks (or the target.process.virtual-addressable-bits
+  /// setting specified by the user) to remove the non-addressable bits and
+  /// return the actual address.
+  lldb::addr_t FixCodeAddress(lldb::addr_t addr);
+  lldb::addr_t FixDataAddress(lldb::addr_t addr);
+  lldb::addr_t FixAnyAddress(lldb::addr_t addr);
+
   /// Allocate memory within the process.
   ///
   /// This function will allocate memory in the process's address space.
diff --git a/lldb/source/API/SBProcess.cpp b/lldb/source/API/SBProcess.cpp
--- a/lldb/source/API/SBProcess.cpp
+++ b/lldb/source/API/SBProcess.cpp
@@ -1243,6 +1243,83 @@
   return sb_proc_info;
 }
 
+addr_t SBProcess::GetCodeAddressMask() {
+  LLDB_INSTRUMENT_VA(this);
+  addr_t default_mask = 0;
+  if (ProcessSP process_sp = GetSP())
+    return process_sp->GetCodeAddressMask();
+  return default_mask;
+}
+
+addr_t SBProcess::GetDataAddressMask() {
+  LLDB_INSTRUMENT_VA(this);
+  addr_t default_mask = 0;
+  if (ProcessSP process_sp = GetSP())
+    return process_sp->GetDataAddressMask();
+  return default_mask;
+}
+
+addr_t SBProcess::GetHighmemCodeAddressMask() {
+  LLDB_INSTRUMENT_VA(this);
+  addr_t default_mask = 0;
+  if (ProcessSP process_sp = GetSP())
+    return process_sp->GetHighmemCodeAddressMask();
+  return default_mask;
+}
+
+addr_t SBProcess::GetHighmemDataAddressMask() {
+  LLDB_INSTRUMENT_VA(this);
+  addr_t default_mask = 0;
+  if (ProcessSP process_sp = GetSP())
+    return process_sp->GetHighmemDataAddressMask();
+  return default_mask;
+}
+
+void SBProcess::SetCodeAddressMask(addr_t mask) {
+  LLDB_INSTRUMENT_VA(this, mask);
+  if (ProcessSP process_sp = GetSP())
+    process_sp->SetCodeAddressMask(mask);
+}
+
+void SBProcess::SetDataAddressMask(addr_t mask) {
+  LLDB_INSTRUMENT_VA(this, mask);
+  if (ProcessSP process_sp = GetSP())
+    process_sp->SetDataAddressMask(mask);
+}
+
+void SBProcess::SetHighmemCodeAddressMask(addr_t mask) {
+  LLDB_INSTRUMENT_VA(this, mask);
+  if (ProcessSP process_sp = GetSP())
+    process_sp->SetHighmemCodeAddressMask(mask);
+}
+
+void SBProcess::SetHighmemDataAddressMask(addr_t mask) {
+  LLDB_INSTRUMENT_VA(this, mask);
+  if (ProcessSP process_sp = GetSP())
+    process_sp->SetHighmemDataAddressMask(mask);
+}
+
+addr_t SBProcess::FixCodeAddress(addr_t addr) {
+  LLDB_INSTRUMENT_VA(this, addr);
+  if (ProcessSP process_sp = GetSP())
+    return process_sp->FixCodeAddress(addr);
+  return addr;
+}
+
+addr_t SBProcess::FixDataAddress(addr_t addr) {
+  LLDB_INSTRUMENT_VA(this, addr);
+  if (ProcessSP process_sp = GetSP())
+    return process_sp->FixDataAddress(addr);
+  return addr;
+}
+
+addr_t SBProcess::FixAnyAddress(addr_t addr) {
+  LLDB_INSTRUMENT_VA(this, addr);
+  if (ProcessSP process_sp = GetSP())
+    return process_sp->FixAnyAddress(addr);
+  return addr;
+}
+
 lldb::addr_t SBProcess::AllocateMemory(size_t size, uint32_t permissions,
                                        lldb::SBError &sb_error) {
   LLDB_INSTRUMENT_VA(this, size, permissions, sb_error);