[vm] Add --macho-min-os-version flag for macOS/iOS targets.

The command line flag allows the user to specify the minimum MacOS or
iOS version used in the build version load command for the Mach-O
dynamic library snapshot. If not specified, the minimum OS version
specified in macOS Mach-O snapshots is 10.15 (Catalina) and the minimum
OS version specified in iOS Mach-O snapshots is 13.

This CL also changes the targeted OS version in the build version load
command to be the same as the minimum OS version.

Adds support to parsing build version load commands to
pkg/native_stack_traces's Mach-O parser in order to test the
existence and contents of build version load commands in
vm/dart/unobfuscated_static_symbols.

TEST=vm/dart/unobfuscated_static_symbols

Issue: #60307
Change-Id: I3ee3ba34297d3261be7e3a1d2fb3c1da1ef0ef05
Cq-Include-Trybots: luci.dart.try:vm-aot-mac-debug-x64-try,vm-aot-mac-debug-arm64-try,vm-aot-linux-debug-arm64-try,vm-aot-linux-debug-x64-try,pkg-mac-release-try,pkg-mac-release-arm64-try,pkg-linux-release-arm64-try
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/438901
Reviewed-by: Ryan Macnak <[email protected]>
Commit-Queue: Tess Strickland <[email protected]>

Author: sstrickl

pkg/native_stack_traces/lib/src/macho.dart

