[vm] Add compact unwinding info to ARM64 Mach-O snapshots.

For other architectures, a __eh_frame section is generated like
for non-MacOS platforms.

TEST=vm/dart/unwinding_information_test

Issue: #60307
Change-Id: I46c6ff1357c222f73a129e1becd9b12b3fb6ef9c
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-aot-linux-release-simarm_x64-try,vm-gcc-linux-try,vm-ubsan-linux-release-arm64-try,vm-aot-win-release-arm64-try
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/433020
Reviewed-by: Slava Egorov <[email protected]>
Reviewed-by: Ryan Macnak <[email protected]>
Commit-Queue: Tess Strickland <[email protected]>

Author: sstrickl

runtime/platform/mach_o.h

@@ -537,6 +537,112 @@ struct cs_code_directory {
   // 8-byte aligned (like blobs) and the hash data is 16-byte aligned.
 };
 
+// Compact unwinding information constants for encodings.
+
+// Architecture-independent constants for encodings.
+
+// A shorthand for the zero-value encoding that denotes that the associated
+// memory space does not contain function instructions.
+static constexpr uint32_t UNWIND_INFO_ENCODING_NONE = 0;
+
+static constexpr uint32_t UNWIND_INFO_ENCODING_IS_NOT_FUNCTION_START =
+    0x80000000;
+static constexpr uint32_t UNWIND_INFO_ENCODING_HAS_LSDA = 0x40000000;
+static constexpr uint32_t UNWIND_INFO_ENCODING_PERSONALITY_MASK = 0x30000000;
+
+// Currently compact unwinding information is only generated for ARM64, so only
+// the constants used by the MachO writer are included below.
+
+// ARM64-specific constants for encodings.
+static constexpr uint32_t UNWIND_INFO_ENCODING_ARM64_MODE_MASK = 0x0F000000;
+
+// A standard ARM64 prologue where FP/LR are immediately pushed on the
+// stack and then SP is copied to FP. If there are any non-volatile
+// registers saved, they are saved in pairs right below the FP/LR pair
+// in register number order.
+//
+// In the MachO writer, this is the only non-zero encoding used and
+// no non-volatile register pairs are recorded as being saved, so
+// the appropriate constants for each pair and for other encodings are elided.
+static constexpr uint32_t UNWIND_INFO_ENCODING_ARM64_MODE_FRAME = 0x04000000;
+
+// Note that fields ending in section_offset are offsets into the unwind info
+// section as a whole, whereas fields ending in page_offset are offsets into
+// the specific second level page (e.g., the page header starts at offset 0).
+
+struct unwind_info_lsda_index {
+  uint32_t function_offset;
+  uint32_t lsda_offset;
+};
+
+struct unwind_info_first_level_page_index {
+  uint32_t function_offset;
+  uint32_t second_level_page_section_offset;
+  uint32_t lsda_index_section_offset;
+};
+
+// Second level pages have two formats: a compressed and a "regular" format.
+// As the Mach-O writer only creates a single second level page with four
+// entries currently, it uses the regular format as it is simpler.
+
+static constexpr uint32_t UNWIND_INFO_REGULAR_SECOND_LEVEL_PAGE = 2;
+
+struct unwind_info_regular_second_level_page_entry {
+  uint32_t function_offset;
+  uint32_t encoding;
+};
+
+struct unwind_info_regular_second_level_page_header {
+  uint32_t kind;  // UNWIND_INFO_REGULAR_SECOND_LEVEL_PAGE
+  uint16_t entry_page_offset;
+  uint16_t entry_count;
+};
+
+static const size_t UNWIND_INFO_SECOND_LEVEL_PAGE_MAX_SIZE = 4 * KB;
+
+static constexpr uint32_t UNWIND_INFO_REGULAR_SECOND_LEVEL_PAGE_MAX_ENTRIES =
+    (UNWIND_INFO_SECOND_LEVEL_PAGE_MAX_SIZE -
+     sizeof(unwind_info_regular_second_level_page_header)) /
+    sizeof(unwind_info_regular_second_level_page_entry);
+
+constexpr size_t UnwindInfoRegularSecondLevelPageSize(intptr_t entries) {
+  return sizeof(unwind_info_regular_second_level_page_header) +
+         sizeof(unwind_info_regular_second_level_page_entry) * entries;
+}
+
+static constexpr uint32_t UNWIND_INFO_VERSION = 1;
+
+struct unwind_info_header {
+  uint32_t version;
+  uint32_t common_encodings_section_offset;
+  uint32_t common_encodings_count;
+  uint32_t personalities_section_offset;
+  uint32_t personalities_count;
+  uint32_t first_level_page_indices_section_offset;
+  uint32_t first_level_page_indices_count;
+
+  // Note that the last first level page indices is a sentinel that contains
+  // the end of the covered space as its function offset and the end
+  // of the lsda array as its lsda_index_section_offset.
+  //
+  // sentinel_index = first_level_page_indices_count - 1
+  //
+  // lsda_size =
+  //    first_level_pages[sentinel_index].lsda_index_section_offset -
+  //    first_level_pages[0].lsda_index_section_offset
+  //
+  // lsda_count = lsda_size / sizeof(unwind_info_lsda_index)
+  // second_level_page_count = sentinel_index;
+
+  // Variadic payload of unwind info section after unwind_info_header:
+  // uint32_t common_encodings[common_encodings_count]
+  // uint32_t personalities[personalities_count]
+  // unwind_info_first_level_page_index
+  //     first_level_pages[first_level_page_indices_count]
+  // unwind_info_lsda_index lsda[lsda_count]
+  // ... regular and compressed second level pages ...
+};
+
 #pragma pack(pop)
 
 }  // namespace mach_o

