[vm] Allow manual loading of Mach-O dynamic library snapshots.

Adds a Mach-O loader, similar to the existing ELF loader, that
can be used on platforms that do not support loading Mach-O dynamic
libraries via dlopen().

Other changes:

* Renames the --force-load-elf-from-memory command line argument
  to --force-load-from-memory.
* Use CPU_TYPE_ANY and CPU_SUBTYPE_ANY for architectures that do
  not have specific constants in <mach/machine.h> (e.g., RISCV),
  as the snapshot header check after loading also catches architecture
  mismatches.
* Emit the unwinding information at the end of the text segment
  for Windows Mach-O snapshots as is done for ELF ones.

TEST=vm/dart/unobfuscated_static_symbols_test
     vm/dart/use_dwarf_stack_traces_flag_test

Issue: #60307
Change-Id: I34a2a334f47d18d5c4f4a712956e71fd0ac94024
Cq-Include-Trybots: luci.dart.try:vm-aot-linux-debug-x64-try,vm-mac-release-arm64-try,vm-aot-mac-release-arm64-try,vm-aot-mac-release-x64-try,vm-aot-dwarf-linux-product-x64-try,vm-linux-debug-x64-try,vm-mac-debug-arm64-try,vm-fuchsia-release-x64-try,vm-fuchsia-release-arm64-try,vm-linux-debug-ia32-try,vm-aot-linux-debug-simarm_x64-try,vm-aot-linux-debug-simriscv32-try,vm-aot-linux-debug-simriscv64-try,vm-aot-linux-release-simarm_x64-try,vm-gcc-linux-try,vm-ubsan-linux-release-arm64-try,vm-aot-win-release-arm64-try,vm-aot-win-release-x64-try,vm-win-release-x64-try,vm-win-release-arm64-try,vm-aot-win-debug-arm64-try,vm-win-debug-arm64-try
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/430100
Reviewed-by: Slava Egorov <[email protected]>
Reviewed-by: Ryan Macnak <[email protected]>

Author: sstrickl

runtime/bin/BUILD.gn

@@ -162,7 +162,7 @@ static_library("crashpad") {
   }
 }
 
