[llvm-lipo] Implement -extract

[alexander-shaposhnikov]

Summary

This diff adds support for -extract.

Test plan: make check-all

[smeenai]

LGTM

[alexander-shaposhnikov]

fix typo

[compnerd]

llvm/tools/llvm-lipo/llvm-lipo.cpp

408

Why not hoist this above the architecture check? This should be super cheap, and avoids doing I/O unless the inputs are good.

llvm/test/tools/llvm-lipo/extract.test

+# RUN: yaml2obj %p/Inputs/i386-x86_64-universal.yaml > %t-universal.o
+
+# RUN: not llvm-lipo %t-universal.o -extract arm64_32 -output /dev/null 2>&1 | FileCheck --check-prefix=ARCH_NOT_IN_FILE %s
+# ARCH_NOT_IN_FILE: does not contain the specified architecture arm64_32
+
+# RUN: yaml2obj %p/Inputs/i386-slice.yaml > %t-i386.o
+# RUN: not llvm-lipo %t-i386.o -extract arm64_32 -output /dev/null 2>&1 | FileCheck --check-prefix=INPUT_NOT_A_FAT_FILE %s
+# INPUT_NOT_A_FAT_FILE: must be a fat file when the -extract option is specified
+
+# RUN: llvm-lipo -create %t-i386.o -output %t-i386-universal.o
+# RUN: llvm-lipo -extract i386 %t-universal.o -output %t-i386-universal-extracted.o
+# RUN: cmp %t-i386-universal.o %t-i386-universal-extracted.o
+# RUN: llvm-lipo -thin i386 %t-i386-universal-extracted.o -output %t-i386-thinned.o
+# RUN: cmp %t-i386.o %t-i386-thinned.o

llvm/tools/llvm-lipo/LipoOpts.td

def info : Option<["-", "--"], "info", KIND_FLAG>,
                     "filename and arch_types. Groups universal binaries "
                     "together followed by thin files">;
 
 def thin : Option<["-", "--"], "thin", KIND_SEPARATE>,
            Group<action_group>,
            HelpText<"Create a thin output file of specified arch_type from the "
                     "fat input file. Requires -output option">;
 
+def extract : Option<["-", "--"], "extract", KIND_SEPARATE>,
+           Group<action_group>,
+           HelpText<"Create a universal output file containing only the specified "
+                    "arch_type from the fat input file. Requires -output option">;
+
 def create : Option<["-", "--"], "create", KIND_FLAG>,
              Group<action_group>,
              HelpText<"Create a universal binary output file from the input "
                       "files. Requires -output option">;
 
 def replace
     : MultiArg<["-", "--"], "replace", 2>,
       Group<action_group>,
       HelpText<"Replace the specified arch type with the contents of the "
                "input_file in a universal binary. Requires -output option">;
 
 def output : Option<["-", "--"], "output", KIND_SEPARATE>,
              HelpText<"Create output file with specified name">;
 def o : JoinedOrSeparate<["-"], "o">, Alias<output>;

llvm/tools/llvm-lipo/llvm-lipo.cpp

