[pkg/dart2native] Refactor MachO parsing.

* Move parsing functions to static methods of the classes that
  represent the data being parsed.

* Move calculations for adjusting offsets in load commands into the
  corresponding classes.

* Make function to insert a new payload segment an instance method
  of MachOFile.

* Remove unnecessary abstractions and definitions for MachO load
  commands that we don't need to parse.

These refactorings are being done to make later changes easier to
review, by first lifting the initial refactorings out into a
separate CL.

Issue: #49783
Change-Id: I133eb368cbb9ee0d8e4f3998ba1a0bbe8555b8aa
Cq-Include-Trybots: luci.dart.try:analyzer-mac-release-try,dart-sdk-mac-arm64-try,dart-sdk-mac-try,pkg-mac-release-arm64-try,pkg-mac-release-try,vm-kernel-precomp-mac-product-x64-try,vm-kernel-precomp-nnbd-mac-release-arm64-try
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/256821
Reviewed-by: Daco Harkes <[email protected]>
Commit-Queue: Tess Strickland <[email protected]>
Reviewed-by: Ryan Macnak <[email protected]>

Author: sstrickl

pkg/dart2native/lib/dart2native_macho.dart

@@ -2,244 +2,15 @@
 // 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.
 
-import 'dart:convert';
 import 'dart:io';
 import 'dart:math';
-import 'dart:typed_data';
 
-import 'package:dart2native/macho.dart';
-import 'package:dart2native/macho_parser.dart';
-
-const String kSnapshotSegmentName = "__CUSTOM";
-const String kSnapshotSectionName = "__dart_app_snap";
-const int kMinimumSegmentSize = 0x4000;
-// Since arm64 macOS has 16K pages, which is larger than the 4K pages on x64
-// macOS, we use this larger page size to ensure the MachO file is aligned
-// properly on all architectures.
-const int kSegmentAlignment = 0x4000;
-
-int align(int size, int base) {
-  final int over = size % base;
-  if (over != 0) {
-    return size + (base - over);
-  }
-  return size;
-}
-
-// Utility for aligning parts of MachO headers to the defined sizes.
-int vmSizeAlign(int size) {
-  return align(max(size, kMinimumSegmentSize), kSegmentAlignment);
-}
-
-// Returns value + amount only if the original value is within the bounds
-// defined by [withinStart, withinStart + withinSize).
-Uint32 addIfWithin(
-    Uint32 value, Uint64 amount, Uint64 withinStart, Uint64 withinSize) {
-  final intWithinStart = withinStart.asInt();
-  final intWithinSize = withinSize.asInt();
-
-  if (value >= intWithinStart && value < (intWithinStart + intWithinSize)) {
-    return (value.asUint64() + amount).asUint32();
-  } else {
-    return value;
-  }
-}
-
-// Trims a bytestring that an arbitrary number of null characters on the end of
-// it.
-String trimmedBytestring(Uint8List bytestring) {
-  return String.fromCharCodes(bytestring.takeWhile((value) => value != 0));
-}
+import './macho.dart';
+import './macho_utils.dart';
 
 // Simplifies casting so we get null values back instead of exceptions.
 T? cast<T>(x) => x is T ? x : null;
 
