Add isa<> support to MachOFile

[pete]

Summary

Hi all

I'm in need of something more fine grained that the kind() method on File. It can only distinguish .o, .so, and .a, but I need to know if, for example, a File* is a MachOFile vs another subclass of SimpleFile like CEntryFile.

This patch is a preliminary implementation which only adds enough to get isa<> to work on MachOFile. If you are all happy with the direction then i'll add support for all of the subclasses of File so that we can do isa<> on anything in the tree.

Alternatively, if only SimpleFile is expected to have interesting subclasses, then i could instead add a SubKind field to SimpleFile instead of changing kind() in File. (BTW, I don't intend for kindUnknownObject to be around for long. If I can do isa<> on all the subclasses then each subclass will have its own entry).

Feedback welcome.

Thanks,
Pete

[lhames]

I've been trying to think of a better way to do this, but I haven't come up with anything yet. It's a pity that we end up mirroring some of the RTTI in the libObject hierarchy, but this really is a distinct hierarchy.

LGTM.

lld/trunk/include/lld/Core/File.h

 /// The Atom objects in a File are owned by the File object.  The Atom objects
 /// are destroyed when the File object is destroyed.
 class File {
 public:
   virtual ~File();
 
   /// \brief Kinds of files that are supported.
   enum Kind {
-    kindObject,        ///< object file (.o)
-    kindSharedLibrary, ///< shared library (.so)
-    kindArchiveLibrary ///< archive (.a)
+    kindErrorObject,          ///< a error object file (.o)
+    kindNormalizedObject,     ///< a normalized file (.o)
+    kindMachObject,           ///< a MachO object file (.o)
+    kindELFObject,            ///< a ELF object file (.o)
+    kindCEntryObject,         ///< a file for CEntries
+    kindEntryObject,          ///< a file for the entry
+    kindUndefinedSymsObject,  ///< a file for undefined symbols
+    kindAliasSymsObject,      ///< a file for alias symbols
+    kindStubHelperObject,     ///< a file for stub helpers
+    kindResolverMergedObject, ///< the resolver merged file.
+    kindSectCreateObject,     ///< a sect create object file (.o)
+    kindSharedLibrary,        ///< shared library (.so)
+    kindArchiveLibrary        ///< archive (.a)
   };
 
   /// \brief Returns file kind.  Need for dyn_cast<> on File objects.
   Kind kind() const {
     return _kind;
   }
 
   /// This returns the path to the file which was used to create this object

 /// An ErrorFile represents a file that doesn't exist.
 /// If you try to parse a file which doesn't exist, an instance of this
 /// class will be returned. That's parse method always returns an error.
 /// This is useful to delay erroring on non-existent files, so that we
 /// can do unit testing a driver using non-existing file paths.
 class ErrorFile : public File {
 public:
   ErrorFile(StringRef path, std::error_code ec)
-      : File(path, kindObject), _ec(ec) {}
+      : File(path, kindErrorObject), _ec(ec) {}
 
   std::error_code doParse() override { return _ec; }
 
   const AtomVector<DefinedAtom> &defined() const override {
     llvm_unreachable("internal error");
   }
   const AtomVector<UndefinedAtom> &undefined() const override {
     llvm_unreachable("internal error");

lld/trunk/include/lld/Core/Resolver.h

ErrorOr<bool> forEachUndefines(File &file, bool searchForOverrides,
                                  UndefCallback callback);
 
   void markLive(const Atom *atom);
   void addAtoms(const std::vector<const DefinedAtom *>&);
   void maybePreloadArchiveMember(StringRef sym);
 
   class MergedFile : public SimpleFile {
   public:
-    MergedFile() : SimpleFile("<linker-internal>") {}
+    MergedFile() : SimpleFile("<linker-internal>", kindResolverMergedObject) {}
     void addAtoms(std::vector<const Atom*>& atoms);
   };
 
   LinkingContext &_ctx;
   SymbolTable _symbolTable;
   std::vector<const Atom *>     _atoms;
   std::set<const Atom *>        _deadStripRoots;
   llvm::DenseSet<const Atom *>  _liveAtoms;

lld/trunk/include/lld/Core/Simple.h

 #include "llvm/ADT/ilist.h"
 #include "llvm/ADT/ilist_node.h"
 #include <atomic>
 
 namespace lld {
 
 class SimpleFile : public File {
 public:
-  SimpleFile(StringRef path) : File(path, kindObject) {}
+  SimpleFile(StringRef path, File::Kind kind)
+    : File(path, kind) {}
 
   void addAtom(const DefinedAtom &a) { _defined.push_back(&a); }
   void addAtom(const UndefinedAtom &a) { _undefined.push_back(&a); }
   void addAtom(const SharedLibraryAtom &a) { _shared.push_back(&a); }
   void addAtom(const AbsoluteAtom &a) { _absolute.push_back(&a); }
 
   void addAtom(const Atom &atom) {
     if (auto *p = dyn_cast<DefinedAtom>(&atom)) {

lld/trunk/lib/Core/LinkingContext.cpp

 std::unique_ptr<File> LinkingContext::createEntrySymbolFile() const {
   return createEntrySymbolFile("<command line option -e>");
 }
 
 std::unique_ptr<File>
 LinkingContext::createEntrySymbolFile(StringRef filename) const {
   if (entrySymbolName().empty())
     return nullptr;
-  std::unique_ptr<SimpleFile> entryFile(new SimpleFile(filename));
+  std::unique_ptr<SimpleFile> entryFile(new SimpleFile(filename,
+                                                       File::kindEntryObject));
   entryFile->addAtom(
       *(new (_allocator) SimpleUndefinedAtom(*entryFile, entrySymbolName())));
   return std::move(entryFile);
 }
 
 std::unique_ptr<File> LinkingContext::createUndefinedSymbolFile() const {
   return createUndefinedSymbolFile("<command line option -u or --defsym>");
 }
 
 std::unique_ptr<File>
 LinkingContext::createUndefinedSymbolFile(StringRef filename) const {
   if (_initialUndefinedSymbols.empty())
     return nullptr;
-  std::unique_ptr<SimpleFile> undefinedSymFile(new SimpleFile(filename));
+  std::unique_ptr<SimpleFile> undefinedSymFile(
+    new SimpleFile(filename, File::kindUndefinedSymsObject));
   for (StringRef undefSym : _initialUndefinedSymbols)
     undefinedSymFile->addAtom(*(new (_allocator) SimpleUndefinedAtom(
                                    *undefinedSymFile, undefSym)));
   return std::move(undefinedSymFile);
 }
 
 std::unique_ptr<File> LinkingContext::createAliasSymbolFile() const {
   if (getAliases().empty())
     return nullptr;
-  std::unique_ptr<SimpleFile> file(new SimpleFile("<alias>"));
+  std::unique_ptr<SimpleFile> file(
+    new SimpleFile("<alias>", File::kindUndefinedSymsObject));
   for (const auto &i : getAliases()) {
     StringRef from = i.first;
     StringRef to = i.second;
     SimpleDefinedAtom *fromAtom = new (_allocator) AliasAtom(*file, from);
     UndefinedAtom *toAtom = new (_allocator) SimpleUndefinedAtom(*file, to);
     fromAtom->addReference(Reference::KindNamespace::all,
                            Reference::KindArch::all, Reference::kindLayoutAfter,
                            0, toAtom, 0);

lld/trunk/lib/Core/Resolver.cpp

if (std::error_code ec = file->parse()) {
                    << ": " << ec.message() << "\n";
       return false;
     }
     DEBUG_WITH_TYPE("resolver",
                     llvm::dbgs() << "Loaded file: " << file->path() << "\n");
     file->beforeLink();
     updatePreloadArchiveMap();
     switch (file->kind()) {
-    case File::kindObject: {
+    case File::kindErrorObject:
+    case File::kindNormalizedObject:
+    case File::kindMachObject:
+    case File::kindELFObject:
+    case File::kindCEntryObject:
+    case File::kindEntryObject:
+    case File::kindUndefinedSymsObject:
+    case File::kindAliasSymsObject:
+    case File::kindStubHelperObject:
+    case File::kindResolverMergedObject:
+    case File::kindSectCreateObject: {
       // The same file may be visited more than once if the file is
       // in --start-group and --end-group. Only library files should
       // be processed more than once.
       if (seen.count(file))
         break;
       seen.insert(file);
       assert(!file->hasOrdinal());
       file->setOrdinal(_ctx.getNextOrdinalAndIncrement());

lld/trunk/lib/ReaderWriter/ELF/AArch64/AArch64DynamicLibraryWriter.h

 
 AArch64DynamicLibraryWriter::AArch64DynamicLibraryWriter(
     AArch64LinkingContext &ctx, TargetLayout<ELF64LE> &layout)
     : DynamicLibraryWriter(ctx, layout) {}
 
 void AArch64DynamicLibraryWriter::createImplicitFiles(
     std::vector<std::unique_ptr<File>> &result) {
   DynamicLibraryWriter::createImplicitFiles(result);
-  auto gotFile = llvm::make_unique<SimpleFile>("GOTFile");
+  auto gotFile = llvm::make_unique<SimpleFile>("GOTFile", File::kindELFObject);
   gotFile->addAtom(*new (gotFile->allocator()) GlobalOffsetTableAtom(*gotFile));
   gotFile->addAtom(*new (gotFile->allocator()) DynamicAtom(*gotFile));
   result.push_back(std::move(gotFile));
 }
 
 } // namespace elf
 } // namespace lld
 
 #endif

lld/trunk/lib/ReaderWriter/ELF/AArch64/AArch64ExecutableWriter.cpp

 
 AArch64ExecutableWriter::AArch64ExecutableWriter(AArch64LinkingContext &ctx,
                                                  AArch64TargetLayout &layout)
   : ExecutableWriter(ctx, layout), _targetLayout(layout) {}
 
 void AArch64ExecutableWriter::createImplicitFiles(
     std::vector<std::unique_ptr<File>> &result) {
   ExecutableWriter::createImplicitFiles(result);
-  auto gotFile = llvm::make_unique<SimpleFile>("GOTFile");
+  auto gotFile = llvm::make_unique<SimpleFile>("GOTFile", File::kindELFObject);
   gotFile->addAtom(*new (gotFile->allocator()) GlobalOffsetTableAtom(*gotFile));
   if (this->_ctx.isDynamic())
     gotFile->addAtom(*new (gotFile->allocator()) DynamicAtom(*gotFile));
   result.push_back(std::move(gotFile));
 }
 
 void AArch64ExecutableWriter::buildDynamicSymbolTable(const File &file) {
   for (auto sec : this->_layout.sections()) {

lld/trunk/lib/ReaderWriter/ELF/AArch64/AArch64RelocationPass.cpp

public:
 
   ArrayRef<uint8_t> rawContent() const override {
     return ArrayRef<uint8_t>(AArch64PltTlsdescAtomContent, 32);
   }
 };
 
 class ELFPassFile : public SimpleFile {
 public:
-  ELFPassFile(const ELFLinkingContext &eti) : SimpleFile("ELFPassFile") {
+  ELFPassFile(const ELFLinkingContext &eti)
+    : SimpleFile("ELFPassFile", kindELFObject) {
     setOrdinal(eti.getNextOrdinalAndIncrement());
   }
 
   llvm::BumpPtrAllocator _alloc;
 };
 
 /// \brief CRTP base for handling relocations.
 template <class Derived> class AArch64RelocationPass : public Pass {

lld/trunk/lib/ReaderWriter/ELF/ARM/ARMRelocationPass.cpp

 class ARMObjectAtom : public ObjectAtom {
 public:
   ARMObjectAtom(const File &f) : ObjectAtom(f) {}
   Alignment alignment() const override { return 4; }
 };
 
 class ELFPassFile : public SimpleFile {
 public:
-  ELFPassFile(const ELFLinkingContext &eti) : SimpleFile("ELFPassFile") {
+  ELFPassFile(const ELFLinkingContext &eti)
+    : SimpleFile("ELFPassFile", kindELFObject) {
     setOrdinal(eti.getNextOrdinalAndIncrement());
   }
 
   llvm::BumpPtrAllocator _alloc;
 };
 
 /// \brief CRTP base for handling relocations.
 template <class Derived> class ARMRelocationPass : public Pass {

lld/trunk/lib/ReaderWriter/ELF/ELFFile.cpp

 #include "FileCommon.h"
 #include "llvm/ADT/STLExtras.h"
 
 namespace lld {
 namespace elf {
 
 template <typename ELFT>
 ELFFile<ELFT>::ELFFile(StringRef name, ELFLinkingContext &ctx)
-    : SimpleFile(name), _ordinal(0), _doStringsMerge(ctx.mergeCommonStrings()),
-      _useWrap(false), _ctx(ctx) {
+    : SimpleFile(name, kindELFObject), _ordinal(0),
+      _doStringsMerge(ctx.mergeCommonStrings()), _useWrap(false), _ctx(ctx) {
   setLastError(std::error_code());
 }
 
 template <typename ELFT>
 ELFFile<ELFT>::ELFFile(std::unique_ptr<MemoryBuffer> mb, ELFLinkingContext &ctx)
-    : SimpleFile(mb->getBufferIdentifier()), _mb(std::move(mb)), _ordinal(0),
+    : SimpleFile(mb->getBufferIdentifier(), kindELFObject),
+      _mb(std::move(mb)), _ordinal(0),
       _doStringsMerge(ctx.mergeCommonStrings()),
       _useWrap(ctx.wrapCalls().size()), _ctx(ctx) {}
 
 template <typename ELFT>
 std::error_code ELFFile<ELFT>::isCompatible(MemoryBufferRef mb,
                                             ELFLinkingContext &ctx) {
   return elf::isCompatible<ELFT>(mb, ctx);
 }

lld/trunk/lib/ReaderWriter/ELF/ELFLinkingContext.cpp

if (exists(path.str()))
       return path.str().copy(_allocator);
   }
   return make_error_code(llvm::errc::no_such_file_or_directory);
 }
 
 void ELFLinkingContext::createInternalFiles(
     std::vector<std::unique_ptr<File>> &files) const {
   std::unique_ptr<SimpleFile> file(
-      new SimpleFile("<internal file for --defsym>"));
+    new SimpleFile("<internal file for --defsym>", File::kindELFObject));
   for (auto &i : getAbsoluteSymbols()) {
     StringRef sym = i.first;
     uint64_t val = i.second;
     file->addAtom(*(new (_allocator) SimpleAbsoluteAtom(
         *file, sym, Atom::scopeGlobal, val)));
   }
   files.push_back(std::move(file));
   LinkingContext::createInternalFiles(files);
 }
 
 void ELFLinkingContext::finalizeInputFiles() {
   // Add virtual archive that resolves undefined symbols.
   if (_resolver)
     getNodes().push_back(llvm::make_unique<FileNode>(std::move(_resolver)));
 }
 
 std::unique_ptr<File> ELFLinkingContext::createUndefinedSymbolFile() const {
   if (_initialUndefinedSymbols.empty())
     return nullptr;
   std::unique_ptr<SimpleFile> undefinedSymFile(
-      new SimpleFile("command line option -u"));
+      new SimpleFile("command line option -u", File::kindELFObject));
   for (auto undefSymStr : _initialUndefinedSymbols)
     undefinedSymFile->addAtom(*(new (_allocator) CommandLineUndefinedAtom(
         *undefinedSymFile, undefSymStr)));
   return std::move(undefinedSymFile);
 }
 
 void ELFLinkingContext::notifySymbolTableCoalesce(const Atom *existingAtom,
                                                   const Atom *newAtom,

lld/trunk/lib/ReaderWriter/ELF/Hexagon/HexagonTargetHandler.cpp

public:
 
   ArrayRef<uint8_t> rawContent() const override {
     return makeArrayRef(hexagonPltAtomContent);
   }
 };
 
 class ELFPassFile : public SimpleFile {
 public:
-  ELFPassFile(const ELFLinkingContext &eti) : SimpleFile("ELFPassFile") {
+  ELFPassFile(const ELFLinkingContext &eti)
+    : SimpleFile("ELFPassFile", kindELFObject) {
     setOrdinal(eti.getNextOrdinalAndIncrement());
   }
 
   llvm::BumpPtrAllocator _alloc;
 };
 
 /// \brief Create GOT and PLT entries for relocations. Handles standard GOT/PLT
 template <class Derived> class GOTPLTPass : public Pass {

lld/trunk/lib/ReaderWriter/ELF/Mips/MipsRelocationPass.cpp

ArrayRef<uint8_t> rawContent() const override {
     return llvm::makeArrayRef(mipsGot0AtomContent)
         .slice(ELFT::Is64Bits ? 0 : 4);
   }
 };
 
 class RelocationPassFile : public SimpleFile {
 public:
   RelocationPassFile(const ELFLinkingContext &ctx)
-      : SimpleFile("RelocationPassFile") {
+      : SimpleFile("RelocationPassFile", kindELFObject) {
     setOrdinal(ctx.getNextOrdinalAndIncrement());
   }
 
   llvm::BumpPtrAllocator _alloc;
 };
 
 template <typename ELFT> class RelocationPass : public Pass {
 public:

lld/trunk/lib/ReaderWriter/ELF/X86/X86DynamicLibraryWriter.h

 
 X86DynamicLibraryWriter::X86DynamicLibraryWriter(X86LinkingContext &ctx,
                                                  TargetLayout<ELF32LE> &layout)
     : DynamicLibraryWriter(ctx, layout) {}
 
 void X86DynamicLibraryWriter::createImplicitFiles(
     std::vector<std::unique_ptr<File>> &result) {
   DynamicLibraryWriter::createImplicitFiles(result);
-  auto gotFile = llvm::make_unique<SimpleFile>("GOTFile");
+  auto gotFile = llvm::make_unique<SimpleFile>("GOTFile", File::kindELFObject);
   gotFile->addAtom(*new (gotFile->allocator()) GlobalOffsetTableAtom(*gotFile));
   gotFile->addAtom(*new (gotFile->allocator()) DynamicAtom(*gotFile));
   result.push_back(std::move(gotFile));
 }
 
 } // namespace elf
 } // namespace lld
 
 #endif

lld/trunk/lib/ReaderWriter/ELF/X86_64/X86_64DynamicLibraryWriter.h

 
 X86_64DynamicLibraryWriter::X86_64DynamicLibraryWriter(
     X86_64LinkingContext &ctx, X86_64TargetLayout &layout)
     : DynamicLibraryWriter(ctx, layout) {}
 
 void X86_64DynamicLibraryWriter::createImplicitFiles(
     std::vector<std::unique_ptr<File>> &result) {
   DynamicLibraryWriter::createImplicitFiles(result);
-  auto gotFile = llvm::make_unique<SimpleFile>("GOTFile");
+  auto gotFile = llvm::make_unique<SimpleFile>("GOTFile", File::kindELFObject);
   gotFile->addAtom(*new (gotFile->allocator()) GlobalOffsetTableAtom(*gotFile));
   gotFile->addAtom(*new (gotFile->allocator()) DynamicAtom(*gotFile));
   result.push_back(std::move(gotFile));
 }
 
 } // namespace elf
 } // namespace lld
 
 #endif

lld/trunk/lib/ReaderWriter/ELF/X86_64/X86_64ExecutableWriter.h

public:
   X86_64ExecutableWriter(X86_64LinkingContext &ctx, X86_64TargetLayout &layout)
       : ExecutableWriter(ctx, layout), _targetLayout(layout) {}
 
 protected:
   // Add any runtime files and their atoms to the output
   void
   createImplicitFiles(std::vector<std::unique_ptr<File>> &result) override {
     ExecutableWriter::createImplicitFiles(result);
-    auto gotFile = llvm::make_unique<SimpleFile>("GOTFile");
+    auto gotFile = llvm::make_unique<SimpleFile>("GOTFile",
+                                                 File::kindELFObject);
     gotFile->addAtom(*new (gotFile->allocator())
                          GlobalOffsetTableAtom(*gotFile));
     if (this->_ctx.isDynamic())
       gotFile->addAtom(*new (gotFile->allocator()) DynamicAtom(*gotFile));
     result.push_back(std::move(gotFile));
   }
 
   void buildDynamicSymbolTable(const File &file) override {

lld/trunk/lib/ReaderWriter/ELF/X86_64/X86_64RelocationPass.cpp

public:
 
   ArrayRef<uint8_t> rawContent() const override {
     return ArrayRef<uint8_t>(x86_64PltAtomContent, 16);
   }
 };
 
 class ELFPassFile : public SimpleFile {
 public:
-  ELFPassFile(const ELFLinkingContext &eti) : SimpleFile("ELFPassFile") {
+  ELFPassFile(const ELFLinkingContext &eti)
+    : SimpleFile("ELFPassFile", kindELFObject) {
     setOrdinal(eti.getNextOrdinalAndIncrement());
   }
 
   llvm::BumpPtrAllocator _alloc;
 };
 
 /// \brief CRTP base for handling relocations.
 template <class Derived> class RelocationPass : public Pass {

lld/trunk/lib/ReaderWriter/MachO/ExecutableAtoms.h

 
 //
 // CEntryFile adds an UndefinedAtom for "_main" so that the Resolving
 // phase will fail if "_main" is undefined.
 //
 class CEntryFile : public SimpleFile {
 public:
   CEntryFile(const MachOLinkingContext &context)
-      : SimpleFile("C entry"),
+      : SimpleFile("C entry", kindCEntryObject),
        _undefMain(*this, context.entrySymbolName()) {
     this->addAtom(_undefMain);
   }
 
 private:
   SimpleUndefinedAtom   _undefMain;
 };
 
 
 //
 // StubHelperFile adds an UndefinedAtom for "dyld_stub_binder" so that
 // the Resolveing phase will fail if "dyld_stub_binder" is undefined.
 //
 class StubHelperFile : public SimpleFile {
 public:
   StubHelperFile(const MachOLinkingContext &context)
-      : SimpleFile("stub runtime"),
+      : SimpleFile("stub runtime", kindStubHelperObject),
         _undefBinder(*this, context.binderSymbolName()) {
     this->addAtom(_undefBinder);
   }
 
 private:
   SimpleUndefinedAtom   _undefBinder;
 };
 

lld/trunk/lib/ReaderWriter/MachO/File.h

 namespace lld {
 namespace mach_o {
 
 using lld::mach_o::normalized::Section;
 
 class MachOFile : public SimpleFile {
 public:
   MachOFile(std::unique_ptr<MemoryBuffer> mb, MachOLinkingContext *ctx)
-      : SimpleFile(mb->getBufferIdentifier()), _mb(std::move(mb)), _ctx(ctx) {}
+    : SimpleFile(mb->getBufferIdentifier(), File::kindMachObject),
+      _mb(std::move(mb)), _ctx(ctx) {}
 
-  MachOFile(StringRef path) : SimpleFile(path) {}
+  MachOFile(StringRef path) : SimpleFile(path, File::kindMachObject) {}
 
   void addDefinedAtom(StringRef name, Atom::Scope scope,
                       DefinedAtom::ContentType type, DefinedAtom::Merge merge,
                       uint64_t sectionOffset, uint64_t contentSize, bool thumb,
                       bool noDeadStrip, bool copyRefs,
                       const Section *inSection) {
     assert(sectionOffset+contentSize <= inSection->content.size());
     ArrayRef<uint8_t> content = inSection->content.slice(sectionOffset,
void eachAtomInSection(const Section &section, SectionAtomVisitor visitor) {
     if (pos == _sectionAtoms.end())
       return;
     auto vec = pos->second;
 
     for (auto &offAndAtom : vec)
       visitor(offAndAtom.atom, offAndAtom.offset);
   }
 
+  /// Methods for support type inquiry through isa, cast, and dyn_cast:
+  static inline bool classof(const File *F) {
+    return F->kind() == File::kindMachObject;
+  }
+
 protected:
   std::error_code doParse() override {
     // Convert binary file to normalized mach-o.
     auto normFile = normalized::readBinary(_mb, _ctx->arch());
     if (std::error_code ec = normFile.getError())
       return ec;
     // Convert normalized mach-o to atoms.
     if (std::error_code ec = normalized::normalizedObjectToAtoms(

lld/trunk/lib/ReaderWriter/MachO/SectCreateFile.h

public:
 
   private:
     std::string _combinedName;
     StringRef _segName;
     StringRef _sectName;
     std::unique_ptr<MemoryBuffer> _content;
   };
 
-  SectCreateFile() : File("sectcreate", kindObject) {}
+  SectCreateFile() : File("sectcreate", kindSectCreateObject) {}
 
   void addSection(StringRef seg, StringRef sect,
                   std::unique_ptr<MemoryBuffer> content) {
     _definedAtoms.push_back(
       new (allocator()) SectCreateAtom(*this, seg, sect, std::move(content)));
   }
 
   const AtomVector<DefinedAtom> &defined() const override {

lld/trunk/lib/ReaderWriter/YAML/ReaderWriterYAML.cpp

static StringRef input(StringRef scalar, void *ctxt, RefKind &kind) {
     return StringRef("unknown reference kind");
   }
 
   static bool mustQuote(StringRef) { return false; }
 };
 
 template <> struct ScalarEnumerationTraits<lld::File::Kind> {
   static void enumeration(IO &io, lld::File::Kind &value) {
-    io.enumCase(value, "object",         lld::File::kindObject);
+    io.enumCase(value, "error-object",   lld::File::kindErrorObject);
+    io.enumCase(value, "object",         lld::File::kindMachObject);
     io.enumCase(value, "shared-library", lld::File::kindSharedLibrary);
     io.enumCase(value, "static-library", lld::File::kindArchiveLibrary);
   }
 };
 
 template <> struct ScalarEnumerationTraits<lld::Atom::Scope> {
   static void enumeration(IO &io, lld::Atom::Scope &value) {
     io.enumCase(value, "global", lld::Atom::scopeGlobal);
public:
     }
 
     StringRef               _path;
     std::vector<ArchMember> _members;
   };
 
   class NormalizedFile : public lld::File {
   public:
-    NormalizedFile(IO &io) : File("", kindObject), _io(io), _rnb(nullptr) {}
+    NormalizedFile(IO &io)
+      : File("", kindNormalizedObject), _io(io), _rnb(nullptr) {}
     NormalizedFile(IO &io, const lld::File *file)
-        : File(file->path(), kindObject), _io(io),
+        : File(file->path(), kindNormalizedObject), _io(io),
           _rnb(new RefNameBuilder(*file)), _path(file->path()) {
       for (const lld::DefinedAtom *a : file->defined())
         _definedAtoms._atoms.push_back(a);
       for (const lld::UndefinedAtom *a : file->undefined())
         _undefinedAtoms._atoms.push_back(a);
       for (const lld::SharedLibraryAtom *a : file->sharedLibrary())
         _sharedLibraryAtoms._atoms.push_back(a);
       for (const lld::AbsoluteAtom *a : file->absolute())