[dsymutil] Copy the LC_BUILD_VERSION load command into the companion binary

[aprantl]

Summary

LC_BUILD_VERSION contains platform information that is useful for LLDB to match up dSYM bundles with binaries. This patch copies the load command over into the dSYM.

[JDevlieghere]

LGTM

test/tools/dsymutil/X86/lc_build_version.test

1 ↗

(On Diff #173042)

nit: missing space before obj2yaml

llvm/trunk/test/tools/dsymutil/X86/lc_build_version.test

+# RUN: dsymutil -f %p/../Inputs/lc_build_version.x86_64 -o - \
+# RUN:   | obj2yaml | FileCheck %s
+
+CHECK: LoadCommands:
+CHECK:   - cmd:             LC_BUILD_VERSION
+CHECK-NEXT:    cmdsize:         24
+CHECK-NEXT:    platform:        1
+CHECK-NEXT:    minos:           658944
+CHECK-NEXT:    sdk:             658944
+CHECK-NEXT:    ntools:          0
+CHECK-NEXT: - cmd

llvm/trunk/tools/dsymutil/MachOUtils.cpp

return error(Twine("opening ") + DM.getBinaryPath() + ": " +
                  "output file streaming");
   }
 
   auto &InputBinary = *Object;
 
   bool Is64Bit = Writer.is64Bit();
   MachO::symtab_command SymtabCmd = InputBinary.getSymtabLoadCommand();
 
-  // Get UUID.
+  // Compute the number of load commands we will need.
+  unsigned LoadCommandSize = 0;
+  unsigned NumLoadCommands = 0;
+
+  // Get LC_UUID and LC_BUILD_VERSION.
   MachO::uuid_command UUIDCmd;
+  MachO::build_version_command BuildVersionCmd;
   memset(&UUIDCmd, 0, sizeof(UUIDCmd));
-  UUIDCmd.cmd = MachO::LC_UUID;
-  UUIDCmd.cmdsize = sizeof(MachO::uuid_command);
+  memset(&BuildVersionCmd, 0, sizeof(BuildVersionCmd));
   for (auto &LCI : InputBinary.load_commands()) {
-    if (LCI.C.cmd == MachO::LC_UUID) {
+    switch (LCI.C.cmd) {
+    case MachO::LC_UUID:
       UUIDCmd = InputBinary.getUuidCommand(LCI);
-      break;
-    }
-  }
-
-  // Compute the number of load commands we will need.
-  unsigned LoadCommandSize = 0;
-  unsigned NumLoadCommands = 0;
-  // We will copy the UUID if there is one.
-  if (UUIDCmd.cmd != 0) {
       ++NumLoadCommands;
       LoadCommandSize += sizeof(MachO::uuid_command);
+      break;
+    case MachO::LC_BUILD_VERSION:
+      BuildVersionCmd = InputBinary.getBuildVersionLoadCommand(LCI);
+      ++NumLoadCommands;
+      LoadCommandSize += sizeof(MachO::build_version_command);
+      // LLDB doesn't care about the build tools for now.
+      BuildVersionCmd.ntools = 0;
+      break;
+    default:
+      break;
+    }
   }
 
   // If we have a valid symtab to copy, do it.
   bool ShouldEmitSymtab =
       isExecutable(InputBinary) && hasLinkEditSegment(InputBinary);
   if (ShouldEmitSymtab) {
     LoadCommandSize += sizeof(MachO::symtab_command);
     ++NumLoadCommands;
bool generateDsymCompanion(const DebugMap &DM, MCStreamer &MS,
 
   // We gathered all the information we need, start emitting the output file.
   Writer.writeHeader(MachO::MH_DSYM, NumLoadCommands, LoadCommandSize, false);
 
   // Write the load commands.
   assert(OutFile.tell() == HeaderSize);
   if (UUIDCmd.cmd != 0) {
     Writer.W.write<uint32_t>(UUIDCmd.cmd);
-    Writer.W.write<uint32_t>(UUIDCmd.cmdsize);
+    Writer.W.write<uint32_t>(sizeof(UUIDCmd));
     OutFile.write(reinterpret_cast<const char *>(UUIDCmd.uuid), 16);
     assert(OutFile.tell() == HeaderSize + sizeof(UUIDCmd));
   }
+  if (BuildVersionCmd.cmd != 0) {
+    Writer.W.write<uint32_t>(BuildVersionCmd.cmd);
+    Writer.W.write<uint32_t>(sizeof(BuildVersionCmd));
+    Writer.W.write<uint32_t>(BuildVersionCmd.platform);
+    Writer.W.write<uint32_t>(BuildVersionCmd.minos);
+    Writer.W.write<uint32_t>(BuildVersionCmd.sdk);
+    Writer.W.write<uint32_t>(BuildVersionCmd.ntools);
+  }
 
   assert(SymtabCmd.cmd && "No symbol table.");
   uint64_t StringStart = SymtabStart + NumSyms * NListSize;
   if (ShouldEmitSymtab)
     Writer.writeSymtabLoadCommand(SymtabStart, NumSyms, StringStart,
                                   NewStringsSize);
 
   uint64_t DwarfSegmentStart = StringStart + NewStringsSize;