Create "skinny corefiles" for Mach-O with process save-core / reading

[jasonmolenda]

Summary

I implemented something that's been talked about for a while -- creating "skinny corefiles", or a user process corefile that only includes dirty memory in it. This is the patchset to implement this with lldb's "process save-core" and lldb's corefile reading, for Mach-O files.

Because of how the system libraries are shared across all processes on Darwin systems, dumping all available memory for a process involves writing multiple gigabytes for even a trivial command line app. The majority of this corefile are unmodified memory pages for the system libraries; it's a very expensive and slow operation.

This patchset does a few things:

1. Adds support in debugserver to find the list of pages in a memory region that are dirty. It adds a key-value pair to qHostInfo to advertise how large a VM memory page is on the target system, and it includes a list of dirty pages for a memory region in the qMemoryRegionInfo reply to lldb's queries about memory regions.

2. It adds a new LC_NOTE "all image infos" in the corefile, which specifies all binary images that are present in the inferior process and where they are loaded in memory. The filepaths, UUIDs, and segment name+load addresses are required because lldb will not have access to dyld's dyld_all_image_infos structure or the ability to read these binaries out of memory. (normally the segment load addresses could be found by reading the Mach-O load commands for the binaries from the corefile)

3. It adds a new LC_NOTE "executing uuids" in the corefile, which is a list of the UUIDs of the binary images that are actually executing code at the point when the corefile was written. That is, the set of binaries that appear on any backtrace on any thread at the point of the coredump. A graphical app on macOS these days can easily have 500 different binary images loaded in the process; likely only a couple dozen of those are actually executing. Knowing which binary images are executing allows us to do a more expensive search for these most-important binaries, like we do with crashlog.py.

4. Changes the Mach-O corefile creation to only include dirty pages when communicating with a debugserver that provides this information.

5. Read and use the "all image infos" and "executing uuids" in ProcessMachCore.

6. Finally, of course, adds a test case where we have 3 binaries (one executable, two dylibs), hits a breakpoint, saves a skinny corefile. Then it moves the executable to a hidden location that lldb can only discover by calling the dsymForUUID script (to test 'executing uuids'), deletes one dylib, and leaves one at the expected location. It loads the skinny corefile into lldb and confirms that the present libraries are present, the absent library is absent (and its non-dirty memory is unreadable), and we can read variables that are on the heap/stack correctly.

Before this change, the minimum size for a corefile on macOS 10.15 was around 2GB and it would take around 5 minutes to dump. With this change, a simple test binary user process corefile is around 500KB and takes a few seconds to dump. Larger real-world applications will have larger amounts of stack & heap and will have correspondingly larger corefiles.

I'm not thrilled that I'm touching the same parts of lldb as David Spickett in https://reviews.llvm.org/D87442 - we're going to create conflicts depending on which of us lands first. Both of us need to modify the qMemoryRegionInfo packet and lldb's MemoryRegionInfo class to store our additional informations.

The majority of this patch concerns ObjectFileMachO and ProcessMachCore, as well as debugserver; I expect those to be of less interest to any reviewer/commenters. But of course I welcome any suggestions/comments to those parts as well as the other parts of lldb I touched along the way. I did need to add some API/structs in the ObjectFile base class so ObjectFileMachO could pass information up to ProcessMachCore that are very specific to what I'm doing here.

[mib]

lldb/include/lldb/Symbol/ObjectFile.h

700

Little typo here.

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

6863–6868

I guess you probably forgot to remove this comment.

[clayborg]

Many inline comments that should explain everything.

lldb/include/lldb/Symbol/ObjectFile.h

669–692

We shouldn't be exposing mach-o specific stuff here. I think an API that lets the ObjectFile (if it is a core file) load all needed images at the right addresses might be better encapsulated:

virtual llvm::Error LoadCoreFileImages(lldb_private::Target &target);

It returns an error if something the ObjectFile is not a core file or something fatal happens. Then you don't need to expose any of the mach-o specific things here, and we can probably remove the GetCorefileExecutingUUIDs() as well below.

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

6157–6162

Use RangeDataVector from RangeMap.h:

typedef lldb_private::RangeDataVector<lldb::addr_t, lldb::addr_t, uint32_t> PageObjects;

6164–6165

We should add an extra boolean as an argument to allow saving all memory regions, or just the dirty pages?

6202

Use PageObjects as defined above:

PageObjects pages_to_copy;

6223

If we add a bool argument, we might need to return an error if the lldb-server doesn't support the dirty page list stuff. Some regions won't have dirty pages, but we might need add detection for any dirty pages and then error out at the end if user requested a minimal core file

6225–6230

if (prot != 0) 
  pages_to_copy.Append({dirtypage, pagesize, prot});

6233–6238

if (prot != 0) 
  pages_to_copy.Append({addr, size, prot});

6246–6264

Remove all of this and do:

page_objects.CombineConsecutiveEntriesWithEqualData();

6266

use paige_objects directly now since we sorted it above:

for (page_object obj : page_objects) {

6582

Can we get rid of the UUID array we save and add a flag here that states that the library was loaded instead of saving it in a separate load command?

6811

Can we read a "uint32_t flags" field here where one of the bits is a "I was part of the thread stacks"?

6841

We can get rid of this entire load command if we put a bit into the all image info struct. We already have an unused uint32_t field available.

6884

We can get rid of this entire load command if we put a bit into the all image info struct. We already have an unused uint32_t field available.

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

120–124

Remove and just do:

llvm::Error LoadCoreFileImages(lldb_private::Target &target) override;

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

335–349

We can get rid of this entire load command if we put a bit into the all image info struct. We already have an unused uint32_t field available.

416–450

This functionality can be moved to the "ObjectFileMachO::LoadCoreFileImages(lldb_private::Target &target)" function. If we have flags in the all image infos for each library that states if it was part of an active stack, then we can also call the object and symbols download:

Symbols::DownloadObjectAndSymbolFile(module_spec, true);
if (FileSystem::Instance().Exists(module_spec.GetFileSpec()))
  GetTarget().GetOrCreateModule(module_spec, false);
else {
 ...
}

[clayborg]

lldb/include/lldb/Symbol/ObjectFile.h

692

basically all of the code from ProcessMachCore.cpp lines 421-455 can be moved into:

llvm::Error ObjectFileMachO::LoadCoreFileImages(lldb_private::Target &target);

And it can GetOrLoad images directly into the target and set the right load addresses. Then none of the mach-o specifics need to be exposed here.

703

This function probably isn't needed if we put a flag into the all image infos that is saved in the other load command. Inlined comments below will detail where I was thinking.

[jasonmolenda]

Thanks for the suggestions Greg, solid ideas. Let me rework this a bit.

[clayborg]

The other thing to think about is using minidump files instead of mach-o core files. We have them in very good shape and they already have a built in notion of "all image infos". Many more things in there too. Let me know if you want to know more, but I'm not holding my breath! hhaha

[jasonmolenda]

In D88387#2299413, @clayborg wrote:

The other thing to think about is using minidump files instead of mach-o core files. We have them in very good shape and they already have a built in notion of "all image infos". Many more things in there too. Let me know if you want to know more, but I'm not holding my breath! hhaha

For a pure-lldb scenario (process save core; lldb -c) this would be pretty interesting. But it would be a trickier sell for other corefile creators on Darwin, and none of our other tooling would operate on them. Mach-O ride or die! :)

[jasonmolenda]

This patch update incorporates most of Greg's suggestions. Most importantly, I isolated all of the loading of the binaries specified in the corefile down into ObjectFileMachO so I didn't have to add so much special case API to the ObjectFile base API.

Greg made a case in direct email for the usefulness of a full coredump -- e.g. people may save a skinny core on one mac system, and send it to someone on a different mac system where the system libraries are all different, and no backtraces would be meaningful. This patch implements a -f option to process save-core to force a full coredump, if the system defaults to skinny (as it will on macos).

The alternative we were discussing is a hybrid approach where the core dumper saves all of the memory pages that cover the binary, for images that are currently executing on a thread. We'd need the full symbol table, mach-o header, and text which is executing, so it's probably easier to just copy the whole thing in than to try to pare it back. This is an interesting idea, and most of the groundwork is laid for it - we are already computing which libraries are actively executing and noting that in the corefile metadata so lldb can do more expensive searches for those binary images.

I switched to using the RangeDataVector container, but it has a little bug in the CombineConsecutiveEntriesWithEqualData where consecutive entries with the same Data value are combined, even if their ranges are not consecutive. So you could get a vast address range claimed if a user process page and a shared cache page had the same protections. Fixing that and writing a test case, I found a second problem where RangeDataVector isn't setting its 'upper_bound' field properly for this use case and searches don't work as they should. At which point I booted it out of the patch and went back to the hand-rolled container that I'd started with; I'll try to look at RangeDataVector more closely next week and switch to using it in this method. It is a cleaner and simpler approach.

I also got rid of the "executing uuids" LC_NOTE - as Greg pointed out, I have a perfectly good unused field for alignment in the binary image entries already, using that to flag executing images was even easier.

[jasonmolenda]

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

6223

in the qMemoryRegionInfo packet response, a remote stub that can identify dirty pages should include a dirty-pages: key-value entry in every response where they're supported, even if it's an empty list. I clarified this in the docs. That's how we'll detect the difference between "no dirty pages" and "dirty pages not supported".

[jasonmolenda]

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

6223

Oh, and once we're inside lldb, I have the dirty page list returned as an Optional vector. For a memory region where we don't have any dirty page information, there's no vector. For a memory region where we have dirty page information -- and there are no pages, an empty vector is returned.

[jasonmolenda]

Thinking about process save-core and how it will default to a skinny corefile on macOS but a full corefile elsewhere, I'd like to surface some notification to the user about the type of corefile that was created to the user. Maybe add an PluginManager::SavedCoreType {eSavedCoreFull, eSavedCoreDirtyOnly, eSavedCoreDirtyPlusExecutingIMages}, have PluginManager::SaveCore return that enum value so that the "process save-core" user command can print text about the type of corefile that was saved. For a dirty corefile on macos, it could say "Modified-memory-only corefile has been written. This corefile will not be portable between systems, or usable as software updates are applied; --full-corefile can create a corefile appropriate for sharing/archiving." or something.

Also hoping that @DavidSpickett 's changes to qMemoryRegionInfo might land soon so I don't cause conflicts with his patchset. :)

[clayborg]

Nice changes. Just a few changes and should be good to go.

lldb/include/lldb/Symbol/ObjectFile.h

675

process

676

process

lldb/source/API/SBProcess.cpp

1231

We should add another SaveCore() includes the bool argument and have this one call that one.

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

6600

Can this just be a static function in this file without being in the ObjectFileMachO class? That would keep the header file cleaner.

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

18

Don't need this include, it should be forward declared in lldb-forward.h. Move to .cpp file

215–216

move to ObjectFileMachO.cpp, not needed in header file.

218–220

Move to .cpp file? Not needed in header unless this static function takes avantage of being a part of the class which gives it access to non public stuff?

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

1199

IS there a getAsUnsigned?

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

250

uint32_t as the type? This should never be negative, so no need to use a signed value.

595

uint32_t as the type? This should never be negative, so no need to use a signed value.

[DavidSpickett]

For what it's worth I'm aware of this change, don't hold back on my account. It doesn't overlap that much and I think I'll be reworking mine anyway.

[jasonmolenda]

I was thinking about the UI of this some more today.

I think process save-core should take a --core-style argument with an enum of (currently) 'full' or 'modified-memory'. Plugin::SaveCore will take a requested_coredump_style and will return an created_coredump_style. The user can request a modified-memory coredump on linux, but it's not supported so they get a full coredump. We could have "stack-only" coredumps (this would be an awful lot like a minidump iiuc, and may be duplicative), or "modified-memory-plus-binary-images" (better name tbd) which would copy in the binary images of any executing binaries or whatever.

[clayborg]

In D88387#2318226, @jasonmolenda wrote:

I was thinking about the UI of this some more today.

I think process save-core should take a --core-style argument with an enum of (currently) 'full' or 'modified-memory'. Plugin::SaveCore will take a requested_coredump_style and will return an created_coredump_style. The user can request a modified-memory coredump on linux, but it's not supported so they get a full coredump. We could have "stack-only" coredumps (this would be an awful lot like a minidump iiuc, and may be duplicative), or "modified-memory-plus-binary-images" (better name tbd) which would copy in the binary images of any executing binaries or whatever.

That seems like a lot of flavors. At the command level I would suggest just some arguments. To the SaveCore, it can take a bitfield with all of the options the user selected. Options I can think of:

--full: which would specify to save all memory regions
--modified: save any modified data pages that are not thread stacks. I would suggest the core file plug-in returns an error if it doesn't support this to provide a better user experience. This could imply --stacks or it could be a stand alone option.
--stacks: save the thread stacks, very close to minidumps as you mentioned if only this is specified
--stack-functions: save memory for the code for all function bodies from all stack frames in all threads. This helps with stack tracing if we have no access to the system object files
--minimal-heap: save only the allocated memory from heaps. Often times the system malloc allocators will grab large chunks of memory and hand out partial chunks when malloc is called. On Darwin, we could easily find out the actual allocations that are live on the heap and only save
those?
--crashing-thread-only: only save threads that crashed. Cuts down on memory size for stacks, and stack functions.

We could then make a bitfield of options:

enum uint32_t CoreFileOptions {
  eFull = (1u << 0),
  eModifiedPages = (1u << 1),
  eThreadStacks = (1u << 2),
  eThreadFunctions = (1u << 3),
  eMinimalHead = (1u << 4),
  eCrashingThreadOnly = (1u << 5)
};

And then pass a "uint32_t flags" to the save core instead of the bool.

[jasonmolenda]

