Add a stack-memory-only style for Darwin process save-core

[jasonmolenda]

Summary

After adding the "dirty memory only" coredump style, I've been wondering how small a corefile I could get by only saving stack memory. I took a little time today to find out. A normal macOS corefile is a couple of GB, a dirty-memory corefile is around 440kb for a test binary. A stack memory corefile is about 20kb for that test binary.

I added a new "type" key-value pair to the qMemoryRegionInfo packet, and add "stack" to stack memory regions. David added a "flags" k-v pair for MTE but that has a specially formatted string of MTE flags in it (space separated) so I didn't want to mix in with that. It's straightforward to detect different memory types on Darwin systems, but I haven't thought of anything useful I could do by writing out heap dirty memory only or something. Maybe someone will think of some interesting way to use the memory region types.

In the test case, I create a stack-memory-only corefile, then read it back into lldb and fetch some stack & heap objects. SBValue has the unfortunate behavior (IMO) that it doesn't surface memory read errors in any way - so you can ask for a summary or a value of an SBValue object that couldn't read anything, and it will return 0/empty-string. We need to surface memory read errors better in lldb in these cases, this is just one of the issues with that.

I'm not sure a stack-memory-only corefile is especially useful for real C++/ObjC/Swift programs where many objects live on the heap. One thing I've thought about is trying to get a very tiny corefile showing interesting unwind states for writing tests against.

[jasonmolenda]

Handle a bit of state tracking in ObjectFileMachO a little bit more readably.

[jasonmolenda]

Have debugserver report malloc memory regions too, aka heap. I don't know how to use this in lldb yet, but it was easy to add so I thought I'd add it. Maybe we'll come up with an idea for it later. On Darwin, there are multiple types of heap - malloc small, malloc large, malloc tiny, etc - so for these, debugserver will return "type:heap,malloc-small;" etc, so the generic "heap" word is there, but also the more darwin-specific type of heap is given.

lldb/docs/lldb-gdb-remote.txt

name:<name>; // <name> is a hex encoded string that contains the name of
                  // the file while for anonymous regions it have to be the name
                  // associated to the region if that is available.
 
     flags:<flags-string>; // where <flags-string> is a space separated string
                           // of flag names. Currently the only supported flag
                           // is "mt" for AArch64 memory tagging. lldb will
                           // ignore any other flags in this field.
 
+    type:[<type>][,<type>]; // memory types that apply to this region, e.g.
+                 // "stack" for stack memory.
+
     error:<ascii-byte-error-string>; // where <ascii-byte-error-string> is
                                      // a hex encoded string value that
                                      // contains an error string
 
     dirty-pages:[<hexaddr>][,<hexaddr]; // A list of memory pages within this
                  // region that are "dirty" -- they have been modified.
                  // Page addresses are in base16.  The size of a page can
                  // be found from the qHostInfo's page-size key-value.

lldb/include/lldb/Target/MemoryRegionInfo.h

public:
   typedef Range<lldb::addr_t, lldb::addr_t> RangeType;
 
   enum OptionalBool { eDontKnow = -1, eNo = 0, eYes = 1 };
 
   MemoryRegionInfo() = default;
   MemoryRegionInfo(RangeType range, OptionalBool read, OptionalBool write,
                    OptionalBool execute, OptionalBool mapped, ConstString name,
                    OptionalBool flash, lldb::offset_t blocksize,
-                   OptionalBool memory_tagged)
+                   OptionalBool memory_tagged, OptionalBool stack_memory)
       : m_range(range), m_read(read), m_write(write), m_execute(execute),
         m_mapped(mapped), m_name(name), m_flash(flash), m_blocksize(blocksize),
-        m_memory_tagged(memory_tagged) {}
+        m_memory_tagged(memory_tagged), m_is_stack_memory(stack_memory) {}
 
   RangeType &GetRange() { return m_range; }
 
   void Clear() { *this = MemoryRegionInfo(); }
 
   const RangeType &GetRange() const { return m_range; }
 
   OptionalBool GetReadable() const { return m_read; }