@@ -125,6 +125,7 @@ class LoadCommand {
   static const LC_SYMTAB = 0x2;
   static const LC_SEGMENT_64 = 0x19;
   static const LC_UUID = 0x1b;
+  static const LC_BUILD_VERSION = 0x32;
 
   static LoadCommand fromReader(Reader reader) {
     final start = reader.offset; // cmdsize includes size of cmd and cmdsize.
@@ -143,6 +144,9 @@ class LoadCommand {
       case LC_UUID:
         command = UuidCommand.fromReader(reader, cmd, cmdsize);
         break;
+      case LC_BUILD_VERSION:
+        command = BuildVersionCommand.fromReader(reader, cmd, cmdsize);
+        break;
       default:
         break;
     }
@@ -351,6 +355,161 @@ class UuidCommand extends LoadCommand {
   }
 }
 
+class Version {
+  final int x;
+  final int y;
+  final int z;
+
+  const Version(this.x, this.y, this.z);
+
+  static Version fromInt(int v) {
+    final x = (v & 0xffffffff) >> 16;
+    final y = (v & 0xffff) >> 8;
+    final z = v & 0xff;
+    return Version(x, y, z);
+  }
+
+  @override
+  int get hashCode => Object.hash(x, y, z);
+
+  @override
+  bool operator ==(Object other) {
+    if (identical(this, other)) return true;
+    return other is Version && x == other.x && y == other.y && z == other.z;
+  }
+
+  @override
+  String toString() => '$x.$y.$z';
+}
+
+enum Platform {
+  PLATFORM_UNKNOWN(0, 'Unknown'),
+  PLATFORM_ANY(0xFFFFFFFF, 'any'),
+  PLATFORM_MACOS(0x1, 'MacOS'),
+  PLATFORM_IOS(0x2, 'iOS'),
+  PLATFORM_TVOS(0x3, 'TVOS'),
+  PLATFORM_WATCHOS(0x4, 'WatchOS'),
+  PLATFORM_IOSSIMULATOR(0x7, 'iOS Simulator'),
+  PLATFORM_TVOSSIMULATOR(0x8, 'TVOS Simulator'),
+  PLATFORM_WATCHOSSIMULATOR(0x9, 'WatchOS Simulator');
+
+  final int id;
+  final String description;
+
+  const Platform(this.id, this.description);
+
+  static Platform? fromId(int id) {
+    for (final platform in values) {
+      if (platform.id == id) {
+        return platform;
+      }
+    }
+    return null;
+  }
+
+  @override
+  String toString() => description;
+}
+
+enum BuildTool {
+  TOOL_CLANG(1, 'clang'),
+  TOOL_SWIFT(2, 'Swift'),
+  TOOL_LD(3, 'ld'),
+  TOOL_LLD(4, 'lld');
+
+  final int id;
+  final String description;
+
+  const BuildTool(this.id, this.description);
+
+  static BuildTool? fromId(int id) {
+    for (final tool in values) {
+      if (tool.id == id) {
+        return tool;
+      }
+    }
+    return null;
+  }
+
+  @override
+  String toString() => description;
+}
+
+class BuildToolVersion {
+  final int _toolId;
+  final BuildTool? tool;
+  final Version version;
+
+  const BuildToolVersion._(this._toolId, this.tool, this.version);
+
+  factory BuildToolVersion.fromReader(Reader reader) {
+    final id = _readMachOUint32(reader);
+    final tool = BuildTool.fromId(id);
+    final version = Version.fromInt(_readMachOUint32(reader));
+    return BuildToolVersion._(id, tool, version);
+  }
+
+  void writeToStringBuffer(StringBuffer buffer) {
+    buffer
+      ..write('  - ')
+      ..write(tool ?? 'Unknown (0x${paddedHex(_toolId, 4)})')
+      ..write(' (')
+      ..write(version)
+      ..writeln(')');
+  }
+
+  @override
+  String toString() {
+    final buffer = StringBuffer();
+    writeToStringBuffer(buffer);
+    return buffer.toString();
+  }
+}
+
+class BuildVersionCommand extends LoadCommand {
+  final int _platformId;
+  final Platform? platform;
+  final Version minOS;
+  final Version sdk;
+  final List<BuildToolVersion> toolVersions;
+
+  BuildVersionCommand._(super.cmd, super.cmdsize, this._platformId,
+      this.platform, this.minOS, this.sdk, this.toolVersions)
+      : super._();
+
+  static BuildVersionCommand fromReader(Reader reader, int cmd, int cmdsize) {
+    final platformId = _readMachOUint32(reader);
+    final platform = Platform.fromId(platformId);
+    final minOS = Version.fromInt(_readMachOUint32(reader));
+    final sdk = Version.fromInt(_readMachOUint32(reader));
+    final toolCount = _readMachOUint32(reader);
+    final toolVersions = <BuildToolVersion>[];
+    for (int i = 0; i < toolCount; i++) {
+      toolVersions.add(BuildToolVersion.fromReader(reader));
+    }
+    return BuildVersionCommand._(
+        cmd, cmdsize, platformId, platform, minOS, sdk, toolVersions);
+  }
+
+  @override
+  void writeToStringBuffer(StringBuffer buffer) {
+    buffer
+      ..writeln('Build version:')
+      ..write('  Platform: ')
+      ..writeln(platform ?? 'Unknown (0x${paddedHex(_platformId, 4)})')
+      ..write('  Minimum OS: ')
+      ..writeln(minOS)
+      ..write('  Minimum SDK: ')
+      ..writeln(sdk);
+    if (toolVersions.isNotEmpty) {
+      buffer.writeln('  Tools:');
+      for (final v in toolVersions) {
+        v.writeToStringBuffer(buffer);
+      }
+    }
+  }
+}
+
 class MachOHeader {
   final int magic;
   final int cputype;
@@ -529,6 +688,9 @@ class MachO extends DwarfContainer {
       Reader.fromTypedData(reader.bdata,
           wordSize: _header.wordSize, endian: _header.endian);
 
+  Iterable<T> commandsWhereType<T extends LoadCommand>() =>
+      _commands.whereType<T>();
+
   @override
   String? get architecture => CpuType.fromCode(_header.cputype)?.dartName;
 

runtime/tests/vm/dart/unobfuscated_static_symbols_test.dart

@@ -13,6 +13,7 @@ import "dart:io";
 
 import 'package:expect/expect.dart';
 import 'package:native_stack_traces/src/dwarf_container.dart';
+import 'package:native_stack_traces/src/macho.dart' as macho;
 import 'package:path/path.dart' as path;
 
 import 'use_flag_test_helper.dart';
@@ -85,20 +86,33 @@ Future<List<String>?> retrieveDebugMap(
   return await runOutput(dsymutil, ['--dump-debug-map', snapshotPath]);
 }
 
+final hasMinOSVersionOption = Platform.isMacOS || Platform.isIOS;
+final expectedVersion = hasMinOSVersionOption ? macho.Version(1, 2, 3) : null;
+
 Future<void> checkSnapshotType(
   String tempDir,
   String scriptDill,
   SnapshotType snapshotType,
 ) async {
+  final commonOptions = <String>[];
+  if (hasMinOSVersionOption && snapshotType == SnapshotType.machoDylib) {
+    commonOptions.add('--macho-min-os-version=$expectedVersion');
+  }
   // Run the AOT compiler without Dwarf stack trace, once without obfuscation,
   // once with obfuscation, and once with obfuscation and saving debugging
   // information.
   final scriptUnobfuscatedSnapshot = path.join(
     tempDir,
     'unobfuscated-$snapshotType.so',
   );
-  await createSnapshot(scriptDill, snapshotType, scriptUnobfuscatedSnapshot);
+  await createSnapshot(
+    scriptDill,
+    snapshotType,
+    scriptUnobfuscatedSnapshot,
+    commonOptions,
+  );
   final unobfuscatedCase = TestCase(
+    snapshotType,
     scriptUnobfuscatedSnapshot,
     snapshotType.fromFile(scriptUnobfuscatedSnapshot)!,
     debugMap: await retrieveDebugMap(snapshotType, scriptUnobfuscatedSnapshot),
@@ -109,9 +123,11 @@ Future<void> checkSnapshotType(
     'obfuscated-only-$snapshotType.so',
   );
   await createSnapshot(scriptDill, snapshotType, scriptObfuscatedOnlySnapshot, [
+    ...commonOptions,
     '--obfuscate',
   ]);
   final obfuscatedOnlyCase = TestCase(
+    snapshotType,
     scriptObfuscatedOnlySnapshot,
     snapshotType.fromFile(scriptObfuscatedOnlySnapshot)!,
     debugMap: await retrieveDebugMap(
@@ -135,10 +151,12 @@ Future<void> checkSnapshotType(
       'obfuscated-debug-$snapshotType.so',
     );
     await createSnapshot(scriptDill, snapshotType, scriptObfuscatedSnapshot, [
+      ...commonOptions,
       '--obfuscate',
       '--save-debugging-info=$scriptDebuggingInfo',
     ]);
     obfuscatedCase = TestCase(
+      snapshotType,
       scriptObfuscatedSnapshot,
       snapshotType.fromFile(scriptObfuscatedSnapshot)!,
       debuggingInfoContainer: snapshotType.fromFile(scriptDebuggingInfo)!,
@@ -154,11 +172,13 @@ Future<void> checkSnapshotType(
       'obfuscated-separate-debug-$snapshotType.so',
     );
     await createSnapshot(scriptDill, snapshotType, scriptStrippedSnapshot, [
+      ...commonOptions,
       '--strip',
       '--obfuscate',
       '--save-debugging-info=$scriptSeparateDebuggingInfo',
     ]);
     strippedCase = TestCase(
+      snapshotType,
       scriptStrippedSnapshot,
       /*container=*/ null, // No static symbols in stripped snapshot.
       debuggingInfoContainer: snapshotType.fromFile(
@@ -192,12 +212,14 @@ Future<void> checkAssembly(String tempDir, String scriptDill) async {
 }
 
 class TestCase {
+  final SnapshotType type;
   final String snapshotPath;
   final DwarfContainer? container;
   final DwarfContainer? debuggingInfoContainer;
   final List<String>? debugMap;
 
   TestCase(
+    this.type,
     this.snapshotPath,
     this.container, {
     this.debuggingInfoContainer,
@@ -222,6 +244,7 @@ Future<void> checkCases(
       unstrippedObfuscateds.map((c) => c.debugMap!).toList(),
     );
   }
+  checkMachOSnapshots(unobfuscated, obfuscateds);
 }
 
 Future<void> checkTraces(
@@ -412,3 +435,31 @@ void checkDebugMaps(List<String> expected, List<List<String>> cases) {
     }
   }
 }
+
+// Checks for MachO snapshots (not separate debugging information).
+void checkMachOSnapshots(TestCase unobfuscated, List<TestCase> obfuscateds) {
+  checkMachOSnapshot(unobfuscated);
+  obfuscateds.forEach(checkMachOSnapshot);
+}
+
+void checkMachOSnapshot(TestCase testCase) {
+  // The checks below are only for snapshots, not for debugging information.
+  final snapshot = testCase.container;
+  if (snapshot is! macho.MachO) return;
+  final buildVersion = snapshot
+      .commandsWhereType<macho.BuildVersionCommand>()
+      .singleOrNull;
+  final expectedPlatform = Platform.isMacOS
+      ? macho.Platform.PLATFORM_MACOS
+      : Platform.isIOS
+      ? macho.Platform.PLATFORM_IOS
+      : null;
+  Expect.equals(expectedPlatform, buildVersion?.platform);
+  if (testCase.type == SnapshotType.machoDylib) {
+    Expect.equals(expectedVersion, buildVersion?.minOS);
+    Expect.equals(expectedVersion, buildVersion?.sdk);
+    if (buildVersion != null) {
+      Expect.isEmpty(buildVersion.toolVersions);
+    }
+  }
+}

runtime/tests/vm/dart/use_dwarf_stack_traces_flag_deferred_test.dart

@@ -16,7 +16,8 @@ import "dart:io";
 
 import 'package:native_stack_traces/native_stack_traces.dart';
 import 'package:native_stack_traces/src/constants.dart' show rootLoadingUnitId;
-import 'package:native_stack_traces/src/macho.dart';
+import 'package:native_stack_traces/src/macho.dart'
+    show emptyMachOForArchitecture, MachO;
 import 'package:path/path.dart' as path;
 import 'package:test/test.dart';
 

runtime/tests/vm/dart/use_dwarf_stack_traces_flag_test.dart

@@ -10,7 +10,8 @@ import "dart:async";
 import "dart:io";
 
 import 'package:native_stack_traces/native_stack_traces.dart';
-import 'package:native_stack_traces/src/macho.dart';
+import 'package:native_stack_traces/src/macho.dart'
+    show emptyMachOForArchitecture, MachO;
 import 'package:path/path.dart' as path;
 import 'package:test/test.dart';