Add ability for lldb to load binaries in a process/corefile given only a load address & no dynamic loader

[jasonmolenda]

Summary

I'm adding support for a firmware type environment, without any dynamic linker, where we may have more than one binary in memory and we'll only be given the load addresses of the binaries.

lldb already has support for loading a single binary given a UUID & address or slide. It slowly grew to the point (my fault) where three different classes (ProcessGDBRemote, ProcessMachCore, ObjectFileMachO) had versions of code to find and load the correct binary at the correct address into the Target. This would have been yet another variation added to all three places, so obviously the first thing to do was make a unified utility function to do this. I chose a static method in the DynamicLoader base class, LoadBinaryWithUUIDAndAddress() which handles this new case, as well as most of the others. I removed the other copies of code that were doing similar things from those three classes.

I thought of making this a static method in DynamicLoaderStatic. I couldn't come up with a strong preference either way -- it's only a method you'll be calling when you don't have a DynamicLoader plugin, so maybe that is the best place for it.

I added a new key-value to qProcessInfo, binary-addresses, which is a base16 array of addresses where binaries are. When given no UUID, lldb will try to read the binary from memory and find the UUID in the in-memory load commands, then do the normal "find me a binary for this UUID" schemes, loading it into the Target.

lldb already has "main bin spec" and "load binary" LC_NOTEs that always needed a UUID until today; this code now handles the case where no UUID is supplied, but we have a load address. I was a little unhappy to find that UUID::IsValid() returns true for an all-zeroes UUID which seems like it should probably return invalid? The LC_NOTEs use all-zeroes to indicate "no uuid", whereas our UUID class uses "optional data exists". I have a few checks in ObjectFileMachO where I check the uuid_t to see if it is all-zeros before I copy them in to the UUID object.

I tested the qProcessInfo load method manually with a hacked debugserver & lldb which had no DynamicLoaderMacOS plugin; anything less than that looks like a valid macOS debug session and it was difficult to fool lldb into using these correctly.

I wrote a fun test case for the corefile support where it builds three test binaries - an executable and two shared libraries - and a program that creates a corefile of those three binaries at their load addresses. Then we can run lldb on the corefile and confirm it loads binaries already known to lldb, via dsymForUUID, or loads a memory image as a last resort. It took a bit to get the corefile creator working correctly, but it's pretty cool.

One tiny oddity I noticed is that we've ended up with

include/lldb/Target/DynamicLoader.h
source/Core/DynamicLoader.cpp

I didn't look into which one was intended to be correct & fix it for now.

[jasonmolenda]

I was using an obsoleted linker flag to seg the vmaddrs of two dylibs and laying them out there in the corefile. This won't work long-term, and I really wanted to make sure lldb will slide binaries correctly, so I added a new feature to my corefile creator which will apply a slide to the binaries it puts in the corefiles, modifying the segment/section load commands with the slid vmaddrs as if dyld had put them there.

[JDevlieghere]

A few minor nits but the change looks sound to me. It's great to see the existing code getting unified and nice job on that test. LGTM.

lldb/source/Core/DynamicLoader.cpp

192–194

If it wasn't for the fixed-length buffer I probably would've ignored it, but you have the same code on line 222. Might be worth extracting this into a little static helper function/lambda. Something like:

BufferSP ReadModuleFromMemory(ProcessSP process, lldb::addr_t addr) {
    char namebuf[80];
    snprintf(namebuf, sizeof(namebuf), "memory-image-0x%" PRIx64, addr);
    return process->ReadModuleFromMemory(FileSpec(namebuf), addr);
}

238–239

Use LLDB_LOGF which includes the if(log) check. There's some more instances of that below.

lldb/test/API/macosx/lc-note/multiple-binary-corefile/create-multibin-corefile.cpp

2

Are there other tests that can (or will) benefit from this utility? If so I think it would make sense to make it a proper tool that we build with CMake (similar to lldb-test and lldb-instr). That's more of a suggestion for the future, as is I think it's totally fine for this to be part of the test.

[jasonmolenda]

Update patch to address Jonas' feedback, add a better descriptive comment on what my custom corefile creator in the test case does.

lldb/docs/lldb-gdb-remote.txt

 vendor: is a string that represents the vendor (apple)
 endian: is one of "little", "big", or "pdp"
 ptrsize: is a number that represents how big pointers are in bytes
 
 main-binary-uuid: is the UUID of a firmware type binary that the gdb stub knows about
 main-binary-address: is the load address of the firmware type binary
 main-binary-slide: is the slide of the firmware type binary, if address isn't known
 
+binary-addresses: A comma-separated list of binary load addresses base16.  
+                  lldb will parse the binaries in memory to get UUIDs, then
+                  try to find the binaries & debug info by UUID.  Intended for
+                  use with a small number of firmware type binaries where the 
+                  search for binary/debug info may be expensive.
+
 //----------------------------------------------------------------------
 // "qShlibInfoAddr"
 //
 // BRIEF
 //  Get an address where the dynamic linker stores information about
 //  where shared libraries are loaded.
 //
 // PRIORITY TO IMPLEMENT

lldb/include/lldb/Target/DynamicLoader.h

public:
   /// resulting module at the virtual base address \p base_addr.
   /// Note that this calls Target::GetOrCreateModule with notify being false,
   /// so it is necessary to call Target::ModulesDidLoad afterwards.
   virtual lldb::ModuleSP LoadModuleAtAddress(const lldb_private::FileSpec &file,
                                              lldb::addr_t link_map_addr,
                                              lldb::addr_t base_addr,
                                              bool base_addr_is_offset);
 
+  /// Find/load a binary into lldb given a UUID and the address where it is
+  /// loaded in memory, or a slide to be applied to the file address.
+  /// May force an expensive search on the computer to find the binary by
+  /// UUID, should not be used for a large number of binaries - intended for
+  /// an environment where there may be one, or a few, binaries resident in
+  /// memory.
+  ///
+  /// Given a UUID, search for a binary and load it at the address provided,
+  /// or with the slide applied, or at the file address unslid.
+  ///
+  /// Given an address, try to read the binary out of memory, get the UUID,
+  /// find the file if possible and load it unslid, or add the memory module.
+  ///
+  /// \param[in] process
+  ///     The process to add this binary to.
+  ///
+  /// \param[in] uuid
+  ///     UUID of the binary to be loaded.  UUID may be empty, and if a
+  ///     load address is supplied, will read the binary from memory, get
+  ///     a UUID and try to find a local binary.  There is a performance
+  ///     cost to doing this, it is not preferable.
+  ///
+  /// \param[in] value
+  ///     Address where the binary should be loaded, or read out of memory.
+  ///     Or a slide value, to be applied to the file addresses of the binary.
+  ///
+  /// \param[in] value_is_offset
+  ///     A flag indicating that \p value is an address, or an offset to
+  ///     be applied to the file addresses.
+  ///
+  /// \param[in] force_symbol_search
+  ///     Allow the search to do a possibly expensive external search for
+  ///     the ObjectFile and/or SymbolFile.
+  ///
+  /// \param[in] notify
+  ///     Whether ModulesDidLoad should be called when a binary has been added
+  ///     to the Target.  The caller may prefer to batch up these when loading
+  ///     multiple binaries.
+  ///
+  /// \return
+  ///     Returns a shared pointer for the Module that has been added.
+  static lldb::ModuleSP
+  LoadBinaryWithUUIDAndAddress(Process *process, UUID uuid, lldb::addr_t value,
+                               bool value_is_offset, bool force_symbol_search,
+                               bool notify);
+
   /// Get information about the shared cache for a process, if possible.
   ///
   /// On some systems (e.g. Darwin based systems), a set of libraries that are
   /// common to most processes may be put in a single region of memory and
   /// mapped into every process, this is called the shared cache, as a
   /// performance optimization.
   ///
   /// Many targets will not have the concept of a shared cache.