-// Inserts a segment definition into a MachOFile. This does NOT insert the
-// actual segment into the file. It only inserts the definition of that segment
-// into the MachO header.
-//
-// In addition to simply specifying the definition for the segment, this
-// function also moves the existing __LINKEDIT segment to the end of the header
-// definition as is required by the MachO specification (or at least MacOS's
-// implementation of it). In doing so there are several offsets in the original
-// __LINKEDIT segment that must be updated to point to their new location
-// because the __LINKEDIT segment and sections are now in a different
-// place. This function takes care of those shifts as well.
-//
-// Returns the original, unmodified, __LINKEDIT segment.
-Future<MachOSegmentCommand64> insertSegmentDefinition(MachOFile file,
-    File segment, String segmentName, String sectionName) async {
-  // Load in the data to be inserted.
-  final segmentData = await segment.readAsBytes();
-
-  // Find the existing __LINKEDIT segment
-  final linkedit = cast<MachOSegmentCommand64>(file.commands
-      .where((segment) =>
-          segment.asType() is MachOSegmentCommand64 &&
-          MachOConstants.SEG_LINKEDIT ==
-              trimmedBytestring((segment as MachOSegmentCommand64).segname))
-      .first);
-
-  final linkeditIndex = file.commands.indexWhere((segment) =>
-      segment.asType() is MachOSegmentCommand64 &&
-      MachOConstants.SEG_LINKEDIT ==
-          trimmedBytestring((segment as MachOSegmentCommand64).segname));
-
-  if (linkedit == null) {
-    throw FormatException(
-        "Could not find a __LINKEDIT section in the specified binary.");
-  } else {
-    // Create the new segment.
-    final Uint8List segname = Uint8List(16);
-    segname.setRange(0, segmentName.length, ascii.encode(segmentName));
-    segname.fillRange(segmentName.length, 16, 0);
-
-    final Uint64 vmaddr = linkedit.vmaddr;
-    final Uint64 vmsize = Uint64(vmSizeAlign(segmentData.length));
-    final Uint64 fileoff = linkedit.fileoff;
-    final Uint64 filesize = vmsize;
-    final Int32 maxprot = MachOConstants.VM_PROT_READ;
-    final Int32 initprot = maxprot;
-    final Uint32 nsects = Uint32(1);
-
-    final Uint8List sectname = Uint8List(16);
-    sectname.setRange(0, sectionName.length, ascii.encode(sectionName));
-    sectname.fillRange(sectionName.length, 16, 0);
-
-    final Uint64 addr = vmaddr;
-    final Uint64 size = Uint64(segmentData.length);
-    final Uint32 offset = fileoff.asUint32();
-    final Uint32 flags = MachOConstants.S_REGULAR;
-
-    final Uint32 zero = Uint32(0);
-
-    final loadCommandDefinitionSize = 4 * 2;
-    final sectionDefinitionSize = 16 * 2 + 8 * 2 + 4 * 8;
-    final segmentDefinitionSize = 16 + 8 * 4 + 4 * 4;
-    final commandSize = loadCommandDefinitionSize +
-        segmentDefinitionSize +
-        sectionDefinitionSize;
-
-    final loadCommand =
-        MachOLoadCommand(MachOConstants.LC_SEGMENT_64, Uint32(commandSize));
-
-    final section = MachOSection64(sectname, segname, addr, size, offset, zero,
-        zero, zero, flags, zero, zero, zero);
-
-    final segment = MachOSegmentCommand64(Uint32(commandSize), segname, vmaddr,
-        vmsize, fileoff, filesize, maxprot, initprot, nsects, zero, [section]);
-
-    // Setup the new linkedit command.
-    final shiftedLinkeditVmaddr = linkedit.vmaddr + segment.vmsize;
-    final shiftedLinkeditFileoff = linkedit.fileoff + segment.filesize;
-    final shiftedLinkedit = MachOSegmentCommand64(
-        linkedit.cmdsize,
-        linkedit.segname,
-        shiftedLinkeditVmaddr,
-        linkedit.vmsize,
-        shiftedLinkeditFileoff,
-        linkedit.filesize,
-        linkedit.maxprot,
-        linkedit.initprot,
-        linkedit.nsects,
-        linkedit.flags,
-        linkedit.sections);
-
-    // Shift all of the related commands that need to reference the new file
-    // position of the linkedit segment.
-    for (var i = 0; i < file.commands.length; i++) {
-      final command = file.commands[i];
-
-      final offsetAmount = segment.filesize;
-      final withinStart = linkedit.fileoff;
-      final withinSize = linkedit.filesize;
-
-      // For the specific command that we need to adjust, we need to move the
-      // commands' various offsets forward by the new segment's size in the file
-      // (segment.filesize). However, we need to ensure that when we move the
-      // offset forward, we exclude cases where the offset was originally
-      // outside of the linkedit segment (i.e. offset < linkedit.fileoff or
-      // offset >= linkedit.fileoff + linkedit.filesize). The DRY-ing function
-      // addIfWithin takes care of that repeated logic.
-      if (command is MachODyldInfoCommand) {
-        file.commands[i] = MachODyldInfoCommand(
-            command.cmd,
-            command.cmdsize,
-            addIfWithin(
-                command.rebase_off, offsetAmount, withinStart, withinSize),
-            command.rebase_size,
-            addIfWithin(
-                command.bind_off, offsetAmount, withinStart, withinSize),
-            command.bind_size,
-            addIfWithin(
-                command.weak_bind_off, offsetAmount, withinStart, withinSize),
-            command.weak_bind_size,
-            addIfWithin(
-                command.lazy_bind_off, offsetAmount, withinStart, withinSize),
-            command.lazy_bind_size,
-            addIfWithin(
-                command.export_off, offsetAmount, withinStart, withinSize),
-            command.export_size);
-      } else if (command is MachOSymtabCommand) {
-        file.commands[i] = MachOSymtabCommand(
-            command.cmdsize,
-            addIfWithin(command.symoff, offsetAmount, withinStart, withinSize),
-            command.nsyms,
-            addIfWithin(command.stroff, offsetAmount, withinStart, withinSize),
-            command.strsize);
-      } else if (command is MachODysymtabCommand) {
-        file.commands[i] = MachODysymtabCommand(
-            command.cmdsize,
-            command.ilocalsym,
-            command.nlocalsym,
-            command.iextdefsym,
-            command.nextdefsym,
-            command.iundefsym,
-            command.nundefsym,
-            addIfWithin(command.tocoff, offsetAmount, withinStart, withinSize),
-            command.ntoc,
-            addIfWithin(
-                command.modtaboff, offsetAmount, withinStart, withinSize),
-            command.nmodtab,
-            addIfWithin(
-                command.extrefsymoff, offsetAmount, withinStart, withinSize),
-            command.nextrefsyms,
-            addIfWithin(
-                command.indirectsymoff, offsetAmount, withinStart, withinSize),
-            command.nindirectsyms,
-            addIfWithin(
-                command.extreloff, offsetAmount, withinStart, withinSize),
-            command.nextrel,
-            addIfWithin(
-                command.locreloff, offsetAmount, withinStart, withinSize),
-            command.nlocrel);
-      } else if (command is MachOLinkeditDataCommand) {
-        file.commands[i] = MachOLinkeditDataCommand(
-            command.cmd,
-            command.cmdsize,
-            addIfWithin(command.dataoff, offsetAmount, withinStart, withinSize),
-            command.datasize);
-      }
-    }
-
-    // Now we need to build the new header from these modified pieces.
-    file.header = MachOHeader(
-        file.header!.magic,
-        file.header!.cputype,
-        file.header!.cpusubtype,
-        file.header!.filetype,
-        file.header!.ncmds + Uint32(1),
-        file.header!.sizeofcmds + loadCommand.cmdsize,
-        file.header!.flags,
-        file.header!.reserved);
-
-    file.commands[linkeditIndex] = shiftedLinkedit;
-    file.commands.insert(linkeditIndex, segment);
-  }
-
-  return linkedit;
-}
-
 // Pipe from one file stream into another. We do this in chunks to avoid
 // excessive memory load.
 Future<int> pipeStream(RandomAccessFile from, RandomAccessFile to,
@@ -297,17 +68,22 @@ Future writeAppendedMachOExecutable(
     String dartaotruntimePath, String payloadPath, String outputPath) async {
   File originalExecutableFile = File(dartaotruntimePath);
 
-  MachOFile machOFile = MachOFile();
-  await machOFile.loadFromFile(originalExecutableFile);
+  MachOFile machOFile = MachOFile.fromFile(originalExecutableFile);
+  final oldLinkEditSegmentFileOffset = machOFile.linkEditSegment?.fileOffset;
+  if (oldLinkEditSegmentFileOffset == null) {
+    throw FormatException("__LINKEDIT segment not found");
+  }
 
   // Insert the new segment that contains our snapshot data.
   File newSegmentFile = File(payloadPath);
 
-  // Note that these two values MUST match the ones in
-  // runtime/bin/snapshot_utils.cc, which looks specifically for the snapshot in
-  // this segment/section.
-  final linkeditCommand = await insertSegmentDefinition(
-      machOFile, newSegmentFile, kSnapshotSegmentName, kSnapshotSectionName);
+  // Get the length of the contents of the section to be added.
+  final payloadLength = newSegmentFile.lengthSync();
+  // We only need the original offset of the __LINKEDIT segment from the
+  // original headers, which we've already retrieved. Thus, use the new
+  // MachOFile from inserting the snapshot segment from here on.
+  machOFile = machOFile.insertSegmentLoadCommand(
+      payloadLength, snapshotSegmentName, snapshotSectionName);
 
   // Write out the new executable, with the same contents except the new header.
   File outputFile = File(outputPath);
@@ -321,16 +97,22 @@ Future writeAppendedMachOExecutable(
   RandomAccessFile originalFileStream = await originalExecutableFile.open();
   await originalFileStream.setPosition(headerBytesWritten);
 
-  // Write the unchanged data from the original file.
+  // Write the unchanged data from the original file up to the __LINKEDIT
+  // segment contents, so we can insert the snapshot there.
   await pipeStream(originalFileStream, stream,
-      numToWrite: linkeditCommand.fileoff.asInt() - headerBytesWritten);
+      numToWrite: oldLinkEditSegmentFileOffset - headerBytesWritten);
+
+  void addPadding(int size) => stream.writeFromSync(List.filled(size, 0));
+
+  final snapshotSegment = machOFile.snapshotSegment!;
+  // There may be additional padding needed between the old __LINKEDIT file
+  // offset and the start of the new snapshot.
+  addPadding(snapshotSegment.fileOffset - oldLinkEditSegmentFileOffset);
 
   // Write the inserted section data, ensuring that the data is padded to the
   // segment size.
   await pipeStream(newSegmentFileStream, stream);
-  final int newSegmentLength = newSegmentFileStream.lengthSync();
-  final int alignedSegmentSize = vmSizeAlign(newSegmentLength);
-  await stream.writeFrom(List.filled(alignedSegmentSize - newSegmentLength, 0));
+  addPadding(align(payloadLength, segmentAlignment) - payloadLength);
 
   // Copy the rest of the file from the original to the new one.
   await pipeStream(originalFileStream, stream);