-template("build_elf_loader") {
+template("build_shared_object_loaders") {
   source_set(target_name) {
     configs += [
       "..:dart_arch_config",
@@ -175,6 +175,10 @@ template("build_elf_loader") {
     sources = [
       "elf_loader.cc",
       "elf_loader.h",
+      "macho_loader.cc",
+      "macho_loader.h",
+      "mappable.cc",
+      "mappable.h",
       "virtual_memory.h",
       "virtual_memory_fuchsia.cc",
       "virtual_memory_posix.cc",
@@ -184,11 +188,11 @@ template("build_elf_loader") {
   }
 }
 
-build_elf_loader("elf_loader") {
+build_shared_object_loaders("shared_object_loaders") {
   deps = [ ":libdart_builtin" ]
 }
 
-build_elf_loader("elf_loader_product") {
+build_shared_object_loaders("shared_object_loaders_product") {
   deps = [ ":libdart_builtin_product" ]
 }
 
@@ -928,13 +932,13 @@ dart_executable("dartaotruntime") {
 
   if (dart_runtime_mode == "release") {
     extra_deps += [
-      ":elf_loader_product",
       ":native_assets_api_product",
+      ":shared_object_loaders_product",
     ]
   } else {
     extra_deps += [
-      ":elf_loader",
       ":native_assets_api",
+      ":shared_object_loaders",
     ]
   }
 
@@ -966,8 +970,8 @@ dart_executable("dartaotruntime_product") {
   ]
 
   extra_deps += [
-    ":elf_loader_product",
     ":native_assets_api_product",
+    ":shared_object_loaders_product",
   ]
 }
 
@@ -999,9 +1003,9 @@ if (build_analyze_snapshot) {
     ]
 
     if (use_product_mode) {
-      extra_deps += [ ":elf_loader_product" ]
+      extra_deps += [ ":shared_object_loaders_product" ]
     } else {
-      extra_deps += [ ":elf_loader" ]
+      extra_deps += [ ":shared_object_loaders" ]
     }
   }
 }

runtime/bin/elf_loader.cc

@@ -4,165 +4,27 @@
 
 #include "bin/elf_loader.h"
 
+#include <memory>
+#include <utility>
+
 #include "platform/globals.h"
+
 #if defined(DART_HOST_OS_FUCHSIA)
 #include <sys/mman.h>
 #endif
 
-#include <memory>
-#include <utility>
+#include "platform/elf.h"
+#include "platform/unwinding_records.h"
 
 #include "bin/file.h"
+#include "bin/mappable.h"
 #include "bin/virtual_memory.h"
-#include "platform/elf.h"
-
-#include "platform/unwinding_records.h"
 
 namespace dart {
 namespace bin {
 
 namespace elf {
 
-class Mappable {
- public:
-  static Mappable* FromPath(const char* path);
-#if defined(DART_HOST_OS_FUCHSIA) || defined(DART_HOST_OS_LINUX)
-  static Mappable* FromFD(int fd);
-#endif
-  static Mappable* FromMemory(const uint8_t* memory, size_t size);
-
-  virtual MappedMemory* Map(File::MapType type,
-                            uint64_t position,
-                            uint64_t length,
-                            void* start = nullptr) = 0;
-
-  virtual bool SetPosition(uint64_t position) = 0;
-  virtual bool ReadFully(void* dest, int64_t length) = 0;
-
-  virtual ~Mappable() {}
-
- protected:
-  Mappable() {}
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(Mappable);
-};
-
-class FileMappable : public Mappable {
- public:
-  explicit FileMappable(File* file) : Mappable(), file_(file) {}
-
-  ~FileMappable() override { file_->Release(); }
-
-  MappedMemory* Map(File::MapType type,
-                    uint64_t position,
-                    uint64_t length,
-                    void* start = nullptr) override {
-    return file_->Map(type, position, length, start);
-  }
-
-  bool SetPosition(uint64_t position) override {
-    return file_->SetPosition(position);
-  }
-
-  bool ReadFully(void* dest, int64_t length) override {
-    return file_->ReadFully(dest, length);
-  }
-
- private:
-  File* const file_;
-  DISALLOW_COPY_AND_ASSIGN(FileMappable);
-};
-
-class MemoryMappable : public Mappable {
- public:
-  MemoryMappable(const uint8_t* memory, size_t size)
-      : Mappable(), memory_(memory), size_(size), position_(memory) {}
-
-  ~MemoryMappable() override {}
-
-  MappedMemory* Map(File::MapType type,
-                    uint64_t position,
-                    uint64_t length,
-                    void* start = nullptr) override {
-    if (position > size_) return nullptr;
-    MappedMemory* result = nullptr;
-    const uword map_size = Utils::RoundUp(length, VirtualMemory::PageSize());
-    if (start == nullptr) {
-      auto* memory = VirtualMemory::Allocate(
-          map_size, type == File::kReadExecute, "dart-compiled-image");
-      if (memory == nullptr) return nullptr;
-      result = new MappedMemory(memory->address(), memory->size());
-      memory->release();
-      delete memory;
-    } else {
-      result = new MappedMemory(start, map_size,
-                                /*should_unmap=*/false);
-    }
-
-    size_t remainder = 0;
-    if ((position + length) > size_) {
-      remainder = position + length - size_;
-      length = size_ - position;
-    }
-    memcpy(result->address(), memory_ + position, length);  // NOLINT
-    memset(reinterpret_cast<uint8_t*>(result->address()) + length, 0,
-           remainder);
-
-    auto mode = VirtualMemory::kReadOnly;
-    switch (type) {
-      case File::kReadExecute:
-        mode = VirtualMemory::kReadExecute;
-        break;
-      case File::kReadWrite:
-        mode = VirtualMemory::kReadWrite;
-        break;
-      case File::kReadOnly:
-        mode = VirtualMemory::kReadOnly;
-        break;
-      default:
-        UNREACHABLE();
-    }
-
-    VirtualMemory::Protect(result->address(), result->size(), mode);
-
-    return result;
-  }
-
-  bool SetPosition(uint64_t position) override {
-    if (position > size_) return false;
-    position_ = memory_ + position;
-    return true;
-  }
-
-  bool ReadFully(void* dest, int64_t length) override {
-    if ((position_ + length) > (memory_ + size_)) return false;
-    memcpy(dest, position_, length);
-    return true;
-  }
-
- private:
-  const uint8_t* const memory_;
-  const size_t size_;
-  const uint8_t* position_;
-  DISALLOW_COPY_AND_ASSIGN(MemoryMappable);
-};
-
-Mappable* Mappable::FromPath(const char* path) {
-  return new FileMappable(File::Open(/*namespc=*/nullptr, path, File::kRead,
-                                     /*executable=*/true));
-}
-
-#if defined(DART_HOST_OS_FUCHSIA) || defined(DART_HOST_OS_LINUX)
-Mappable* Mappable::FromFD(int fd) {
-  return new FileMappable(File::OpenFD(fd));
-}
-#endif
-
-Mappable* Mappable::FromMemory(const uint8_t* memory, size_t size) {
-  return new MemoryMappable(memory, size);
-}
-
 /// A loader for a subset of ELF which may be used to load objects produced by
 /// Dart_CreateAppAOTSnapshotAsElf.
 class LoadedElf {
@@ -560,6 +422,7 @@ MappedMemory* LoadedElf::MapFilePiece(uword file_start,
 }  // namespace dart
 
 using namespace dart::bin::elf;  // NOLINT
+using Mappable = dart::bin::Mappable;
 
 #if defined(DART_HOST_OS_FUCHSIA) || defined(DART_HOST_OS_LINUX)
 DART_EXPORT Dart_LoadedElf* Dart_LoadELF_Fd(int fd,