public:
   }
 
   bool operator==(const MemoryRegionInfo &rhs) const {
     return m_range == rhs.m_range && m_read == rhs.m_read &&
            m_write == rhs.m_write && m_execute == rhs.m_execute &&
            m_mapped == rhs.m_mapped && m_name == rhs.m_name &&
            m_flash == rhs.m_flash && m_blocksize == rhs.m_blocksize &&
            m_memory_tagged == rhs.m_memory_tagged &&
-           m_pagesize == rhs.m_pagesize;
+           m_pagesize == rhs.m_pagesize &&
+           m_is_stack_memory == rhs.m_is_stack_memory;
   }
 
   bool operator!=(const MemoryRegionInfo &rhs) const { return !(*this == rhs); }
 
   /// Get the target system's VM page size in bytes.
   /// \return
   ///     0 is returned if this information is unavailable.
   int GetPageSize() { return m_pagesize; }
 
   /// Get a vector of target VM pages that are dirty -- that have been
   /// modified -- within this memory region.  This is an Optional return
   /// value; it will only be available if the remote stub was able to
   /// detail this.
   llvm::Optional<std::vector<lldb::addr_t>> &GetDirtyPageList() {
     return m_dirty_pages;
   }
 
+  OptionalBool IsStackMemory() const { return m_is_stack_memory; }
+
+  void SetIsStackMemory(OptionalBool val) { m_is_stack_memory = val; }
+
   void SetPageSize(int pagesize) { m_pagesize = pagesize; }
 
   void SetDirtyPageList(std::vector<lldb::addr_t> pagelist) {
     if (m_dirty_pages.hasValue())
       m_dirty_pages.getValue().clear();
     m_dirty_pages = std::move(pagelist);
   }
 
 protected:
   RangeType m_range;
   OptionalBool m_read = eDontKnow;
   OptionalBool m_write = eDontKnow;
   OptionalBool m_execute = eDontKnow;
   OptionalBool m_mapped = eDontKnow;
   ConstString m_name;
   OptionalBool m_flash = eDontKnow;
   lldb::offset_t m_blocksize = 0;
   OptionalBool m_memory_tagged = eDontKnow;
+  OptionalBool m_is_stack_memory = eDontKnow;
   int m_pagesize = 0;
   llvm::Optional<std::vector<lldb::addr_t>> m_dirty_pages;
 };
   
 inline bool operator<(const MemoryRegionInfo &lhs,
                       const MemoryRegionInfo &rhs) {
   return lhs.GetRange() < rhs.GetRange();
 }

lldb/include/lldb/lldb-enumerations.h

enum CommandInterpreterResult {
   eCommandInterpreterResultQuitRequested,
 };
 
 // Style of core file to create when calling SaveCore.
 enum SaveCoreStyle {
   eSaveCoreUnspecified = 0,
   eSaveCoreFull = 1,
   eSaveCoreDirtyOnly = 2,
+  eSaveCoreStackOnly = 3,
 };
 
 } // namespace lldb
 
 #endif // LLDB_LLDB_ENUMERATIONS_H

lldb/source/Commands/CommandObjectProcess.cpp

 };
 
 // CommandObjectProcessSaveCore
 #pragma mark CommandObjectProcessSaveCore
 
 static constexpr OptionEnumValueElement g_corefile_save_style[] = {
     {eSaveCoreFull, "full", "Create a core file with all memory saved"},
     {eSaveCoreDirtyOnly, "modified-memory",
-     "Create a corefile with only modified memory saved"}};
+     "Create a corefile with only modified memory saved"},
+    {eSaveCoreStackOnly, "stack",
+     "Create a corefile with only stack  memory saved"}};
 
 static constexpr OptionEnumValues SaveCoreStyles() {
   return OptionEnumValues(g_corefile_save_style);
 }
 
 #define LLDB_OPTIONS_process_save_core
 #include "CommandOptions.inc"
 
