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.

include/lld/Core/File.h

 
   /// \brief Kinds of files that are supported.
   enum Kind {
-    kindObject,        ///< object file (.o)
+    kindUnknownObject, ///< object file (.o)
+    kindMachObject,    ///< MachO object file (.o)
     kindSharedLibrary, ///< shared library (.so)
     kindArchiveLibrary ///< archive (.a)
   };

 class ErrorFile : public File {
 public:
   ErrorFile(StringRef path, std::error_code ec)
-      : File(path, kindObject), _ec(ec) {}
+      : File(path, kindUnknownObject), _ec(ec) {}
 
   std::error_code doParse() override { return _ec; }
 

include/lld/Core/Simple.h

 
 class SimpleFile : public File {
 public:
-  SimpleFile(StringRef path) : File(path, kindObject) {}
+  SimpleFile(StringRef path, File::Kind kind = File::kindUnknownObject)
+    : File(path, kind) {}
 
   void addAtom(const DefinedAtom &a) { _defined.push_back(&a); }
   void addAtom(const UndefinedAtom &a) { _undefined.push_back(&a); }

lib/Core/Resolver.cpp

     file->beforeLink();
     updatePreloadArchiveMap();
     switch (file->kind()) {
-    case File::kindObject: {
+    case File::kindUnknownObject:
+    case File::kindMachObject: {
       // 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.

lib/ReaderWriter/MachO/File.h

 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,

   MachOLinkingContext::OS OS() const { return _os; }
   void setOS(MachOLinkingContext::OS os) { _os = os; }
 
+  /// 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.

lib/ReaderWriter/MachO/SectCreateFile.h

     std::unique_ptr<MemoryBuffer> _content;
   };
 
-  SectCreateFile() : File("sectcreate", kindObject) {}
+  SectCreateFile() : File("sectcreate", kindUnknownObject) {}
 
   void addSection(StringRef seg, StringRef sect,
                   std::unique_ptr<MemoryBuffer> content) {

lib/ReaderWriter/YAML/ReaderWriterYAML.cpp

 
 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, "object",         lld::File::kindUnknownObject);
+    io.enumCase(value, "object",         lld::File::kindMachObject);
     io.enumCase(value, "shared-library", lld::File::kindSharedLibrary);
     io.enumCase(value, "static-library", lld::File::kindArchiveLibrary);
   }

 
   class NormalizedFile : public lld::File {
   public:
-    NormalizedFile(IO &io) : File("", kindObject), _io(io), _rnb(nullptr) {}
+    NormalizedFile(IO &io)
+      : File("", kindUnknownObject), _io(io), _rnb(nullptr) {}
     NormalizedFile(IO &io, const lld::File *file)
-        : File(file->path(), kindObject), _io(io),
+        : File(file->path(), kindUnknownObject), _io(io),
           _rnb(new RefNameBuilder(*file)), _path(file->path()) {
       for (const lld::DefinedAtom *a : file->defined())
         _definedAtoms._atoms.push_back(a);