[lld-macho] Fold __objc_imageinfo sections

[int3]

Summary

Previously, we treated it as a regular ConcatInputSection. However, ld64
actually parses its contents and uses that to synthesize a single image
info struct, generating one 8-byte section instead of `8 * number of
object files with ObjC code`.

I'm not entirely sure what impact this section has on the runtime, so I
just tried to follow ld64's semantics as closely as possible in this
diff. My main motivation though was to reduce binary size.

No significant perf change on chromium_framework on my 16-core Mac Pro:

           base           diff           difference (95% CI)
sys_time   1.764 ± 0.062  1.748 ± 0.032  [  -2.4% ..   +0.5%]
user_time  5.112 ± 0.104  5.106 ± 0.046  [  -0.9% ..   +0.7%]
wall_time  6.111 ± 0.184  6.085 ± 0.076  [  -1.6% ..   +0.8%]
samples    30             32

[int3]

add test for invalid size

[int3]

update

[int3]

remove stray changes

[int3]

tweak comments

[int3]

simplify

[thakis]

Seems alright.

This saves 8 bytes times num .o files, so order of ~100kiB?

[int3]

Hm for chromium_framework it only saves 4560 bytes (4096 after alignment). I guess it would be more accurate to say it saves 8 * number of files with objC code. The size diff is a lot more significant in our internal apps presumably for that reason though (on the order of 100KiB indeed)

lld/MachO/Driver.cpp

SmallVector<StringRef> v{section_names::got,
                              section_names::cfString,
                              section_names::moduleInitFunc,
                              section_names::moduleTermFunc,
                              section_names::objcClassList,
                              section_names::objcNonLazyClassList,
                              section_names::objcCatList,
                              section_names::objcNonLazyCatList,
                              section_names::objcProtoList,
-                             section_names::objcImageInfo};
+                             section_names::objCImageInfo};
     for (StringRef s : v)
       config->sectionRenameMap[{segment_names::data, s}] = {
           segment_names::dataConst, s};
   }
   config->sectionRenameMap[{segment_names::text, section_names::staticInit}] = {
       segment_names::text, section_names::text};
   config->sectionRenameMap[{segment_names::import, section_names::pointers}] = {
       config->dataConst ? segment_names::dataConst : segment_names::data,
for (const Section *section : file->sections) {
           if (in.wordLiteralSection->inputOrder == UnspecifiedInputOrder)
             in.wordLiteralSection->inputOrder = inputOrder++;
           in.wordLiteralSection->addInput(isec);
         } else {
           llvm_unreachable("unexpected input section kind");
         }
       }
     }