public:
   LipoOptTable() : OptTable(LipoInfoTable) {}
 };
 
 enum class LipoAction {
   PrintArchs,
   PrintInfo,
   VerifyArch,
   ThinArch,
+  ExtractArch,
   CreateUniversal,
   ReplaceArch,
 };
 
 struct InputFile {
   Optional<StringRef> ArchType;
   StringRef FileName;
 };
 
 struct Config {
   SmallVector<InputFile, 1> InputFiles;
   SmallVector<std::string, 1> VerifyArchList;
   SmallVector<InputFile, 1> ReplacementFiles;
   StringMap<const uint32_t> SegmentAlignments;
-  std::string ThinArchType;
+  std::string ArchType;
   std::string OutputFile;
   LipoAction ActionToPerform;
 };
 
 // For compatibility with cctools lipo, a file's alignment is calculated as the
 // minimum aligment of all segments. For object files, the file's alignment is
 // the maximum alignment of its sections.
 static uint32_t calculateFileAlignment(const MachOObjectFile &O) {
static Config parseLipoOptions(ArrayRef<const char *> ArgsArr) {
 
   case LIPO_info:
     C.ActionToPerform = LipoAction::PrintInfo;
     return C;
 
   case LIPO_thin:
     if (C.InputFiles.size() > 1)
       reportError("thin expects a single input file");
-    C.ThinArchType = ActionArgs[0]->getValue();
-    validateArchitectureName(C.ThinArchType);
     if (C.OutputFile.empty())
       reportError("thin expects a single output file");
-
+    C.ArchType = ActionArgs[0]->getValue();
+    validateArchitectureName(C.ArchType);
     C.ActionToPerform = LipoAction::ThinArch;
     return C;
 
+  case LIPO_extract:
+    if (C.InputFiles.size() > 1)
+      reportError("extract expects a single input file");
+    if (C.OutputFile.empty())
+      reportError("extract expects a single output file");
+    C.ArchType = ActionArgs[0]->getValue();
+    validateArchitectureName(C.ArchType);
+    C.ActionToPerform = LipoAction::ExtractArch;
+    return C;
+
   case LIPO_create:
     if (C.OutputFile.empty())
       reportError("create expects a single output file to be specified");
     C.ActionToPerform = LipoAction::CreateUniversal;
     return C;
 
   case LIPO_replace:
     for (auto Action : ActionArgs) {
if (!Binary->isMachOUniversalBinary()) {
              << " is architecture: ";
       printBinaryArchs(Binary, outs());
     }
   }
   exit(EXIT_SUCCESS);
 }
 
 LLVM_ATTRIBUTE_NORETURN
-static void extractSlice(ArrayRef<OwningBinary<Binary>> InputBinaries,
-                         StringRef ThinArchType, StringRef OutputFileName) {
-  assert(!ThinArchType.empty() && "The architecture type should be non-empty");
+static void thinSlice(ArrayRef<OwningBinary<Binary>> InputBinaries,
+                      StringRef ArchType, StringRef OutputFileName) {
+  assert(!ArchType.empty() && "The architecture type should be non-empty");
   assert(InputBinaries.size() == 1 && "Incorrect number of input binaries");
   assert(!OutputFileName.empty() && "Thin expects a single output file");
 
   if (InputBinaries.front().getBinary()->isMachO()) {
     reportError("input file " +
                 InputBinaries.front().getBinary()->getFileName() +
                 " must be a fat file when the -thin option is specified");
     exit(EXIT_FAILURE);
   }
 
   auto *UO = cast<MachOUniversalBinary>(InputBinaries.front().getBinary());
   Expected<std::unique_ptr<MachOObjectFile>> Obj =
-      UO->getMachOObjectForArch(ThinArchType);
-  Expected<std::unique_ptr<Archive>> Ar = UO->getArchiveForArch(ThinArchType);
+      UO->getMachOObjectForArch(ArchType);
+  Expected<std::unique_ptr<Archive>> Ar = UO->getArchiveForArch(ArchType);
   if (!Obj && !Ar)
     reportError("fat input file " + UO->getFileName() +
-                " does not contain the specified architecture " + ThinArchType +
+                " does not contain the specified architecture " + ArchType +
                 " to thin it to");
   Binary *B = Obj ? static_cast<Binary *>(Obj->get())
                   : static_cast<Binary *>(Ar->get());
   Expected<std::unique_ptr<FileOutputBuffer>> OutFileOrError =
       FileOutputBuffer::create(OutputFileName,
                                B->getMemoryBufferRef().getBufferSize(),
                                sys::fs::can_execute(UO->getFileName())
                                    ? FileOutputBuffer::F_executable
SmallVector<Slice, 1> Slices =
       buildSlices(InputBinaries, Alignments, ExtractedObjects);
   checkArchDuplicates(Slices);
   checkUnusedAlignments(Slices, Alignments);
   createUniversalBinary(Slices, OutputFileName);
 
   exit(EXIT_SUCCESS);
 }
 
+LLVM_ATTRIBUTE_NORETURN
+static void extractSlice(ArrayRef<OwningBinary<Binary>> InputBinaries,
+                         const StringMap<const uint32_t> &Alignments,
+                         StringRef ArchType, StringRef OutputFileName) {
+  assert(!ArchType.empty() &&
+         "The architecture type should be non-empty");
+  assert(InputBinaries.size() == 1 && "Incorrect number of input binaries");
+  assert(!OutputFileName.empty() && "Thin expects a single output file");
+
+  if (InputBinaries.front().getBinary()->isMachO()) {
+    reportError("input file " +
+                InputBinaries.front().getBinary()->getFileName() +
+                " must be a fat file when the -extract option is specified");
+    exit(EXIT_FAILURE);
+  }
+
+  SmallVector<std::unique_ptr<MachOObjectFile>, 2> ExtractedObjects;
+  SmallVector<Slice, 2> Slices =
+      buildSlices(InputBinaries, Alignments, ExtractedObjects);
+  erase_if(Slices, [ArchType](const Slice &S) {
+    return ArchType != S.getArchString();
+  });
+
+  if (Slices.empty())
+    reportError(
+        "fat input file " + InputBinaries.front().getBinary()->getFileName() +
+        " does not contain the specified architecture " + ArchType);
+  createUniversalBinary(Slices, OutputFileName);
+  exit(EXIT_SUCCESS);
+}
+
 static StringMap<Slice>
 buildReplacementSlices(ArrayRef<OwningBinary<Binary>> ReplacementBinaries,
                        const StringMap<const uint32_t> &Alignments) {
   StringMap<Slice> Slices;
   // populates StringMap of slices to replace with; error checks for mismatched
   // replace flag args, fat files, and duplicate arch_types
   for (const auto &OB : ReplacementBinaries) {
     const Binary *ReplacementBinary = OB.getBinary();
case LipoAction::VerifyArch:
     break;
   case LipoAction::PrintArchs:
     printArchs(InputBinaries);
     break;
   case LipoAction::PrintInfo:
     printInfo(InputBinaries);
     break;
   case LipoAction::ThinArch:
-    extractSlice(InputBinaries, C.ThinArchType, C.OutputFile);
+    thinSlice(InputBinaries, C.ArchType, C.OutputFile);
+    break;
+  case LipoAction::ExtractArch:
+    extractSlice(InputBinaries, C.SegmentAlignments, C.ArchType, C.OutputFile);
     break;
   case LipoAction::CreateUniversal:
     createUniversalBinary(InputBinaries, C.SegmentAlignments, C.OutputFile);
     break;
   case LipoAction::ReplaceArch:
     replaceSlices(InputBinaries, C.SegmentAlignments, C.OutputFile,
                   C.ReplacementFiles);
     break;
   }
   return EXIT_SUCCESS;
 }