Yeah, I'm not opposed to mutually exclusive options to process save-core to request a specific style of coredump to be created, whether it's a --core-style enum or a series of flags isn't important to me. Right now I only intend to add the two that are possible - a full coredump or a modified-memory (dirty memory) coredump, on macOS. Whether it's passed as an enum or bitflag I don't have a preference, although a bitflag makes it sound like there could be multiple of them selected, when that's not what I'd be envisioning here. (if we were doing a series of flags for the lldb API, it would make more sense if we had different types of memory that could be coredumped and you could set the flags for what you want included. stack, heap, shared memory, binary images, etc.)

I forgot to respond to your suggestion about the SB API Process::SaveCore. I'm a little reluctant to add anything there yet because we're going from one style of coredump to two right now, and I'm not sure if we're going to stay at 2 forever or if we're going to evolve this into a panoply of different coredump styles and I'm not confident enough about this to want to put it in API. But I'm not wedded to that position.

[clayborg]

In D88387#2318495, @jasonmolenda wrote:

Yeah, I'm not opposed to mutually exclusive options to process save-core to request a specific style of coredump to be created, whether it's a --core-style enum or a series of flags isn't important to me. Right now I only intend to add the two that are possible - a full coredump or a modified-memory (dirty memory) coredump, on macOS. Whether it's passed as an enum or bitflag I don't have a preference, although a bitflag makes it sound like there could be multiple of them selected, when that's not what I'd be envisioning here. (if we were doing a series of flags for the lldb API, it would make more sense if we had different types of memory that could be coredumped and you could set the flags for what you want included. stack, heap, shared memory, binary images, etc.)

I think eventually it would be nice to get to multiple of the flags, but we can start with full or dirty only is fine.

I forgot to respond to your suggestion about the SB API Process::SaveCore. I'm a little reluctant to add anything there yet because we're going from one style of coredump to two right now, and I'm not sure if we're going to stay at 2 forever or if we're going to evolve this into a panoply of different coredump styles and I'm not confident enough about this to want to put it in API. But I'm not wedded to that position.

Sounds good, lets work this out first internally and then expose via the SB API when we are ready.

[labath]

/me parachutes into the discussion.

On the topic of interfaces, I'd like to say that eventually I'd like to have the ability to choose the format for the core file that lldb generates (so that one can generate minidump files on mac or linux). There's no direct implications of that for this patch, as the two choices are likely to be orthogonal (full or "skinny" minidumps make sense too), it would just be good to leave room for this extension in the future (e.g. in the SB API).

As for the flag discussion, it might be interesting to note that the linux coredump_filter is a set of flags

bit 0  Dump anonymous private mappings.
bit 1  Dump anonymous shared mappings.
bit 2  Dump file-backed private mappings.
bit 3  Dump file-backed shared mappings.
bit 4 (since Linux 2.6.24)
       Dump ELF headers.
bit 5 (since Linux 2.6.28)
       Dump private huge pages.
bit 6 (since Linux 2.6.28)
       Dump shared huge pages.
bit 7 (since Linux 4.4)
       Dump private DAX pages.
bit 8 (since Linux 4.4)
       Dump shared DAX pages.

I have no plans on doing anything with that, though someone theoretically might. However, I think that even if we do have the ability to fine-tune the core contents via individual flags, we should probably still have some way to select some reasonable set of predefined flags.

Lastly, I think it would be good to extend the memory region command to show the new MemoryRegionInfo contents. If for nothing else, then to enable the testing of this (pretty large) patch in a more granular way. Having this in the output of memory region would enable splitting the gdb-remote part of this into a separate patch.

[jasonmolenda]

Thanks for the feedback Pavel. Good point on piping the dirty pages list through the memory region command and adding tests for that. And good thoughts on different memory types that could be included in the corefile. I think we may revisit how the 'process save-core' command arguments work as we add more formats. We could do some pretty cool stuff here.

I'm not going to bite this off right now, but I was thinking about the fact that a "dirty memory only" corefile depends on having all the binaries on the system that the corefile was taken. Why can't you run lldb on a dirty memory corefile and create a full corefile from it, if it's on the same system with the same libraries?

Also, with a full corefile, if we know the dirty-memory-page list, if a memory region corresponds to a binary (libc.so text for instance), why should we read the memory from the inferior at all? We can copy the pages of the binary into the memory buffer. On a Darwin system, the vast majority of a full corefile are system binaries that are unmodified; it would make a full coredump a lot faster to create. I don't think perf is the most important thing with a corefile, but just some thoughts I had while looking at this.

[jasonmolenda]

Update to address previous review comments. (1) Update SBMemoryRegionInfo API to provide access to the dirty page information. (2) Update the 'memory region' command output to print the dirty page list. (3) Update the 'process save-core' command to take a --style option with accepts an enum for the type of corefile. (4) Update 'process save-core' text to explain the limitations of a modified-memory-only corefile. (5) Add a API/functionalities/gdb_remote_client test with a stub that returns the region infos with these new fields, and tests the SBMemoryRegionInfo object filled in on the debugger side. I think that's everything.

There's still a hang when running the GDBRemoteCommunicationClientTest.cpp tests (GDBRemoteCommunicationClientTest::GetMemoryRegionInfo and GDBRemoteCommunicationClientTest::GetMemoryRegionInfoInvalidResponse) that I haven't gotten to the bottom of yet, but I thought I'd update the patchset on the phab with where I am now, while I work through this last issue.

[labath]

lldb/include/lldb/Target/MemoryRegionInfo.h

41–43

This bit is unnecessary. In fact, I'd implement the entire function as *this = MemoryRegionInfo();

115

const Optional<...> & to avoid a copy.

122–124

m_dirty_pages = std::move(pagelist);

lldb/include/lldb/lldb-private-interfaces.h

58–59

Maybe just have one argument which will be set on exit to reflect the actual style that was used?

lldb/source/API/SBMemoryRegionInfo.cpp

142

const T &

lldb/source/Commands/CommandObjectMemory.cpp

1742

const T &

1750–1760

I think something like this ought to do:
AppendMessageWithFormatv("Dirty pages: {0:@[x]}.\n", llvm::make_range(dirty_page_list->begin(), dirty_page_list->end()));

lldb/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp

194

I don't think this is a good use of that constant. Minidumps can also come in "full" styles, which includes all memory, or some smaller ones, where only the heap (or it's modified portion, or just stack, etc.) is included.

In essence, "minidump" is just a format, just like "elf" and "macho". It's peculiarity is that it is different from the native object file format, but that's not relevant here.

I think that the best way to handle this is to make the choice of format should be orthogonal to the choice of what goes into the dump. Currently we don't allow the user to pick a format, and that's fine -- we'll just pick whatever is the native format for the given platform. But I don't think we should start mixing the two.

[DavidSpickett]

FYI my change to add the memory tagging flag (https://reviews.llvm.org/D87442) has landed so you will have some conflicts.

[jasonmolenda]

Update patch to:

1. Fix the testsuite hang I was getting in the unittests.

2. Incorporate Pavel's great review feedback from last November -- thanks Pavel! Most importantly, I misunderstood the nature of Minidumps, I thought a Minidump described a minimal snapshot of process memory (maybe stack memory) that can be captured for more detailed crash analysis, so I offered it as a coredump style in addition to "full coredump" and "dirty memory coredump", but this was incorrect. I've removed Minidump as a coredump style option.

3. Rebased to current llvm.

It all looks good, pasts the testsuite on Darwin, by-hand testing all works right. I'll land it soon.

lldb/bindings/interface/SBMemoryRegionInfo.i

public:
     IsExecutable ();
 
     bool
     IsMapped ();
 
     const char *
     GetName ();
 
+    %feature("autodoc", "
+        GetRegionEnd(SBMemoryRegionInfo self) -> lldb::addr_t
+        Returns whether this memory region has a list of modified (dirty)
+        pages available or not.  When calling GetNumDirtyPages(), you will
+        have 0 returned for both \"dirty page list is not known\" and 
+        \"empty dirty page list\" (that is, no modified pages in this
+        memory region).  You must use this method to disambiguate.") HasDirtyMemoryPageList;
+    bool 
+    HasDirtyMemoryPageList();
+
+    %feature("autodoc", "
+        GetNumDirtyPages(SBMemoryRegionInfo self) -> uint32_t
+        Return the number of dirty (modified) memory pages in this
+        memory region, if available.  You must use the 
+        SBMemoryRegionInfo::HasDirtyMemoryPageList() method to
+        determine if a dirty memory list is available; it will depend
+        on the target system can provide this information.") GetNumDirtyPages;
+    uint32_t 
+    GetNumDirtyPages();
+
+    %feature("autodoc", "
+        GetDirtyPageAddressAtIndex(SBMemoryRegionInfo self, uint32_t idx) -> lldb::addr_t
+        Return the address of a modified, or dirty, page of memory.
+        If the provided index is out of range, or this memory region 
+        does not have dirty page information, LLDB_INVALID_ADDRESS 
+        is returned.") GetDirtyPageAddressAtIndex;
+    addr_t 
+    GetDirtyPageAddressAtIndex(uint32_t idx);
+
+    %feature("autodoc", "
+        GetPageSize(SBMemoryRegionInfo self) -> int
+        Return the size of pages in this memory region.  0 will be returned
+        if this information was unavailable.") GetPageSize();
+    int
+    GetPageSize();
+
     bool
     operator == (const lldb::SBMemoryRegionInfo &rhs) const;
 
     bool
     operator != (const lldb::SBMemoryRegionInfo &rhs) const;
 
     bool
     GetDescription (lldb::SBStream &description);
 
     STRING_EXTENSION(SBMemoryRegionInfo)
 };
 
 } // namespace lldb

lldb/docs/lldb-gdb-remote.txt

 os_kernel: a string describing the kernel version
 os_version: a version string that represents the current OS version (10.8.2)
 watchpoint_exceptions_received: one of "before" or "after" to specify if a watchpoint is triggered before or after the pc when it stops
 default_packet_timeout: an unsigned number that specifies the default timeout in seconds
 distribution_id: optional. For linux, specifies distribution id (e.g. ubuntu, fedora, etc.)
 osmajor: optional, specifies the major version number of the OS (e.g. for macOS 10.12.2, it would be 10)
 osminor: optional, specifies the minor version number of the OS (e.g. for macOS 10.12.2, it would be 12)
 ospatch: optional, specifies the patch level number of the OS (e.g. for macOS 10.12.2, it would be 2)
+vm-page-size: optional, specifies the target system VM page size, base 10.
+           Needed for the "dirty-pages:" list in the qMemoryRegionInfo
+           packet, where a list of dirty pages is sent from the remote 
+           stub.  This page size tells lldb how large each dirty page is.
 addressing_bits: optional, specifies how many bits in addresses are
      significant for addressing, base 10.  If bits 38..0
      in a 64-bit pointer are significant for addressing,
-     then the value is 39.  This is needed on e.g. Aarch64
+     then the value is 39.  This is needed on e.g. AArch64
      v8.3 ABIs that use pointer authentication, so lldb
      knows which bits to clear/set to get the actual
      addresses.
 
 //----------------------------------------------------------------------
 // "qGDBServerVersion"
 //
 // BRIEF
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.
 
     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.
+                 //
+                 // If the stub supports identifying dirty pages within a
+                 // memory region, this key should always be present for all
+                 // qMemoryRegionInfo replies.  This key with no pages 
+                 // listed ("dirty-pages:;") indicates no dirty pages in 
+                 // this memory region.  The *absence* of this key means
+                 // that this stub cannot determine dirty pages.
+
 If the address requested is not in a mapped region (e.g. we've jumped through
 a NULL pointer and are at 0x0) currently lldb expects to get back the size
 of the unmapped region -- that is, the distance to the next valid region.
 For instance, with a macOS process which has nothing mapped in the first
 4GB of its address space, if we're asking about address 0x2,
 
   qMemoryRegionInfo:2
   start:2;size:fffffffe;

lldb/include/lldb/API/SBMemoryRegionInfo.h

public:
   /// address.
   ///
   /// \return
   ///     In case of memory mapped files it is the absolute path of
   ///     the file otherwise it is a name associated with the memory
   ///     region. If no name can be determined the returns nullptr.
   const char *GetName();
 
+  /// Returns whether this memory region has a list of memory pages
+  /// that have been modified -- that are dirty.
+  ///
+  /// \return
+  ///     True if the dirty page list is available.
+  bool HasDirtyMemoryPageList();
+
+  /// Returns the number of modified pages -- dirty pages -- in this
+  /// memory region.
+  ///
+  /// \return
+  ///     The number of dirty page entries will be returned.  If
+  ///     there are no dirty pages in this memory region, 0 will
+  ///     be returned.  0 will also be returned if the dirty page
+  ///     list is not available for this memory region -- you must
+  ///     use HasDirtyMemoryPageList() to check for that.
+  uint32_t GetNumDirtyPages();
+
+  /// Returns the address of a memory page that has been modified in
+  /// this region.
+  ///
+  /// \return
+  ///     Returns the address for his dirty page in the list.
+  ///     If this memory region does not have a dirty page list,
+  ///     LLDB_INVALID_ADDRESS is returned.
+  addr_t GetDirtyPageAddressAtIndex(uint32_t idx);
+
+  /// Returns the size of a memory page in this region.
+  ///
+  /// \return
+  ///     Returns the size of the memory pages in this region,
+  ///     or 0 if this information is unavailable.
+  int GetPageSize();
+
   bool operator==(const lldb::SBMemoryRegionInfo &rhs) const;
 
   bool operator!=(const lldb::SBMemoryRegionInfo &rhs) const;
 
   bool GetDescription(lldb::SBStream &description);
 
 private:
   friend class SBProcess;

lldb/include/lldb/Core/PluginManager.h

public:
 
   static ObjectFileGetModuleSpecifications
   GetObjectFileGetModuleSpecificationsCallbackAtIndex(uint32_t idx);
 
   static ObjectFileCreateMemoryInstance
   GetObjectFileCreateMemoryCallbackForPluginName(ConstString name);
 
   static Status SaveCore(const lldb::ProcessSP &process_sp,
-                         const FileSpec &outfile);
+                         const FileSpec &outfile,
+                         lldb::SaveCoreStyle &core_style);
 
   // ObjectContainer
   static bool
   RegisterPlugin(ConstString name, const char *description,
                  ObjectContainerCreateInstance create_callback,
                  ObjectFileGetModuleSpecifications get_module_specifications);
 
   static bool UnregisterPlugin(ObjectContainerCreateInstance create_callback);

lldb/include/lldb/Symbol/ObjectFile.h

public:
   ///
   /// \param[in] target
   ///     Target where to load.
   virtual std::vector<LoadableData> GetLoadableData(Target &target);
 
   /// Creates a plugin-specific call frame info
   virtual std::unique_ptr<CallFrameInfo> CreateCallFrameInfo();
 
+  /// Load binaries listed in a corefile
+  ///
+  /// A corefile may have metadata listing binaries that can be loaded,
+  /// and the offsets at which they were loaded.  This method will try
+  /// to add them to the Target.  If any binaries were loaded,
+  ///
+  /// \param[in] process
+  ///     Process where to load binaries.
+  ///
+  /// \return
+  ///     Returns true if any binaries were loaded.
+
+  virtual bool LoadCoreFileImages(lldb_private::Process &process) {
+    return false;
+  }
+
 protected:
   // Member variables.
   FileSpec m_file;
   Type m_type;
   Strata m_strata;
   lldb::addr_t m_file_offset; ///< The offset in bytes into the file, or the
                               ///address in memory
   lldb::addr_t m_length; ///< The length of this object file if it is known (can
                          ///be zero if length is unknown or can't be
                          ///determined).
   DataExtractor
       m_data; ///< The data for this object file so things can be parsed lazily.
   lldb::ProcessWP m_process_wp;
   const lldb::addr_t m_memory_addr;
   std::unique_ptr<lldb_private::SectionList> m_sections_up;
   std::unique_ptr<lldb_private::Symtab> m_symtab_up;
   uint32_t m_synthetic_symbol_idx;
 
   /// Sets the architecture for a module.  At present the architecture can
   /// only be set if it is invalid.  It is not allowed to switch from one
   /// concrete architecture to another.
   ///
   /// \param[in] new_arch
   ///     The architecture this module will be set to.
   ///
   /// \return
   ///     Returns \b true if the architecture was changed, \b

lldb/include/lldb/Target/MemoryRegionInfo.h

 //===-- MemoryRegionInfo.h ---------------------------------------*- C++
 //-*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_TARGET_MEMORYREGIONINFO_H
 #define LLDB_TARGET_MEMORYREGIONINFO_H
 
+#include <vector>
+
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/RangeMap.h"
+#include "llvm/ADT/Optional.h"
 #include "llvm/Support/FormatProviders.h"
 
 namespace lldb_private {
 class MemoryRegionInfo {
 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)
       : 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) {}
 
   RangeType &GetRange() { return m_range; }
 
-  void Clear() {
-    m_range.Clear();
-    m_read = m_write = m_execute = m_memory_tagged = eDontKnow;
-  }
+  void Clear() { *this = MemoryRegionInfo(); }
 
   const RangeType &GetRange() const { return m_range; }
 
   OptionalBool GetReadable() const { return m_read; }
 
   OptionalBool GetWritable() const { return m_write; }
 
   OptionalBool GetExecutable() const { return m_execute; }
 
   OptionalBool GetMapped() const { return m_mapped; }
 
   ConstString GetName() const { return m_name; }
 
void SetLLDBPermissions(uint32_t permissions) {
     m_execute = (permissions & lldb::ePermissionsExecutable) ? eYes : eNo;
   }
 
   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_memory_tagged == rhs.m_memory_tagged &&
+           m_pagesize == rhs.m_pagesize;
   }
 
   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;