lldb/source/Core/DynamicLoader.cpp

 //===-- DynamicLoader.cpp -------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Target/DynamicLoader.h"
 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
+#include "lldb/Symbol/LocateSymbolFile.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/MemoryRegionInfo.h"
+#include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/ConstString.h"
+#include "lldb/Utility/LLDBLog.h"
+#include "lldb/Utility/Log.h"
 #include "lldb/lldb-private-interfaces.h"
 
 #include "llvm/ADT/StringRef.h"
 
 #include <memory>
 
 #include <cassert>
 
if (ModuleSP module_sp = FindModuleViaTarget(file)) {
     UpdateLoadedSections(module_sp, link_map_addr, base_addr,
                          base_addr_is_offset);
     return module_sp;
   }
 
   return nullptr;
 }
 
+static ModuleSP ReadUnnamedMemoryModule(Process *process, addr_t addr) {
+  char namebuf[80];
+  snprintf(namebuf, sizeof(namebuf), "memory-image-0x%" PRIx64, addr);
+  return process->ReadModuleFromMemory(FileSpec(namebuf), addr);
+}
+
+ModuleSP DynamicLoader::LoadBinaryWithUUIDAndAddress(Process *process,
+                                                     UUID uuid, addr_t value,
+                                                     bool value_is_offset,
+                                                     bool force_symbol_search,
+                                                     bool notify) {
+  ModuleSP memory_module_sp;
+  ModuleSP module_sp;
+  PlatformSP platform_sp = process->GetTarget().GetPlatform();
+  Target &target = process->GetTarget();
+  Status error;
+  ModuleSpec module_spec;
+  module_spec.GetUUID() = uuid;
+
+  if (!uuid.IsValid() && !value_is_offset) {
+    memory_module_sp = ReadUnnamedMemoryModule(process, value);
+
+    if (memory_module_sp)
+      uuid = memory_module_sp->GetUUID();
+  }
+
+  if (uuid.IsValid()) {
+    ModuleSpec module_spec;
+    module_spec.GetUUID() = uuid;
+
+    if (!module_sp)
+      module_sp = target.GetOrCreateModule(module_spec, false, &error);
+
+    // If we haven't found a binary, or we don't have a SymbolFile, see
+    // if there is an external search tool that can find it.
+    if (force_symbol_search &&
+        (!module_sp || !module_sp->GetSymbolFileFileSpec())) {
+      Symbols::DownloadObjectAndSymbolFile(module_spec, error, true);
+      if (FileSystem::Instance().Exists(module_spec.GetFileSpec())) {
+        module_sp = std::make_shared<Module>(module_spec);
+      }
+    }
+  }
+
+  // If we couldn't find the binary anywhere else, as a last resort,
+  // read it out of memory.
+  if (!module_sp.get() && value != LLDB_INVALID_ADDRESS && !value_is_offset) {
+    if (!memory_module_sp)
+      memory_module_sp = ReadUnnamedMemoryModule(process, value);
+    if (memory_module_sp)
+      module_sp = memory_module_sp;
+  }
+
+  Log *log = GetLog(LLDBLog::DynamicLoader);
+  if (module_sp.get()) {
+    target.GetImages().AppendIfNeeded(module_sp, false);
+
+    bool changed = false;
+    if (module_sp->GetObjectFile()) {
+      if (value != LLDB_INVALID_ADDRESS) {
+        LLDB_LOGF(log, "Loading binary UUID %s at %s 0x%" PRIx64,
+                  uuid.GetAsString().c_str(),
+                  value_is_offset ? "offset" : "address", value);
+        module_sp->SetLoadAddress(target, value, value_is_offset, changed);
+      } else {
+        // No address/offset/slide, load the binary at file address,
+        // offset 0.
+        LLDB_LOGF(log, "Loading binary UUID %s at file address",
+                  uuid.GetAsString().c_str());
+        module_sp->SetLoadAddress(target, 0, true /* value_is_slide */,
+                                  changed);
+      }
+    } else {
+      // In-memory image, load at its true address, offset 0.
+      LLDB_LOGF(log, "Loading binary UUID %s from memory at address 0x%" PRIx64,
+                uuid.GetAsString().c_str(), value);
+      module_sp->SetLoadAddress(target, 0, true /* value_is_slide */, changed);
+    }
+
+    if (notify) {
+      ModuleList added_module;
+      added_module.Append(module_sp, false);
+      target.ModulesDidLoad(added_module);
+    }
+  } else {
+    LLDB_LOGF(log, "Unable to find binary with UUID %s and load it at "
+                  "%s 0x%" PRIx64,
+                  uuid.GetAsString().c_str(),
+                  value_is_offset ? "offset" : "address", value);
+  }
+
+  return module_sp;
+}
+
 int64_t DynamicLoader::ReadUnsignedIntWithSizeInBytes(addr_t addr,
                                                       int size_in_bytes) {
   Status error;
   uint64_t value =
       m_process->ReadUnsignedIntegerFromMemory(addr, size_in_bytes, 0, error);
   if (error.Fail())
     return -1;
   else

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

for (uint32_t i = 0; i < m_header.ncmds; ++i) {
               return false;
             if (value == LLDB_INVALID_ADDRESS &&
                 slide != LLDB_INVALID_ADDRESS) {
               value = slide;
               value_is_offset = true;
             }
 
             if (m_data.CopyData(offset, sizeof(uuid_t), raw_uuid) != 0) {
+              if (!uuid_is_null(raw_uuid))
                 uuid = UUID::fromOptionalData(raw_uuid, sizeof(uuid_t));
               // convert the "main bin spec" type into our
               // ObjectFile::BinaryType enum
               switch (binspec_type) {
               case 0:
                 type = eBinaryTypeUnknown;
                 break;
               case 1:
                 type = eBinaryTypeKernel;
if (lc.cmd == LC_NOTE) {
                  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);
+          if (!uuid_is_null(uuid))
             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';
if (lc.cmd == LC_NOTE) {
           memcpy(&uuid, m_data.GetData(&fileoff, sizeof(uuid_t)),
                  sizeof(uuid_t));
           uint64_t load_address = m_data.GetU64(&fileoff);
           uint64_t slide = m_data.GetU64(&fileoff);
           std::string filename = m_data.GetCStr(&fileoff);
 
           MachOCorefileImageEntry image_entry;
           image_entry.filename = filename;
+          if (!uuid_is_null(uuid))
             image_entry.uuid = UUID::fromData(uuid, sizeof(uuid_t));
           image_entry.load_address = load_address;
           image_entry.slide = slide;
+          image_entry.currently_executing = true;
           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();
   Log *log = GetLog(LLDBLog::DynamicLoader);
 
   ModuleList added_modules;
   for (const MachOCorefileImageEntry &image : image_infos.all_image_infos) {
+    ModuleSP module_sp;
+
+    if (!image.filename.empty()) {
+      Status error;
       ModuleSpec module_spec;
       module_spec.GetUUID() = image.uuid;
-    if (image.filename.empty()) {
-      char namebuf[80];
-      if (image.load_address != LLDB_INVALID_ADDRESS)
-        snprintf(namebuf, sizeof(namebuf), "mem-image-0x%" PRIx64,
-                 image.load_address);
-      else
-        snprintf(namebuf, sizeof(namebuf), "mem-image+0x%" PRIx64, image.slide);
-      module_spec.GetFileSpec() = FileSpec(namebuf);
-    } else {
       module_spec.GetFileSpec() = FileSpec(image.filename.c_str());
-    }
       if (image.currently_executing) {
-      Status error;
         Symbols::DownloadObjectAndSymbolFile(module_spec, error, true);
         if (FileSystem::Instance().Exists(module_spec.GetFileSpec())) {
           process.GetTarget().GetOrCreateModule(module_spec, false);
         }
       }
-    Status error;
-    ModuleSP module_sp =
+      module_sp =
           process.GetTarget().GetOrCreateModule(module_spec, false, &error);
-    if (!module_sp.get() || !module_sp->GetObjectFile()) {
+      process.GetTarget().GetImages().AppendIfNeeded(module_sp,
+                                                     false /* notify */);
+    } else {
       if (image.load_address != LLDB_INVALID_ADDRESS) {
-        module_sp = process.ReadModuleFromMemory(module_spec.GetFileSpec(),
-                                                 image.load_address);
+        module_sp = DynamicLoader::LoadBinaryWithUUIDAndAddress(
+            &process, image.uuid, image.load_address,
+            false /* value_is_offset */, image.currently_executing,
+            false /* notify */);
+      } else if (image.slide != LLDB_INVALID_ADDRESS) {
+        module_sp = DynamicLoader::LoadBinaryWithUUIDAndAddress(
+            &process, image.uuid, image.slide, true /* value_is_offset */,
+            image.currently_executing, false /* notify */);
       }
     }
+
     if (module_sp.get()) {
       // Will call ModulesDidLoad with all modules once they've all
       // been added to the Target with load addresses.  Don't notify
       // here, before the load address is set.
-      const bool notify = false;
-      process.GetTarget().GetImages().AppendIfNeeded(module_sp, notify);
-      added_modules.Append(module_sp, notify);
+      added_modules.Append(module_sp, false /* notify */);
       if (image.segment_load_addresses.size() > 0) {
         if (log) {
           std::string uuidstr = image.uuid.GetAsString();
           log->Printf("ObjectFileMachO::LoadCoreFileImages adding binary '%s' "
                       "UUID %s with section load addresses",
                       image.filename.c_str(), uuidstr.c_str());
         }
         for (auto name_vmaddr_tuple : image.segment_load_addresses) {

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

public:
 
   std::chrono::seconds GetHostDefaultPacketTimeout();
 
   const ArchSpec &GetProcessArchitecture();
 
   bool GetProcessStandaloneBinary(UUID &uuid, lldb::addr_t &value,
                                   bool &value_is_offset);
 
+  std::vector<lldb::addr_t> GetProcessStandaloneBinaries();
+
   void GetRemoteQSupported();
 
   bool GetVContSupported(char flavor);
 
   bool GetpPacketSupported(lldb::tid_t tid);
 
   bool GetxPacketSupported();
 
protected:
   uint32_t m_num_supported_hardware_watchpoints = 0;
   uint32_t m_addressing_bits = 0;
 
   ArchSpec m_host_arch;
   ArchSpec m_process_arch;
   UUID m_process_standalone_uuid;
   lldb::addr_t m_process_standalone_value = LLDB_INVALID_ADDRESS;
   bool m_process_standalone_value_is_offset = false;
+  std::vector<lldb::addr_t> m_binary_addresses;
   llvm::VersionTuple m_os_version;
   llvm::VersionTuple m_maccatalyst_version;
   std::string m_os_build;
   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 =

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

if (!m_process_standalone_uuid.IsValid() &&
     return false;
 
   uuid = m_process_standalone_uuid;
   value = m_process_standalone_value;
   value_is_offset = m_process_standalone_value_is_offset;
   return true;
 }
 
+std::vector<addr_t>
+GDBRemoteCommunicationClient::GetProcessStandaloneBinaries() {
+  if (m_qProcessInfo_is_valid == eLazyBoolCalculate)
+    GetCurrentProcessInfo();
+  return m_binary_addresses;
+}
+
 bool GDBRemoteCommunicationClient::GetGDBServerVersion() {
   if (m_qGDBServerVersion_is_valid == eLazyBoolCalculate) {
     m_gdb_server_name.clear();
     m_gdb_server_version = 0;
     m_qGDBServerVersion_is_valid = eLazyBoolNo;
 
     StringExtractorGDBRemote response;
     if (SendPacketAndWaitForResponse("qGDBServerVersion", response) ==
if (response.IsNormalResponse()) {
         } else if (name.equals("main-binary-address")) {
           StringExtractor extractor(value);
           m_process_standalone_value =
               extractor.GetU64(LLDB_INVALID_ADDRESS, 16);
           if (m_process_standalone_value != LLDB_INVALID_ADDRESS) {
             m_process_standalone_value_is_offset = false;
             ++num_keys_decoded;
           }
+        } else if (name.equals("binary-addresses")) {
+          addr_t addr;
+          while (!value.empty()) {
+            llvm::StringRef addr_str;
+            std::tie(addr_str, value) = value.split(',');
+            if (!addr_str.getAsInteger(16, addr))
+              m_binary_addresses.push_back(addr);
+          }
         }
       }
       if (num_keys_decoded > 0)
         m_qProcessInfo_is_valid = eLazyBoolYes;
       if (pid != LLDB_INVALID_PROCESS_ID) {
         m_curr_pid_is_valid = eLazyBoolYes;
         m_curr_pid_run = m_curr_pid = pid;
       }

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

if (m_gdb_comm.GetStopReply(response)) {
       UUID standalone_uuid;
       addr_t standalone_value;
       bool standalone_value_is_offset;
       if (m_gdb_comm.GetProcessStandaloneBinary(
               standalone_uuid, standalone_value, standalone_value_is_offset)) {
         ModuleSP module_sp;
 
         if (standalone_uuid.IsValid()) {
-          ModuleSpec module_spec;
-          module_spec.GetUUID() = standalone_uuid;
-
-          // Look up UUID in global module cache before attempting
-          // a more expensive search.
-          Status error = ModuleList::GetSharedModule(module_spec, module_sp,
-                                                     nullptr, nullptr, nullptr);
-
-          if (!module_sp) {
-            // Force a an external lookup, if that tool is available.
-            if (!module_spec.GetSymbolFileSpec()) {
-              Status error;
-              Symbols::DownloadObjectAndSymbolFile(module_spec, error, true);
-            }
-
-            if (FileSystem::Instance().Exists(module_spec.GetFileSpec())) {
-              module_sp = std::make_shared<Module>(module_spec);
-            }
-          }
-
-          // If we couldn't find the binary anywhere else, as a last resort,
-          // read it out of memory.
-          if (!module_sp.get() && standalone_value != LLDB_INVALID_ADDRESS &&
-              !standalone_value_is_offset) {
-            char namebuf[80];
-            snprintf(namebuf, sizeof(namebuf), "mem-image-0x%" PRIx64,
-                     standalone_value);
-            module_sp =
-                ReadModuleFromMemory(FileSpec(namebuf), standalone_value);
-          }
+          const bool force_symbol_search = true;
+          const bool notify = true;
+          DynamicLoader::LoadBinaryWithUUIDAndAddress(
+              this, standalone_uuid, standalone_value,
+              standalone_value_is_offset, force_symbol_search, notify);
 
-          Log *log = GetLog(LLDBLog::DynamicLoader);
-          if (module_sp.get()) {
-            target.GetImages().AppendIfNeeded(module_sp, false);
-
-            bool changed = false;
-            if (module_sp->GetObjectFile()) {
-              if (standalone_value != LLDB_INVALID_ADDRESS) {
-                if (log)
-                  log->Printf("Loading binary UUID %s at %s 0x%" PRIx64,
-                              standalone_uuid.GetAsString().c_str(),
-                              standalone_value_is_offset ? "offset" : "address",
-                              standalone_value);
-                module_sp->SetLoadAddress(target, standalone_value,
-                                          standalone_value_is_offset, changed);
-              } else {
-                // No address/offset/slide, load the binary at file address,
-                // offset 0.
-                if (log)
-                  log->Printf("Loading binary UUID %s at file address",
-                              standalone_uuid.GetAsString().c_str());
-                const bool value_is_slide = true;
-                module_sp->SetLoadAddress(target, 0, value_is_slide, changed);
-              }
-            } else {
-              // In-memory image, load at its true address, offset 0.
-              if (log)
-                log->Printf("Loading binary UUID %s from memory",
-                            standalone_uuid.GetAsString().c_str());
-              const bool value_is_slide = true;
-              module_sp->SetLoadAddress(target, 0, value_is_slide, changed);
-            }
-
-            ModuleList added_module;
-            added_module.Append(module_sp, false);
-            target.ModulesDidLoad(added_module);
-          } else {
-            if (log)
-              log->Printf("Unable to find binary with UUID %s and load it at "
-                          "%s 0x%" PRIx64,
-                          standalone_uuid.GetAsString().c_str(),
-                          standalone_value_is_offset ? "offset" : "address",
-                          standalone_value);
-          }
+      // The remote stub may know about a list of binaries to
+      // force load into the process -- a firmware type situation
+      // where multiple binaries are present in virtual memory,
+      // and we are only given the addresses of the binaries.
+      // Not intended for use with userland debugging when we
+      // a DynamicLoader plugin that knows how to find the loaded
+      // binaries and will track updates as binaries are added.
+
+      std::vector<addr_t> bin_addrs = m_gdb_comm.GetProcessStandaloneBinaries();
+      if (bin_addrs.size()) {
+        UUID uuid;
+        const bool value_is_slide = false;
+        for (addr_t addr : bin_addrs) {
+          const bool force_symbol_search = true;
+          const bool notify = true;
+          DynamicLoader::LoadBinaryWithUUIDAndAddress(
+              this, uuid, addr, value_is_slide, force_symbol_search, notify);
         }
       }
 
       const StateType state = SetThreadStopInfo(response);
       if (state != eStateInvalid) {
         SetPrivateState(state);
       } else
         error.SetErrorStringWithFormat(

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

case llvm::MachO::MH_EXECUTE:
         return true;
       }
       break;
     }
   }
   return false;
 }
 
-// We have a hint about a binary -- a UUID, possibly a load address.
-// Try to load a file with that UUID into lldb, and if we have a load
-// address, set it correctly.  Else assume that the binary was loaded
-// with no slide.
-static bool load_standalone_binary(UUID uuid, addr_t value,
-                                   bool value_is_offset, Target &target) {
-  if (uuid.IsValid()) {
-    ModuleSpec module_spec;
-    module_spec.GetUUID() = uuid;
-
-    // Look up UUID in global module cache before attempting
-    // dsymForUUID-like action.
-    ModuleSP module_sp;
-    Status error = ModuleList::GetSharedModule(module_spec, module_sp, nullptr,
-                                               nullptr, nullptr);
-
-    if (!module_sp.get()) {
-      // Force a a dsymForUUID lookup, if that tool is available.
-      if (!module_spec.GetSymbolFileSpec()) {
-        Status error;
-        Symbols::DownloadObjectAndSymbolFile(module_spec, error, true);
-      }
-
-      if (FileSystem::Instance().Exists(module_spec.GetFileSpec())) {
-        module_sp = std::make_shared<Module>(module_spec);
-      }
-    }
-
-    // If we couldn't find the binary anywhere else, as a last resort,
-    // read it out of memory in the corefile.
-    if (!module_sp.get() && value != LLDB_INVALID_ADDRESS && !value_is_offset) {
-      char namebuf[80];
-      snprintf(namebuf, sizeof(namebuf), "mem-image-0x%" PRIx64, value);
-      module_sp =
-          target.GetProcessSP()->ReadModuleFromMemory(FileSpec(namebuf), value);
-    }
-
-    if (module_sp.get()) {
-      target.SetArchitecture(module_sp->GetObjectFile()->GetArchitecture());
-      target.GetImages().AppendIfNeeded(module_sp, false);
-
-      // TODO: Instead of using the load address as a value, if we create a
-      // memory module from that address, we could get the correct segment
-      // offset values from the in-memory load commands and set them correctly.
-      // In case the load address we were given is not correct for all segments,
-      // e.g. something in the shared cache.  DynamicLoaderDarwinKernel does
-      // something similar for kexts.  In the context of a corefile, this would
-      // be an inexpensive operation.  Not all binaries in a corefile will have
-      // a Mach-O header/load commands in memory, so this will not work in all
-      // cases.
-
-      bool changed = false;
-      if (module_sp->GetObjectFile()) {
-        if (value != LLDB_INVALID_ADDRESS) {
-          module_sp->SetLoadAddress(target, value, value_is_offset, changed);
-        } else {
-          // No address/offset/slide, load the binary at file address,
-          // offset 0.
-          const bool value_is_slide = true;
-          module_sp->SetLoadAddress(target, 0, value_is_slide, changed);
-        }
-      } else {
-        // In-memory image, load at its true address, offset 0.
-        const bool value_is_slide = true;
-        module_sp->SetLoadAddress(target, 0, value_is_slide, changed);
-      }
-
-      ModuleList added_module;
-      added_module.Append(module_sp, false);
-      target.ModulesDidLoad(added_module);
-
-      // Flush info in the process (stack frames, etc).
-      ProcessSP process_sp(target.GetProcessSP());
-      if (process_sp)
-        process_sp->Flush();
-
-      return true;
-    }
-  }
-  return false;
-}
-
 // Process Control
 Status ProcessMachCore::DoLoadCore() {
   Log *log(GetLog(LLDBLog::DynamicLoader | LLDBLog::Process));
   Status error;
   if (!m_core_module_sp) {
     error.SetErrorString("invalid core module");
     return error;
   }
if (core_objfile->GetCorefileMainBinaryInfo(objfile_binary_value,
     if (log) {
       log->Printf(
           "ProcessMachCore::DoLoadCore: using binary hint from 'main bin spec' "
           "LC_NOTE with UUID %s value 0x%" PRIx64
           " value is offset %d and type %d",
           objfile_binary_uuid.GetAsString().c_str(), objfile_binary_value,
           objfile_binary_value_is_offset, type);
     }
-    if (objfile_binary_value != LLDB_INVALID_ADDRESS &&
-        !objfile_binary_value_is_offset) {
-      if (type == ObjectFile::eBinaryTypeUser) {
-        load_standalone_binary(objfile_binary_uuid, objfile_binary_value,
-                               objfile_binary_value_is_offset, GetTarget());
-        m_dyld_addr = objfile_binary_value;
-        m_dyld_plugin_name = DynamicLoaderMacOSXDYLD::GetPluginNameStatic();
-        found_main_binary_definitively = true;
-      }
-      if (type == ObjectFile::eBinaryTypeKernel) {
-        m_mach_kernel_addr = objfile_binary_value;
-        m_dyld_plugin_name = DynamicLoaderDarwinKernel::GetPluginNameStatic();
-        found_main_binary_definitively = true;
-      }
-    }
-    if (!found_main_binary_definitively) {
-      // ObjectFile::eBinaryTypeStandalone, undeclared types
-      if (load_standalone_binary(objfile_binary_uuid, objfile_binary_value,
-                                 objfile_binary_value_is_offset, GetTarget())) {
-        found_main_binary_definitively = true;
-        m_dyld_plugin_name = DynamicLoaderStatic::GetPluginNameStatic();
-      }
+    const bool force_symbol_search = true;
+    const bool notify = true;
+    if (DynamicLoader::LoadBinaryWithUUIDAndAddress(
+            this, objfile_binary_uuid, objfile_binary_value,
+            objfile_binary_value_is_offset, force_symbol_search, notify)) {
+      found_main_binary_definitively = true;
+      m_dyld_plugin_name = DynamicLoaderStatic::GetPluginNameStatic();
+    }
     }
   }
 
   // This checks for the presence of an LC_IDENT string in a core file;
   // LC_IDENT is very obsolete and should not be used in new code, but if the
   // load command is present, let's use the contents.
   UUID ident_uuid;
   addr_t ident_binary_addr = LLDB_INVALID_ADDRESS;
if (corefile_identifier.find("Darwin Kernel") != std::string::npos &&
         log->Printf("ProcessMachCore::DoLoadCore: Found kernel binary via "
                     "LC_IDENT/kern ver str LC_NOTE");
       m_mach_kernel_addr = ident_binary_addr;
       found_main_binary_definitively = true;
     } else if (ident_uuid.IsValid()) {
       // We have no address specified, only a UUID.  Load it at the file
       // address.
       const bool value_is_offset = false;
-      if (load_standalone_binary(ident_uuid, ident_binary_addr, value_is_offset,
-                                 GetTarget())) {
+      const bool force_symbol_search = true;
+      const bool notify = true;
+      if (DynamicLoader::LoadBinaryWithUUIDAndAddress(
+              this, ident_uuid, ident_binary_addr, value_is_offset,
+              force_symbol_search, notify)) {
         found_main_binary_definitively = true;
         m_dyld_plugin_name = DynamicLoaderStatic::GetPluginNameStatic();
       }
     }
   }
 
   bool did_load_extra_binaries = core_objfile->LoadCoreFileImages(*this);
   // If we have a "all image infos" LC_NOTE, try to load all of the

lldb/test/API/macosx/lc-note/multiple-binary-corefile/Makefile

+MAKE_DSYM := NO
+C_SOURCES := main.c
+LD_EXTRAS := -L. -lone -ltwo
+
+.PHONY: libone.dylib libtwo.dylib
+all: libone.dylib libtwo.dylib a.out create-empty-corefile 
+
+create-empty-corefile:
+  "$(MAKE)" -f "$(MAKEFILE_RULES)" EXE=create-multibin-corefile \
+    CXX_SOURCES=create-multibin-corefile.cpp
+
+libone.dylib: one.c
+  $(MAKE) -f $(MAKEFILE_RULES) \
+    DYLIB_ONLY=YES DYLIB_NAME=one DYLIB_C_SOURCES=one.c
+
+libtwo.dylib: two.c
+  $(MAKE) -f $(MAKEFILE_RULES) \
+    DYLIB_ONLY=YES DYLIB_NAME=two DYLIB_C_SOURCES=two.c
+
+include Makefile.rules

lldb/test/API/macosx/lc-note/multiple-binary-corefile/TestMultipleBinaryCorefile.py

+"""Test corefiles with "main bin spec"/"load binary" with only addrs work."""
+
+
+import os
+import re
+import subprocess
+
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class TestMultipleBinaryCorefile(TestBase):
+
+    def initial_setup(self):
+        self.build()
+        self.aout_exe_basename = "a.out"
+        self.libone_exe_basename = "libone.dylib"
+        self.libtwo_exe_basename = "libtwo.dylib"
+        self.aout_exe = self.getBuildArtifact(self.aout_exe_basename)
+        self.aout_slide = 0x5000
+        self.libone_exe = self.getBuildArtifact(self.libone_exe_basename)
+        self.libone_slide = 0x100840000
+        self.libtwo_exe = self.getBuildArtifact(self.libtwo_exe_basename)
+        self.libtwo_slide = 0
+        self.corefile = self.getBuildArtifact("multiple-binaries.core")
+        self.create_corefile = self.getBuildArtifact("create-multibin-corefile")
+        cmd="%s %s %s@%x %s@%x %s@%x" % (self.create_corefile, self.corefile, 
+                                self.aout_exe, self.aout_slide,
+                                self.libone_exe, self.libone_slide,
+                                self.libtwo_exe, self.libtwo_slide)
+        call(cmd, shell=True)
+
+
+    def load_corefile_and_test(self):
+        target = self.dbg.CreateTarget('')
+        err = lldb.SBError()
+        if self.TraceOn():
+            self.runCmd("script print('loading corefile %s')" % self.corefile)
+        process = target.LoadCore(self.corefile)
+        self.assertEqual(process.IsValid(), True)
+        if self.TraceOn():
+            self.runCmd("script print('image list after loading corefile:')")
+            self.runCmd("image list")
+
+        self.assertEqual(target.GetNumModules(), 3)
+        fspec = target.GetModuleAtIndex(0).GetFileSpec()
+        self.assertEqual(fspec.GetFilename(), self.aout_exe_basename)
+
+        # libone.dylib was never loaded into lldb, see that we added a memory module.
+        fspec = target.GetModuleAtIndex(1).GetFileSpec()
+        self.assertIn('memory-image', fspec.GetFilename())
+
+        dwarfdump_uuid_regex = re.compile(
+            'UUID: ([-0-9a-fA-F]+) \(([^\(]+)\) .*')
+        dwarfdump_cmd_output = subprocess.check_output(
+                ('/usr/bin/dwarfdump --uuid "%s"' % self.libone_exe), shell=True).decode("utf-8")
+        libone_uuid = None
+        for line in dwarfdump_cmd_output.splitlines():
+            match = dwarfdump_uuid_regex.search(line)
+            if match:
+                libone_uuid = match.group(1)
+
+        memory_image_uuid = target.GetModuleAtIndex(1).GetUUIDString()
+        self.assertEqual(libone_uuid, memory_image_uuid)
+
+        fspec = target.GetModuleAtIndex(2).GetFileSpec()
+        self.assertEqual(fspec.GetFilename(), self.libtwo_exe_basename)
+
+        # Executables "always" have this base address
+        aout_load = target.GetModuleAtIndex(0).GetObjectFileHeaderAddress().GetLoadAddress(target)
+        self.assertEqual(aout_load, 0x100000000 + self.aout_slide)
+
+        # Value from Makefile
+        libone_load = target.GetModuleAtIndex(1).GetObjectFileHeaderAddress().GetLoadAddress(target)
+        self.assertEqual(libone_load, self.libone_slide)
+
+        # Value from Makefile
+        libtwo_load = target.GetModuleAtIndex(2).GetObjectFileHeaderAddress().GetLoadAddress(target)
+        self.assertEqual(libtwo_load, self.libtwo_slide)
+
+        self.dbg.DeleteTarget(target)
+        self.dbg.Clear()
+
+    NO_DEBUG_INFO_TESTCASE = True
+
+    @skipIf(archs=no_match(['x86_64', 'arm64', 'arm64e', 'aarch64']))
+    @skipIfRemote
+    @skipUnlessDarwin
+    def test_corefile_binaries_dsymforuuid(self):
+        self.initial_setup()
+
+        if self.TraceOn():
+            self.runCmd("log enable lldb dyld host")
+            self.addTearDownHook(lambda: self.runCmd("log disable lldb dyld host"))
+
+        ## We can hook in our dsym-for-uuid shell script to lldb with this env
+        ## var instead of requiring a defaults write.
+        dsym_for_uuid = self.getBuildArtifact("dsym-for-uuid.sh")
+        os.environ['LLDB_APPLE_DSYMFORUUID_EXECUTABLE'] = dsym_for_uuid
+        if self.TraceOn():
+            print("Setting env var LLDB_APPLE_DSYMFORUUID_EXECUTABLE=" + dsym_for_uuid)
+        self.addTearDownHook(lambda: os.environ.pop('LLDB_APPLE_DSYMFORUUID_EXECUTABLE', None))
+
+        self.runCmd("settings set target.load-script-from-symbol-file true")
+        self.addTearDownHook(lambda: self.runCmd("settings set target.load-script-from-symbol-file false"))
+
+        dwarfdump_uuid_regex = re.compile(
+            'UUID: ([-0-9a-fA-F]+) \(([^\(]+)\) .*')
+        dwarfdump_cmd_output = subprocess.check_output(
+                ('/usr/bin/dwarfdump --uuid "%s"' % self.libtwo_exe), shell=True).decode("utf-8")
+        libtwo_uuid = None
+        for line in dwarfdump_cmd_output.splitlines():
+            match = dwarfdump_uuid_regex.search(line)
+            if match:
+                libtwo_uuid = match.group(1)
+        self.assertNotEqual(libtwo_uuid, None, "Could not get uuid of built libtwo.dylib")
+
+        ###  Create our dsym-for-uuid shell script which returns 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" ]' % (libtwo_uuid),
+                'then',
+                '  echo "<key>DBGError</key><string>not found</string>"',
+                '  echo "</plist>"', 
+                '  exit 1',
+                'fi',
+                '  uuid=%s' % libtwo_uuid,
+                '  bin=%s' % self.libtwo_exe,
+                '  dsym=%s.dSYM/Contents/Resources/DWARF/%s' % (self.libtwo_exe, os.path.basename(self.libtwo_exe)),
+                'echo "<dict><key>$uuid</key><dict>"',
+                '',
+                'echo "<key>DBGDSYMPath</key><string>$dsym</string>"',
+                'echo "<key>DBGSymbolRichExecutable</key><string>$bin</string>"',
+                'echo "</dict></dict></plist>"',
+                'exit $ret'
+                ]
+
+        with open(dsym_for_uuid, "w") as writer:
+            for l in shell_cmds:
+                writer.write(l + '\n')
+
+        os.chmod(dsym_for_uuid, 0o755)
+
+        # Register TWO of our binaries, but require dsymForUUID to find the third.
+        target = self.dbg.CreateTarget(self.aout_exe, '', '', False, lldb.SBError())
+        self.dbg.DeleteTarget(target)
+
+        if self.TraceOn():
+            self.runCmd("script print('Global image list, before loading corefile:')")
+            self.runCmd("image list -g")
+
+        self.load_corefile_and_test()
+
+    @skipIf(archs=no_match(['x86_64', 'arm64', 'arm64e', 'aarch64']))
+    @skipIfRemote
+    @skipUnlessDarwin
+    def test_corefile_binaries_preloaded(self):
+        self.initial_setup()
+
+        if self.TraceOn():
+            self.runCmd("log enable lldb dyld host")
+            self.addTearDownHook(lambda: self.runCmd("log disable lldb dyld host"))
+
+        # Register all three binaries in lldb's global module
+        # cache, then throw the Targets away.
+        target = self.dbg.CreateTarget(self.aout_exe, '', '', False, lldb.SBError())
+        self.dbg.DeleteTarget(target)
+        target = self.dbg.CreateTarget(self.libtwo_exe, '', '', False, lldb.SBError())
+        self.dbg.DeleteTarget(target)
+
+        if self.TraceOn():
+            self.runCmd("script print('Global image list, before loading corefile:')")
+            self.runCmd("image list -g")
+
+        self.load_corefile_and_test()

lldb/test/API/macosx/lc-note/multiple-binary-corefile/create-multibin-corefile.cpp

+#include <errno.h>
+#include <fcntl.h>
+#include <inttypes.h>
+#include <mach-o/loader.h>
+#include <mach/thread_status.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <string>
+#include <sys/errno.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/uio.h>
+#include <unistd.h>
+#include <uuid/uuid.h>
+#include <vector>
+
+// Given a list of binaries, and optional slides to be applied,
+// create a corefile whose memory is those binaries laid at at
+// their slid addresses.
+//
+// Add a 'main bin spec' LC_NOTE for the first binary, and
+// 'load binary' LC_NOTEs for any additional binaries, and
+// these LC_NOTEs will ONLY have the vmaddr of the binary - no
+// UUID, no slide, no filename.
+//
+// Test that lldb can use the load addresses, find the UUIDs,
+// and load the binaries/dSYMs and put them at the correct load
+// address.
+
+struct main_bin_spec_payload {
+  uint32_t version;
+  uint32_t type;
+  uint64_t address;
+  uint64_t slide;
+  uuid_t uuid;
+  uint32_t log2_pagesize;
+  uint32_t platform;
+};
+
+struct load_binary_payload {
+  uint32_t version;
+  uuid_t uuid;
+  uint64_t address;
+  uint64_t slide;
+  const char name[4];
+};
+
+union uint32_buf {
+  uint8_t bytebuf[4];
+  uint32_t val;
+};
+
+union uint64_buf {
+  uint8_t bytebuf[8];
+  uint64_t val;
+};
+
+void add_uint64(std::vector<uint8_t> &buf, uint64_t val) {
+  uint64_buf conv;
+  conv.val = val;
+  for (int i = 0; i < 8; i++)
+    buf.push_back(conv.bytebuf[i]);
+}
+
+void add_uint32(std::vector<uint8_t> &buf, uint32_t val) {
+  uint32_buf conv;
+  conv.val = val;
+  for (int i = 0; i < 4; i++)
+    buf.push_back(conv.bytebuf[i]);
+}
+
+std::vector<uint8_t> lc_thread_load_command(cpu_type_t cputype) {
+  std::vector<uint8_t> data;
+  // Emit an LC_THREAD register context appropriate for the cputype
+  // of the binary we're embedded.  The tests in this case do not
+  // use the register values, so 0's are fine, lldb needs to see at
+  // least one LC_THREAD in the corefile.
+#if defined(__x86_64__)
+  if (cputype == CPU_TYPE_X86_64) {
+    add_uint32(data, LC_THREAD); // thread_command.cmd
+    add_uint32(data,
+               16 + (x86_THREAD_STATE64_COUNT * 4)); // thread_command.cmdsize
+    add_uint32(data, x86_THREAD_STATE64);            // thread_command.flavor
+    add_uint32(data, x86_THREAD_STATE64_COUNT);      // thread_command.count
+    for (int i = 0; i < x86_THREAD_STATE64_COUNT; i++) {
+      add_uint32(data, 0); // whatever, just some empty register values
+    }
+  }
+#endif
+#if defined(__arm64__) || defined(__aarch64__)
+  if (cputype == CPU_TYPE_ARM64) {
+    add_uint32(data, LC_THREAD); // thread_command.cmd
+    add_uint32(data,
+               16 + (ARM_THREAD_STATE64_COUNT * 4)); // thread_command.cmdsize
+    add_uint32(data, ARM_THREAD_STATE64);            // thread_command.flavor
+    add_uint32(data, ARM_THREAD_STATE64_COUNT);      // thread_command.count
+    for (int i = 0; i < ARM_THREAD_STATE64_COUNT; i++) {
+      add_uint32(data, 0); // whatever, just some empty register values
+    }
+  }
+#endif
+  return data;
+}
+
+void add_lc_note_main_bin_spec_load_command(
+    std::vector<std::vector<uint8_t>> &loadcmds, std::vector<uint8_t> &payload,
+    int payload_file_offset, std::string uuidstr, uint64_t address,
+    uint64_t slide) {
+  std::vector<uint8_t> loadcmd_data;
+
+  add_uint32(loadcmd_data, LC_NOTE); // note_command.cmd
+  add_uint32(loadcmd_data, 40);      // note_command.cmdsize
+  char lc_note_name[16];
+  memset(lc_note_name, 0, 16);
+  strcpy(lc_note_name, "main bin spec");
+
+  // lc_note.data_owner
+  for (int i = 0; i < 16; i++)
+    loadcmd_data.push_back(lc_note_name[i]);
+
+  // we start writing the payload at payload_file_offset to leave
+  // room at the start for the header & the load commands.
+  uint64_t current_payload_offset = payload.size() + payload_file_offset;
+
+  add_uint64(loadcmd_data, current_payload_offset); // note_command.offset
+  add_uint64(loadcmd_data,
+             sizeof(struct main_bin_spec_payload)); // note_command.size
+
+  loadcmds.push_back(loadcmd_data);
+
+  // Now write the "main bin spec" payload.
+  add_uint32(payload, 2);       // version
+  add_uint32(payload, 3);       // type == 3 [ firmware, standalone, etc ]
+  add_uint64(payload, address); // load address
+  add_uint64(payload, slide);   // slide
+  uuid_t uuid;
+  uuid_parse(uuidstr.c_str(), uuid);
+  for (int i = 0; i < sizeof(uuid_t); i++)
+    payload.push_back(uuid[i]);
+  add_uint32(payload, 0); // log2_pagesize unspecified
+  add_uint32(payload, 0); // platform unspecified
+}
+
+void add_lc_note_load_binary_load_command(
+    std::vector<std::vector<uint8_t>> &loadcmds, std::vector<uint8_t> &payload,
+    int payload_file_offset, std::string uuidstr, uint64_t address,
+    uint64_t slide) {
+  std::vector<uint8_t> loadcmd_data;
+
+  add_uint32(loadcmd_data, LC_NOTE); // note_command.cmd
+  add_uint32(loadcmd_data, 40);      // note_command.cmdsize
+  char lc_note_name[16];
+  memset(lc_note_name, 0, 16);
+  strcpy(lc_note_name, "load binary");
+
+  // lc_note.data_owner
+  for (int i = 0; i < 16; i++)
+    loadcmd_data.push_back(lc_note_name[i]);
+
+  // we start writing the payload at payload_file_offset to leave
+  // room at the start for the header & the load commands.
+  uint64_t current_payload_offset = payload.size() + payload_file_offset;
+
+  add_uint64(loadcmd_data, current_payload_offset); // note_command.offset
+  add_uint64(loadcmd_data,
+             sizeof(struct load_binary_payload)); // note_command.size
+
+  loadcmds.push_back(loadcmd_data);
+
+  // Now write the "load binary" payload.
+  add_uint32(payload, 1); // version
+  uuid_t uuid;
+  uuid_parse(uuidstr.c_str(), uuid);
+  for (int i = 0; i < sizeof(uuid_t); i++)
+    payload.push_back(uuid[i]);
+  add_uint64(payload, address); // load address
+  add_uint64(payload, slide);   // slide
+  add_uint32(payload, 0);       // name
+}
+
+void add_lc_segment(std::vector<std::vector<uint8_t>> &loadcmds,
+                    std::vector<uint8_t> &payload, int payload_file_offset,
+                    uint64_t vmaddr, uint64_t size) {
+  std::vector<uint8_t> loadcmd_data;
+  struct segment_command_64 seg;
+  seg.cmd = LC_SEGMENT_64;
+  seg.cmdsize = sizeof(struct segment_command_64); // no sections
+  memset(seg.segname, 0, 16);
+  seg.vmaddr = vmaddr;
+  seg.vmsize = size;
+  seg.fileoff = payload.size() + payload_file_offset;
+  seg.filesize = size;
+  seg.maxprot = 1;
+  seg.initprot = 1;
+  seg.nsects = 0;
+  seg.flags = 0;
+
+  uint8_t *p = (uint8_t *)&seg;
+  for (int i = 0; i < sizeof(struct segment_command_64); i++) {
+    loadcmd_data.push_back(*(p + i));
+  }
+  loadcmds.push_back(loadcmd_data);
+}
+
+std::string scan_binary(const char *fn, uint64_t &vmaddr, cpu_type_t &cputype,
+                        cpu_subtype_t &cpusubtype) {
+  FILE *f = fopen(fn, "r");
+  if (f == nullptr) {
+    fprintf(stderr, "Unable to open binary '%s' to get uuid\n", fn);
+    exit(1);
+  }
+  uint32_t num_of_load_cmds = 0;
+  uint32_t size_of_load_cmds = 0;
+  std::string uuid;
+  off_t file_offset = 0;
+  vmaddr = UINT64_MAX;
+
+  uint8_t magic[4];
+  if (::fread(magic, 1, 4, f) != 4) {
+    fprintf(stderr, "Failed to read magic number from input file %s\n", fn);
+    exit(1);
+  }
+  uint8_t magic_32_be[] = {0xfe, 0xed, 0xfa, 0xce};
+  uint8_t magic_32_le[] = {0xce, 0xfa, 0xed, 0xfe};
+  uint8_t magic_64_be[] = {0xfe, 0xed, 0xfa, 0xcf};
+  uint8_t magic_64_le[] = {0xcf, 0xfa, 0xed, 0xfe};
+
+  if (memcmp(magic, magic_32_be, 4) == 0 ||
+      memcmp(magic, magic_64_be, 4) == 0) {
+    fprintf(stderr, "big endian corefiles not supported\n");
+    exit(1);
+  }
+
+  ::fseeko(f, 0, SEEK_SET);
+  if (memcmp(magic, magic_32_le, 4) == 0) {
+    struct mach_header mh;
+    if (::fread(&mh, 1, sizeof(mh), f) != sizeof(mh)) {
+      fprintf(stderr, "error reading mach header from input file\n");
+      exit(1);
+    }
+    if (mh.cputype != CPU_TYPE_X86_64 && mh.cputype != CPU_TYPE_ARM64) {
+      fprintf(stderr,
+              "This tool creates an x86_64/arm64 corefile but "
+              "the supplied binary '%s' is cputype 0x%x\n",
+              fn, (uint32_t)mh.cputype);
+      exit(1);
+    }
+    num_of_load_cmds = mh.ncmds;
+    size_of_load_cmds = mh.sizeofcmds;
+    file_offset += sizeof(struct mach_header);
+    cputype = mh.cputype;
+    cpusubtype = mh.cpusubtype;
+  } else {
+    struct mach_header_64 mh;
+    if (::fread(&mh, 1, sizeof(mh), f) != sizeof(mh)) {
+      fprintf(stderr, "error reading mach header from input file\n");
+      exit(1);
+    }
+    if (mh.cputype != CPU_TYPE_X86_64 && mh.cputype != CPU_TYPE_ARM64) {
+      fprintf(stderr,
+              "This tool creates an x86_64/arm64 corefile but "
+              "the supplied binary '%s' is cputype 0x%x\n",
+              fn, (uint32_t)mh.cputype);
+      exit(1);
+    }
+    num_of_load_cmds = mh.ncmds;
+    size_of_load_cmds = mh.sizeofcmds;
+    file_offset += sizeof(struct mach_header_64);
+    cputype = mh.cputype;
+    cpusubtype = mh.cpusubtype;
+  }
+
+  off_t load_cmds_offset = file_offset;
+
+  for (int i = 0; i < num_of_load_cmds &&
+                  (file_offset - load_cmds_offset) < size_of_load_cmds;
+       i++) {
+    ::fseeko(f, file_offset, SEEK_SET);
+    uint32_t cmd;
+    uint32_t cmdsize;
+    ::fread(&cmd, sizeof(uint32_t), 1, f);
+    ::fread(&cmdsize, sizeof(uint32_t), 1, f);
+    if (vmaddr == UINT64_MAX && cmd == LC_SEGMENT_64) {
+      struct segment_command_64 segcmd;
+      ::fseeko(f, file_offset, SEEK_SET);
+      if (::fread(&segcmd, 1, sizeof(segcmd), f) != sizeof(segcmd)) {
+        fprintf(stderr, "Unable to read LC_SEGMENT_64 load command.\n");
+        exit(1);
+      }
+      if (strcmp("__TEXT", segcmd.segname) == 0)
+        vmaddr = segcmd.vmaddr;
+    }
+    if (cmd == LC_UUID) {
+      struct uuid_command uuidcmd;
+      ::fseeko(f, file_offset, SEEK_SET);
+      if (::fread(&uuidcmd, 1, sizeof(uuidcmd), f) != sizeof(uuidcmd)) {
+        fprintf(stderr, "Unable to read LC_UUID load command.\n");
+        exit(1);
+      }
+      uuid_string_t uuidstr;
+      uuid_unparse(uuidcmd.uuid, uuidstr);
+      uuid = uuidstr;
+    }
+    file_offset += cmdsize;
+  }
+  return uuid;
+}
+
+void slide_macho_binary(std::vector<uint8_t> &image, uint64_t slide) {
+  uint8_t *p = image.data();
+  struct mach_header_64 *mh = (struct mach_header_64 *)p;
+  p += sizeof(struct mach_header_64);
+  for (int lc_idx = 0; lc_idx < mh->ncmds; lc_idx++) {
+    struct load_command *lc = (struct load_command *)p;
+    if (lc->cmd == LC_SEGMENT_64) {
+      struct segment_command_64 *seg = (struct segment_command_64 *)p;
+      if (seg->maxprot != 0 && seg->nsects > 0) {
+        seg->vmaddr += slide;
+        uint8_t *j = p + sizeof(segment_command_64);
+        for (int sect_idx = 0; sect_idx < seg->nsects; sect_idx++) {
+          struct section_64 *sect = (struct section_64 *)j;
+          sect->addr += slide;
+          j += sizeof(struct section_64);
+        }
+      }
+    }
+    p += lc->cmdsize;
+  }
+}
+
+int main(int argc, char **argv) {
+  if (argc < 3) {
+    fprintf(stderr,
+            "usage: output-corefile binary1[@optional-slide] "
+            "[binary2[@optional-slide] [binary3[@optional-slide] ...]]\n");
+    exit(1);
+  }
+
+  // An array of load commands (in the form of byte arrays)
+  std::vector<std::vector<uint8_t>> load_commands;
+
+  // An array of corefile contents (page data, lc_note data, etc)
+  std::vector<uint8_t> payload;
+
+  std::vector<std::string> input_filenames;
+  std::vector<uint64_t> input_slides;
+  std::vector<uint64_t> input_filesizes;
+  std::vector<uint64_t> input_filevmaddrs;
+  uint64_t main_binary_cputype = CPU_TYPE_ARM64;
+  uint64_t vmaddr = UINT64_MAX;
+  cpu_type_t cputype;
+  cpu_subtype_t cpusubtype;
+  for (int i = 2; i < argc; i++) {
+    std::string filename;
+    std::string filename_and_opt_hex(argv[i]);
+    uint64_t slide = 0;
+    auto at_pos = filename_and_opt_hex.find_last_of('@');
+    if (at_pos == std::string::npos) {
+      filename = filename_and_opt_hex;
+    } else {
+      filename = filename_and_opt_hex.substr(0, at_pos);
+      std::string hexstr = filename_and_opt_hex.substr(at_pos + 1);
+      errno = 0;
+      slide = (uint64_t)strtoull(hexstr.c_str(), nullptr, 16);
+      if (errno != 0) {
+        fprintf(stderr, "Unable to parse hex slide value in %s\n", argv[i]);
+        exit(1);
+      }
+    }
+    struct stat stbuf;
+    if (stat(filename.c_str(), &stbuf) == -1) {
+      fprintf(stderr, "Unable to stat '%s', exiting.\n", filename.c_str());
+      exit(1);
+    }
+    input_filenames.push_back(filename);
+    input_slides.push_back(slide);
+    input_filesizes.push_back(stbuf.st_size);
+    scan_binary(filename.c_str(), vmaddr, cputype, cpusubtype);
+    input_filevmaddrs.push_back(vmaddr + slide);
+    if (i == 2) {
+      main_binary_cputype = cputype;
+    }
+  }
+
+  const char *output_corefile_name = argv[1];
+  std::string empty_uuidstr = "00000000-0000-0000-0000-000000000000";
+
+  // First add all the load commands / payload so we can figure out how large
+  // the load commands will actually be.
+  load_commands.push_back(lc_thread_load_command(cputype));
+
+  add_lc_note_main_bin_spec_load_command(load_commands, payload, 0,
+                                         empty_uuidstr, 0, UINT64_MAX);
+  for (int i = 1; i < input_filenames.size(); i++) {
+    add_lc_note_load_binary_load_command(load_commands, payload, 0,
+                                         empty_uuidstr, 0, UINT64_MAX);
+  }
+
+  for (int i = 0; i < input_filenames.size(); i++) {
+    add_lc_segment(load_commands, payload, 0, 0, 0);
+  }
+
+  int size_of_load_commands = 0;
+  for (const auto &lc : load_commands)
+    size_of_load_commands += lc.size();
+
+  int size_of_header_and_load_cmds =
+      sizeof(struct mach_header_64) + size_of_load_commands;
+
+  // Erase the load commands / payload now that we know how much space is
+  // needed, redo it.
+  load_commands.clear();
+  payload.clear();
+
+  // Push the LC_THREAD load command.
+  load_commands.push_back(lc_thread_load_command(main_binary_cputype));
+
+  const off_t payload_offset = size_of_header_and_load_cmds;
+
+  add_lc_note_main_bin_spec_load_command(load_commands, payload, payload_offset,
+                                         empty_uuidstr, input_filevmaddrs[0],
+                                         UINT64_MAX);
+
+  for (int i = 1; i < input_filenames.size(); i++) {
+    add_lc_note_load_binary_load_command(load_commands, payload, payload_offset,
+                                         empty_uuidstr, input_filevmaddrs[i],
+                                         UINT64_MAX);
+  }
+
+  for (int i = 0; i < input_filenames.size(); i++) {
+    add_lc_segment(load_commands, payload, payload_offset, input_filevmaddrs[i],
+                   input_filesizes[i]);
+
+    // Copy the contents of the binary into payload.
+    int fd = open(input_filenames[i].c_str(), O_RDONLY);
+    if (fd == -1) {
+      fprintf(stderr, "Unable to open %s for reading\n",
+              input_filenames[i].c_str());
+      exit(1);
+    }
+    std::vector<uint8_t> binary_contents;
+    for (int j = 0; j < input_filesizes[i]; j++) {
+      uint8_t byte;
+      read(fd, &byte, 1);
+      binary_contents.push_back(byte);
+    }
+    close(fd);
+
+    size_t cur_payload_size = payload.size();
+    payload.resize(cur_payload_size + binary_contents.size());
+    slide_macho_binary(binary_contents, input_slides[i]);
+    memcpy(payload.data() + cur_payload_size, binary_contents.data(),
+           binary_contents.size());
+  }
+
+  struct mach_header_64 mh;
+  mh.magic = MH_MAGIC_64;
+  mh.cputype = cputype;
+
+  mh.cpusubtype = cpusubtype;
+  mh.filetype = MH_CORE;
+  mh.ncmds = load_commands.size();
+  mh.sizeofcmds = size_of_load_commands;
+  mh.flags = 0;
+  mh.reserved = 0;
+
+  FILE *f = fopen(output_corefile_name, "w");
+
+  if (f == nullptr) {
+    fprintf(stderr, "Unable to open file %s for writing\n",
+            output_corefile_name);
+    exit(1);
+  }
+
+  fwrite(&mh, sizeof(mh), 1, f);
+
+  for (const auto &lc : load_commands)
+    fwrite(lc.data(), lc.size(), 1, f);
+
+  fwrite(payload.data(), payload.size(), 1, f);
+
+  fclose(f);
+}

lldb/test/API/macosx/lc-note/multiple-binary-corefile/main.c

+#include <stdio.h>
+int one();
+int two();
+int main() {
+  puts("this is the standalone binary test program");
+  return one() + two();
+}

lldb/test/API/macosx/lc-note/multiple-binary-corefile/one.c

+int one() { return 5; }

lldb/test/API/macosx/lc-note/multiple-binary-corefile/two.c

+int two() { return 10; }