+    if (!file->objCImageInfo.empty())
+      in.objCImageInfo->addFile(file);
   }
   assert(inputOrder <= UnspecifiedInputOrder);
 }
 
 static void foldIdenticalLiterals() {
   TimeTraceScope timeScope("Fold identical literals");
   // We always create a cStringSection, regardless of whether dedupLiterals is
   // true. If it isn't, we simply create a non-deduplicating CStringSection.

lld/MachO/InputFiles.h

public:
   Kind kind() const { return fileKind; }
   StringRef getName() const { return name; }
   static void resetIdCount() { idCount = 0; }
 
   MemoryBufferRef mb;
 
   std::vector<Symbol *> symbols;
   std::vector<Section *> sections;
+  ArrayRef<uint8_t> objCImageInfo;
 
   // If not empty, this stores the name of the archive containing this file.
   // We use this string for creating error messages.
   std::string archiveName;
 
   // Provides an easy way to sort InputFiles deterministically.
   const int id;
 

lld/MachO/InputFiles.cpp

if (sectionType(sec.flags) == S_CSTRING_LITERALS ||
       if (config->callGraphProfileSort && name == section_names::cgProfile)
         checkError(parseCallGraph(data, callGraph));
       // ld64 does not appear to emit contents from sections within the __LLVM
       // segment. Symbols within those sections point to bitcode metadata
       // instead of actual symbols. Global symbols within those sections could
       // have the same name without causing duplicate symbol errors. To avoid
       // spurious duplicate symbol errors, we do not parse these sections.
       // TODO: Evaluate whether the bitcode metadata is needed.
+    } else if (name == section_names::objCImageInfo &&
+               segname == segment_names::data) {
+      objCImageInfo = data;
     } else {
       if (name == section_names::addrSig)
         addrSigSection = sections.back();
 
       auto *isec = make<ConcatInputSection>(section, data, align);
       if (isDebugSection(isec->getFlags()) &&
           isec->getSegName() == segment_names::dwarf) {
         // Instead of emitting DWARF sections, we emit STABS symbols to the

lld/MachO/InputSection.h

 constexpr const char literals[] = "__literals";
 constexpr const char moduleInitFunc[] = "__mod_init_func";
 constexpr const char moduleTermFunc[] = "__mod_term_func";
 constexpr const char nonLazySymbolPtr[] = "__nl_symbol_ptr";
 constexpr const char objcCatList[] = "__objc_catlist";
 constexpr const char objcClassList[] = "__objc_classlist";
 constexpr const char objcClassRefs[] = "__objc_classrefs";
 constexpr const char objcConst[] = "__objc_const";
-constexpr const char objcImageInfo[] = "__objc_imageinfo";
+constexpr const char objCImageInfo[] = "__objc_imageinfo";
 constexpr const char objcNonLazyCatList[] = "__objc_nlcatlist";
 constexpr const char objcNonLazyClassList[] = "__objc_nlclslist";
 constexpr const char objcProtoList[] = "__objc_protolist";
 constexpr const char pageZero[] = "__pagezero";
 constexpr const char pointers[] = "__pointers";
 constexpr const char rebase[] = "__rebase";
 constexpr const char staticInit[] = "__StaticInit";
 constexpr const char stringTable[] = "__string_table";

lld/MachO/SyntheticSections.h

 #include "InputSection.h"
 #include "OutputSection.h"
 #include "OutputSegment.h"
 #include "Target.h"
 #include "Writer.h"
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Hashing.h"
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/MC/StringTableBuilder.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/raw_ostream.h"
 
 #include <unordered_map>
 
 namespace llvm {
private:
   // We're using unordered_map instead of DenseMap here because we need to
   // support all possible integer values -- there are no suitable tombstone
   // values for DenseMap.
   std::unordered_map<UInt128, uint64_t, Hasher<UInt128>> literal16Map;
   std::unordered_map<uint64_t, uint64_t> literal8Map;
   std::unordered_map<uint32_t, uint64_t> literal4Map;
 };
 
+class ObjCImageInfoSection final : public SyntheticSection {
+public:
+  ObjCImageInfoSection();
+  bool isNeeded() const override { return !files.empty(); }
+  uint64_t getSize() const override { return 8; }
+  void addFile(const InputFile *file) {
+    assert(!file->objCImageInfo.empty());
+    files.push_back(file);
+  }
+  void finalizeContents();
+  void writeTo(uint8_t *buf) const override;
+
+private:
+  struct ImageInfo {
+    uint8_t swiftVersion = 0;
+    bool hasCategoryClassProperties = false;
+  } info;
+  static ImageInfo parseImageInfo(const InputFile *);
+  std::vector<const InputFile *> files; // files with image info
+};
+
 struct InStruct {
   const uint8_t *bufferStart = nullptr;
   MachHeaderSection *header = nullptr;
   CStringSection *cStringSection = nullptr;
   WordLiteralSection *wordLiteralSection = nullptr;
   RebaseSection *rebase = nullptr;
   BindingSection *binding = nullptr;
   WeakBindingSection *weakBinding = nullptr;
   LazyBindingSection *lazyBinding = nullptr;
   ExportSection *exports = nullptr;
   GotSection *got = nullptr;
   TlvPointerSection *tlvPointers = nullptr;
   LazyPointerSection *lazyPointers = nullptr;
   StubsSection *stubs = nullptr;
   StubHelperSection *stubHelper = nullptr;
   UnwindInfoSection *unwindInfo = nullptr;
+  ObjCImageInfoSection *objCImageInfo = nullptr;
   ConcatInputSection *imageLoaderCache = nullptr;
 };
 
 extern InStruct in;
 extern std::vector<SyntheticSection *> syntheticSections;
 
 void createSyntheticSymbols();
 
 } // namespace macho
 } // namespace lld
 
 #endif

lld/MachO/SyntheticSections.cpp

void WordLiteralSection::writeTo(uint8_t *buf) const {
   for (const auto &p : literal8Map)
     memcpy(buf + p.second * 8, &p.first, 8);
   buf += literal8Map.size() * 8;
 
   for (const auto &p : literal4Map)
     memcpy(buf + p.second * 4, &p.first, 4);
 }
 
+ObjCImageInfoSection::ObjCImageInfoSection()
+    : SyntheticSection(segment_names::data, section_names::objCImageInfo) {}
+
+ObjCImageInfoSection::ImageInfo
+ObjCImageInfoSection::parseImageInfo(const InputFile *file) {
+  ImageInfo info;
+  ArrayRef<uint8_t> data = file->objCImageInfo;
+  // The image info struct has the following layout:
+  // struct {
+  //   uint32_t version;
+  //   uint32_t flags;
+  // };
+  if (data.size() < 8) {
+    warn(toString(file) + ": invalid __objc_imageinfo size");
+    return info;
+  }
+
+  auto *buf = reinterpret_cast<const uint32_t *>(data.data());
+  if (read32le(buf) != 0) {
+    warn(toString(file) + ": invalid __objc_imageinfo version");
+    return info;
+  }
+
+  uint32_t flags = read32le(buf + 1);
+  info.swiftVersion = (flags >> 8) & 0xff;
+  info.hasCategoryClassProperties = flags & 0x40;
+  return info;
+}
+
+static std::string swiftVersionString(uint8_t version) {
+  switch (version) {
+    case 1:
+      return "1.0";
+    case 2:
+      return "1.1";
+    case 3:
+      return "2.0";
+    case 4:
+      return "3.0";
+    case 5:
+      return "4.0";
+    default:
+      return ("0x" + Twine::utohexstr(version)).str();
+  }
+}
+
+// Validate each object file's __objc_imageinfo and use them to generate the
+// image info for the output binary. Only two pieces of info are relevant:
+// 1. The Swift version (should be identical across inputs)
+// 2. `bool hasCategoryClassProperties` (true only if true for all inputs)
+void ObjCImageInfoSection::finalizeContents() {
+  assert(files.size() != 0); // should have already been checked via isNeeded()
+
+  info.hasCategoryClassProperties = true;
+  const InputFile *firstFile;
+  for (auto file : files) {
+    ImageInfo inputInfo = parseImageInfo(file);
+    info.hasCategoryClassProperties &= inputInfo.hasCategoryClassProperties;
+
+    if (inputInfo.swiftVersion != 0) {
+      if (info.swiftVersion != 0 &&
+          info.swiftVersion != inputInfo.swiftVersion) {
+        error("Swift version mismatch: " + toString(firstFile) +
+              " has version " + swiftVersionString(info.swiftVersion) +
+              " but " + toString(file) + " has version " +
+              swiftVersionString(inputInfo.swiftVersion));
+      } else {
+        info.swiftVersion = inputInfo.swiftVersion;
+        firstFile = file;
+      }
+    }
+  }
+}
+
+void ObjCImageInfoSection::writeTo(uint8_t *buf) const {
+  uint32_t flags = info.hasCategoryClassProperties ? 0x40 : 0x0;
+  flags |= info.swiftVersion << 8;
+  write32le(buf + 4, flags);
+}
+
 void macho::createSyntheticSymbols() {
   auto addHeaderSymbol = [](const char *name) {
     symtab->addSynthetic(name, in.header->isec, /*value=*/0,
                          /*isPrivateExtern=*/true, /*includeInSymtab=*/false,
                          /*referencedDynamically=*/false);
   };
 
   switch (config->outputType) {

lld/MachO/Writer.cpp

template <class LP> void Writer::run() {
 
   // Do not proceed if there was an undefined symbol.
   reportPendingUndefinedSymbols();
   if (errorCount())
     return;
 
   if (in.stubHelper->isNeeded())
     in.stubHelper->setup();
+
+  if (in.objCImageInfo->isNeeded())
+    in.objCImageInfo->finalizeContents();
+
   // At this point, we should know exactly which output sections are needed,
   // courtesy of scanSymbols() and scanRelocations().
   createOutputSections<LP>();
 
   // After this point, we create no new segments; HOWEVER, we might
   // yet create branch-range extension thunks for architectures whose
   // hardware call instructions have limited range, e.g., ARM(64).
   // The thunks are created as InputSections interspersed among
void macho::createSyntheticSections() {
   in.lazyBinding = make<LazyBindingSection>();
   in.exports = make<ExportSection>();
   in.got = make<GotSection>();
   in.tlvPointers = make<TlvPointerSection>();
   in.lazyPointers = make<LazyPointerSection>();
   in.stubs = make<StubsSection>();
   in.stubHelper = make<StubHelperSection>();
   in.unwindInfo = makeUnwindInfoSection();
+  in.objCImageInfo = make<ObjCImageInfoSection>();
 
   // This section contains space for just a single word, and will be used by
   // dyld to cache an address to the image loader it uses.
   uint8_t *arr = bAlloc().Allocate<uint8_t>(target->wordSize);
   memset(arr, 0, target->wordSize);
   in.imageLoaderCache = makeSyntheticInputSection(
       segment_names::data, section_names::data, S_REGULAR,
       ArrayRef<uint8_t>{arr, target->wordSize},

lld/test/MachO/builtin-rename.s

 # NDATA-DAG: __DATA,__cfstring __DATA__cfstring
 # NDATA-DAG: __DATA,__mod_init_func __DATA__mod_init_func
 # NDATA-DAG: __DATA,__mod_term_func __DATA__mod_term_func
 # NDATA-DAG: __DATA,__objc_classlist __DATA__objc_classlist
 # NDATA-DAG: __DATA,__objc_nlclslist __DATA__objc_nlclslist
 # NDATA-DAG: __DATA,__objc_catlist __DATA__objc_catlist
 # NDATA-DAG: __DATA,__objc_nlcatlist __DATA__objc_nlcatlist
 # NDATA-DAG: __DATA,__objc_protolist __DATA__objc_protolist
-# NDATA-DAG: __DATA,__objc_imageinfo __DATA__objc_imageinfo
 # NDATA-DAG: __DATA,__nl_symbol_ptr __IMPORT__pointers
 
 # YDATA-DAG: __DATA_CONST,__auth_got __DATA__auth_got
 # YDATA-DAG: __DATA_CONST,__auth_ptr __DATA__auth_ptr
 # YDATA-DAG: __DATA_CONST,__nl_symbol_ptr __DATA__nl_symbol_ptr
 # YDATA-DAG: __DATA_CONST,__const __DATA__const
 # YDATA-DAG: __DATA_CONST,__cfstring __DATA__cfstring
 # YDATA-DAG: __DATA_CONST,__mod_init_func __DATA__mod_init_func
 # YDATA-DAG: __DATA_CONST,__mod_term_func __DATA__mod_term_func
 # YDATA-DAG: __DATA_CONST,__objc_classlist __DATA__objc_classlist
 # YDATA-DAG: __DATA_CONST,__objc_nlclslist __DATA__objc_nlclslist
 # YDATA-DAG: __DATA_CONST,__objc_catlist __DATA__objc_catlist
 # YDATA-DAG: __DATA_CONST,__objc_nlcatlist __DATA__objc_nlcatlist
 # YDATA-DAG: __DATA_CONST,__objc_protolist __DATA__objc_protolist
-# YDATA-DAG: __DATA_CONST,__objc_imageinfo __DATA__objc_imageinfo
 # YDATA-DAG: __DATA_CONST,__nl_symbol_ptr __IMPORT__pointers
 
 ## LLD doesn't support defining symbols in synthetic sections, so we test them
 ## via this slightly more awkward route.
 # RUN: llvm-readobj --section-headers %t/ydata | \
 # RUN:     FileCheck %s --check-prefix=SYNTH -DSEGNAME=__DATA_CONST
 # RUN: llvm-readobj --section-headers %t/ndata | \
 # RUN:     FileCheck %s --check-prefix=SYNTH -DSEGNAME=__DATA

 __DATA__objc_nlcatlist:
   .space 8
 
 .section __DATA,__objc_protolist
 .global __DATA__objc_protolist
 __DATA__objc_protolist:
   .space 8
 
-.section __DATA,__objc_imageinfo
-.global __DATA__objc_imageinfo
-__DATA__objc_imageinfo:
-  .space 8
+## __objc_imageinfo should get moved under __DATA_CONST as well, but symbols
+## within __objc_imageinfo get dropped during link, so we are cannot test this
+## case using the output of `llvm-objdump --syms`. TODO: rewrite test to use
+## `llvm-readobj --section-headers`, which will avoid this issue.
+# .section __DATA,__objc_imageinfo
+# .global __DATA__objc_imageinfo
+# __DATA__objc_imageinfo:
+#   .space 8
 
 .section __IMPORT,__pointers,non_lazy_symbol_pointers
 .global __IMPORT__pointers
 __IMPORT__pointers:
   .space 8
 
 .section __TEXT,__StaticInit
 .section __TEXT,__StaticInit

lld/test/MachO/objc-imageinfo.s

+# REQUIRES: x86
+
+# RUN: rm -rf %t; split-file %s %t
+
+## ld64 ignores the __objc_imageinfo section entirely if there is no actual
+## ObjC class + category data in the file. LLD doesn't yet do this check, but
+## to make this test work for both linkers, I am inserting an appropriate class
+## definition into each test file.
+# RUN: cat %t/no-category-cls.s   %t/foo-cls.s > %t/no-category-cls-1.s
+# RUN: cat %t/with-category-cls.s %t/foo-cls.s > %t/with-category-cls-1.s
+# RUN: cat %t/ignored-flags.s     %t/foo-cls.s > %t/ignored-flags-1.s
+# RUN: cat %t/invalid-version.s   %t/foo-cls.s > %t/invalid-version-1.s
+# RUN: cat %t/invalid-size.s      %t/foo-cls.s > %t/invalid-size-1.s
+# RUN: cat %t/swift-version-1.s   %t/foo-cls.s > %t/swift-version-1-1.s
+# RUN: cat %t/swift-version-2.s   %t/foo-cls.s > %t/swift-version-2-1.s
+
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/no-category-cls-1.s   -o %t/no-category-cls.o
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/with-category-cls-1.s -o %t/with-category-cls.o
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/ignored-flags-1.s     -o %t/ignored-flags.o
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/invalid-version-1.s   -o %t/invalid-version.o
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/swift-version-1-1.s   -o %t/swift-version-1.o
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/swift-version-2-1.s   -o %t/swift-version-2.o
+# RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %t/invalid-size-1.s      -o %t/invalid-size.o
+
+# RUN: %lld -dylib -lSystem %t/with-category-cls.o -o %t/test-with-cat
+# RUN: llvm-objdump --macho --section="__DATA_CONST,__objc_imageinfo" --syms \
+# RUN:   %t/test-with-cat | FileCheck %s --check-prefix=HAS-CAT-CLS \
+# RUN:   --implicit-check-not=_discard_me
+
+# RUN: %lld -dylib -lSystem %t/no-category-cls.o -o %t/test-no-cat
+# RUN: llvm-objdump --macho --section="__DATA_CONST,__objc_imageinfo" --syms \
+# RUN:   %t/test-no-cat | FileCheck %s --check-prefix=NO-CAT-CLS \
+# RUN:   --implicit-check-not=_discard_me
+
+# RUN: %lld -dylib -lSystem %t/no-category-cls.o %t/with-category-cls.o -o %t/test1
+# RUN: llvm-objdump --macho --section="__DATA_CONST,__objc_imageinfo" %t/test1 \
+# RUN:   | FileCheck %s --check-prefix=NO-CAT-CLS
+
+# RUN: %lld -dylib -lSystem %t/with-category-cls.o %t/ignored-flags.o -o %t/test2
+# RUN: llvm-objdump --macho --section="__DATA_CONST,__objc_imageinfo" %t/test2 \
+# RUN:   | FileCheck %s --check-prefix=HAS-CAT-CLS
+
+# RUN: %lld -dylib -lSystem %t/no-category-cls.o %t/ignored-flags.o -o %t/test3
+# RUN: llvm-objdump --macho --section="__DATA_CONST,__objc_imageinfo" %t/test3 \
+# RUN:   | FileCheck %s --check-prefix=NO-CAT-CLS
+
+# RUN: %no-fatal-warnings-lld -dylib -lSystem %t/with-category-cls.o \
+# RUN:   %t/invalid-version.o -o %t/test4 2>&1 | FileCheck %s \
+# RUN:   --check-prefix=IMAGE-VERSION
+# RUN: llvm-objdump --macho --section="__DATA_CONST,__objc_imageinfo" %t/test4 \
+# RUN:   | FileCheck %s --check-prefix=NO-CAT-CLS
+
+# RUN: %no-fatal-warnings-lld -dylib -lSystem %t/no-category-cls.o \
+# RUN:   %t/invalid-version.o -o %t/test5 2>&1 | FileCheck %s \
+# RUN:   --check-prefix=IMAGE-VERSION
+# RUN: llvm-objdump --macho --section="__DATA_CONST,__objc_imageinfo" %t/test5 \
+# RUN:   | FileCheck %s --check-prefix=NO-CAT-CLS
+
+# RUN: %no-fatal-warnings-lld -dylib -lSystem %t/with-category-cls.o \
+# RUN:   %t/invalid-size.o -o %t/test6 2>&1 | FileCheck %s \
+# RUN:   --check-prefix=INVALID-SIZE
+# RUN: llvm-objdump --macho --section="__DATA_CONST,__objc_imageinfo" %t/test6 \
+# RUN:   | FileCheck %s --check-prefix=NO-CAT-CLS
+
+# RUN: not %lld -dylib -lSystem %t/swift-version-1.o %t/swift-version-2.o -o \
+# RUN:   /dev/null 2>&1 | FileCheck %s --check-prefix=SWIFT-MISMATCH-12
+# RUN: not %lld -dylib -lSystem %t/swift-version-2.o %t/swift-version-1.o -o \
+# RUN:   /dev/null 2>&1 | FileCheck %s --check-prefix=SWIFT-MISMATCH-21
+
+## with-category-cls.o does not have a Swift version (it's set to zero) and
+## should be compatible with any Swift version.
+# RUN: %lld -dylib -lSystem %t/with-category-cls.o %t/swift-version-1.o -o %t/swift-v1
+# RUN: llvm-objdump --macho --section="__DATA_CONST,__objc_imageinfo" \
+# RUN:   %t/swift-v1 | FileCheck %s --check-prefix=SWIFT-V1
+# RUN: %lld -dylib -lSystem %t/with-category-cls.o %t/swift-version-2.o -o %t/swift-v2
+# RUN: llvm-objdump --macho --section="__DATA_CONST,__objc_imageinfo" \
+# RUN:   %t/swift-v2 | FileCheck %s --check-prefix=SWIFT-V2
+
+# HAS-CAT-CLS:       Contents of (__DATA_CONST,__objc_imageinfo) section
+# HAS-CAT-CLS:       00 00 00 40 00 00 00
+# HAS-CAT-CLS-EMPTY:
+
+# NO-CAT-CLS:       Contents of (__DATA_CONST,__objc_imageinfo) section
+# NO-CAT-CLS:       00 00 00 00 00 00 00
+# NO-CAT-CLS-EMPTY:
+
+# SWIFT-V1:       Contents of (__DATA_CONST,__objc_imageinfo) section
+# SWIFT-V1:       00 00 00 40 01 00 00
+# SWIFT-V1-EMPTY:
+
+# SWIFT-V2:       Contents of (__DATA_CONST,__objc_imageinfo) section
+# SWIFT-V2:       00 00 00 40 02 00 00
+# SWIFT-V2-EMPTY:
+
+# IMAGE-VERSION: warning: {{.*}}invalid-version.o: invalid __objc_imageinfo version
+
+# INVALID-SIZE: warning: {{.*}}invalid-size.o: invalid __objc_imageinfo size
+
+# SWIFT-MISMATCH-12: error: Swift version mismatch: {{.*}}swift-version-1.o has version 1.0 but {{.*}}swift-version-2.o has version 1.1
+# SWIFT-MISMATCH-21: error: Swift version mismatch: {{.*}}swift-version-2.o has version 1.1 but {{.*}}swift-version-1.o has version 1.0
+
+#--- no-category-cls.s
+.section __DATA,__objc_imageinfo,regular,no_dead_strip
+## ld64 discards any symbols in this section; we follow suit.
+_discard_me:
+.long 0
+.long 0
+
+#--- with-category-cls.s
+.section __DATA,__objc_imageinfo,regular,no_dead_strip
+_discard_me:
+.long 0
+.long 0x40 ## "has category class properties" flag
+
+#--- ignored-flags.s
+.section __DATA,__objc_imageinfo,regular,no_dead_strip
+.long 0
+## Only the 0x40 flag is carried through to the output binary.
+.long (0x40 | 0x20 | 0x4 | 0x2)
+
+#--- invalid-version.s
+.section __DATA,__objc_imageinfo,regular,no_dead_strip
+.long 1 ## only 0 is valid; the flag field below will not be parsed.
+.long 0x40
+
+#--- invalid-size.s
+.section __DATA,__objc_imageinfo
+.long 0
+
+#--- swift-version-1.s
+.section __DATA,__objc_imageinfo,regular,no_dead_strip
+.long 0
+.byte 0x40
+.byte 0x1 ## Swift version
+.short 0
+
+#--- swift-version-2.s
+.section __DATA,__objc_imageinfo,regular,no_dead_strip
+.long 0
+.byte 0x40
+.byte 0x2 ## Swift version
+.short 0
+
+#--- foo-cls.s
+.section __TEXT,__objc_classname,cstring_literals
+L_CAT_NAME:
+.asciz "barcat"
+
+.section __DATA,__objc_data
+.p2align 3
+_OBJC_CLASS_$_FooClass:
+.space 40
+
+.section __DATA,__objc_const
+.p2align 3
+__OBJC_$_CATEGORY_INSTANCE_METHODS_FooClass_$_barcat:
+
+.p2align 3
+__OBJC_$_CATEGORY_FooClass_$_barcat:
+.quad L_CAT_NAME
+.quad _OBJC_CLASS_$_FooClass
+.quad __OBJC_$_CATEGORY_INSTANCE_METHODS_FooClass_$_barcat
+.quad 0
+.quad 0
+.quad 0
+.quad 0
+.long 64
+.space 4
+
+.section __DATA,__objc_catlist,regular,no_dead_strip
+.p2align 3
+.quad __OBJC_$_CATEGORY_FooClass_$_barcat