+  }
+
+  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;
+  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();
 }
 
 inline bool operator<(const MemoryRegionInfo &lhs, lldb::addr_t rhs) {

lldb/include/lldb/lldb-enumerations.h

enum CommandArgumentType {
   eArgTypePlatform,
   eArgTypeWatchpointID,
   eArgTypeWatchpointIDRange,
   eArgTypeWatchType,
   eArgRawInput,
   eArgTypeCommand,
   eArgTypeColumnNum,
   eArgTypeModuleUUID,
+  eArgTypeSaveCoreStyle,
   eArgTypeLastArg // Always keep this entry as the last entry in this
                   // enumeration!!
 };
 
 /// Symbol types.
 // Symbol holds the SymbolType in a 6-bit field (m_type), so if you get over 63
 // entries you will have to resize that field.
 enum SymbolType {
enum CommandInterpreterResult {
   /// crashed.
   eCommandInterpreterResultInferiorCrash,
   /// Stopped because the corresponding option was set and a command returned
   /// an error.
   eCommandInterpreterResultCommandError,
   /// Stopped because quit was requested.
   eCommandInterpreterResultQuitRequested,
 };
+
+// Style of core file to create when calling SaveCore.
+enum SaveCoreStyle {
+  eSaveCoreUnspecified = 0,
+  eSaveCoreFull = 1,
+  eSaveCoreDirtyOnly = 2,
+};
+
 } // namespace lldb
 
 #endif // LLDB_LLDB_ENUMERATIONS_H

lldb/include/lldb/lldb-private-interfaces.h

typedef ObjectFile *(*ObjectFileCreateInstance)(const lldb::ModuleSP &module_sp,
                                                 lldb::offset_t data_offset,
                                                 const FileSpec *file,
                                                 lldb::offset_t file_offset,
                                                 lldb::offset_t length);
 typedef ObjectFile *(*ObjectFileCreateMemoryInstance)(
     const lldb::ModuleSP &module_sp, lldb::DataBufferSP &data_sp,
     const lldb::ProcessSP &process_sp, lldb::addr_t offset);
 typedef bool (*ObjectFileSaveCore)(const lldb::ProcessSP &process_sp,
-                                   const FileSpec &outfile, Status &error);
+                                   const FileSpec &outfile,
+                                   lldb::SaveCoreStyle &core_style,
+                                   Status &error);
 typedef EmulateInstruction *(*EmulateInstructionCreateInstance)(
     const ArchSpec &arch, InstructionType inst_type);
 typedef OperatingSystem *(*OperatingSystemCreateInstance)(Process *process,
                                                           bool force);
 typedef Language *(*LanguageCreateInstance)(lldb::LanguageType language);
 typedef LanguageRuntime *(*LanguageRuntimeCreateInstance)(
     Process *process, lldb::LanguageType language);
 typedef lldb::CommandObjectSP (*LanguageRuntimeGetCommandObject)(

lldb/packages/Python/lldbsuite/test/tools/lldb-server/gdbremote_testcase.py

def parse_memory_region_packet(self, context):
         # Validate keys are known.
         for (key, val) in list(mem_region_dict.items()):
             self.assertIn(key,
                 ["start",
                  "size",
                  "permissions",
                  "flags",
                  "name",
-                 "error"])
+                 "error",
+                 "dirty-pages"])
             self.assertIsNotNone(val)
 
         mem_region_dict["name"] = seven.unhexlify(mem_region_dict.get("name", ""))
         # Return the dictionary of key-value pairs for the memory region.
         return mem_region_dict
 
     def assert_address_within_memory_region(
             self, test_address, mem_region_dict):

lldb/source/API/SBMemoryRegionInfo.cpp

 }
 
 const char *SBMemoryRegionInfo::GetName() {
   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBMemoryRegionInfo, GetName);
 
   return m_opaque_up->GetName().AsCString();
 }
 
+bool SBMemoryRegionInfo::HasDirtyMemoryPageList() {
+  LLDB_RECORD_METHOD_NO_ARGS(bool, SBMemoryRegionInfo, HasDirtyMemoryPageList);
+
+  return m_opaque_up->GetDirtyPageList().hasValue();
+}
+
+uint32_t SBMemoryRegionInfo::GetNumDirtyPages() {
+  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBMemoryRegionInfo, GetNumDirtyPages);
+
+  uint32_t num_dirty_pages = 0;
+  llvm::Optional<std::vector<addr_t>> dirty_page_list =
+      m_opaque_up->GetDirtyPageList();
+  if (dirty_page_list.hasValue())
+    num_dirty_pages = dirty_page_list.getValue().size();
+
+  return num_dirty_pages;
+}
+
+addr_t SBMemoryRegionInfo::GetDirtyPageAddressAtIndex(uint32_t idx) {
+  LLDB_RECORD_METHOD(addr_t, SBMemoryRegionInfo, GetDirtyPageAddressAtIndex,
+                     (uint32_t), idx);
+
+  addr_t dirty_page_addr = LLDB_INVALID_ADDRESS;
+  const llvm::Optional<std::vector<addr_t>> &dirty_page_list =
+      m_opaque_up->GetDirtyPageList();
+  if (dirty_page_list.hasValue() && idx < dirty_page_list.getValue().size())
+    dirty_page_addr = dirty_page_list.getValue()[idx];
+
+  return dirty_page_addr;
+}
+
+int SBMemoryRegionInfo::GetPageSize() {
+  LLDB_RECORD_METHOD_NO_ARGS(int, SBMemoryRegionInfo, GetPageSize);
+  return m_opaque_up->GetPageSize();
+}
+
 bool SBMemoryRegionInfo::GetDescription(SBStream &description) {
   LLDB_RECORD_METHOD(bool, SBMemoryRegionInfo, GetDescription,
                      (lldb::SBStream &), description);
 
   Stream &strm = description.ref();
   const addr_t load_addr = m_opaque_up->GetRange().base;
 
   strm.Printf("[0x%16.16" PRIx64 "-0x%16.16" PRIx64 " ", load_addr,

lldb/source/API/SBProcess.cpp

std::lock_guard<std::recursive_mutex> guard(
       process_sp->GetTarget().GetAPIMutex());
 
   if (process_sp->GetState() != eStateStopped) {
     error.SetErrorString("the process is not stopped");
     return LLDB_RECORD_RESULT(error);
   }
 
   FileSpec core_file(file_name);
-  error.ref() = PluginManager::SaveCore(process_sp, core_file);
+  SaveCoreStyle core_style = SaveCoreStyle::eSaveCoreFull;
+  error.ref() = PluginManager::SaveCore(process_sp, core_file, core_style);
   return LLDB_RECORD_RESULT(error);
 }
 
 lldb::SBError
 SBProcess::GetMemoryRegionInfo(lldb::addr_t load_addr,
                                SBMemoryRegionInfo &sb_region_info) {
   LLDB_RECORD_METHOD(lldb::SBError, SBProcess, GetMemoryRegionInfo,
                      (lldb::addr_t, lldb::SBMemoryRegionInfo &), load_addr,

lldb/source/Commands/CommandObjectMemory.cpp

if (error.Success()) {
           range_info.GetRange().GetRangeEnd(), range_info.GetReadable(),
           range_info.GetWritable(), range_info.GetExecutable(), name ? " " : "",
           name, section_name ? " " : "", section_name);
       MemoryRegionInfo::OptionalBool memory_tagged =
           range_info.GetMemoryTagged();
       if (memory_tagged == MemoryRegionInfo::OptionalBool::eYes)
         result.AppendMessage("memory tagging: enabled");
 
+      const llvm::Optional<std::vector<addr_t>> &dirty_page_list =
+          range_info.GetDirtyPageList();
+      if (dirty_page_list.hasValue()) {
+        const size_t page_count = dirty_page_list.getValue().size();
+        result.AppendMessageWithFormat(
+            "Modified memory (dirty) page list provided, %zu entries.\n",
+            page_count);
+        if (page_count > 0) {
+          bool print_comma = false;
+          result.AppendMessageWithFormat("Dirty pages: ");
+          for (size_t i = 0; i < page_count; i++) {
+            if (print_comma)
+              result.AppendMessageWithFormat(", ");
+            else
+              print_comma = true;
+            result.AppendMessageWithFormat("0x%" PRIx64,
+                                           dirty_page_list.getValue()[i]);
+          }
+          result.AppendMessageWithFormat(".\n");
+        }
+      }
+
       m_prev_end_addr = range_info.GetRange().GetRangeEnd();
       result.SetStatus(eReturnStatusSuccessFinishResult);
       return true;
     }
 
     result.AppendErrorWithFormat("%s\n", error.AsCString());
     return false;
   }
CommandObjectMemory::CommandObjectMemory(CommandInterpreter &interpreter)
   LoadSubCommand("write",
                  CommandObjectSP(new CommandObjectMemoryWrite(interpreter)));
   LoadSubCommand("history",
                  CommandObjectSP(new CommandObjectMemoryHistory(interpreter)));
   LoadSubCommand("region",
                  CommandObjectSP(new CommandObjectMemoryRegion(interpreter)));
 }
 
 CommandObjectMemory::~CommandObjectMemory() = default;

lldb/source/Commands/CommandObjectProcess.cpp

bool DoExecute(Args &command, CommandReturnObject &result) override {
     }
     return result.Succeeded();
   }
 };
 
 // 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"}};