bool DoExecute(Args &command, CommandReturnObject &result) override {
     ProcessSP process_sp = m_exe_ctx.GetProcessSP();
     if (process_sp) {
       if (command.GetArgumentCount() == 1) {
         FileSpec output_file(command.GetArgumentAtIndex(0));
         SaveCoreStyle corefile_style = m_options.m_requested_save_core_style;
         Status error =
             PluginManager::SaveCore(process_sp, output_file, corefile_style);
         if (error.Success()) {
-          if (corefile_style == SaveCoreStyle::eSaveCoreDirtyOnly) {
+          if (corefile_style == SaveCoreStyle::eSaveCoreDirtyOnly ||
+              corefile_style == SaveCoreStyle::eSaveCoreStackOnly) {
             result.AppendMessageWithFormat(
-                "\nModified-memory only corefile "
-                "created.  This corefile may not show \n"
-                "library/framework/app binaries "
+                "\nModified-memory or stack-memory only corefile "
+                "created.  This corefile may \n"
+                "not show library/framework/app binaries "
                 "on a different system, or when \n"
                 "those binaries have "
                 "been updated/modified. Copies are not included\n"
                 "in this corefile.  Use --style full to include all "
                 "process memory.\n");
           }
           result.SetStatus(eReturnStatusSuccessFinishResult);
         } else {

lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

 //
 // To compute where everything will be laid out in the
 // payload, we need to iterate over the images and calculate
 // how many segment_vmaddr structures each image will need,
 // and how long each image's filepath c-string is. There
 // are some multiple passes over the image list while calculating
 // everything.
 
-static offset_t
-CreateAllImageInfosPayload(const lldb::ProcessSP &process_sp,
-                           offset_t initial_file_offset,
-                           StreamString &all_image_infos_payload) {
+static offset_t CreateAllImageInfosPayload(
+    const lldb::ProcessSP &process_sp, offset_t initial_file_offset,
+    StreamString &all_image_infos_payload, SaveCoreStyle core_style) {
   Target &target = process_sp->GetTarget();
-  const ModuleList &modules = target.GetImages();
-  size_t modules_count = modules.GetSize();
+  ModuleList modules = target.GetImages();
+
+  // stack-only corefiles have no reason to include binaries that
+  // are not executing; we're trying to make the smallest corefile
+  // we can, so leave the rest out.
+  if (core_style == SaveCoreStyle::eSaveCoreStackOnly)
+    modules.Clear();
 
   std::set<std::string> executing_uuids;
   ThreadList &thread_list(process_sp->GetThreadList());
   for (uint32_t i = 0; i < thread_list.GetSize(); i++) {
     ThreadSP thread_sp = thread_list.GetThreadAtIndex(i);
     uint32_t stack_frame_count = thread_sp->GetStackFrameCount();
     for (uint32_t j = 0; j < stack_frame_count; j++) {
       StackFrameSP stack_frame_sp = thread_sp->GetStackFrameAtIndex(j);
       Address pc = stack_frame_sp->GetFrameCodeAddress();
       ModuleSP module_sp = pc.GetModule();
       if (module_sp) {
         UUID uuid = module_sp->GetUUID();
         if (uuid.IsValid()) {
           executing_uuids.insert(uuid.GetAsString());
+          modules.AppendIfNeeded(module_sp);
         }
       }
     }
   }
+  size_t modules_count = modules.GetSize();
 
   struct all_image_infos_header infos;
   infos.version = 1;
   infos.imgcount = modules_count;
   infos.entries_size = sizeof(image_entry);
   infos.entries_fileoff = initial_file_offset + sizeof(all_image_infos_header);
   infos.unused = 0;
 

 };
 
 bool ObjectFileMachO::SaveCore(const lldb::ProcessSP &process_sp,
                                const FileSpec &outfile,
                                lldb::SaveCoreStyle &core_style, Status &error) {
   if (!process_sp)
     return false;
 
-  // For Mach-O, we can only create full corefiles or dirty-page-only
-  // corefiles.  The default is dirty-page-only.
-  if (core_style != SaveCoreStyle::eSaveCoreFull) {
+  // Default on macOS is to create a dirty-memory-only corefile.
+  if (core_style == SaveCoreStyle::eSaveCoreUnspecified) {
     core_style = SaveCoreStyle::eSaveCoreDirtyOnly;
-  } else {
-    core_style = SaveCoreStyle::eSaveCoreFull;
   }
 
   Target &target = process_sp->GetTarget();
   const ArchSpec target_arch = target.GetArchitecture();
   const llvm::Triple &target_triple = target_arch.GetTriple();
   if (target_triple.getVendor() == llvm::Triple::Apple &&
       (target_triple.getOS() == llvm::Triple::MacOSX ||
        target_triple.getOS() == llvm::Triple::IOS ||
if (make_core) {
             prot |= VM_PROT_EXECUTE;
 
           const addr_t addr = range_info.GetRange().GetRangeBase();
           const addr_t size = range_info.GetRange().GetByteSize();
 
           if (size == 0)
             break;
 
-          if (prot != 0) {
+          bool include_this_region = true;
+          bool dirty_pages_only = false;
+          if (core_style == SaveCoreStyle::eSaveCoreStackOnly) {
+            dirty_pages_only = true;
+            if (range_info.IsStackMemory() != MemoryRegionInfo::eYes) {
+              include_this_region = false;
+            }
+          }
+          if (core_style == SaveCoreStyle::eSaveCoreDirtyOnly) {
+            dirty_pages_only = true;
+          }
+
+          if (prot != 0 && include_this_region) {
             addr_t pagesize = range_info.GetPageSize();
             const llvm::Optional<std::vector<addr_t>> &dirty_page_list =
                 range_info.GetDirtyPageList();
-            if (core_style == SaveCoreStyle::eSaveCoreDirtyOnly &&
-                dirty_page_list.hasValue()) {
-              core_style = SaveCoreStyle::eSaveCoreDirtyOnly;
+            if (dirty_pages_only && dirty_page_list.hasValue()) {
               for (addr_t dirtypage : dirty_page_list.getValue()) {
                 page_object obj;
                 obj.addr = dirtypage;
                 obj.size = pagesize;
                 obj.prot = prot;
                 pages_to_copy.push_back(obj);
               }
             } else {
if (make_core) {
               last_obj.prot == obj.prot) {
             last_obj.size += obj.size;
             continue;
           }
           combined_page_objects.push_back(last_obj);
           last_obj = obj;
         }
 
+        // If we only ended up with one contiguous memory segment
+        if (combined_page_objects.size() == 0 &&
+            last_obj.addr != LLDB_INVALID_ADDRESS) {
+          combined_page_objects.push_back(last_obj);
+        }
+
         for (page_object obj : combined_page_objects) {
           uint32_t cmd_type = LC_SEGMENT_64;
           uint32_t segment_size = sizeof(llvm::MachO::segment_command_64);
           if (addr_byte_size == 4) {
             cmd_type = LC_SEGMENT;
             segment_size = sizeof(llvm::MachO::segment_command);
           }
           llvm::MachO::segment_command_64 segment = {
if (make_core) {
         }
 
         // Add "all image infos" LC_NOTE
         std::unique_ptr<LCNoteEntry> all_image_infos_lcnote_up(
             new LCNoteEntry(addr_byte_size, byte_order));
         all_image_infos_lcnote_up->name = "all image infos";
         all_image_infos_lcnote_up->payload_file_offset = file_offset;
         file_offset = CreateAllImageInfosPayload(
-            process_sp, file_offset, all_image_infos_lcnote_up->payload);
+            process_sp, file_offset, all_image_infos_lcnote_up->payload,
+            core_style);
         lc_notes.push_back(std::move(all_image_infos_lcnote_up));
 
         // Add LC_NOTE load commands
         for (auto &lcnote : lc_notes) {
           // Add the LC_NOTE load command to the file.
           buffer.PutHex32(LC_NOTE);
           buffer.PutHex32(sizeof(llvm::MachO::note_command));
           char namebuf[16];

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

if (SendPacketAndWaitForResponse(packet, response) ==
             // To account for trailing whitespace
             if (flag.size()) {
               if (flag == "mt") {
                 region_info.SetMemoryTagged(MemoryRegionInfo::eYes);
                 break;
               }
             }
           }
+        } else if (name.equals("type")) {
+          std::string comma_sep_str = value.str();
+          size_t comma_pos;
+          while ((comma_pos = comma_sep_str.find(',')) != std::string::npos) {
+            comma_sep_str[comma_pos] = '\0';
+            if (comma_sep_str == "stack") {
+              region_info.SetIsStackMemory(MemoryRegionInfo::eYes);
+            }
+          }
+          // handle final (or only) type of "stack"
+          if (comma_sep_str == "stack") {
+            region_info.SetIsStackMemory(MemoryRegionInfo::eYes);
+          }
         } else if (name.equals("error")) {
           StringExtractorGDBRemote error_extractor(value);
           std::string error_string;
           // Now convert the HEX bytes into a string value
           error_extractor.GetHexByteString(error_string);
           error.SetErrorString(error_string.c_str());
         } else if (name.equals("dirty-pages")) {
           std::vector<addr_t> dirty_page_list;

lldb/test/API/macosx/skinny-corefile/TestSkinnyCorefile.py

 """Test that lldb can create a skinny corefile, and load all available libraries correctly."""
 
 
 
 import os
 import re
 import subprocess
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
-class TestFirmwareCorefiles(TestBase):
+class TestSkinnyCorefile(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @skipIf(debug_info=no_match(["dsym"]), bugnumber="This test is looking explicitly for a dSYM")
     @skipUnlessDarwin
     def test_lc_note(self):
         self.build()
         self.aout_exe = self.getBuildArtifact("a.out")

lldb/test/API/macosx/stack-corefile/Makefile

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

lldb/test/API/macosx/stack-corefile/TestStackCorefile.py

+"""Test that lldb can create a stack-only corefile, and load the main binary."""
+
+import os
+import re
+import subprocess
+
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+class TestStackCorefile(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @no_debug_info_test
+    @skipUnlessDarwin
+    def test(self):
+
+        corefile = self.getBuildArtifact("process.core")
+        self.build()
+        (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(
+            self, "// break here", lldb.SBFileSpec("main.c"))
+
+        frame = thread.GetFrameAtIndex(0)
+        stack_int = frame.GetValueForVariablePath("stack_int")
+        heap_int = frame.GetValueForVariablePath("*heap_int")
+        stack_str = frame.GetValueForVariablePath("stack_str")
+        heap_str = frame.GetValueForVariablePath("heap_str")
+        self.assertEqual(stack_int.GetValueAsUnsigned(), 5)
+        self.assertEqual(heap_int.GetValueAsUnsigned(), 10)
+        self.assertEqual(stack_str.summary, '"stack string"')
+        self.assertEqual(heap_str.summary, '"heap string"')
+
+        self.runCmd("process save-core -s stack " + corefile)
+        process.Kill()
+        self.dbg.DeleteTarget(target)
+
+        # Now load the corefile
+        target = self.dbg.CreateTarget('')
+        process = target.LoadCore(corefile)
+        thread = process.GetSelectedThread()
+        self.assertTrue(process.IsValid())
+        self.assertTrue(process.GetSelectedThread().IsValid())
+        if self.TraceOn():
+            self.runCmd("image list")
+            self.runCmd("bt")
+            self.runCmd("fr v")
+        num_modules = target.GetNumModules()
+        #  We should only have the a.out binary and possibly
+        # the libdyld.dylib.  Extra libraries loaded means 
+        # extra LC_NOTE and unnecessarily large corefile.
+        self.assertTrue(num_modules == 1 or num_modules == 2)
+
+        # The heap variables should be unavailable now.
+        frame = thread.GetFrameAtIndex(0)
+        stack_int = frame.GetValueForVariablePath("stack_int")
+        heap_int = frame.GetValueForVariablePath("*heap_int")
+        stack_str = frame.GetValueForVariablePath("stack_str")
+        heap_str = frame.GetValueForVariablePath("heap_str")
+
+        ## The heap SBValues both come back as IsValid()==true,
+        ## which I'm not so sure is a great/correct thing --
+        ## it hides the memory read error that actually happened,
+        ## and we don't have a real value.
+        self.assertEqual(stack_int.GetValueAsUnsigned(), 5)
+        self.assertEqual(heap_int.GetValueAsUnsigned(), 0)
+        self.assertEqual(stack_str.summary, '"stack string"')
+        self.assertEqual(heap_str.summary, '""')

lldb/test/API/macosx/stack-corefile/main.c

+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int main() {
+  int stack_int = 5;
+  int *heap_int = (int*) malloc(sizeof (int));
+  *heap_int = 10;
+
+  char stack_str[80];
+  strcpy (stack_str, "stack string");
+  char *heap_str = (char*) malloc(80);
+  strcpy (heap_str, "heap string");
+
+  return stack_int; // break here;
+}

lldb/tools/debugserver/source/DNBDefs.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_TOOLS_DEBUGSERVER_SOURCE_DNBDEFS_H
 #define LLDB_TOOLS_DEBUGSERVER_SOURCE_DNBDEFS_H
 
 #include <csignal>
 #include <cstdint>
 #include <cstdio>
+#include <string>
 #include <sys/syslimits.h>
 #include <unistd.h>
 #include <vector>
 
 // Define nub_addr_t and the invalid address value from the architecture
 #if defined(__x86_64__) || defined(__arm64__) || defined(__aarch64__)
 
 // 64 bit address architectures
struct DNBExecutableImageInfo {
   uuid_t uuid;            // Unique identifier for matching with symbols
   uint32_t
       num_segments; // Number of contiguous memory segments to in SEGMENTS array
   DNBSegment *segments; // Array of contiguous memory segments in executable
 };
 
 struct DNBRegionInfo {
 public:
-  DNBRegionInfo() : addr(0), size(0), permissions(0), dirty_pages() {}
+  DNBRegionInfo()
+      : addr(0), size(0), permissions(0), dirty_pages(), vm_types() {}
   nub_addr_t addr;
   nub_addr_t size;
   uint32_t permissions;
   std::vector<nub_addr_t> dirty_pages;
+  std::vector<std::string> vm_types;
 };
 
 enum DNBProfileDataScanType {
   eProfileHostCPU = (1 << 0),
   eProfileCPU = (1 << 1),
 
   eProfileThreadsCPU =
       (1 << 2), // By default excludes eProfileThreadName and eProfileQueueName.

lldb/tools/debugserver/source/MacOSX/MachVMMemory.cpp

nub_bool_t MachVMMemory::GetMemoryRegionInfo(task_t task, nub_addr_t address,
   MachVMRegion vmRegion(task);
 
   if (vmRegion.GetRegionForAddress(address)) {
     region_info->addr = vmRegion.StartAddress();
     region_info->size = vmRegion.GetByteSize();
     region_info->permissions = vmRegion.GetDNBPermissions();
     region_info->dirty_pages =
         get_dirty_pages(task, vmRegion.StartAddress(), vmRegion.GetByteSize());
+    region_info->vm_types = vmRegion.GetMemoryTypes();
   } else {
     region_info->addr = address;
     region_info->size = 0;
     if (vmRegion.GetError().Success()) {
       // vmRegion.GetRegionForAddress() return false, indicating that "address"
       // wasn't in a valid region, but the "vmRegion" info was successfully
       // read from the task which means the info describes the next valid
       // region from which we can infer the size of this invalid region

lldb/tools/debugserver/source/MacOSX/MachVMRegion.h

public:
   bool ContainsAddress(mach_vm_address_t addr) const {
     return addr >= StartAddress() && addr < EndAddress();
   }
 
   bool SetProtections(mach_vm_address_t addr, mach_vm_size_t size,
                       vm_prot_t prot);
   bool RestoreProtections();
   bool GetRegionForAddress(nub_addr_t addr);
+  std::vector<std::string> GetMemoryTypes() const;
 
   uint32_t GetDNBPermissions() const;
 
   const DNBError &GetError() { return m_err; }
 
 protected:
 #if defined(VM_REGION_SUBMAP_SHORT_INFO_COUNT_64)
   typedef vm_region_submap_short_info_data_64_t RegionInfo;

lldb/tools/debugserver/source/MacOSX/MachVMRegion.cpp

uint32_t MachVMRegion::GetDNBPermissions() const {
   if ((m_data.protection & VM_PROT_READ) == VM_PROT_READ)
     dnb_permissions |= eMemoryPermissionsReadable;
   if ((m_data.protection & VM_PROT_WRITE) == VM_PROT_WRITE)
     dnb_permissions |= eMemoryPermissionsWritable;
   if ((m_data.protection & VM_PROT_EXECUTE) == VM_PROT_EXECUTE)
     dnb_permissions |= eMemoryPermissionsExecutable;
   return dnb_permissions;
 }
+
+std::vector<std::string> MachVMRegion::GetMemoryTypes() const {
+  std::vector<std::string> types;
+  if (m_data.user_tag == VM_MEMORY_STACK) {
+    if (m_data.protection == VM_PROT_NONE) {
+      types.push_back("stack-guard");
+    } else {
+      types.push_back("stack");
+    }
+  }
+  if (m_data.user_tag == VM_MEMORY_MALLOC) {
+    if (m_data.protection == VM_PROT_NONE)
+      types.push_back("malloc-guard");
+    else if (m_data.share_mode == SM_EMPTY)
+      types.push_back("malloc-reserved");
+    else
+      types.push_back("malloc-metadata");
+  }
+  if (m_data.user_tag == VM_MEMORY_MALLOC_NANO ||
+      m_data.user_tag == VM_MEMORY_MALLOC_TINY ||
+      m_data.user_tag == VM_MEMORY_MALLOC_SMALL ||
+      m_data.user_tag == VM_MEMORY_MALLOC_LARGE ||
+      m_data.user_tag == VM_MEMORY_MALLOC_LARGE_REUSED ||
+      m_data.user_tag == VM_MEMORY_MALLOC_LARGE_REUSABLE ||
+      m_data.user_tag == VM_MEMORY_MALLOC_HUGE ||
+      m_data.user_tag == VM_MEMORY_REALLOC ||
+      m_data.user_tag == VM_MEMORY_SBRK) {
+    types.push_back("heap");
+    if (m_data.user_tag == VM_MEMORY_MALLOC_TINY) {
+      types.push_back("malloc-tiny");
+    }
+    if (m_data.user_tag == VM_MEMORY_MALLOC_LARGE) {
+      types.push_back("malloc-large");
+    }
+    if (m_data.user_tag == VM_MEMORY_MALLOC_SMALL) {
+      types.push_back("malloc-small");
+    }
+  }
+  return types;
+}

lldb/tools/debugserver/source/RNBRemote.cpp

if (region_info.dirty_pages.size() > 0) {
       for (nub_addr_t addr : region_info.dirty_pages) {
         if (!first)
           ostrm << ",";
         first = false;
         ostrm << "0x" << std::hex << addr;
       }
     }
     ostrm << ";";
+    if (!region_info.vm_types.empty()) {
+      for (size_t i = 0; i < region_info.vm_types.size(); i++) {
+        if (i)
+          ostrm << ",";
+        ostrm << region_info.vm_types[i];
+      }
+      ostrm << ";";
+    }
   }
   return SendPacket(ostrm.str());
 }
 
 // qGetProfileData;scan_type:0xYYYYYYY
 rnb_err_t RNBRemote::HandlePacket_GetProfileData(const char *p) {
   nub_process_t pid = m_ctx.ProcessID();
   if (pid == INVALID_NUB_PROCESS)