runtime/tests/vm/dart/unobfuscated_static_symbols_test.dart

@@ -12,9 +12,7 @@
 import "dart:io";
 
 import 'package:expect/expect.dart';
-import 'package:native_stack_traces/elf.dart';
 import 'package:native_stack_traces/src/dwarf_container.dart';
-import 'package:native_stack_traces/src/macho.dart';
 import 'package:path/path.dart' as path;
 
 import 'use_flag_test_helper.dart';
@@ -62,76 +60,6 @@ Future<void> main(List<String> args) async {
   });
 }
 
-const commonGenSnapshotArgs = <String>[
-  // Make sure that the runs are deterministic so we can depend on the same
-  // snapshot being generated each time.
-  '--deterministic',
-];
-
-enum SnapshotType {
-  elf,
-  machoDylib,
-  assembly;
-
-  String get kindString {
-    switch (this) {
-      case elf:
-        return 'app-aot-elf';
-      case machoDylib:
-        return 'app-aot-macho-dylib';
-      case assembly:
-        return 'app-aot-assembly';
-    }
-  }
-
-  String get fileArgumentName {
-    switch (this) {
-      case elf:
-        return 'elf';
-      case machoDylib:
-        return 'macho';
-      case assembly:
-        return 'assembly';
-    }
-  }
-
-  DwarfContainer? fromFile(String filename) {
-    switch (this) {
-      case elf:
-        return Elf.fromFile(filename);
-      case machoDylib:
-        return MachO.fromFile(filename);
-      case assembly:
-        return Elf.fromFile(filename) ?? MachO.fromFile(filename);
-    }
-  }
-
-  @override
-  String toString() => name;
-}
-
-Future<void> createSnapshot(
-  String scriptDill,
-  SnapshotType snapshotType,
-  String finalPath, [
-  List<String> extraArgs = const [],
-]) async {
-  String output = finalPath;
-  if (snapshotType == SnapshotType.assembly) {
-    output = path.withoutExtension(finalPath) + '.S';
-  }
-  await run(genSnapshot, <String>[
-    ...commonGenSnapshotArgs,
-    ...extraArgs,
-    '--snapshot-kind=${snapshotType.kindString}',
-    '--${snapshotType.fileArgumentName}=$output',
-    scriptDill,
-  ]);
-  if (snapshotType == SnapshotType.assembly) {
-    await assembleSnapshot(output, finalPath);
-  }
-}
-
 Future<List<String>?> retrieveDebugMap(
   SnapshotType snapshotType,
   String snapshotPath,

runtime/tests/vm/dart/unwinding_information_test.dart

@@ -0,0 +1,130 @@
+// Copyright (c) 2025, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+// This test checks that the compact unwinding information is appropriately
+// generated for Mac ARM64 snapshots.
+
+// OtherResources=use_save_debugging_info_flag_program.dart
+
+import "dart:io";
+
+import 'package:expect/expect.dart';
+import 'package:native_stack_traces/src/dwarf_container.dart';
+import 'package:path/path.dart' as path;
+
+import 'use_flag_test_helper.dart';
+
+Future<void> main(List<String> args) async {
+  if (!isAOTRuntime) {
+    return; // Running in JIT: AOT binaries not available.
+  }
+
+  // Currently, this test only checks compact unwinding information, which
+  // is only generated on Mac ARM64 binaries.
+  if (!Platform.isMacOS || !buildDir.endsWith('ARM64')) {
+    return;
+  }
+
+  // These are the tools we need to be available to run on a given platform:
+  if (!await testExecutable(genSnapshot)) {
+    throw "Cannot run test as $genSnapshot not available";
+  }
+  if (!await testExecutable(dartPrecompiledRuntime)) {
+    throw "Cannot run test as $dartPrecompiledRuntime not available";
+  }
+  if (!File(platformDill).existsSync()) {
+    throw "Cannot run test as $platformDill does not exist";
+  }
+
+  await withTempDir('unwinding-information', (String tempDir) async {
+    final cwDir = path.dirname(Platform.script.toFilePath());
+    final script = path.join(
+      cwDir,
+      'use_save_debugging_info_flag_program.dart',
+    );
+    final scriptDill = path.join(tempDir, 'flag_program.dill');
+
+    // Compile script to Kernel IR.
+    await run(genKernel, <String>[
+      '--aot',
+      '--platform=$platformDill',
+      '-o',
+      scriptDill,
+      script,
+    ]);
+
+    await checkMachO(tempDir, scriptDill);
+  });
+}
+
+Future<List<String>> retrieveUnwindInfo(
+  SnapshotType snapshotType,
+  String snapshotPath,
+) async {
+  if (snapshotType != SnapshotType.machoDylib) {
+    throw ArgumentError("Unhandled snapshot type");
+  }
+  final objdump = llvmTool('llvm-objdump');
+  if (objdump == null) {
+    throw StateError('Expected llvm-objdump in buildutils');
+  }
+  return await runOutput(objdump, ['--macho', '-u', snapshotPath]);
+}
+
+Future<void> checkSnapshotType(
+  String tempDir,
+  String scriptDill,
+  SnapshotType snapshotType,
+) async {
+  final scriptUnstrippedSnapshot = path.join(
+    tempDir,
+    'unstripped-$snapshotType.so',
+  );
+  await createSnapshot(scriptDill, snapshotType, scriptUnstrippedSnapshot);
+  final unstrippedCase = TestCase(
+    snapshotType,
+    scriptUnstrippedSnapshot,
+    snapshotType.fromFile(scriptUnstrippedSnapshot)!,
+    await retrieveUnwindInfo(snapshotType, scriptUnstrippedSnapshot),
+  );
+
+  final scriptStrippedSnapshot = path.join(
+    tempDir,
+    'stripped-$snapshotType.so',
+  );
+  await createSnapshot(scriptDill, snapshotType, scriptStrippedSnapshot, [
+    '--strip',
+  ]);
+  final strippedCase = TestCase(
+    snapshotType,
+    scriptStrippedSnapshot,
+    snapshotType.fromFile(scriptStrippedSnapshot)!,
+    await retrieveUnwindInfo(snapshotType, scriptStrippedSnapshot),
+  );
+
+  checkCases(unstrippedCase, strippedCase);
+}
+
+Future<void> checkMachO(String tempDir, String scriptDill) async {
+  await checkSnapshotType(tempDir, scriptDill, SnapshotType.machoDylib);
+}
+
+class TestCase {
+  final SnapshotType snapshotType;
+  final String snapshotPath;
+  final DwarfContainer container;
+  final List<String> unwindInfo;
+
+  TestCase(
+    this.snapshotType,
+    this.snapshotPath,
+    this.container,
+    this.unwindInfo,
+  );
+}
+
+void checkCases(TestCase unstripped, TestCase stripped) {
+  Expect.isNotEmpty(unstripped.unwindInfo);
+  Expect.deepEquals(unstripped.unwindInfo, stripped.unwindInfo);
+}