+
+static constexpr OptionEnumValues SaveCoreStyles() {
+  return OptionEnumValues(g_corefile_save_style);
+}
+
+#define LLDB_OPTIONS_process_save_core
+#include "CommandOptions.inc"
+
 class CommandObjectProcessSaveCore : public CommandObjectParsed {
 public:
   CommandObjectProcessSaveCore(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "process save-core",
                             "Save the current process as a core file using an "
                             "appropriate file type.",
-                            "process save-core FILE",
+                            "process save-core [-s corefile-style] FILE",
                             eCommandRequiresProcess | eCommandTryTargetAPILock |
                                 eCommandProcessMustBeLaunched) {}
 
   ~CommandObjectProcessSaveCore() override = default;
 
+  Options *GetOptions() override { return &m_options; }
+
+  class CommandOptions : public Options {
+  public:
+    CommandOptions()
+        : Options(), m_requested_save_core_style(eSaveCoreUnspecified) {}
+
+    ~CommandOptions() override = default;
+
+    llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
+      return llvm::makeArrayRef(g_process_save_core_options);
+    }
+
+    Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
+                          ExecutionContext *execution_context) override {
+      const int short_option = m_getopt_table[option_idx].val;
+      Status error;
+
+      switch (short_option) {
+      case 's':
+        m_requested_save_core_style =
+            (lldb::SaveCoreStyle)OptionArgParser::ToOptionEnum(
+                option_arg, GetDefinitions()[option_idx].enum_values,
+                eSaveCoreUnspecified, error);
+        break;
+      default:
+        llvm_unreachable("Unimplemented option");
+      }
+
+      return {};
+    }
+
+    void OptionParsingStarting(ExecutionContext *execution_context) override {
+      m_requested_save_core_style = eSaveCoreUnspecified;
+    }
+
+    // Instance variables to hold the values for command options.
+    SaveCoreStyle m_requested_save_core_style;
+  };
+
 protected:
   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));
-        Status error = PluginManager::SaveCore(process_sp, output_file);
+        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) {
+            result.AppendMessageWithFormat(
+                "\nModified-memory only corefile "
+                "created.  This corefile may not show \n"
+                "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 {
           result.AppendErrorWithFormat(
               "Failed to save core file for process: %s\n", error.AsCString());
         }
       } else {
         result.AppendErrorWithFormat("'%s' takes one arguments:\nUsage: %s\n",
                                      m_cmd_name.c_str(), m_cmd_syntax.c_str());
       }
     } else {
       result.AppendError("invalid process");
       return false;
     }
 
     return result.Succeeded();
   }
+
+  CommandOptions m_options;
 };
 
 // CommandObjectProcessStatus
 #pragma mark CommandObjectProcessStatus
 #define LLDB_OPTIONS_process_status
 #include "CommandOptions.inc"
 
 class CommandObjectProcessStatus : public CommandObjectParsed {

lldb/source/Commands/Options.td

def process_handle_pass : Option<"pass", "p">, Group<1>, Arg<"Boolean">,
     Desc<"Whether or not the signal should be passed to the process.">;
 }
 
 let Command = "process status" in {
   def process_status_verbose : Option<"verbose", "v">, Group<1>,
     Desc<"Show verbose process status including extended crash information.">;
 }
 
+let Command = "process save_core" in {
+  def process_save_core_style : Option<"style", "s">, Group<1>,
+    EnumArg<"SaveCoreStyle", "SaveCoreStyles()">, Desc<"Request a specific style "
+    "of corefile to be saved.">;
+}
+
 let Command = "script import" in {
   def script_import_allow_reload : Option<"allow-reload", "r">, Group<1>,
     Desc<"Allow the script to be loaded even if it was already loaded before. "
     "This argument exists for backwards compatibility, but reloading is always "
     "allowed, whether you specify it or not.">;
   def relative_to_command_file : Option<"relative-to-command-file", "c">,
     Group<1>, Desc<"Resolve non-absolute paths relative to the location of the "
     "current command file. This argument can only be used when the command is "

lldb/source/Core/PluginManager.cpp

PluginManager::GetObjectFileCreateMemoryCallbackForPluginName(
   for (auto &instance : instances) {
     if (instance.name == name)
       return instance.create_memory_callback;
   }
   return nullptr;
 }
 
 Status PluginManager::SaveCore(const lldb::ProcessSP &process_sp,
-                               const FileSpec &outfile) {
+                               const FileSpec &outfile,
+                               lldb::SaveCoreStyle &core_style) {
   Status error;
   auto &instances = GetObjectFileInstances().GetInstances();
   for (auto &instance : instances) {
-    if (instance.save_core && instance.save_core(process_sp, outfile, error))
+    if (instance.save_core &&
+        instance.save_core(process_sp, outfile, core_style, error))
       return error;
   }
   error.SetErrorString(
       "no ObjectFile plugins were able to save a core for this process");
   return error;
 }
 
 #pragma mark ObjectContainer

lldb/source/Interpreter/CommandObject.cpp

CommandObject::ArgumentTableEntry CommandObject::g_arguments_data[] = {
     { eArgTypeNone, "none", CommandCompletions::eNoCompletion, { nullptr, false }, "No help available for this." },
     { eArgTypePlatform, "platform-name", CommandCompletions::ePlatformPluginCompletion, { nullptr, false }, "The name of an installed platform plug-in . Type 'platform list' to see a complete list of installed platforms." },
     { eArgTypeWatchpointID, "watchpt-id", CommandCompletions::eNoCompletion, { nullptr, false }, "Watchpoint IDs are positive integers." },
     { eArgTypeWatchpointIDRange, "watchpt-id-list", CommandCompletions::eNoCompletion, { nullptr, false }, "For example, '1-3' or '1 to 3'." },
     { eArgTypeWatchType, "watch-type", CommandCompletions::eNoCompletion, { nullptr, false }, "Specify the type for a watchpoint." },
     { eArgRawInput, "raw-input", CommandCompletions::eNoCompletion, { nullptr, false }, "Free-form text passed to a command without prior interpretation, allowing spaces without requiring quotes.  To pass arguments and free form text put two dashes ' -- ' between the last argument and any raw input." },
     { eArgTypeCommand, "command", CommandCompletions::eNoCompletion, { nullptr, false }, "An LLDB Command line command." },
     { eArgTypeColumnNum, "column", CommandCompletions::eNoCompletion, { nullptr, false }, "Column number in a source file." },
-    { eArgTypeModuleUUID, "module-uuid", CommandCompletions::eModuleUUIDCompletion, { nullptr, false }, "A module UUID value." }
+    { eArgTypeModuleUUID, "module-uuid", CommandCompletions::eModuleUUIDCompletion, { nullptr, false }, "A module UUID value." },
+    { eArgTypeSaveCoreStyle, "corefile-style", CommandCompletions::eNoCompletion, { nullptr, false }, "The type of corefile that lldb will try to create, dependant on this target's capabilities." }
     // clang-format on
 };
 
 const CommandObject::ArgumentTableEntry *CommandObject::GetArgumentTable() {
   // If this assertion fires, then the table above is out of date with the
   // CommandArgumentType enumeration
   static_assert((sizeof(CommandObject::g_arguments_data) /
                  sizeof(CommandObject::ArgumentTableEntry)) == eArgTypeLastArg,
                 "");
   return CommandObject::g_arguments_data;
 }

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

 #define LLDB_SOURCE_PLUGINS_OBJECTFILE_MACH_O_OBJECTFILEMACHO_H
 
 #include "lldb/Core/Address.h"
 #include "lldb/Core/FileSpecList.h"
 #include "lldb/Host/SafeMachO.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/RangeMap.h"
 #include "lldb/Utility/UUID.h"
 
 // This class needs to be hidden as eventually belongs in a plugin that
 // will export the ObjectFile protocol
 class ObjectFileMachO : public lldb_private::ObjectFile {
 public:
   ObjectFileMachO(const lldb::ModuleSP &module_sp, lldb::DataBufferSP &data_sp,
                   lldb::offset_t data_offset,
                   const lldb_private::FileSpec *file, lldb::offset_t offset,
static size_t GetModuleSpecifications(const lldb_private::FileSpec &file,
                                         lldb::DataBufferSP &data_sp,
                                         lldb::offset_t data_offset,
                                         lldb::offset_t file_offset,
                                         lldb::offset_t length,
                                         lldb_private::ModuleSpecList &specs);
 
   static bool SaveCore(const lldb::ProcessSP &process_sp,
                        const lldb_private::FileSpec &outfile,
+                       lldb::SaveCoreStyle &core_style,
                        lldb_private::Status &error);
 
   static bool MagicBytesMatch(lldb::DataBufferSP &data_sp, lldb::addr_t offset,
                               lldb::addr_t length);
 
   // LLVM RTTI support
   static char ID;
   bool isA(const void *ClassID) const override {
public:
   uint32_t GetNumThreadContexts() override;
 
   std::string GetIdentifierString() override;
 
   bool GetCorefileMainBinaryInfo(lldb::addr_t &address,
                                  lldb_private::UUID &uuid,
                                  ObjectFile::BinaryType &type) override;
 
+  bool LoadCoreFileImages(lldb_private::Process &process) override;
+
   lldb::RegisterContextSP
   GetThreadContextAtIndex(uint32_t idx, lldb_private::Thread &thread) override;
 
   ObjectFile::Type CalculateType() override;
 
   ObjectFile::Strata CalculateStrata() override;
 
   llvm::VersionTuple GetVersion() override;
 
   llvm::VersionTuple GetMinimumOSVersion() override;
 
protected:
   void ProcessSegmentCommand(const llvm::MachO::load_command &load_cmd,
                              lldb::offset_t offset, uint32_t cmd_idx,
                              SegmentParsingContext &context);
   void SanitizeSegmentCommand(llvm::MachO::segment_command_64 &seg_cmd,
                               uint32_t cmd_idx);
 
   bool SectionIsLoadable(const lldb_private::Section *section);
 
+  /// A corefile may include metadata about all of the binaries that were
+  /// present in the process when the corefile was taken.  This is only
+  /// implemented for Mach-O files for now; we'll generalize it when we
+  /// have other systems that can include the same.
+  struct MachOCorefileImageEntry {
+    std::string filename;
+    lldb_private::UUID uuid;
+    lldb::addr_t load_address = LLDB_INVALID_ADDRESS;
+    bool currently_executing;
+    std::vector<std::tuple<lldb_private::ConstString, lldb::addr_t>>
+        segment_load_addresses;
+  };
+
+  struct MachOCorefileAllImageInfos {
+    std::vector<MachOCorefileImageEntry> all_image_infos;
+    bool IsValid() { return all_image_infos.size() > 0; }
+  };
+
+  /// Get the list of binary images that were present in the process
+  /// when the corefile was produced.
+  /// \return
+  ///     The MachOCorefileAllImageInfos object returned will have
+  ///     IsValid() == false if the information is unavailable.
+  MachOCorefileAllImageInfos GetCorefileAllImageInfos();
+
   llvm::MachO::mach_header m_header;
   static lldb_private::ConstString GetSegmentNameTEXT();
   static lldb_private::ConstString GetSegmentNameDATA();
   static lldb_private::ConstString GetSegmentNameDATA_DIRTY();
   static lldb_private::ConstString GetSegmentNameDATA_CONST();
   static lldb_private::ConstString GetSegmentNameOBJC();
   static lldb_private::ConstString GetSegmentNameLINKEDIT();
   static lldb_private::ConstString GetSegmentNameDWARF();

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

 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Progress.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Host/SafeMachO.h"
 #include "lldb/Symbol/DWARFCallFrameInfo.h"
+#include "lldb/Symbol/LocateSymbolFile.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/DynamicLoader.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
lldb::addr_t ObjectFileMachO::CalculateSectionLoadAddressForMemoryImage(
     lldb::addr_t header_load_address, const Section *header_section,
     const Section *section) {
   ModuleSP module_sp = GetModule();
   if (module_sp && header_section && section &&
       header_load_address != LLDB_INVALID_ADDRESS) {
     lldb::addr_t file_addr = header_section->GetFileAddress();
     if (file_addr != LLDB_INVALID_ADDRESS && SectionIsLoadable(section))
       return section->GetFileAddress() - file_addr + header_load_address;
   }
   return LLDB_INVALID_ADDRESS;
 }
 
 bool ObjectFileMachO::SetLoadAddress(Target &target, lldb::addr_t value,
                                      bool value_is_offset) {
   ModuleSP module_sp = GetModule();
   if (!module_sp)
     return false;
 
   SectionList *section_list = GetSectionList();
   if (!section_list)
     return false;
 
   size_t num_loaded_sections = 0;
   const size_t num_sections = section_list->GetSize();
 
if (mach_header_section) {
         lldb::addr_t section_load_addr =
             CalculateSectionLoadAddressForMemoryImage(
                 value, mach_header_section, section_sp.get());
         if (section_load_addr != LLDB_INVALID_ADDRESS) {
           if (target.GetSectionLoadList().SetSectionLoadAddress(
                   section_sp, section_load_addr))
             ++num_loaded_sections;
         }
       }
     }
   }
   return num_loaded_sections > 0;
 }
 
+struct all_image_infos_header {
+  uint32_t version;         // currently 1
+  uint32_t imgcount;        // number of binary images
+  uint64_t entries_fileoff; // file offset in the corefile of where the array of
+                            // struct entry's begin.
+  uint32_t entries_size;    // size of 'struct entry'.
+  uint32_t unused;
+};
+
+struct image_entry {
+  uint64_t filepath_offset;  // offset in corefile to c-string of the file path,
+                             // UINT64_MAX if unavailable.
+  uuid_t uuid;               // uint8_t[16].  should be set to all zeroes if
+                             // uuid is unknown.
+  uint64_t load_address;     // UINT64_MAX if unknown.
+  uint64_t seg_addrs_offset; // offset to the array of struct segment_vmaddr's.
+  uint32_t segment_count;    // The number of segments for this binary.
+  uint32_t unused;
+
+  image_entry() {
+    filepath_offset = UINT64_MAX;
+    memset(&uuid, 0, sizeof(uuid_t));
+    segment_count = 0;
+    load_address = UINT64_MAX;
+    seg_addrs_offset = UINT64_MAX;
+    unused = 0;
+  }
+  image_entry(const image_entry &rhs) {
+    filepath_offset = rhs.filepath_offset;
+    memcpy(&uuid, &rhs.uuid, sizeof(uuid_t));
+    segment_count = rhs.segment_count;
+    seg_addrs_offset = rhs.seg_addrs_offset;
+    load_address = rhs.load_address;
+    unused = rhs.unused;
+  }
+};
+
+struct segment_vmaddr {
+  char segname[16];
+  uint64_t vmaddr;
+  uint64_t unused;
+
+  segment_vmaddr() {
+    memset(&segname, 0, 16);
+    vmaddr = UINT64_MAX;
+    unused = 0;
+  }
+  segment_vmaddr(const segment_vmaddr &rhs) {
+    memcpy(&segname, &rhs.segname, 16);
+    vmaddr = rhs.vmaddr;
+    unused = rhs.unused;
+  }
+};
+
+// Write the payload for the "all image infos" LC_NOTE into
+// the supplied all_image_infos_payload, assuming that this
+// will be written into the corefile starting at
+// initial_file_offset.
+//
+// The placement of this payload is a little tricky.  We're
+// laying this out as
+//
+// 1. header (struct all_image_info_header)
+// 2. Array of fixed-size (struct image_entry)'s, one
+//    per binary image present in the process.
+// 3. Arrays of (struct segment_vmaddr)'s, a varying number
+//    for each binary image.
+// 4. Variable length c-strings of binary image filepaths,
+//    one per binary.
+//
+// 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) {
+  Target &target = process_sp->GetTarget();
+  const ModuleList &modules = target.GetImages();
+  size_t modules_count = modules.GetSize();
+
+  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());
+        }
+      }
+    }
+  }
+
+  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;
+
+  all_image_infos_payload.PutHex32(infos.version);
+  all_image_infos_payload.PutHex32(infos.imgcount);
+  all_image_infos_payload.PutHex64(infos.entries_fileoff);
+  all_image_infos_payload.PutHex32(infos.entries_size);
+  all_image_infos_payload.PutHex32(infos.unused);
+
+  // First create the structures for all of the segment name+vmaddr vectors
+  // for each module, so we will know the size of them as we add the
+  // module entries.
+  std::vector<std::vector<segment_vmaddr>> modules_segment_vmaddrs;
+  for (size_t i = 0; i < modules_count; i++) {
+    ModuleSP module = modules.GetModuleAtIndex(i);
+
+    SectionList *sections = module->GetSectionList();
+    size_t sections_count = sections->GetSize();
+    std::vector<segment_vmaddr> segment_vmaddrs;
+    for (size_t j = 0; j < sections_count; j++) {
+      SectionSP section = sections->GetSectionAtIndex(j);
+      if (!section->GetParent().get()) {
+        addr_t vmaddr = section->GetLoadBaseAddress(&target);
+        if (vmaddr == LLDB_INVALID_ADDRESS)
+          continue;
+        ConstString name = section->GetName();
+        segment_vmaddr seg_vmaddr;
+        strncpy(seg_vmaddr.segname, name.AsCString(),
+                sizeof(seg_vmaddr.segname));
+        seg_vmaddr.vmaddr = vmaddr;
+        seg_vmaddr.unused = 0;
+        segment_vmaddrs.push_back(seg_vmaddr);
+      }
+    }
+    modules_segment_vmaddrs.push_back(segment_vmaddrs);
+  }
+
+  offset_t size_of_vmaddr_structs = 0;
+  for (size_t i = 0; i < modules_segment_vmaddrs.size(); i++) {
+    size_of_vmaddr_structs +=
+        modules_segment_vmaddrs[i].size() * sizeof(segment_vmaddr);
+  }
+
+  offset_t size_of_filepath_cstrings = 0;
+  for (size_t i = 0; i < modules_count; i++) {
+    ModuleSP module_sp = modules.GetModuleAtIndex(i);
+    size_of_filepath_cstrings += module_sp->GetFileSpec().GetPath().size() + 1;
+  }
+
+  // Calculate the file offsets of our "all image infos" payload in the
+  // corefile. initial_file_offset the original value passed in to this method.
+
+  offset_t start_of_entries =
+      initial_file_offset + sizeof(all_image_infos_header);
+  offset_t start_of_seg_vmaddrs =
+      start_of_entries + sizeof(image_entry) * modules_count;
+  offset_t start_of_filenames = start_of_seg_vmaddrs + size_of_vmaddr_structs;
+
+  offset_t final_file_offset = start_of_filenames + size_of_filepath_cstrings;
+
+  // Now write the one-per-module 'struct image_entry' into the
+  // StringStream; keep track of where the struct segment_vmaddr
+  // entries for each module will end up in the corefile.
+
+  offset_t current_string_offset = start_of_filenames;
+  offset_t current_segaddrs_offset = start_of_seg_vmaddrs;
+  std::vector<struct image_entry> image_entries;
+  for (size_t i = 0; i < modules_count; i++) {
+    ModuleSP module_sp = modules.GetModuleAtIndex(i);
+
+    struct image_entry ent;
+    memcpy(&ent.uuid, module_sp->GetUUID().GetBytes().data(), sizeof(ent.uuid));
+    if (modules_segment_vmaddrs[i].size() > 0) {
+      ent.segment_count = modules_segment_vmaddrs[i].size();
+      ent.seg_addrs_offset = current_segaddrs_offset;
+    }
+    ent.filepath_offset = current_string_offset;
+    ObjectFile *objfile = module_sp->GetObjectFile();
+    if (objfile) {
+      Address base_addr(objfile->GetBaseAddress());
+      if (base_addr.IsValid()) {
+        ent.load_address = base_addr.GetLoadAddress(&target);
+      }
+    }
+
+    all_image_infos_payload.PutHex64(ent.filepath_offset);
+    all_image_infos_payload.PutRawBytes(ent.uuid, sizeof(ent.uuid));
+    all_image_infos_payload.PutHex64(ent.load_address);
+    all_image_infos_payload.PutHex64(ent.seg_addrs_offset);
+    all_image_infos_payload.PutHex32(ent.segment_count);
+
+    if (executing_uuids.find(module_sp->GetUUID().GetAsString()) !=
+        executing_uuids.end())
+      all_image_infos_payload.PutHex32(1);
+    else
+      all_image_infos_payload.PutHex32(0);
+
+    current_segaddrs_offset += ent.segment_count * sizeof(segment_vmaddr);
+    current_string_offset += module_sp->GetFileSpec().GetPath().size() + 1;
+  }
+
+  // Now write the struct segment_vmaddr entries into the StringStream.
+
+  for (size_t i = 0; i < modules_segment_vmaddrs.size(); i++) {
+    if (modules_segment_vmaddrs[i].size() == 0)
+      continue;
+    for (struct segment_vmaddr segvm : modules_segment_vmaddrs[i]) {
+      all_image_infos_payload.PutRawBytes(segvm.segname, sizeof(segvm.segname));
+      all_image_infos_payload.PutHex64(segvm.vmaddr);
+      all_image_infos_payload.PutHex64(segvm.unused);
+    }
+  }
+
+  for (size_t i = 0; i < modules_count; i++) {
+    ModuleSP module_sp = modules.GetModuleAtIndex(i);
+    std::string filepath = module_sp->GetFileSpec().GetPath();
+    all_image_infos_payload.PutRawBytes(filepath.data(), filepath.size() + 1);
+  }
+
+  return final_file_offset;
+}
+
+// Temp struct used to combine contiguous memory regions with
+// identical permissions.
+struct page_object {
+  addr_t addr;
+  addr_t size;
+  uint32_t prot;
+};
+
 bool ObjectFileMachO::SaveCore(const lldb::ProcessSP &process_sp,
-                               const FileSpec &outfile, Status &error) {
+                               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) {
+    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 ||
        target_triple.getOS() == llvm::Triple::WatchOS ||
        target_triple.getOS() == llvm::Triple::TvOS)) {
if (target_triple.getVendor() == llvm::Triple::Apple &&
 
     if (make_core) {
       std::vector<llvm::MachO::segment_command_64> segment_load_commands;
       //                uint32_t range_info_idx = 0;
       MemoryRegionInfo range_info;
       Status range_error = process_sp->GetMemoryRegionInfo(0, range_info);
       const uint32_t addr_byte_size = target_arch.GetAddressByteSize();
       const ByteOrder byte_order = target_arch.GetByteOrder();
+      std::vector<page_object> pages_to_copy;
+
       if (range_error.Success()) {
         while (range_info.GetRange().GetRangeBase() != LLDB_INVALID_ADDRESS) {
-          const addr_t addr = range_info.GetRange().GetRangeBase();
-          const addr_t size = range_info.GetRange().GetByteSize();
-
-          if (size == 0)
-            break;
-
           // Calculate correct protections
           uint32_t prot = 0;
           if (range_info.GetReadable() == MemoryRegionInfo::eYes)
             prot |= VM_PROT_READ;
           if (range_info.GetWritable() == MemoryRegionInfo::eYes)
             prot |= VM_PROT_WRITE;
           if (range_info.GetExecutable() == MemoryRegionInfo::eYes)
             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) {
-            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 = {
-                cmd_type,     // uint32_t cmd;
-                segment_size, // uint32_t cmdsize;
-                {0},          // char segname[16];
-                addr, // uint64_t vmaddr;    // uint32_t for 32-bit Mach-O
-                size, // uint64_t vmsize;    // uint32_t for 32-bit Mach-O
-                0,    // uint64_t fileoff;   // uint32_t for 32-bit Mach-O
-                size, // uint64_t filesize;  // uint32_t for 32-bit Mach-O
-                prot, // uint32_t maxprot;
-                prot, // uint32_t initprot;
-                0,    // uint32_t nsects;
-                0};   // uint32_t flags;
-            segment_load_commands.push_back(segment);
-          } else {
-            // No protections and a size of 1 used to be returned from old
-            // debugservers when we asked about a region that was past the
-            // last memory region and it indicates the end...
-            if (size == 1)
-              break;
-          }
-
-          range_error = process_sp->GetMemoryRegionInfo(
-              range_info.GetRange().GetRangeEnd(), range_info);
-          if (range_error.Fail())
-            break;
+            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;
+              for (addr_t dirtypage : dirty_page_list.getValue()) {
+                page_object obj = {
+                    .addr = dirtypage, .size = pagesize, .prot = prot};
+                pages_to_copy.push_back(obj);
+              }
+            } else {
+              page_object obj = {.addr = addr, .size = size, .prot = prot};
+              pages_to_copy.push_back(obj);
+            }
+          }
+
+          range_error = process_sp->GetMemoryRegionInfo(
+              range_info.GetRange().GetRangeEnd(), range_info);
+          if (range_error.Fail())
+            break;
+        }
+
+        // Combine contiguous entries that have the same
+        // protections so we don't have an excess of
+        // load commands.
+        std::vector<page_object> combined_page_objects;
+        page_object last_obj;
+        last_obj.addr = LLDB_INVALID_ADDRESS;
+        for (page_object obj : pages_to_copy) {
+          if (last_obj.addr == LLDB_INVALID_ADDRESS) {
+            last_obj = obj;
+            continue;
+          }
+          if (last_obj.addr + last_obj.size == obj.addr &&
+              last_obj.prot == obj.prot) {
+            last_obj.size += obj.size;
+            continue;
+          }
+          combined_page_objects.push_back(last_obj);
+          last_obj = obj;
+        }
+
+        for (page_object obj : combined_page_objects) {
+              obj.addr,     // uint64_t vmaddr;    // uint32_t for 32-bit
+                            // Mach-O
+              obj.size,     // uint64_t vmsize;    // uint32_t for 32-bit
+                            // Mach-O
+              0,            // uint64_t fileoff;   // uint32_t for 32-bit Mach-O
+              obj.size,     // uint64_t filesize;  // uint32_t for 32-bit
+                            // Mach-O
+              obj.prot,     // uint32_t maxprot;
+              obj.prot,     // uint32_t initprot;
+              0,            // uint32_t nsects;
+              0};           // uint32_t flags;
         }
 
         StreamString buffer(Stream::eBinary, addr_byte_size, byte_order);
 
         llvm::MachO::mach_header_64 mach_header;
         if (addr_byte_size == 8) {
           mach_header.magic = MH_MAGIC_64;
         } else {
           mach_header.magic = MH_MAGIC;
         }
         mach_header.cputype = target_arch.GetMachOCPUType();
         mach_header.cpusubtype = target_arch.GetMachOCPUSubType();
         mach_header.filetype = MH_CORE;
         mach_header.ncmds = segment_load_commands.size();
         mach_header.flags = 0;
         mach_header.reserved = 0;
         ThreadList &thread_list = process_sp->GetThreadList();
         const uint32_t num_threads = thread_list.GetSize();
 
         // Make an array of LC_THREAD data items. Each one contains the
         // contents of the LC_THREAD load command. The data doesn't contain
         // the load command + load command size, we will add the load command
         // and load command size as we emit the data.
         std::vector<StreamString> LC_THREAD_datas(num_threads);
         for (auto &LC_THREAD_data : LC_THREAD_datas) {
           LC_THREAD_data.GetFlags().Set(Stream::eBinary);
           LC_THREAD_data.SetAddressByteSize(addr_byte_size);
           LC_THREAD_data.SetByteOrder(byte_order);
         }
         for (uint32_t thread_idx = 0; thread_idx < num_threads; ++thread_idx) {
           ThreadSP thread_sp(thread_list.GetThreadAtIndex(thread_idx));
if (make_core) {
         }
 
         // and the size of all LC_THREAD load command
         for (const auto &LC_THREAD_data : LC_THREAD_datas) {
           ++mach_header.ncmds;
           mach_header.sizeofcmds += 8 + LC_THREAD_data.GetSize();
         }
 
+        // LC_NOTE "all image infos"
+        mach_header.ncmds++;
+        mach_header.sizeofcmds += sizeof(llvm::MachO::note_command);
+
         // Write the mach header
         buffer.PutHex32(mach_header.magic);
         buffer.PutHex32(mach_header.cputype);
         buffer.PutHex32(mach_header.cpusubtype);
         buffer.PutHex32(mach_header.filetype);
         buffer.PutHex32(mach_header.ncmds);
         buffer.PutHex32(mach_header.sizeofcmds);
         buffer.PutHex32(mach_header.flags);
         if (addr_byte_size == 8) {
           buffer.PutHex32(mach_header.reserved);
         }
 
         // Skip the mach header and all load commands and align to the next
         // 0x1000 byte boundary
         addr_t file_offset = buffer.GetSize() + mach_header.sizeofcmds;
-        if (file_offset & 0x00000fff) {
-          file_offset += 0x00001000ull;
-          file_offset &= (~0x00001000ull + 1);
-        }
+
+        file_offset = llvm::alignTo(file_offset, 16);
+
+        // Create the "all image infos" LC_NOTE payload
+        StreamString all_image_infos_payload(Stream::eBinary, addr_byte_size,
+                                             byte_order);
+        offset_t all_image_infos_payload_start = file_offset;
+        file_offset = CreateAllImageInfosPayload(process_sp, file_offset,
+                                                 all_image_infos_payload);
+
+        // Add the "all image infos" LC_NOTE load command
+        llvm::MachO::note_command all_image_info_note = {
+            LC_NOTE,                           /* uint32_t cmd */
+            sizeof(llvm::MachO::note_command), /* uint32_t cmdsize */
+            "all image infos",                 /* char data_owner[16] */
+            all_image_infos_payload_start,     /* uint64_t offset */
+            file_offset - all_image_infos_payload_start /* uint64_t size */
+        };
+        buffer.PutHex32(all_image_info_note.cmd);
+        buffer.PutHex32(all_image_info_note.cmdsize);
+        buffer.PutRawBytes(all_image_info_note.data_owner,
+                           sizeof(all_image_info_note.data_owner));
+        buffer.PutHex64(all_image_info_note.offset);
+        buffer.PutHex64(all_image_info_note.size);
+
+        // Align to 4096-byte page boundary for the LC_SEGMENTs.
+        file_offset = llvm::alignTo(file_offset, 4096);
 
         for (auto &segment : segment_load_commands) {
           segment.fileoff = file_offset;
           file_offset += segment.filesize;
         }
 
         // Write out all of the LC_THREAD load commands
         for (const auto &LC_THREAD_data : LC_THREAD_datas) {
           const size_t LC_THREAD_data_size = LC_THREAD_data.GetSize();
           buffer.PutHex32(LC_THREAD);
           buffer.PutHex32(8 + LC_THREAD_data_size); // cmd + cmdsize + data
           buffer.Write(LC_THREAD_data.GetString().data(), LC_THREAD_data_size);
         }
 
         // Write out all of the segment load commands
         for (const auto &segment : segment_load_commands) {
-          printf("0x%8.8x 0x%8.8x [0x%16.16" PRIx64 " - 0x%16.16" PRIx64
-                 ") [0x%16.16" PRIx64 " 0x%16.16" PRIx64
-                 ") 0x%8.8x 0x%8.8x 0x%8.8x 0x%8.8x]\n",
-                 segment.cmd, segment.cmdsize, segment.vmaddr,
-                 segment.vmaddr + segment.vmsize, segment.fileoff,
-                 segment.filesize, segment.maxprot, segment.initprot,
-                 segment.nsects, segment.flags);
-
           buffer.PutHex32(segment.cmd);
           buffer.PutHex32(segment.cmdsize);
           buffer.PutRawBytes(segment.segname, sizeof(segment.segname));
           if (addr_byte_size == 8) {
             buffer.PutHex64(segment.vmaddr);
             buffer.PutHex64(segment.vmsize);
             buffer.PutHex64(segment.fileoff);
             buffer.PutHex64(segment.filesize);
if (make_core) {
         } else {
           // Read 1 page at a time
           uint8_t bytes[0x1000];
           // Write the mach header and load commands out to the core file
           size_t bytes_written = buffer.GetString().size();
           error =
               core_file.get()->Write(buffer.GetString().data(), bytes_written);
           if (error.Success()) {
+
+            if (core_file.get()->SeekFromStart(all_image_info_note.offset) ==
+                -1) {
+              error.SetErrorStringWithFormat(
+                  "Unable to seek to corefile pos to write all iamge infos");
+              return false;
+            }
+
+            bytes_written = all_image_infos_payload.GetString().size();
+            error = core_file.get()->Write(
+                all_image_infos_payload.GetString().data(), bytes_written);
+            if (!error.Success())
+              return false;
+
             // Now write the file data for all memory segments in the process
             for (const auto &segment : segment_load_commands) {
               if (core_file.get()->SeekFromStart(segment.fileoff) == -1) {
                 error.SetErrorStringWithFormat(
                     "unable to seek to offset 0x%" PRIx64 " in '%s'",
                     segment.fileoff, core_file_path.c_str());
                 break;
               }
 
-              printf("Saving %" PRId64
-                     " bytes of data for memory region at 0x%" PRIx64 "\n",
-                     segment.vmsize, segment.vmaddr);
+              target.GetDebugger().GetAsyncOutputStream()->Printf(
+                  "Saving %" PRId64
               addr_t bytes_left = segment.vmsize;
               addr_t addr = segment.vmaddr;
               Status memory_read_error;
               while (bytes_left > 0 && error.Success()) {
                 const size_t bytes_to_read =
                     bytes_left > sizeof(bytes) ? sizeof(bytes) : bytes_left;
 
                 // In a savecore setting, we don't really care about caching,
if (make_core) {
         }
       } else {
         error.SetErrorString(
             "process doesn't support getting memory region info");
       }
     }
     return true; // This is the right plug to handle saving core files for
                  // this process
   }
   return false;
 }
+
+ObjectFileMachO::MachOCorefileAllImageInfos
+ObjectFileMachO::GetCorefileAllImageInfos() {
+  MachOCorefileAllImageInfos image_infos;
+
+  // Look for an "all image infos" LC_NOTE.
+  lldb::offset_t offset = MachHeaderSizeFromMagic(m_header.magic);
+  for (uint32_t i = 0; i < m_header.ncmds; ++i) {
+    const uint32_t cmd_offset = offset;
+    llvm::MachO::load_command lc;
+    if (m_data.GetU32(&offset, &lc.cmd, 2) == nullptr)
+      break;
+    if (lc.cmd == LC_NOTE) {
+      char data_owner[17];
+      m_data.CopyData(offset, 16, data_owner);
+      data_owner[16] = '\0';
+      offset += 16;
+      uint64_t fileoff = m_data.GetU64_unchecked(&offset);
+      offset += 4; /* size unused */
+
+      if (strcmp("all image infos", data_owner) == 0) {
+        offset = fileoff;
+        // Read the struct all_image_infos_header.
+        uint32_t version = m_data.GetU32(&offset);
+        if (version != 1) {
+          return image_infos;
+        }
+        uint32_t imgcount = m_data.GetU32(&offset);
+        uint64_t entries_fileoff = m_data.GetU64(&offset);
+        offset += 4; // uint32_t entries_size;
+        offset += 4; // uint32_t unused;
+
+        offset = entries_fileoff;
+        for (uint32_t i = 0; i < imgcount; i++) {
+          // Read the struct image_entry.
+          offset_t filepath_offset = m_data.GetU64(&offset);
+          uuid_t uuid;
+          memcpy(&uuid, m_data.GetData(&offset, sizeof(uuid_t)),
+                 sizeof(uuid_t));
+          uint64_t load_address = m_data.GetU64(&offset);
+          offset_t seg_addrs_offset = m_data.GetU64(&offset);
+          uint32_t segment_count = m_data.GetU32(&offset);
+          uint32_t currently_executing = m_data.GetU32(&offset);
+
+          MachOCorefileImageEntry image_entry;
+          image_entry.filename = (const char *)m_data.GetCStr(&filepath_offset);
+          image_entry.uuid = UUID::fromData(uuid, sizeof(uuid_t));
+          image_entry.load_address = load_address;
+          image_entry.currently_executing = currently_executing;
+
+          offset_t seg_vmaddrs_offset = seg_addrs_offset;
+          for (uint32_t j = 0; j < segment_count; j++) {
+            char segname[17];
+            m_data.CopyData(seg_vmaddrs_offset, 16, segname);
+            segname[16] = '\0';
+            seg_vmaddrs_offset += 16;
+            uint64_t vmaddr = m_data.GetU64(&seg_vmaddrs_offset);
+            seg_vmaddrs_offset += 8; /* unused */
+
+            std::tuple<ConstString, addr_t> new_seg{ConstString(segname),
+                                                    vmaddr};
+            image_entry.segment_load_addresses.push_back(new_seg);
+          }
+          image_infos.all_image_infos.push_back(image_entry);
+        }
+      }
+    }
+    offset = cmd_offset + lc.cmdsize;
+  }
+
+  return image_infos;
+}
+
+bool ObjectFileMachO::LoadCoreFileImages(lldb_private::Process &process) {
+  MachOCorefileAllImageInfos image_infos = GetCorefileAllImageInfos();
+  bool added_images = false;
+  if (image_infos.IsValid()) {
+    for (const MachOCorefileImageEntry &image : image_infos.all_image_infos) {
+      ModuleSpec module_spec;
+      module_spec.GetUUID() = image.uuid;
+      module_spec.GetFileSpec() = FileSpec(image.filename.c_str());
+      if (image.currently_executing) {
+        Symbols::DownloadObjectAndSymbolFile(module_spec, true);
+        if (FileSystem::Instance().Exists(module_spec.GetFileSpec())) {
+          process.GetTarget().GetOrCreateModule(module_spec, false);
+        }
+      }
+      Status error;
+      ModuleSP module_sp =
+          process.GetTarget().GetOrCreateModule(module_spec, false, &error);
+      if (!module_sp.get() || !module_sp->GetObjectFile()) {
+        if (image.load_address != LLDB_INVALID_ADDRESS) {
+          module_sp = process.ReadModuleFromMemory(module_spec.GetFileSpec(),
+                                                   image.load_address);
+        }
+      }
+      if (module_sp.get() && module_sp->GetObjectFile()) {
+        added_images = true;
+        if (module_sp->GetObjectFile()->GetType() ==
+            ObjectFile::eTypeExecutable) {
+          process.GetTarget().SetExecutableModule(module_sp, eLoadDependentsNo);
+        }
+        for (auto name_vmaddr_tuple : image.segment_load_addresses) {
+          SectionList *sectlist = module_sp->GetObjectFile()->GetSectionList();
+          if (sectlist) {
+            SectionSP sect_sp =
+                sectlist->FindSectionByName(std::get<0>(name_vmaddr_tuple));
+            if (sect_sp) {
+              process.GetTarget().SetSectionLoadAddress(
+                  sect_sp, std::get<1>(name_vmaddr_tuple));
+            }
+          }
+        }
+      }
+    }
+  }
+  return added_images;
+}

lldb/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.h

static size_t GetModuleSpecifications(const lldb_private::FileSpec &file,
                                         lldb::DataBufferSP &data_sp,
                                         lldb::offset_t data_offset,
                                         lldb::offset_t file_offset,
                                         lldb::offset_t length,
                                         lldb_private::ModuleSpecList &specs);
 
   static bool SaveCore(const lldb::ProcessSP &process_sp,
                        const lldb_private::FileSpec &outfile,
+                       lldb::SaveCoreStyle &core_style,
                        lldb_private::Status &error);
 
   static bool MagicBytesMatch(lldb::DataBufferSP &data_sp);
 
   static lldb::SymbolType MapSymbolType(uint16_t coff_symbol_type);
 
   // LLVM RTTI support
   static char ID;

lldb/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp

default:
     break;
   }
 
   return specs.GetSize() - initial_count;
 }
 
 bool ObjectFilePECOFF::SaveCore(const lldb::ProcessSP &process_sp,
                                 const lldb_private::FileSpec &outfile,
+                                lldb::SaveCoreStyle &core_style,
                                 lldb_private::Status &error) {
+  core_style = eSaveCoreFull;
   return SaveMiniDump(process_sp, outfile, error);
 }
 
 bool ObjectFilePECOFF::MagicBytesMatch(DataBufferSP &data_sp) {
   DataExtractor data(data_sp, eByteOrderLittle, 4);
   lldb::offset_t offset = 0;
   uint16_t magic = data.GetU16(&offset);
   return magic == IMAGE_DOS_SIGNATURE;

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

Status GetWatchpointsTriggerAfterInstruction(bool &after,
                                                const ArchSpec &arch);
 
   const ArchSpec &GetHostArchitecture();
 
   std::chrono::seconds GetHostDefaultPacketTimeout();
 
   const ArchSpec &GetProcessArchitecture();
 
   void GetRemoteQSupported();
 
   bool GetVContSupported(char flavor);
 
   bool GetpPacketSupported(lldb::tid_t tid);
 
   bool GetxPacketSupported();
 
   bool GetVAttachOrWaitSupported();
protected:
   std::string m_os_kernel;
   std::string m_hostname;
   std::string m_gdb_server_name; // from reply to qGDBServerVersion, empty if
                                  // qGDBServerVersion is not supported
   uint32_t m_gdb_server_version =
       UINT32_MAX; // from reply to qGDBServerVersion, zero if
                   // qGDBServerVersion is not supported
   std::chrono::seconds m_default_packet_timeout;
+  int m_target_vm_page_size = 0; // target system VM page size; 0 unspecified
   uint64_t m_max_packet_size = 0;    // as returned by qSupported
   std::string m_qSupported_response; // the complete response to qSupported
 
   bool m_supported_async_json_packets_is_valid = false;
   lldb_private::StructuredData::ObjectSP m_supported_async_json_packets_sp;
 
   std::vector<MemoryRegionInfo> m_qXfer_memory_map;
   bool m_qXfer_memory_map_loaded = false;

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

 #include <cmath>
 #include <sys/stat.h>
 
 #include <numeric>
 #include <sstream>
 
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Host/HostInfo.h"
+#include "lldb/Host/StringConvert.h"
 #include "lldb/Host/XML.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/UnixSignals.h"
 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/LLDBAssert.h"
if (!did_exec) {
     m_host_arch.Clear();
     m_os_version = llvm::VersionTuple();
     m_os_build.clear();
     m_os_kernel.clear();
     m_hostname.clear();
     m_gdb_server_name.clear();
     m_gdb_server_version = UINT32_MAX;
     m_default_packet_timeout = seconds(0);
+    m_target_vm_page_size = 0;
     m_max_packet_size = 0;
     m_qSupported_response.clear();
     m_supported_async_json_packets_is_valid = false;
     m_supported_async_json_packets_sp.reset();
     m_supports_jModulesInfo = true;
   }
 
   // These flags should be reset when we first connect to a GDB server and when
if (SendPacketAndWaitForResponse("qHostInfo", response, false) ==
               ++num_keys_decoded;
           } else if (name.equals("default_packet_timeout")) {
             uint32_t timeout_seconds;
             if (!value.getAsInteger(0, timeout_seconds)) {
               m_default_packet_timeout = seconds(timeout_seconds);
               SetPacketTimeout(m_default_packet_timeout);
               ++num_keys_decoded;
             }
+          } else if (name.equals("vm-page-size")) {
+            int page_size;
+            if (!value.getAsInteger(0, page_size)) {
+              m_target_vm_page_size = page_size;
+              ++num_keys_decoded;
+            }
           }
         }
 
         if (num_keys_decoded > 0)
           m_qHostInfo_is_valid = eLazyBoolYes;
 
         if (triple.empty()) {
           if (arch_name.empty()) {
if (SendPacketAndWaitForResponse(packet, response, false) ==
             }
           }
         } 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;
+          std::string comma_sep_str = value.str();
+          size_t comma_pos;
+          addr_t page;
+          while ((comma_pos = comma_sep_str.find(',')) != std::string::npos) {
+            comma_sep_str[comma_pos] = '\0';
+            page = StringConvert::ToUInt64(comma_sep_str.c_str(),
+                                           LLDB_INVALID_ADDRESS, 16);
+            if (page != LLDB_INVALID_ADDRESS)
+              dirty_page_list.push_back(page);
+            comma_sep_str.erase(0, comma_pos + 1);
+          }
+          page = StringConvert::ToUInt64(comma_sep_str.c_str(),
+                                         LLDB_INVALID_ADDRESS, 16);
+          if (page != LLDB_INVALID_ADDRESS)
+            dirty_page_list.push_back(page);
+          region_info.SetDirtyPageList(dirty_page_list);
         }
       }
 
+      if (m_target_vm_page_size != 0)
+        region_info.SetPageSize(m_target_vm_page_size);
+
       if (region_info.GetRange().IsValid()) {
         // We got a valid address range back but no permissions -- which means
         // this is an unmapped page
         if (!saw_permissions) {
           region_info.SetReadable(MemoryRegionInfo::eNo);
           region_info.SetWritable(MemoryRegionInfo::eNo);
           region_info.SetExecutable(MemoryRegionInfo::eNo);
           region_info.SetMapped(MemoryRegionInfo::eNo);

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

if (section) {
           section_vm_addr, section->GetByteSize(), permissions));
     }
   }
   if (!ranges_are_sorted) {
     m_core_aranges.Sort();
     m_core_range_infos.Sort();
   }
 
-
   bool found_main_binary_definitively = false;
 
   addr_t objfile_binary_addr;
   UUID objfile_binary_uuid;
   ObjectFile::BinaryType type;
   if (core_objfile->GetCorefileMainBinaryInfo(objfile_binary_addr,
                                               objfile_binary_uuid, type)) {
     if (log) {
       log->Printf(
           "ProcessMachCore::DoLoadCore: using binary hint from 'main bin spec' "
           "LC_NOTE with UUID %s address 0x%" PRIx64 " and type %d",
           objfile_binary_uuid.GetAsString().c_str(), objfile_binary_addr, type);
     }
     if (objfile_binary_addr != LLDB_INVALID_ADDRESS) {
       if (type == ObjectFile::eBinaryTypeUser) {
         m_dyld_addr = objfile_binary_addr;
         m_dyld_plugin_name = DynamicLoaderMacOSXDYLD::GetPluginNameStatic();
         found_main_binary_definitively = true;
       }
       if (type == ObjectFile::eBinaryTypeKernel) {
         m_mach_kernel_addr = objfile_binary_addr;
         m_dyld_plugin_name = DynamicLoaderDarwinKernel::GetPluginNameStatic();
         found_main_binary_definitively = true;
if (!found_main_binary_definitively) {
     } else if (ident_uuid.IsValid()) {
       if (load_standalone_binary(ident_uuid, ident_binary_addr, GetTarget())) {
         found_main_binary_definitively = true;
         m_dyld_plugin_name = DynamicLoaderStatic::GetPluginNameStatic();
       }
     }
   }
 
+  // If we have a "all image infos" LC_NOTE, try to load all of the
+  // binaries listed, and set their Section load addresses in the Target.
+  if (found_main_binary_definitively == false &&
+      core_objfile->LoadCoreFileImages(*this)) {
+    m_dyld_plugin_name = DynamicLoaderDarwinKernel::GetPluginNameStatic();
+    found_main_binary_definitively = true;
+  }
+
   if (!found_main_binary_definitively &&
       (m_dyld_addr == LLDB_INVALID_ADDRESS ||
        m_mach_kernel_addr == LLDB_INVALID_ADDRESS)) {
     // We need to locate the main executable in the memory ranges we have in
     // the core file.  We need to search for both a user-process dyld binary
     // and a kernel binary in memory; we must look at all the pages in the
     // binary so we don't miss one or the other.  Step through all memory
     // segments searching for a kernel binary and for a user process dyld --
     // we'll decide which to prefer later if both are present.
 
     const size_t num_core_aranges = m_core_aranges.GetSize();
     for (size_t i = 0; i < num_core_aranges; ++i) {
       const VMRangeToFileOffset::Entry *entry =
           m_core_aranges.GetEntryAtIndex(i);
       lldb::addr_t section_vm_addr_start = entry->GetRangeBase();
       lldb::addr_t section_vm_addr_end = entry->GetRangeEnd();
       for (lldb::addr_t section_vm_addr = section_vm_addr_start;
            section_vm_addr < section_vm_addr_end; section_vm_addr += 0x1000) {
         GetDynamicLoaderAddress(section_vm_addr);
       }
     }
   }
 
   if (!found_main_binary_definitively &&
       m_mach_kernel_addr != LLDB_INVALID_ADDRESS) {
     // In the case of multiple kernel images found in the core file via
     // exhaustive search, we may not pick the correct one.  See if the
     // DynamicLoaderDarwinKernel's search heuristics might identify the correct
     // one. Most of the time, I expect the address from SearchForDarwinKernel()
     // will be the same as the address we found via exhaustive search.
 
     if (!GetTarget().GetArchitecture().IsValid() && m_core_module_sp.get()) {
       GetTarget().SetArchitecture(m_core_module_sp->GetArchitecture());
     }
 

lldb/test/API/functionalities/gdb_remote_client/TestMemoryRegionDirtyPages.py

+import lldb
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test.decorators import *
+from gdbclientutils import *
+
+
+class TestMemoryRegionDirtyPages(GDBRemoteTestBase):
+
+    @skipIfXmlSupportMissing
+    def test(self):
+        class MyResponder(MockGDBServerResponder):
+
+            def qHostInfo(self):
+                return "ptrsize:8;endian:little;vm-page-size:4096;"
+
+            def qMemoryRegionInfo(self, addr):
+                if addr == 0:
+                    return "start:0;size:100000000;"
+                if addr == 0x100000000:
+                    return "start:100000000;size:4000;permissions:rx;dirty-pages:;"
+                if addr == 0x100004000:
+                    return "start:100004000;size:4000;permissions:r;dirty-pages:0x100004000;"
+                if addr == 0x1000a2000:
+                    return "start:1000a2000;size:5000;permissions:r;dirty-pages:0x1000a2000,0x1000a3000,0x1000a4000,0x1000a5000,0x1000a6000;"
+
+        self.server.responder = MyResponder()
+        target = self.dbg.CreateTarget('')
+        if self.TraceOn():
+          self.runCmd("log enable gdb-remote packets")
+          self.addTearDownHook(
+                lambda: self.runCmd("log disable gdb-remote packets"))
+        process = self.connect(target)
+
+        # A memory region where we don't know anything about dirty pages
+        region = lldb.SBMemoryRegionInfo()
+        err = process.GetMemoryRegionInfo(0, region)
+        self.assertTrue(err.Success())
+        self.assertFalse(region.HasDirtyMemoryPageList())
+        self.assertEqual(region.GetNumDirtyPages(), 0)
+        region.Clear()
+
+        # A memory region with dirty page information -- and zero dirty pages
+        err = process.GetMemoryRegionInfo(0x100000000, region)
+        self.assertTrue(err.Success())
+        self.assertTrue(region.HasDirtyMemoryPageList())
+        self.assertEqual(region.GetNumDirtyPages(), 0)
+        self.assertEqual(region.GetPageSize(), 4096)
+        region.Clear()
+
+        # A memory region with one dirty page
+        err = process.GetMemoryRegionInfo(0x100004000, region)
+        self.assertTrue(err.Success())
+        self.assertTrue(region.HasDirtyMemoryPageList())
+        self.assertEqual(region.GetNumDirtyPages(), 1)
+        self.assertEqual(region.GetDirtyPageAddressAtIndex(0), 0x100004000)
+        region.Clear()
+
+        # A memory region with multple dirty pages
+        err = process.GetMemoryRegionInfo(0x1000a2000, region)
+        self.assertTrue(err.Success())
+        self.assertTrue(region.HasDirtyMemoryPageList())
+        self.assertEqual(region.GetNumDirtyPages(), 5)
+        self.assertEqual(region.GetDirtyPageAddressAtIndex(4), 0x1000a6000)
+        region.Clear()
+

lldb/test/API/functionalities/gdb_remote_client/gdbclientutils.py

def respond(self, packet):
         if packet.startswith("qThreadStopInfo"):
             threadnum = int (packet[15:], 16)
             return self.threadStopInfo(threadnum)
         if packet == "QThreadSuffixSupported":
             return self.QThreadSuffixSupported()
         if packet == "QListThreadsInStopReply":
             return self.QListThreadsInStopReply()
         if packet.startswith("qMemoryRegionInfo:"):
-            return self.qMemoryRegionInfo()
+            return self.qMemoryRegionInfo(int(packet.split(':')[1], 16))
         if packet == "qQueryGDBServer":
             return self.qQueryGDBServer()
         if packet == "qHostInfo":
             return self.qHostInfo()
         if packet == "qGetWorkingDir":
             return self.qGetWorkingDir()
         if packet == "qOffsets":
             return self.qOffsets();
def other(self, packet):
         return ""
 
     def QThreadSuffixSupported(self):
         return ""
 
     def QListThreadsInStopReply(self):
         return ""
 
-    def qMemoryRegionInfo(self):
+    def qMemoryRegionInfo(self, addr):
         return ""
 
     def qPathComplete(self):
         return ""
 
     """
     Raised when we receive a packet for which there is no default action.
     Override the responder class to implement behavior suitable for the test at

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

+LD_EXTRAS = -L. -lto-be-removed -lpresent
+C_SOURCES = main.c
+
+include Makefile.rules
+
+a.out: libto-be-removed libpresent
+
+libto-be-removed: libpresent
+  $(MAKE) -f $(MAKEFILE_RULES) \
+    DYLIB_ONLY=YES DYLIB_C_SOURCES=to-be-removed.c DYLIB_NAME=to-be-removed \
+    LD_EXTRAS="-L. -lpresent"
+
+libpresent:
+  $(MAKE) -f $(MAKEFILE_RULES) \
+    DYLIB_ONLY=YES DYLIB_C_SOURCES=present.c DYLIB_NAME=present 

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):
+
+    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")
+        self.aout_dsym = self.getBuildArtifact("a.out.dSYM")
+        self.to_be_removed_dylib = self.getBuildArtifact("libto-be-removed.dylib")
+        self.to_be_removed_dsym = self.getBuildArtifact("libto-be-removed.dylib.dSYM")
+        self.corefile = self.getBuildArtifact("process.core")
+        self.dsym_for_uuid = self.getBuildArtifact("dsym-for-uuid.sh")
+
+        # After the corefile is created, we'll move a.out and a.out.dSYM 
+        # into hide.noindex and lldb will have to use the 
+        # LLDB_APPLE_DSYMFORUUID_EXECUTABLE script to find them.
+        self.hide_dir = self.getBuildArtifact("hide.noindex")
+        lldbutil.mkdir_p(self.hide_dir)
+        self.hide_aout_exe = self.getBuildArtifact("hide.noindex/a.out")
+        self.hide_aout_dsym = self.getBuildArtifact("hide.noindex/a.out.dSYM")
+
+        # We can hook in our dsym-for-uuid shell script to lldb with 
+        # this env var instead of requiring a defaults write.
+        os.environ['LLDB_APPLE_DSYMFORUUID_EXECUTABLE'] = self.dsym_for_uuid
+        self.addTearDownHook(lambda: os.environ.pop('LLDB_APPLE_DSYMFORUUID_EXECUTABLE', None))
+
+        dwarfdump_uuid_regex = re.compile(
+            'UUID: ([-0-9a-fA-F]+) \(([^\(]+)\) .*')
+        dwarfdump_cmd_output = subprocess.check_output(
+                ('/usr/bin/dwarfdump --uuid "%s"' % self.aout_exe), shell=True).decode("utf-8")
+        aout_uuid = None
+        for line in dwarfdump_cmd_output.splitlines():
+            match = dwarfdump_uuid_regex.search(line)
+            if match:
+                aout_uuid = match.group(1)
+        self.assertNotEqual(aout_uuid, None, "Could not get uuid of built a.out")
+
+        ###  Create our dsym-for-uuid shell script which returns self.hide_aout_exe.
+        shell_cmds = [
+                '#! /bin/sh',
+                '# the last argument is the uuid',
+                'while [ $# -gt 1 ]',
+                'do',
+                '  shift',
+                'done',
+                'ret=0',
+                'echo "<?xml version=\\"1.0\\" encoding=\\"UTF-8\\"?>"',
+                'echo "<!DOCTYPE plist PUBLIC \\"-//Apple//DTD PLIST 1.0//EN\\" \\"http://www.apple.com/DTDs/PropertyList-1.0.dtd\\">"',
+                'echo "<plist version=\\"1.0\\">"',
+                '',
+                'if [ "$1" = "%s" ]' % aout_uuid,
+                'then',
+                '  uuid=%s' % aout_uuid,
+                '  bin=%s' % self.hide_aout_exe,
+                '  dsym=%s.dSYM/Contents/Resources/DWARF/%s' % (self.hide_aout_exe, os.path.basename(self.hide_aout_exe)),
+                'fi',
+                'if [ -z "$uuid" -o -z "$bin" -o ! -f "$bin" ]',
+                'then',
+                '  echo "<key>DBGError</key><string>not found</string>"',
+                '  echo "</plist>"', 
+                '  exit 1',
+                'fi',
+                'echo "<dict><key>$uuid</key><dict>"',
+                '',
+                'echo "<key>DBGArchitecture</key><string>x86_64</string>"',
+                'echo "<key>DBGDSYMPath</key><string>$dsym</string>"',
+                'echo "<key>DBGSymbolRichExecutable</key><string>$bin</string>"',
+                'echo "</dict></dict></plist>"',
+                'exit $ret'
+                ]
+
+        with open(self.dsym_for_uuid, "w") as writer:
+            for l in shell_cmds:
+                writer.write(l + '\n')
+
+        os.chmod(self.dsym_for_uuid, 0o755)
+
+
+        # Launch a live process with a.out, libto-be-removed.dylib, 
+        # libpresent.dylib all in their original locations, create
+        # a corefile at the breakpoint.
+        (target, process, t, bp) = lldbutil.run_to_source_breakpoint (
+                self, "break here", lldb.SBFileSpec('present.c'))
+
+        self.assertTrue(process.IsValid())
+
+        if self.TraceOn():
+            self.runCmd("bt")
+            self.runCmd("image list")
+
+        self.runCmd("process save-core " + self.corefile)
+        process.Kill()
+        target.Clear()
+
+        # Move the main binary and its dSYM into the hide.noindex
+        # directory.  Now the only way lldb can find them is with
+        # the LLDB_APPLE_DSYMFORUUID_EXECUTABLE shell script -
+        # so we're testing that this dSYM discovery method works.
+        os.rename(self.aout_exe, self.hide_aout_exe)
+        os.rename(self.aout_dsym, self.hide_aout_dsym)
+
+        # Completely remove the libto-be-removed.dylib, so we're
+        # testing that lldb handles an unavailable binary correctly,
+        # and non-dirty memory from this binary (e.g. the executing
+        # instructions) are NOT included in the corefile.
+        os.unlink(self.to_be_removed_dylib)
+        shutil.rmtree(self.to_be_removed_dsym)
+
+
+        # Now load the corefile
+        self.target = self.dbg.CreateTarget('')
+        self.process = self.target.LoadCore(self.corefile)
+        self.assertTrue(self.process.IsValid())
+        if self.TraceOn():
+            self.runCmd("image list")
+            self.runCmd("bt")
+
+        self.assertTrue(self.process.IsValid())
+        self.assertTrue(self.process.GetSelectedThread().IsValid())
+
+        # f0 is present() in libpresent.dylib
+        f0 = self.process.GetSelectedThread().GetFrameAtIndex(0)
+        to_be_removed_dirty_data = f0.FindVariable("to_be_removed_dirty_data")
+        self.assertEqual(to_be_removed_dirty_data.GetValueAsUnsigned(), 20)
+
+        present_heap_buf = f0.FindVariable("present_heap_buf")
+        self.assertTrue("have ints 5 20 20 5" in present_heap_buf.GetSummary())
+
+
+        # f1 is to_be_removed() in libto-be-removed.dylib
+        # it has been removed since the corefile was created,
+        # and the instructions for this frame should NOT be included
+        # in the corefile.  They were not dirty pages.
+        f1 = self.process.GetSelectedThread().GetFrameAtIndex(1) 
+        err = lldb.SBError()
+        uint = self.process.ReadUnsignedFromMemory(f1.GetPC(), 4, err)
+        self.assertTrue(err.Fail())
+
+
+        # TODO Future testing could check that read-only constant data
+        # (main_const_data, present_const_data) can be read both as an
+        # SBValue and in an expression -- which means lldb needs to read
+        # them out of the binaries, they are not present in the corefile.
+        # And checking file-scope dirty data (main_dirty_data, 
+        # present_dirty_data) the same way would be good, instead of just
+        # checking the heap and stack like are being done right now.

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

+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "present.h"
+#include "to-be-removed.h"
+
+const int main_const_data = 5;
+int main_dirty_data = 10;
+int main(int argc, char **argv) {
+
+  to_be_removed_init(argc);
+  present_init(argc);
+  main_dirty_data += argc;
+
+  char *heap_buf = (char *)malloc(80);
+  strcpy(heap_buf, "this is a string on the heap");
+
+  return to_be_removed(heap_buf, main_const_data, main_dirty_data);
+}

lldb/test/API/macosx/skinny-corefile/present.h

+void present_init (int in);
+int present (char *to_be_removed_heap_buf, int to_be_removed_const_data, int to_be_removed_dirty_data);

lldb/test/API/macosx/skinny-corefile/present.c

+#include <stdio.h>
+#include <stdlib.h>
+
+#include "present.h"
+
+const int present_const_data = 5;
+int present_dirty_data = 10;
+
+void present_init(int in) { present_dirty_data += 10; }
+
+int present(char *to_be_removed_heap_buf, int to_be_removed_const_data,
+            int to_be_removed_dirty_data) {
+  char *present_heap_buf = (char *)malloc(256);
+  sprintf(present_heap_buf, "have ints %d %d %d %d", to_be_removed_const_data,
+          to_be_removed_dirty_data, present_dirty_data, present_const_data);
+  printf("%s\n", present_heap_buf);
+  puts(to_be_removed_heap_buf);
+
+  puts("break here");
+
+  return present_const_data + present_dirty_data;
+}

lldb/test/API/macosx/skinny-corefile/to-be-removed.h

+void to_be_removed_init (int in);
+int to_be_removed (char *main_heap_buf, int main_const_data, int main_dirty_data);

lldb/test/API/macosx/skinny-corefile/to-be-removed.c

+#include <stdio.h>
+#include <stdlib.h>
+
+#include "present.h"
+#include "to-be-removed.h"
+
+const int to_be_removed_const_data = 5;
+int to_be_removed_dirty_data = 10;
+
+void to_be_removed_init(int in) { to_be_removed_dirty_data += 10; }
+
+int to_be_removed(char *main_heap_buf, int main_const_data,
+                  int main_dirty_data) {
+  char *to_be_removed_heap_buf = (char *)malloc(256);
+  sprintf(to_be_removed_heap_buf, "got string '%s' have int %d %d %d",
+          main_heap_buf, to_be_removed_dirty_data, main_const_data,
+          main_dirty_data);
+  printf("%s\n", to_be_removed_heap_buf);
+  return present(to_be_removed_heap_buf, to_be_removed_const_data,
+                 to_be_removed_dirty_data);
+}

lldb/test/API/tools/lldb-server/TestGdbRemoteHostInfo.py

KNOWN_HOST_INFO_KEYS = set([
         "maccatalyst_version",
         "os_build",
         "os_kernel",
         "os_version",
         "ostype",
         "ptrsize",
         "triple",
         "vendor",
+        "vm-page-size",
         "watchpoint_exceptions_received",
     ])
 
     DARWIN_REQUIRED_HOST_INFO_KEYS = set([
         "cputype",
         "cpusubtype",
         "endian",
         "ostype",

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 <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
 typedef uint64_t nub_addr_t;
 #define INVALID_NUB_ADDRESS ((nub_addr_t)~0ull)
 
struct DNBExecutableImageInfo {
   nub_addr_t header_addr; // Executable header address
   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() {}
   nub_addr_t addr;
   nub_addr_t size;
   uint32_t permissions;
+  std::vector<nub_addr_t> dirty_pages;
 };
 
 enum DNBProfileDataScanType {
   eProfileHostCPU = (1 << 0),
   eProfileCPU = (1 << 1),
 
   eProfileThreadsCPU =
       (1 << 2), // By default excludes eProfileThreadName and eProfileQueueName.

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

if (page_size > 0) {
     nub_size_t page_offset = (addr % page_size);
     nub_size_t bytes_left_in_page = page_size - page_offset;
     if (count > bytes_left_in_page)
       count = bytes_left_in_page;
   }
   return count;
 }
 
+#define MAX_STACK_ALLOC_DISPOSITIONS                                           \
+  (16 * 1024 / sizeof(int)) // 16K of allocations
+
+std::vector<nub_addr_t> get_dirty_pages(task_t task, mach_vm_address_t addr,
+                                        mach_vm_size_t size) {
+  std::vector<nub_addr_t> dirty_pages;
+
+  int pages_to_query = size / vm_page_size;
+  // Don't try to fetch too many pages' dispositions in a single call or we
+  // could blow our stack out.
+  mach_vm_size_t dispositions_size =
+      std::min(pages_to_query, (int)MAX_STACK_ALLOC_DISPOSITIONS);
+  int dispositions[dispositions_size];
+
+  mach_vm_size_t chunk_count =
+      ((pages_to_query + MAX_STACK_ALLOC_DISPOSITIONS - 1) /
+       MAX_STACK_ALLOC_DISPOSITIONS);
+
+  for (mach_vm_size_t cur_disposition_chunk = 0;
+       cur_disposition_chunk < chunk_count; cur_disposition_chunk++) {
+    mach_vm_size_t dispositions_already_queried =
+        cur_disposition_chunk * MAX_STACK_ALLOC_DISPOSITIONS;
+
+    mach_vm_size_t chunk_pages_to_query = std::min(
+        pages_to_query - dispositions_already_queried, dispositions_size);
+    mach_vm_address_t chunk_page_aligned_start_addr =
+        addr + (dispositions_already_queried * vm_page_size);
+
+    kern_return_t kr = mach_vm_page_range_query(
+        task, chunk_page_aligned_start_addr,
+        chunk_pages_to_query * vm_page_size, (mach_vm_address_t)dispositions,
+        &chunk_pages_to_query);
+    if (kr != KERN_SUCCESS)
+      return dirty_pages;
+    for (mach_vm_size_t i = 0; i < chunk_pages_to_query; i++) {
+      uint64_t dirty_addr = chunk_page_aligned_start_addr + (i * vm_page_size);
+      if (dispositions[i] & VM_PAGE_QUERY_PAGE_DIRTY)
+        dirty_pages.push_back(dirty_addr);
+    }
+  }
+  return dirty_pages;
+}
+
 nub_bool_t MachVMMemory::GetMemoryRegionInfo(task_t task, nub_addr_t address,
                                              DNBRegionInfo *region_info) {
   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());
   } 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/RNBRemote.cpp

 
 #include <bsm/audit.h>
 #include <bsm/audit_session.h>
 #include <cerrno>
 #include <csignal>
 #include <libproc.h>
 #include <mach-o/loader.h>
 #include <mach/exception_types.h>
+#include <mach/mach_vm.h>
 #include <mach/task_info.h>
 #include <pwd.h>
 #include <sys/stat.h>
 #include <sys/sysctl.h>
 #include <unistd.h>
 
 #if defined(__APPLE__)
 #include <pthread.h>
rnb_err_t RNBRemote::HandlePacket_MemoryRegionInfo(const char *p) {
 
   errno = 0;
   uint64_t address = strtoul(p, NULL, 16);
   if (errno != 0 && address == 0) {
     return HandlePacket_ILLFORMED(
         __FILE__, __LINE__, p, "Invalid address in qMemoryRegionInfo packet");
   }
 
-  DNBRegionInfo region_info = {0, 0, 0};
+  DNBRegionInfo region_info;
   DNBProcessMemoryRegionInfo(m_ctx.ProcessID(), address, &region_info);
   std::ostringstream ostrm;
 
   // start:3a50000,size:100000,permissions:rwx
   ostrm << "start:" << std::hex << region_info.addr << ';';
 
   if (region_info.size > 0)
     ostrm << "size:" << std::hex << region_info.size << ';';
 
   if (region_info.permissions) {
     ostrm << "permissions:";
 
     if (region_info.permissions & eMemoryPermissionsReadable)
       ostrm << 'r';
     if (region_info.permissions & eMemoryPermissionsWritable)
       ostrm << 'w';
     if (region_info.permissions & eMemoryPermissionsExecutable)
       ostrm << 'x';
     ostrm << ';';
+
+    ostrm << "dirty-pages:";
+    if (region_info.dirty_pages.size() > 0) {
+      bool first = true;
+      for (nub_addr_t addr : region_info.dirty_pages) {
+        if (!first)
+          ostrm << ",";
+        first = false;
+        ostrm << "0x" << std::hex << addr;
+      }
+    }
+    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)
if (promoted_to_64)
     strm << "ptrsize:8;";
   else
     strm << "ptrsize:" << std::dec << sizeof(void *) << ';';
 
 #if defined(TARGET_OS_WATCH) && TARGET_OS_WATCH == 1
   strm << "default_packet_timeout:10;";
 #endif
 
+  strm << "vm-page-size:" << std::dec << vm_page_size << ";";
+
   return SendPacket(strm.str());
 }
 
 void XMLElementStart(std::ostringstream &s, uint32_t indent, const char *name,
                      bool has_attributes) {
   if (indent)
     s << INDENT_WITH_SPACES(indent);
   s << '<' << name;